wellton/hhvm
1
0
Fork 0
Código Issues Pull Requests Ações Pacotes Projetos Versões Wiki Atividade

remove "get" from label, trace, block, hint, next, taken, extra

Ver Código-Fonte 
Makes the code less repetitive and easier to read
Esse commit está contido em:
Edwin Smith
2013-05-29 09:40:41 -07:00
commit de sgolemon
pai 0e7c8a33f2
commit 8a8b27071f
25 arquivos alterados com 390 adições e 391 exclusões
Baixar Arquivo de Patch Baixar Arquivo de Diff Expandir todos os arquivos Colapsar todos os arquivos
hphp/runtime/vm/translator/hopt/block.h
+11 -11
Ver Arquivo
@@ -51,16 +51,16 @@ struct Block : boost::noncopyable {
push_back(label);
}
IRInstruction* getLabel() const {
IRInstruction* label() const {
assert(front()->op() == DefLabel);
return front();
}
uint32_t id() const { return m_id; }
Trace* getTrace() const { return m_trace; }
Trace* trace() const { return m_trace; }
void setTrace(Trace* t) { m_trace = t; }
Hint hint() const { return m_hint; }
void setHint(Hint hint) { m_hint = hint; }
Hint getHint() const { return m_hint; }
void addEdge(IRInstruction* jmp);
void removeEdge(IRInstruction* jmp);
@@ -80,7 +80,7 @@ struct Block : boost::noncopyable {
bool isMain() const;
/*
* Returns: !getTaken() && !getNext().
* Returns: !taken() && !next().
*/
bool isExit() const;
@@ -105,12 +105,12 @@ struct Block : boost::noncopyable {
// return the fallthrough block. Should be nullptr if the last
// instruction is a Terminal.
Block* getNext() const { return m_next.to(); }
Block* next() const { return m_next.to(); }
void setNext(Block* b) { m_next.setTo(b); }
// return the target block if the last instruction is a branch.
Block* getTaken() const {
return back()->getTaken();
Block* taken() const {
return back()->taken();
}
// return the postorder number of this block. (updated each time
@@ -138,7 +138,7 @@ struct Block : boost::noncopyable {
// return an iterator to a specific instruction
iterator iteratorTo(IRInstruction* inst) {
assert(inst->getBlock() == this);
assert(inst->block() == this);
return m_instrs.iterator_to(*inst);
}
@@ -163,7 +163,7 @@ struct Block : boost::noncopyable {
void forEachSrc(unsigned i, L body) {
for (Edge& e : m_preds) {
IRInstruction* jmp = e.from()->back();
assert(jmp->op() == Jmp_ && jmp->getTaken() == this);
assert(jmp->op() == Jmp_ && jmp->taken() == this);
body(jmp, jmp->src(i));
}
}
@@ -190,7 +190,7 @@ struct Block : boost::noncopyable {
// list-compatible interface; these delegate to m_instrs but also update
// inst.m_block
InstructionList& getInstrs() { return m_instrs; }
InstructionList& instrs() { return m_instrs; }
bool empty() const { return m_instrs.empty(); }
iterator begin() { return m_instrs.begin(); }
iterator end() { return m_instrs.end(); }
@@ -204,7 +204,7 @@ struct Block : boost::noncopyable {
void splice(iterator pos, Block* from, iterator begin, iterator end) {
assert(from != this);
for (auto i = begin; i != end; ++i) (*i).setBlock(this);
m_instrs.splice(pos, from->getInstrs(), begin, end);
m_instrs.splice(pos, from->instrs(), begin, end);
}
void push_back(IRInstruction* inst) {
inst->setBlock(this);
hphp/runtime/vm/translator/hopt/cfg.h
+6 -6
Ver Arquivo
@@ -41,12 +41,12 @@ struct PostorderSort {
assert(!block->empty());
if (m_visited.test(block->id())) return;
m_visited.set(block->id());
Block* taken = block->getTaken();
if (taken && taken->getTrace()->isMain() != block->getTrace()->isMain()) {
Block* taken = block->taken();
if (taken && taken->trace()->isMain() != block->trace()->isMain()) {
walk(taken);
taken = nullptr;
}
if (Block* next = block->getNext()) walk(next);
if (Block* next = block->next()) walk(next);
if (taken) walk(taken);
m_visitor(block);
}
@@ -154,11 +154,11 @@ void forEachTrace(Trace* main, Body body) {
*/
template <class Body>
void forEachTraceBlock(Trace* main, Body body) {
for (Block* block : main->getBlocks()) {
for (Block* block : main->blocks()) {
body(block);
}
for (Trace* exit : main->getExitTraces()) {
for (Block* block : exit->getBlocks()) {
for (Block* block : exit->blocks()) {
body(block);
}
}
@@ -178,7 +178,7 @@ void forEachInst(const BlockList& blocks, Body body) {
template <class Body>
void forEachInst(Trace* trace, Body body) {
forEachInst(trace->getBlocks(), body);
forEachInst(trace->blocks(), body);
}
/*
hphp/runtime/vm/translator/hopt/check.cpp
+8 -8
Ver Arquivo
@@ -71,15 +71,15 @@ bool checkBlock(Block* b) {
if (b->skipLabel() != b->end()) {
assert(b->skipLabel()->op() == Marker);
}
if (b->back()->isTerminal()) assert(!b->getNext());
if (b->getTaken()) {
if (b->back()->isTerminal()) assert(!b->next());
if (b->taken()) {
// only Jmp_ can branch to a join block expecting values.
assert(b->back()->op() == Jmp_ ||
b->getTaken()->front()->numDsts() == 0);
b->taken()->front()->numDsts() == 0);
}
if (b->getNext()) {
if (b->next()) {
// cannot fall-through to join block expecting values
assert(b->getNext()->front()->numDsts() == 0);
assert(b->next()->front()->numDsts() == 0);
}
{
@@ -91,15 +91,15 @@ bool checkBlock(Block* b) {
assert(!inst.isBlockEnd());
}
for (DEBUG_ONLY IRInstruction& inst : *b) {
assert(inst.getBlock() == b);
assert(inst.block() == b);
}
}
for (int i = 0; i < b->front()->numDsts(); ++i) {
auto const traceBlocks = b->getTrace()->getBlocks();
auto const traceBlocks = b->trace()->blocks();
b->forEachSrc(i, [&](IRInstruction* inst, SSATmp*) {
assert(std::find(traceBlocks.begin(), traceBlocks.end(),
inst->getBlock()) != traceBlocks.end());
inst->block()) != traceBlocks.end());
});
}
hphp/runtime/vm/translator/hopt/codegen.cpp
+109 -109
Ver Arquivo
@@ -778,14 +778,14 @@ void CodeGenerator::emitReqBindJcc(ConditionCode cc,
void CodeGenerator::cgJcc(IRInstruction* inst) {
emitCompare(inst->src(0), inst->src(1));
emitFwdJcc(opToConditionCode(inst->op()), inst->getTaken());
emitFwdJcc(opToConditionCode(inst->op()), inst->taken());
}
void CodeGenerator::cgReqBindJcc(IRInstruction* inst) {
// TODO(#2404427): prepareForTestAndSmash?
emitCompare(inst->src(0), inst->src(1));
emitReqBindJcc(opToConditionCode(inst->op()),
inst->getExtra<ReqBindJccData>());
inst->extra<ReqBindJccData>());
}
#define X(x) \
@@ -1094,7 +1094,7 @@ void CodeGenerator::cgCallHelper(Asm& a,
* bytecode offset.
*/
void CodeGenerator::cgMarker(IRInstruction* inst) {
m_curBcOff = inst->getExtra<MarkerData>()->bcOff;
m_curBcOff = inst->extra<MarkerData>()->bcOff;
}
void CodeGenerator::cgMov(IRInstruction* inst) {
@@ -1706,10 +1706,10 @@ void CodeGenerator::emitIsTypeTest(IRInstruction* inst, JmpFn doJcc) {
auto const src = inst->src(0);
// punt if specialized object for now
if (inst->getTypeParam().strictSubtypeOf(Type::Obj)) {
if (inst->typeParam().strictSubtypeOf(Type::Obj)) {
CG_PUNT(IsType-SpecializedUnsupported);
}
if (inst->getTypeParam().equals(Type::Obj)) {
if (inst->typeParam().equals(Type::Obj)) {
auto const srcReg = m_regs[src].getReg();
if (src->isA(Type::PtrToGen)) {
emitTestTVType(m_as, KindOfObject, srcReg[TVOFF(m_type)]);
@@ -1737,7 +1737,7 @@ void CodeGenerator::emitIsTypeTest(IRInstruction* inst, JmpFn doJcc) {
if (src->isA(Type::PtrToGen)) {
PhysReg base = m_regs[src].getReg();
emitTypeTest(inst->getTypeParam(), base[TVOFF(m_type)],
emitTypeTest(inst->typeParam(), base[TVOFF(m_type)],
base[TVOFF(m_data)],
[&](ConditionCode cc) { doJcc(cc); });
return;
@@ -1750,7 +1750,7 @@ void CodeGenerator::emitIsTypeTest(IRInstruction* inst, JmpFn doJcc) {
CG_PUNT(IsType-KnownType);
}
PhysReg dataSrcReg = m_regs[src].getReg(); // data register
emitTypeTest(inst->getTypeParam(), typeSrcReg, dataSrcReg,
emitTypeTest(inst->typeParam(), typeSrcReg, dataSrcReg,
[&](ConditionCode cc) { doJcc(cc); });
}
@@ -1802,7 +1802,7 @@ void CodeGenerator::cgIsTypeCommon(IRInstruction* inst, bool negate) {
void CodeGenerator::cgJmpIsTypeCommon(IRInstruction* inst, bool negate) {
emitIsTypeTest(inst,
[&](ConditionCode cc) {
emitFwdJcc(negate ? ccNegate(cc) : cc, inst->getTaken());
emitFwdJcc(negate ? ccNegate(cc) : cc, inst->taken());
});
}
@@ -1883,24 +1883,24 @@ void CodeGenerator::cgNInstanceOfBitmask(IRInstruction* inst) {
void CodeGenerator::cgJmpInstanceOfBitmask(IRInstruction* inst) {
emitInstanceBitmaskCheck(inst);
emitFwdJcc(CC_NZ, inst->getTaken());
emitFwdJcc(CC_NZ, inst->taken());
}
void CodeGenerator::cgJmpNInstanceOfBitmask(IRInstruction* inst) {
emitInstanceBitmaskCheck(inst);
emitFwdJcc(CC_Z, inst->getTaken());
emitFwdJcc(CC_Z, inst->taken());
}
void CodeGenerator::cgReqBindJmpInstanceOfBitmask(IRInstruction* inst) {
emitInstanceBitmaskCheck(inst);
emitReqBindJcc(opToConditionCode(inst->op()),
inst->getExtra<ReqBindJccData>());
inst->extra<ReqBindJccData>());
}
void CodeGenerator::cgReqBindJmpNInstanceOfBitmask(IRInstruction* inst) {
emitInstanceBitmaskCheck(inst);
emitReqBindJcc(opToConditionCode(inst->op()),
inst->getExtra<ReqBindJccData>());
inst->extra<ReqBindJccData>());
}
/*
@@ -2145,7 +2145,7 @@ void CodeGenerator::cgLdFuncCached(IRInstruction* inst) {
void CodeGenerator::cgLdFuncCachedSafe(IRInstruction* inst) {
cgLdFuncCachedCommon(inst);
if (Block* taken = inst->getTaken()) {
if (Block* taken = inst->taken()) {
emitFwdJcc(m_as, CC_Z, taken);
}
}
@@ -2298,7 +2298,7 @@ void CodeGenerator::emitReqBindAddr(const Func* func,
}
void CodeGenerator::cgJmpSwitchDest(IRInstruction* inst) {
JmpSwitchData* data = inst->getExtra<JmpSwitchDest>();
JmpSwitchData* data = inst->extra<JmpSwitchDest>();
SSATmp* index = inst->src(0);
auto indexReg = m_regs[index].getReg();
@@ -2349,7 +2349,7 @@ static TCA sswitchHelperFast(const StringData* val,
}
void CodeGenerator::cgLdSSwitchDestFast(IRInstruction* inst) {
auto data = inst->getExtra<LdSSwitchDestFast>();
auto data = inst->extra<LdSSwitchDestFast>();
auto table = m_tx64->m_globalData.alloc<SSwitchMap>(64);
table->init(data->numCases);
@@ -2383,7 +2383,7 @@ static TCA sswitchHelperSlow(TypedValue typedVal,
}
void CodeGenerator::cgLdSSwitchDestSlow(IRInstruction* inst) {
auto data = inst->getExtra<LdSSwitchDestSlow>();
auto data = inst->extra<LdSSwitchDestSlow>();
auto strtab = m_tx64->m_globalData.alloc<const StringData*>(
sizeof(const StringData*), data->numCases);
@@ -2419,7 +2419,7 @@ void CodeGenerator::cgLdSSwitchDestSlow(IRInstruction* inst) {
void CodeGenerator::cgDefInlineFP(IRInstruction* inst) {
auto const fp = m_regs[inst->src(0)].getReg();
auto const fakeRet = m_tx64->getRetFromInlinedFrame();
auto const retBCOff = inst->getExtra<DefInlineFP>()->retBCOff;
auto const retBCOff = inst->extra<DefInlineFP>()->retBCOff;
m_as. storeq (fakeRet, fp[AROFF(m_savedRip)]);
m_as. storel (retBCOff, fp[AROFF(m_soff)]);
@@ -2440,7 +2440,7 @@ void CodeGenerator::cgReDefSP(IRInstruction* inst) {
// a DefGeneratorSP or something similar.
auto fp = m_regs[inst->src(0)].getReg();
auto dst = m_regs[inst->dst()].getReg();
auto off = -inst->getExtra<ReDefSP>()->offset * sizeof(Cell);
auto off = -inst->extra<ReDefSP>()->offset * sizeof(Cell);
emitLea(m_as, fp[off], dst);
}
@@ -2566,14 +2566,14 @@ int CodeGenerator::getIterOffset(SSATmp* tmp) {
void CodeGenerator::cgStLoc(IRInstruction* inst) {
cgStore(m_regs[inst->src(0)].getReg(),
getLocalOffset(inst->getExtra<StLoc>()->locId),
getLocalOffset(inst->extra<StLoc>()->locId),
inst->src(1),
true /* store type */);
}
void CodeGenerator::cgStLocNT(IRInstruction* inst) {
cgStore(m_regs[inst->src(0)].getReg(),
getLocalOffset(inst->getExtra<StLocNT>()->locId),
getLocalOffset(inst->extra<StLocNT>()->locId),
inst->src(1),
false /* store type */);
}
@@ -2586,7 +2586,7 @@ void CodeGenerator::cgSyncABIRegs(IRInstruction* inst) {
void CodeGenerator::cgReqBindJmp(IRInstruction* inst) {
m_tx64->emitBindJmp(
m_as,
SrcKey(getCurFunc(), inst->getExtra<ReqBindJmp>()->offset)
SrcKey(getCurFunc(), inst->extra<ReqBindJmp>()->offset)
);
}
@@ -2616,14 +2616,14 @@ static void emitExitNoIRStats(Asm& a,
void CodeGenerator::cgReqBindJmpNoIR(IRInstruction* inst) {
auto const dest = SrcKey(getCurFunc(),
inst->getExtra<ReqBindJmpNoIR>()->offset);
inst->extra<ReqBindJmpNoIR>()->offset);
emitExitNoIRStats(m_as, m_tx64, getCurFunc(), dest);
m_tx64->emitBindJmp(m_as, dest, REQ_BIND_JMP_NO_IR);
}
void CodeGenerator::cgReqRetranslateNoIR(IRInstruction* inst) {
auto const dest = SrcKey(getCurFunc(),
inst->getExtra<ReqRetranslateNoIR>()->offset);
inst->extra<ReqRetranslateNoIR>()->offset);
emitExitNoIRStats(m_as, m_tx64, getCurFunc(), dest);
m_tx64->emitReqRetransNoIR(m_as, dest);
}
@@ -2687,15 +2687,15 @@ void CodeGenerator::cgIncRef(IRInstruction* inst) {
}
void CodeGenerator::cgDecRefStack(IRInstruction* inst) {
cgDecRefMem(inst->getTypeParam(),
cgDecRefMem(inst->typeParam(),
m_regs[inst->src(0)].getReg(),
cellsToBytes(inst->getExtra<DecRefStack>()->offset),
cellsToBytes(inst->extra<DecRefStack>()->offset),
nullptr);
}
void CodeGenerator::cgDecRefThis(IRInstruction* inst) {
SSATmp* fp = inst->src(0);
Block* exit = inst->getTaken();
Block* exit = inst->taken();
auto fpReg = m_regs[fp].getReg();
auto scratchReg = m_rScratch;
@@ -2725,10 +2725,10 @@ void CodeGenerator::cgDecRefThis(IRInstruction* inst) {
}
void CodeGenerator::cgDecRefLoc(IRInstruction* inst) {
cgDecRefMem(inst->getTypeParam(),
cgDecRefMem(inst->typeParam(),
m_regs[inst->src(0)].getReg(),
getLocalOffset(inst->getExtra<DecRefLoc>()->locId),
inst->getTaken());
getLocalOffset(inst->extra<DecRefLoc>()->locId),
inst->taken());
}
void CodeGenerator::cgGenericRetDecRefs(IRInstruction* inst) {
@@ -3100,16 +3100,16 @@ void CodeGenerator::cgDecRefMem(Type type,
void CodeGenerator::cgDecRefMem(IRInstruction* inst) {
assert(inst->src(0)->type().isPtr());
cgDecRefMem(inst->getTypeParam(),
cgDecRefMem(inst->typeParam(),
m_regs[inst->src(0)].getReg(),
inst->src(1)->getValInt(),
inst->getTaken());
inst->taken());
}
void CodeGenerator::cgDecRefWork(IRInstruction* inst, bool genZeroCheck) {
SSATmp* src = inst->src(0);
if (!isRefCounted(src)) return;
Block* exit = inst->getTaken();
Block* exit = inst->taken();
Type type = src->type();
if (type.isKnownDataType()) {
cgDecRefStaticType(type, m_regs[src].getReg(), exit, genZeroCheck);
@@ -3124,19 +3124,19 @@ void CodeGenerator::cgDecRefWork(IRInstruction* inst, bool genZeroCheck) {
void CodeGenerator::cgDecRef(IRInstruction *inst) {
// DecRef may bring the count to zero, and run the destructor.
// Generate code for this.
assert(!inst->getTaken());
assert(!inst->taken());
cgDecRefWork(inst, true);
}
void CodeGenerator::cgDecRefNZ(IRInstruction* inst) {
// DecRefNZ cannot bring the count to zero.
// Therefore, we don't generate zero-checking code.
assert(!inst->getTaken());
assert(!inst->taken());
cgDecRefWork(inst, false);
}
void CodeGenerator::cgDecRefNZOrBranch(IRInstruction* inst) {
assert(inst->getTaken());
assert(inst->taken());
cgDecRefWork(inst, true);
}
@@ -3145,8 +3145,8 @@ void CodeGenerator::cgSpillFrame(IRInstruction* inst) {
auto const fp = inst->src(1);
auto const func = inst->src(2);
auto const objOrCls = inst->src(3);
auto const magicName = inst->getExtra<SpillFrame>()->invName;
auto const nArgs = inst->getExtra<SpillFrame>()->numArgs;
auto const magicName = inst->extra<SpillFrame>()->invName;
auto const nArgs = inst->extra<SpillFrame>()->numArgs;
const int64_t spOffset = -kNumActRecCells * sizeof(Cell);
@@ -3375,7 +3375,7 @@ void CodeGenerator::cgAllocObjFast(IRInstruction* inst) {
}
void CodeGenerator::cgInlineCreateCont(IRInstruction* inst) {
auto const& data = *inst->getExtra<InlineCreateCont>();
auto const& data = *inst->extra<InlineCreateCont>();
auto const helper = data.origFunc->isMethod()
? &VMExecutionContext::createContinuationHelper<true>
: &VMExecutionContext::createContinuationHelper<false>;
@@ -3401,8 +3401,8 @@ void CodeGenerator::cgInlineCreateCont(IRInstruction* inst) {
}
void CodeGenerator::cgCallArray(IRInstruction* inst) {
Offset pc = inst->getExtra<CallArray>()->pc;
Offset after = inst->getExtra<CallArray>()->after;
Offset pc = inst->extra<CallArray>()->pc;
Offset after = inst->extra<CallArray>()->after;
ArgGroup args(m_regs);
args.imm(pc).imm(after);
@@ -3448,9 +3448,9 @@ void CodeGenerator::cgCall(IRInstruction* inst) {
}
void CodeGenerator::cgCastStk(IRInstruction *inst) {
Type type = inst->getTypeParam();
Type type = inst->typeParam();
SSATmp* sp = inst->src(0);
uint32_t offset = inst->getExtra<CastStk>()->offset;
uint32_t offset = inst->extra<CastStk>()->offset;
PhysReg spReg = m_regs[sp].getReg();
ArgGroup args(m_regs);
@@ -3485,7 +3485,7 @@ void CodeGenerator::cgCallBuiltin(IRInstruction* inst) {
SSATmp* dst = inst->dst();
auto dstReg = m_regs[dst].getReg(0);
auto dstType = m_regs[dst].getReg(1);
Type returnType = inst->getTypeParam();
Type returnType = inst->typeParam();
const Func* func = f->getValFunc();
DataType funcReturnType = func->returnType();
@@ -3600,7 +3600,7 @@ void CodeGenerator::cgSpillStack(IRInstruction* inst) {
// If our value came from a LdStack on the same sp and offset,
// we don't need to spill it.
if (inst->op() == LdStack && inst->src(0) == sp &&
inst->getExtra<LdStack>()->offset * sizeof(Cell) == offset) {
inst->extra<LdStack>()->offset * sizeof(Cell) == offset) {
FTRACE(6, "{}: Not spilling spill value {} from {}\n",
__func__, i, inst->toString());
} else {
@@ -3645,7 +3645,7 @@ void CodeGenerator::cgNativeImpl(IRInstruction* inst) {
void CodeGenerator::cgLdThis(IRInstruction* inst) {
SSATmp* dst = inst->dst();
SSATmp* src = inst->src(0);
Block* label = inst->getTaken();
Block* label = inst->taken();
// mov dst, [fp + 0x20]
auto dstReg = m_regs[dst].getReg();
@@ -3706,7 +3706,7 @@ void CodeGenerator::cgLdCctx(IRInstruction* inst) {
void CodeGenerator::cgLdConst(IRInstruction* inst) {
auto const dstReg = m_regs[inst->dst()].getReg();
auto const val = inst->getExtra<LdConst>()->as<uintptr_t>();
auto const val = inst->extra<LdConst>()->as<uintptr_t>();
if (dstReg == InvalidReg) return;
emitLoadImm(m_as, val, dstReg);
}
@@ -3819,7 +3819,7 @@ void CodeGenerator::cgLdStaticLocCached(IRInstruction* inst) {
m_as.loadq (rVmTl[ch], outReg);
m_as.testq (outReg, outReg);
emitFwdJcc(m_as, CC_Z, inst->getTaken());
emitFwdJcc(m_as, CC_Z, inst->taken());
}
// If label is set and type is not Gen, this method generates a check
@@ -3827,8 +3827,8 @@ void CodeGenerator::cgLdStaticLocCached(IRInstruction* inst) {
void CodeGenerator::cgLoadTypedValue(PhysReg base,
int64_t off,
IRInstruction* inst) {
Block* label = inst->getTaken();
Type type = inst->getTypeParam();
Block* label = inst->taken();
Type type = inst->typeParam();
SSATmp* dst = inst->dst();
assert(type == dst->type());
@@ -3859,14 +3859,14 @@ void CodeGenerator::cgLoadTypedValue(PhysReg base,
if (typeDstReg != InvalidReg) {
emitLoadTVType(m_as, base[off + TVOFF(m_type)], typeDstReg);
if (label) {
emitTypeCheck(inst->getTypeParam(), typeDstReg,
valueDstReg, inst->getTaken());
emitTypeCheck(inst->typeParam(), typeDstReg,
valueDstReg, inst->taken());
}
} else if (label) {
emitTypeCheck(inst->getTypeParam(),
emitTypeCheck(inst->typeParam(),
base[off + TVOFF(m_type)],
base[off + TVOFF(m_data)],
inst->getTaken());
inst->taken());
}
// Load value if it's not dead
@@ -3931,16 +3931,16 @@ void CodeGenerator::cgStore(PhysReg base,
void CodeGenerator::cgLoad(PhysReg base,
int64_t off,
IRInstruction* inst) {
Type type = inst->getTypeParam();
Type type = inst->typeParam();
if (type.needsReg()) {
return cgLoadTypedValue(base, off, inst);
}
Block* label = inst->getTaken();
Block* label = inst->taken();
if (label != NULL) {
emitTypeCheck(inst->getTypeParam(),
emitTypeCheck(inst->typeParam(),
base[off + TVOFF(m_type)],
base[off + TVOFF(m_data)],
inst->getTaken());
inst->taken());
}
if (type.isNull()) return; // these are constants
auto dstReg = m_regs[inst->dst()].getReg();
@@ -3996,13 +3996,13 @@ void CodeGenerator::cgLdAddr(IRInstruction* inst) {
void CodeGenerator::cgLdLoc(IRInstruction* inst) {
cgLoad(m_regs[inst->src(0)].getReg(),
getLocalOffset(inst->getExtra<LdLoc>()->locId),
getLocalOffset(inst->extra<LdLoc>()->locId),
inst);
}
void CodeGenerator::cgLdLocAddr(IRInstruction* inst) {
auto const fpReg = m_regs[inst->src(0)].getReg();
auto const offset = getLocalOffset(inst->getExtra<LdLocAddr>()->locId);
auto const offset = getLocalOffset(inst->extra<LdLocAddr>()->locId);
if (m_regs[inst->dst()].hasReg()) {
m_as.lea(fpReg[offset], m_regs[inst->dst()].getReg());
}
@@ -4010,45 +4010,45 @@ void CodeGenerator::cgLdLocAddr(IRInstruction* inst) {
void CodeGenerator::cgLdStackAddr(IRInstruction* inst) {
auto const base = m_regs[inst->src(0)].getReg();
auto const offset = cellsToBytes(inst->getExtra<LdStackAddr>()->offset);
auto const offset = cellsToBytes(inst->extra<LdStackAddr>()->offset);
m_as.lea (base[offset], m_regs[inst->dst()].getReg());
}
void CodeGenerator::cgLdStack(IRInstruction* inst) {
assert(inst->getTaken() == nullptr);
assert(inst->taken() == nullptr);
cgLoad(m_regs[inst->src(0)].getReg(),
cellsToBytes(inst->getExtra<LdStack>()->offset),
cellsToBytes(inst->extra<LdStack>()->offset),
inst);
}
void CodeGenerator::cgGuardStk(IRInstruction* inst) {
auto const rSP = m_regs[inst->src(0)].getReg();
auto const baseOff = cellsToBytes(inst->getExtra<GuardStk>()->offset);
emitTypeGuard(inst->getTypeParam(),
auto const baseOff = cellsToBytes(inst->extra<GuardStk>()->offset);
emitTypeGuard(inst->typeParam(),
rSP[baseOff + TVOFF(m_type)],
rSP[baseOff + TVOFF(m_data)]);
}
void CodeGenerator::cgCheckStk(IRInstruction* inst) {
auto const rbase = m_regs[inst->src(0)].getReg();
auto const baseOff = cellsToBytes(inst->getExtra<CheckStk>()->offset);
emitTypeCheck(inst->getTypeParam(), rbase[baseOff + TVOFF(m_type)],
rbase[baseOff + TVOFF(m_data)], inst->getTaken());
auto const baseOff = cellsToBytes(inst->extra<CheckStk>()->offset);
emitTypeCheck(inst->typeParam(), rbase[baseOff + TVOFF(m_type)],
rbase[baseOff + TVOFF(m_data)], inst->taken());
}
void CodeGenerator::cgGuardLoc(IRInstruction* inst) {
auto const rFP = m_regs[inst->src(0)].getReg();
auto const baseOff = getLocalOffset(inst->getExtra<GuardLoc>()->locId);
emitTypeGuard(inst->getTypeParam(),
auto const baseOff = getLocalOffset(inst->extra<GuardLoc>()->locId);
emitTypeGuard(inst->typeParam(),
rFP[baseOff + TVOFF(m_type)],
rFP[baseOff + TVOFF(m_data)]);
}
void CodeGenerator::cgCheckLoc(IRInstruction* inst) {
auto const rbase = m_regs[inst->src(0)].getReg();
auto const baseOff = getLocalOffset(inst->getExtra<CheckLoc>()->locId);
emitTypeCheck(inst->getTypeParam(), rbase[baseOff + TVOFF(m_type)],
rbase[baseOff + TVOFF(m_data)], inst->getTaken());
auto const baseOff = getLocalOffset(inst->extra<CheckLoc>()->locId);
emitTypeCheck(inst->typeParam(), rbase[baseOff + TVOFF(m_type)],
rbase[baseOff + TVOFF(m_data)], inst->taken());
}
template<class Loc>
@@ -4065,8 +4065,8 @@ void CodeGenerator::emitSideExitGuard(Type type,
void CodeGenerator::cgSideExitGuardLoc(IRInstruction* inst) {
auto const fp = m_regs[inst->src(0)].getReg();
auto const extra = inst->getExtra<SideExitGuardLoc>();
emitSideExitGuard(inst->getTypeParam(),
auto const extra = inst->extra<SideExitGuardLoc>();
emitSideExitGuard(inst->typeParam(),
fp[getLocalOffset(extra->checkedSlot) + TVOFF(m_type)],
fp[getLocalOffset(extra->checkedSlot) + TVOFF(m_data)],
extra->taken);
@@ -4074,8 +4074,8 @@ void CodeGenerator::cgSideExitGuardLoc(IRInstruction* inst) {
void CodeGenerator::cgSideExitGuardStk(IRInstruction* inst) {
auto const sp = m_regs[inst->src(0)].getReg();
auto const extra = inst->getExtra<SideExitGuardStk>();
emitSideExitGuard(inst->getTypeParam(),
auto const extra = inst->extra<SideExitGuardStk>();
emitSideExitGuard(inst->typeParam(),
sp[cellsToBytes(extra->checkedSlot) + TVOFF(m_type)],
sp[cellsToBytes(extra->checkedSlot) + TVOFF(m_data)],
extra->taken);
@@ -4091,9 +4091,9 @@ void CodeGenerator::cgCheckType(IRInstruction* inst) {
auto const rData = m_regs[src].getReg(0);
auto const rType = m_regs[src].getReg(1);
emitTypeTest(inst->getTypeParam(), rType, rData,
emitTypeTest(inst->typeParam(), rType, rData,
[&](ConditionCode cc) {
emitFwdJcc(ccNegate(cc), inst->getTaken());
emitFwdJcc(ccNegate(cc), inst->taken());
auto const dstReg = m_regs[inst->dst()].getReg();
if (dstReg != InvalidReg) {
@@ -4104,8 +4104,8 @@ void CodeGenerator::cgCheckType(IRInstruction* inst) {
void CodeGenerator::cgCheckTypeMem(IRInstruction* inst) {
auto const reg = m_regs[inst->src(0)].getReg();
emitTypeCheck(inst->getTypeParam(), reg[TVOFF(m_type)],
reg[TVOFF(m_data)], inst->getTaken());
emitTypeCheck(inst->typeParam(), reg[TVOFF(m_type)],
reg[TVOFF(m_data)], inst->taken());
}
void CodeGenerator::cgGuardRefs(IRInstruction* inst) {
@@ -4235,7 +4235,7 @@ void CodeGenerator::cgLdClsMethodCache(IRInstruction* inst) {
SSATmp* className = inst->src(0);
SSATmp* methodName = inst->src(1);
SSATmp* baseClass = inst->src(2);
Block* label = inst->getTaken();
Block* label = inst->taken();
// Stats::emitInc(a, Stats::TgtCache_StaticMethodHit);
const StringData* cls = className->getValStr();
@@ -4356,7 +4356,7 @@ void CodeGenerator::cgLdClsMethodFCache(IRInstruction* inst) {
const StringData* methName = inst->src(1)->getValStr();
SSATmp* srcCtxTmp = inst->src(2);
PhysReg srcCtxReg = m_regs[srcCtxTmp].getReg(0);
Block* exitLabel = inst->getTaken();
Block* exitLabel = inst->taken();
const StringData* clsName = cls->name();
CacheHandle ch = StaticMethodFCache::alloc(clsName, methName,
getContextName(getCurClass()));
@@ -4416,7 +4416,7 @@ void CodeGenerator::cgLdClsPropAddrCached(IRInstruction* inst) {
SSATmp* propName = inst->src(1);
SSATmp* clsName = inst->src(2);
SSATmp* cxt = inst->src(3);
Block* target = inst->getTaken();
Block* target = inst->taken();
const StringData* propNameString = propName->getValStr();
const StringData* clsNameString = clsName->getValStr();
@@ -4461,7 +4461,7 @@ void CodeGenerator::cgLdClsPropAddr(IRInstruction* inst) {
SSATmp* cls = inst->src(0);
SSATmp* prop = inst->src(1);
SSATmp* cxt = inst->src(2);
Block* target = inst->getTaken();
Block* target = inst->taken();
auto dstReg = m_regs[dst].getReg();
if (dstReg == InvalidReg && target) {
// result is unused but this instruction was not eliminated
@@ -4511,7 +4511,7 @@ void CodeGenerator::cgLdClsCached(IRInstruction* inst) {
void CodeGenerator::cgLdClsCachedSafe(IRInstruction* inst) {
cgLdClsCachedCommon(inst);
if (Block* taken = inst->getTaken()) {
if (Block* taken = inst->taken()) {
emitFwdJcc(CC_Z, taken);
}
}
@@ -4547,7 +4547,7 @@ void CodeGenerator::cgLookupClsCns(IRInstruction* inst) {
SSATmp* cnsName = inst->src(0);
SSATmp* cls = inst->src(1);
assert(inst->getTypeParam() == Type::Cell);
assert(inst->typeParam() == Type::Cell);
assert(cnsName->isConst() && cnsName->type() == Type::StaticStr);
assert(cls->isConst() && cls->type() == Type::StaticStr);
@@ -4603,7 +4603,7 @@ static TypedValue lookupCnsHelper(const TypedValue* tv, StringData* nm) {
void CodeGenerator::cgLookupCns(IRInstruction* inst) {
SSATmp* cnsNameTmp = inst->src(0);
assert(inst->getTypeParam() == Type::Cell);
assert(inst->typeParam() == Type::Cell);
assert(cnsNameTmp->isConst() && cnsNameTmp->type() == Type::StaticStr);
const StringData* cnsName = cnsNameTmp->getValStr();
@@ -4702,7 +4702,7 @@ void CodeGenerator::cgLdGblAddr(IRInstruction* inst) {
cgCallHelper(m_as, (TCA)ldGblAddrHelper, dstReg, kNoSyncPoint,
ArgGroup(m_regs).ssa(inst->src(0)));
m_as.testq(dstReg, dstReg);
emitFwdJcc(CC_Z, inst->getTaken());
emitFwdJcc(CC_Z, inst->taken());
}
void CodeGenerator::cgLdGblAddrDef(IRInstruction* inst) {
@@ -4734,33 +4734,33 @@ void CodeGenerator::emitTestZero(SSATmp* src) {
void CodeGenerator::cgJmpZero(IRInstruction* inst) {
emitTestZero(inst->src(0));
emitFwdJcc(CC_Z, inst->getTaken());
emitFwdJcc(CC_Z, inst->taken());
}
void CodeGenerator::cgJmpNZero(IRInstruction* inst) {
emitTestZero(inst->src(0));
emitFwdJcc(CC_NZ, inst->getTaken());
emitFwdJcc(CC_NZ, inst->taken());
}
void CodeGenerator::cgReqBindJmpZero(IRInstruction* inst) {
// TODO(#2404427): prepareForTestAndSmash?
emitTestZero(inst->src(0));
emitReqBindJcc(CC_Z, inst->getExtra<ReqBindJmpZero>());
emitReqBindJcc(CC_Z, inst->extra<ReqBindJmpZero>());
}
void CodeGenerator::cgReqBindJmpNZero(IRInstruction* inst) {
// TODO(#2404427): prepareForTestAndSmash?
emitTestZero(inst->src(0));
emitReqBindJcc(CC_NZ, inst->getExtra<ReqBindJmpNZero>());
emitReqBindJcc(CC_NZ, inst->extra<ReqBindJmpNZero>());
}
void CodeGenerator::cgJmp_(IRInstruction* inst) {
assert(inst->numSrcs() == inst->getTaken()->getLabel()->numDsts());
assert(inst->numSrcs() == inst->taken()->label()->numDsts());
if (unsigned n = inst->numSrcs()) {
// Parallel-copy sources to the label's destination registers.
// TODO: t2040286: this only works if all destinations fit in registers.
SrcRange srcs = inst->srcs();
DstRange dsts = inst->getTaken()->getLabel()->dsts();
DstRange dsts = inst->taken()->label()->dsts();
ArgGroup args(m_regs);
for (unsigned i = 0, j = 0; i < n; i++) {
assert(srcs[i]->type().subtypeOf(dsts[i].type()));
@@ -4792,7 +4792,7 @@ void CodeGenerator::cgJmp_(IRInstruction* inst) {
shuffleArgs(m_as, args);
}
if (!m_state.noTerminalJmp_) {
emitFwdJmp(m_as, inst->getTaken(), m_state);
emitFwdJmp(m_as, inst->taken(), m_state);
}
}
@@ -4801,7 +4801,7 @@ void CodeGenerator::cgJmpIndirect(IRInstruction* inst) {
}
void CodeGenerator::cgCheckInit(IRInstruction* inst) {
Block* label = inst->getTaken();
Block* label = inst->taken();
assert(label);
SSATmp* src = inst->src(0);
@@ -4816,7 +4816,7 @@ void CodeGenerator::cgCheckInit(IRInstruction* inst) {
}
void CodeGenerator::cgCheckInitMem(IRInstruction* inst) {
Block* label = inst->getTaken();
Block* label = inst->taken();
assert(label);
SSATmp* base = inst->src(0);
int64_t offset = inst->src(1)->getValInt();
@@ -4828,14 +4828,14 @@ void CodeGenerator::cgCheckInitMem(IRInstruction* inst) {
}
void CodeGenerator::cgExitWhenSurprised(IRInstruction* inst) {
Block* label = inst->getTaken();
Block* label = inst->taken();
m_tx64->emitTestSurpriseFlags(m_as);
emitFwdJcc(CC_NZ, label);
}
void CodeGenerator::cgExitOnVarEnv(IRInstruction* inst) {
SSATmp* fp = inst->src(0);
Block* label = inst->getTaken();
Block* label = inst->taken();
assert(!(fp->isConst()));
@@ -4845,7 +4845,7 @@ void CodeGenerator::cgExitOnVarEnv(IRInstruction* inst) {
}
void CodeGenerator::cgReleaseVVOrExit(IRInstruction* inst) {
auto* const label = inst->getTaken();
auto* const label = inst->taken();
auto const rFp = m_regs[inst->src(0)].getReg();
m_as. cmpq (0, rFp[AROFF(m_varEnv)]);
@@ -5024,7 +5024,7 @@ void CodeGenerator::cgContRaiseCheck(IRInstruction* inst) {
SSATmp* cont = inst->src(0);
m_as.test_imm32_disp_reg32(0x1, CONTOFF(m_should_throw),
m_regs[cont].getReg());
emitFwdJcc(CC_NZ, inst->getTaken());
emitFwdJcc(CC_NZ, inst->taken());
}
void CodeGenerator::cgContPreNext(IRInstruction* inst) {
@@ -5035,7 +5035,7 @@ void CodeGenerator::cgContPreNext(IRInstruction* inst) {
"m_done should immediately precede m_running");
// Check m_done and m_running at the same time
m_as.test_imm32_disp_reg32(0x0101, doneOffset, contReg);
emitFwdJcc(CC_NZ, inst->getTaken());
emitFwdJcc(CC_NZ, inst->taken());
// ++m_index
m_as.add_imm64_disp_reg64(0x1, CONTOFF(m_index), contReg);
@@ -5046,7 +5046,7 @@ void CodeGenerator::cgContPreNext(IRInstruction* inst) {
void CodeGenerator::cgContStartedCheck(IRInstruction* inst) {
m_as.cmp_imm64_disp_reg64(0, CONTOFF(m_index),
m_regs[inst->src(0)].getReg());
emitFwdJcc(CC_L, inst->getTaken());
emitFwdJcc(CC_L, inst->taken());
}
void CodeGenerator::cgIterNextK(IRInstruction* inst) {
@@ -5143,7 +5143,7 @@ void traceCallback(ActRec* fp, Cell* sp, int64_t pcOff, void* rip) {
}
void CodeGenerator::cgDbgAssertType(IRInstruction* inst) {
emitTypeTest(inst->getTypeParam(),
emitTypeTest(inst->typeParam(),
m_regs[inst->src(0)].getReg(1),
m_regs[inst->src(0)].getReg(0),
[&](ConditionCode cc) {
@@ -5206,7 +5206,7 @@ void CodeGenerator::cgBlock(Block* block, vector<TransBCMapping>* bcMap) {
for (IRInstruction& instr : *block) {
IRInstruction* inst = &instr;
if (inst->op() == Marker) {
m_state.lastMarker = inst->getExtra<Marker>();
m_state.lastMarker = inst->extra<Marker>();
if (m_tx64 && m_tx64->isTransDBEnabled() && bcMap) {
bcMap->push_back((TransBCMapping){Offset(m_state.lastMarker->bcOff),
m_as.code.frontier,
@@ -5235,8 +5235,8 @@ LiveRegs computeLiveRegs(const IRFactory* factory, const RegAllocInfo& regs,
postorderWalk(
[&](Block* block) {
RegSet& live = liveMap[block];
if (Block* taken = block->getTaken()) live = liveMap[taken];
if (Block* next = block->getNext()) live |= liveMap[next];
if (Block* taken = block->taken()) live = liveMap[taken];
if (Block* next = block->next()) live |= liveMap[next];
for (auto it = block->end(); it != block->begin(); ) {
IRInstruction& inst = *--it;
for (const SSATmp& dst : inst.dsts()) {
@@ -5290,7 +5290,7 @@ void genCodeForTrace(Trace* trace,
// If the block ends with a Jmp_ and the next block is going to be
// its target, we don't need to actually emit it.
IRInstruction* last = block->back();
state.noTerminalJmp_ = last->op() == Jmp_ && nextBlock == last->getTaken();
state.noTerminalJmp_ = last->op() == Jmp_ && nextBlock == last->taken();
CodeGenerator cg(trace, a, astubs, tx64, state);
if (state.asmInfo) {
@@ -5299,7 +5299,7 @@ void genCodeForTrace(Trace* trace,
cg.cgBlock(block, bcMap);
state.lastMarker = nullptr;
if (auto next = block->getNext()) {
if (auto next = block->next()) {
if (next != nextBlock) {
// If there's a fallthrough block and it's not the next thing
// going into this assembler, then emit a jump to it.
hphp/runtime/vm/translator/hopt/dce.cpp
+10 -10
Ver Arquivo
@@ -117,7 +117,7 @@ typedef StateVector<SSATmp, uint32_t> UseCounts;
typedef std::list<const IRInstruction*> WorkList;
void removeDeadInstructions(Trace* trace, const DceState& state) {
auto &blocks = trace->getBlocks();
auto &blocks = trace->blocks();
for (auto it = blocks.begin(), end = blocks.end(); it != end;) {
auto cur = it; ++it;
Block* block = *cur;
@@ -187,7 +187,7 @@ BlockList removeUnreachable(Trace* trace, IRFactory* factory) {
continue;
}
FTRACE(5, "erasing block {}\n", (*bit)->id());
if ((*bit)->getTaken() && (*bit)->back()->op() == Jmp_) {
if ((*bit)->taken() && (*bit)->back()->op() == Jmp_) {
needsReflow = true;
}
bit = t->erase(bit);
@@ -212,7 +212,7 @@ initInstructions(const BlockList& blocks, DceState& state) {
if (inst.isControlFlowInstruction()) {
// mark the destination label so that the destination trace
// is marked reachable
state[inst.getTaken()->getLabel()].setLive();
state[inst.taken()->label()].setLive();
}
if (inst.isEssential()) {
state[inst].setLive();
@@ -374,10 +374,10 @@ void sinkIncRefs(Trace* trace, IRFactory* irFactory, DceState& state) {
toSink.remove(srcInst);
}
}
if (Block* target = inst->getTaken()) {
if (Block* target = inst->taken()) {
if (!pushedTo[target->id()]) {
pushedTo[target->id()] = 1;
Trace* exit = target->getTrace();
Trace* exit = target->trace();
if (exit != trace) processExit(exit);
}
}
@@ -526,7 +526,7 @@ void consumeIncRef(const IRInstruction* consumer, const SSATmp* src,
const IRInstruction* srcInst = src->inst();
visitedSrcs.insert(src);
if (srcInst->op() == CheckType &&
srcInst->getTypeParam().maybeCounted()) {
srcInst->typeParam().maybeCounted()) {
// srcInst is a CheckType that guards to a refcounted type. We need to
// trace through to its source. If the CheckType guards to a non-refcounted
// type then the reference is consumed by CheckType itself.
@@ -537,7 +537,7 @@ void consumeIncRef(const IRInstruction* consumer, const SSATmp* src,
// providing a value for it.
for (unsigned i = 0, n = srcInst->numDsts(); i < n; ++i) {
if (srcInst->dst(i) == src) {
srcInst->getBlock()->forEachSrc(i,
srcInst->block()->forEachSrc(i,
[&](IRInstruction* jmp, SSATmp* val) {
consumeIncRef(consumer, val, state, ssas, visitedSrcs);
}
@@ -559,7 +559,7 @@ void consumeIncRef(const IRInstruction* consumer, const SSATmp* src,
if (srcInst->op() == IncRef) {
// <inst> consumes <srcInst> which is an IncRef, so we mark <srcInst> as
// REFCOUNT_CONSUMED.
if (consumer->getTrace()->isMain() || !srcInst->getTrace()->isMain()) {
if (consumer->trace()->isMain() || !srcInst->trace()->isMain()) {
// <srcInst> is consumed from its own trace.
state[srcInst].setCountConsumed();
} else {
@@ -579,7 +579,7 @@ void consumeIncRef(const IRInstruction* consumer, const SSATmp* src,
// Publicly exported functions:
void removeDeadInstructions(Trace* trace, const boost::dynamic_bitset<>& live) {
auto &blocks = trace->getBlocks();
auto &blocks = trace->blocks();
for (auto it = blocks.begin(), end = blocks.end(); it != end;) {
auto cur = it; ++it;
Block* block = *cur;
@@ -594,7 +594,7 @@ void removeDeadInstructions(Trace* trace, const boost::dynamic_bitset<>& live) {
void eliminateDeadCode(Trace* trace, IRFactory* irFactory) {
auto removeEmptyExitTraces = [&] {
trace->getExitTraces().remove_if([](Trace* exit) {
return exit->getBlocks().empty();
return exit->blocks().empty();
});
};
hphp/runtime/vm/translator/hopt/extradata.h
+2 -2
Ver Arquivo
@@ -312,7 +312,7 @@ X(SideExitGuardStk, SideExitGuardData);
template<bool hasExtra, Opcode opc, class T> struct AssertExtraTypes {
static void doassert() {
assert(!"called getExtra on an opcode without extra data");
assert(!"called extra on an opcode without extra data");
}
};
@@ -320,7 +320,7 @@ template<Opcode opc, class T> struct AssertExtraTypes<true,opc,T> {
static void doassert() {
typedef typename IRExtraDataType<opc>::type ExtraType;
if (!std::is_same<ExtraType,T>::value) {
assert(!"getExtra<T> was called with an extra data "
assert(!"extra<T> was called with an extra data "
"type that doesn't match the opcode type");
}
}
hphp/runtime/vm/translator/hopt/hhbctranslator.cpp
+3 -3
Ver Arquivo
@@ -2090,7 +2090,7 @@ SSATmp* HhbcTranslator::emitDecRefLocalsInline(SSATmp* retVal) {
* matter. This will need to be revisted then.
*/
int retValLocId = (!isInlining() && retValSrcLoc && retValSrcOpc == LdLoc) ?
retValSrcLoc->inst()->getExtra<LocalId>()->locId : -1;
retValSrcLoc->inst()->extra<LocalId>()->locId : -1;
for (int id = getCurFunc()->numLocals() - 1; id >= 0; --id) {
if (retValLocId == id) {
gen(DecRef, retVal);
@@ -2700,7 +2700,7 @@ void HhbcTranslator::emitBindMem(SSATmp* ptr, SSATmp* src) {
pushIncRef(src);
gen(StMem, ptr, cns(0), src);
if (isRefCounted(src) && src->type().canRunDtor()) {
Block* exitBlock = getExitTrace(getNextSrcKey().offset())->front();
Block* exitBlock = getExitTrace(nextSrcKey().offset())->front();
Block::iterator markerInst = exitBlock->skipLabel();
exitBlock->insert(++markerInst, m_irFactory.gen(DecRef, prevValue));
gen(DecRefNZOrBranch, exitBlock, prevValue);
@@ -2955,7 +2955,7 @@ void HhbcTranslator::emitMod() {
// will raise a notice and produce the boolean false. Punch out
// here and resume after the Mod instruction; this should be rare.
auto const exit = getExitTraceWarn(
getNextSrcKey().offset(),
nextSrcKey().offset(),
exitSpillValues,
StringData::GetStaticString(Strings::DIVISION_BY_ZERO)
);
hphp/runtime/vm/translator/hopt/hhbctranslator.h
+3 -3
Ver Arquivo
@@ -107,8 +107,8 @@ struct HhbcTranslator {
const Func* func);
// Accessors.
Trace* getTrace() const { return m_tb->getTrace(); }
TraceBuilder* getTraceBuilder() const { return m_tb.get(); }
Trace* trace() const { return m_tb->trace(); }
TraceBuilder* traceBuilder() const { return m_tb.get(); }
// In between each emit* call, irtranslator indicates the new
// bytecode offset (or whether we're finished) using this API.
@@ -591,7 +591,7 @@ private:
* Return the SrcKey for the next HHBC (whether it is in this
* tracelet or not).
*/
SrcKey getNextSrcKey() const {
SrcKey nextSrcKey() const {
SrcKey srcKey(getCurFunc(), bcOff());
srcKey.advance(getCurFunc()->unit());
return srcKey;
hphp/runtime/vm/translator/hopt/ir.cpp
+38 -38
Ver Arquivo
@@ -303,7 +303,7 @@ IRInstruction::IRInstruction(Arena& arena, const IRInstruction* inst, Id id)
: nullptr)
{
std::copy(inst->m_srcs, inst->m_srcs + inst->m_numSrcs, m_srcs);
setTaken(inst->getTaken());
setTaken(inst->taken());
}
const char* opcodeName(Opcode opcode) { return OpInfo[opcode].name; }
@@ -319,8 +319,8 @@ Opcode getStackModifyingOpcode(Opcode opc) {
return opc;
}
Trace* IRInstruction::getTrace() const {
return getBlock()->getTrace();
Trace* IRInstruction::trace() const {
return block()->trace();
}
bool IRInstruction::hasExtra() const {
@@ -378,7 +378,7 @@ bool IRInstruction::consumesReference(int srcNo) const {
// to a notCounted type.
if (m_op == CheckType) {
assert(srcNo == 0);
return src(0)->type().maybeCounted() && getTypeParam().notCounted();
return src(0)->type().maybeCounted() && typeParam().notCounted();
}
// SpillStack consumes inputs 2 and onward
if (m_op == SpillStack) return srcNo >= 2;
@@ -811,14 +811,14 @@ void IRInstruction::convertToNop() {
void IRInstruction::convertToJmp() {
assert(isControlFlowInstruction());
assert(getBlock()->back() == this);
assert(block()->back() == this);
m_op = Jmp_;
m_typeParam = Type::None;
m_numSrcs = 0;
m_numDsts = 0;
m_srcs = nullptr;
m_dst = nullptr;
getBlock()->setNext(nullptr);
block()->setNext(nullptr);
}
void IRInstruction::convertToMov() {
@@ -841,7 +841,7 @@ void IRInstruction::become(IRFactory* factory, IRInstruction* other) {
m_extra = other->m_extra ? cloneExtra(m_op, other->m_extra, arena) : nullptr;
m_srcs = new (arena) SSATmp*[m_numSrcs];
std::copy(other->m_srcs, other->m_srcs + m_numSrcs, m_srcs);
setTaken(other->getTaken());
setTaken(other->taken());
}
IRInstruction* IRInstruction::clone(IRFactory* factory) const {
@@ -867,7 +867,7 @@ bool Block::isMain() const {
}
bool Block::isExit() const {
return !getTaken() && !getNext();
return !taken() && !next();
}
bool IRInstruction::cseEquals(IRInstruction* inst) const {
@@ -947,83 +947,83 @@ int SSATmp::numNeededRegs() const {
bool SSATmp::getValBool() const {
assert(isConst());
assert(m_inst->getTypeParam().equals(Type::Bool));
return m_inst->getExtra<ConstData>()->as<bool>();
assert(m_inst->typeParam().equals(Type::Bool));
return m_inst->extra<ConstData>()->as<bool>();
}
int64_t SSATmp::getValInt() const {
assert(isConst());
assert(m_inst->getTypeParam().equals(Type::Int));
return m_inst->getExtra<ConstData>()->as<int64_t>();
assert(m_inst->typeParam().equals(Type::Int));
return m_inst->extra<ConstData>()->as<int64_t>();
}
int64_t SSATmp::getValRawInt() const {
assert(isConst());
return m_inst->getExtra<ConstData>()->as<int64_t>();
return m_inst->extra<ConstData>()->as<int64_t>();
}
double SSATmp::getValDbl() const {
assert(isConst());
assert(m_inst->getTypeParam().equals(Type::Dbl));
return m_inst->getExtra<ConstData>()->as<double>();
assert(m_inst->typeParam().equals(Type::Dbl));
return m_inst->extra<ConstData>()->as<double>();
}
const StringData* SSATmp::getValStr() const {
assert(isConst());
assert(m_inst->getTypeParam().equals(Type::StaticStr));
return m_inst->getExtra<ConstData>()->as<const StringData*>();
assert(m_inst->typeParam().equals(Type::StaticStr));
return m_inst->extra<ConstData>()->as<const StringData*>();
}
const ArrayData* SSATmp::getValArr() const {
assert(isConst());
// TODO: Task #2124292, Reintroduce StaticArr
assert(m_inst->getTypeParam().subtypeOf(Type::Arr));
return m_inst->getExtra<ConstData>()->as<const ArrayData*>();
assert(m_inst->typeParam().subtypeOf(Type::Arr));
return m_inst->extra<ConstData>()->as<const ArrayData*>();
}
const Func* SSATmp::getValFunc() const {
assert(isConst());
assert(m_inst->getTypeParam().equals(Type::Func));
return m_inst->getExtra<ConstData>()->as<const Func*>();
assert(m_inst->typeParam().equals(Type::Func));
return m_inst->extra<ConstData>()->as<const Func*>();
}
const Class* SSATmp::getValClass() const {
assert(isConst());
assert(m_inst->getTypeParam().equals(Type::Cls));
return m_inst->getExtra<ConstData>()->as<const Class*>();
assert(m_inst->typeParam().equals(Type::Cls));
return m_inst->extra<ConstData>()->as<const Class*>();
}
const NamedEntity* SSATmp::getValNamedEntity() const {
assert(isConst());
assert(m_inst->getTypeParam().equals(Type::NamedEntity));
return m_inst->getExtra<ConstData>()->as<const NamedEntity*>();
assert(m_inst->typeParam().equals(Type::NamedEntity));
return m_inst->extra<ConstData>()->as<const NamedEntity*>();
}
uintptr_t SSATmp::getValBits() const {
assert(isConst());
return m_inst->getExtra<ConstData>()->as<uintptr_t>();
return m_inst->extra<ConstData>()->as<uintptr_t>();
}
Variant SSATmp::getValVariant() const {
switch (m_inst->getTypeParam().toDataType()) {
switch (m_inst->typeParam().toDataType()) {
case KindOfUninit:
case KindOfNull:
return uninit_null();
case KindOfBoolean:
return m_inst->getExtra<ConstData>()->as<bool>();
return m_inst->extra<ConstData>()->as<bool>();
case KindOfInt64:
return m_inst->getExtra<ConstData>()->as<int64_t>();
return m_inst->extra<ConstData>()->as<int64_t>();
case KindOfDouble:
return m_inst->getExtra<ConstData>()->as<double>();
return m_inst->extra<ConstData>()->as<double>();
case KindOfString:
case KindOfStaticString:
return (litstr)m_inst->getExtra<ConstData>()
return (litstr)m_inst->extra<ConstData>()
->as<const StringData*>()->data();
case KindOfArray:
return Array(ArrayData::GetScalarArray(m_inst->getExtra<ConstData>()
return Array(ArrayData::GetScalarArray(m_inst->extra<ConstData>()
->as<ArrayData*>()));
case KindOfObject:
return m_inst->getExtra<ConstData>()->as<const Object*>();
return m_inst->extra<ConstData>()->as<const Object*>();
default:
assert(false);
return uninit_null();
@@ -1032,8 +1032,8 @@ Variant SSATmp::getValVariant() const {
TCA SSATmp::getValTCA() const {
assert(isConst());
assert(m_inst->getTypeParam().equals(Type::TCA));
return m_inst->getExtra<ConstData>()->as<TCA>();
assert(m_inst->typeParam().equals(Type::TCA));
return m_inst->extra<ConstData>()->as<TCA>();
}
std::string SSATmp::toString() const {
@@ -1165,9 +1165,9 @@ DomChildren findDomChildren(const BlockList& blocks) {
}
bool hasInternalFlow(Trace* trace) {
for (Block* block : trace->getBlocks()) {
if (Block* taken = block->getTaken()) {
if (taken->getTrace() == trace) return true;
for (Block* block : trace->blocks()) {
if (Block* taken = block->taken()) {
if (taken->trace() == trace) return true;
}
}
return false;
hphp/runtime/vm/translator/hopt/irinstruction.h
+10 -10
Ver Arquivo
@@ -79,15 +79,15 @@ struct IRInstruction {
* Pre: op() == opc
*/
template<Opcode opc>
const typename IRExtraDataType<opc>::type* getExtra() const {
assert(opc == op() && "getExtra type error");
const typename IRExtraDataType<opc>::type* extra() const {
assert(opc == op() && "ExtraData type error");
assert(m_extra != nullptr);
return static_cast<typename IRExtraDataType<opc>::type*>(m_extra);
}
template<Opcode opc>
typename IRExtraDataType<opc>::type* getExtra() {
assert(opc == op() && "getExtra type error");
typename IRExtraDataType<opc>::type* extra() {
assert(opc == op() && "ExtraData type error");
return static_cast<typename IRExtraDataType<opc>::type*>(m_extra);
}
@@ -100,7 +100,7 @@ struct IRInstruction {
* that is supposed to be able to handle multiple opcode types that
* share the same kind of extra data.
*/
template<class T> const T* getExtra() const {
template<class T> const T* extra() const {
auto opcode = op();
if (debug) assert_opcode_extra<T>(opcode);
return static_cast<const T*>(m_extra);
@@ -172,7 +172,7 @@ struct IRInstruction {
Opcode op() const { return m_op; }
void setOpcode(Opcode newOpc) { m_op = newOpc; }
Type getTypeParam() const { return m_typeParam; }
Type typeParam() const { return m_typeParam; }
void setTypeParam(Type t) { m_typeParam = t; }
uint32_t numSrcs() const { return m_numSrcs; }
void setNumSrcs(uint32_t i) {
@@ -223,21 +223,21 @@ struct IRInstruction {
* inserting it in any blocks.
*/
bool isTransient() const { return m_id == kTransient; }
Trace* getTrace() const;
Trace* trace() const;
/*
* getBlock() and setBlock() keep track of the block that contains this
* block() and setBlock() keep track of the block that contains this
* instruction, as well as where the taken edge is coming from, if there
* is a taken edge.
*/
Block* getBlock() const { return m_taken.from(); }
Block* block() const { return m_taken.from(); }
void setBlock(Block* b) { m_taken.setFrom(b); }
/*
* Optional control flow edge. If present, this instruction must
* be the last one in the block.
*/
Block* getTaken() const { return m_taken.to(); }
Block* taken() const { return m_taken.to(); }
void setTaken(Block* b) {
if (isTransient()) m_taken.setTransientTo(b);
else m_taken.setTo(b);
hphp/runtime/vm/translator/hopt/irtranslator.cpp
+3 -3
Ver Arquivo
@@ -1869,7 +1869,7 @@ TranslatorX64::irTranslateTracelet(Tracelet& t,
StackTraceNoHeap::AddExtraLogging(
"Assertion failure",
folly::format("{}\n\nActive Trace:\n{}\n",
fa.summary, m_hhbcTrans->getTrace()->toString()).str());
fa.summary, m_hhbcTrans->trace()->toString()).str());
abort();
} catch (const std::exception& e) {
transResult = Failure;
@@ -1921,7 +1921,7 @@ void TranslatorX64::hhirTraceEnd() {
void TranslatorX64::hhirTraceCodeGen(vector<TransBCMapping>* bcMap) {
using namespace JIT;
HPHP::JIT::Trace* trace = m_hhbcTrans->getTrace();
HPHP::JIT::Trace* trace = m_hhbcTrans->trace();
auto finishPass = [&](const char* msg, int level,
const RegAllocInfo* regs = nullptr,
const LifetimeInfo* lifetime = nullptr) {
@@ -1930,7 +1930,7 @@ void TranslatorX64::hhirTraceCodeGen(vector<TransBCMapping>* bcMap) {
};
finishPass(" after initial translation ", kIRLevel);
optimizeTrace(trace, m_hhbcTrans->getTraceBuilder());
optimizeTrace(trace, m_hhbcTrans->traceBuilder());
finishPass(" after optimizing ", kOptLevel);
auto* factory = m_irFactory.get();
hphp/runtime/vm/translator/hopt/jumpopts.cpp
+16 -16
Ver Arquivo
@@ -36,14 +36,14 @@ namespace {
void elimUnconditionalJump(Trace* trace, IRFactory* irFactory) {
boost::dynamic_bitset<> isJoin(irFactory->numBlocks());
boost::dynamic_bitset<> havePred(irFactory->numBlocks());
for (Block* block : trace->getBlocks()) {
if (block->getTaken()) {
auto id = block->getTaken()->id();
for (Block* block : trace->blocks()) {
if (block->taken()) {
auto id = block->taken()->id();
isJoin[id] = havePred[id];
havePred[id] = 1;
}
if (block->getNext()) {
auto id = block->getNext()->id();
if (block->next()) {
auto id = block->next()->id();
isJoin[id] = havePred[id];
havePred[id] = 1;
}
@@ -51,8 +51,8 @@ void elimUnconditionalJump(Trace* trace, IRFactory* irFactory) {
Block* lastBlock = trace->back();
auto lastInst = lastBlock->backIter(); // iterator to last instruction
IRInstruction& jmp = *lastInst;
if (jmp.op() == Jmp_ && !isJoin[jmp.getTaken()->id()]) {
Block* target = jmp.getTaken();
if (jmp.op() == Jmp_ && !isJoin[jmp.taken()->id()]) {
Block* target = jmp.taken();
lastBlock->splice(lastInst, target, target->skipLabel(), target->end());
lastBlock->erase(lastInst); // delete the jmp
}
@@ -152,14 +152,14 @@ void optimizeCondTraceExit(Trace* trace, IRFactory* irFactory) {
opcodeName(jccBlock->back()->op()));
auto const jccInst = jccBlock->back();
auto const jccExitTrace = jccInst->getTaken();
auto const jccExitTrace = jccInst->taken();
if (!isNormalExit(jccExitTrace)) return;
FTRACE(5, "exit trace is side-effect free\n");
auto const newOpcode = jmpToReqBindJmp(jccBlock->back()->op());
ReqBindJccData data;
data.taken = jccExitTrace->back()->getExtra<ReqBindJmp>()->offset;
data.notTaken = mainExit->back()->getExtra<ReqBindJmp>()->offset;
data.taken = jccExitTrace->back()->extra<ReqBindJmp>()->offset;
data.notTaken = mainExit->back()->extra<ReqBindJmp>()->offset;
FTRACE(5, "replacing {} with {}\n", jccInst->id(), opcodeName(newOpcode));
irFactory->replace(
@@ -183,7 +183,7 @@ void optimizeSideExits(Trace* trace, IRFactory* irFactory) {
forEachInst(trace, [&] (IRInstruction* inst) {
if (inst->op() != CheckStk && inst->op() != CheckLoc) return;
auto const exitBlock = inst->getTaken();
auto const exitBlock = inst->taken();
if (!isNormalExit(exitBlock)) return;
auto const syncABI = &*boost::prior(exitBlock->backIter());
@@ -198,18 +198,18 @@ void optimizeSideExits(Trace* trace, IRFactory* irFactory) {
SideExitGuardData data;
data.checkedSlot = isStack
? inst->getExtra<CheckStk>()->offset
: inst->getExtra<CheckLoc>()->locId;
data.taken = exitBlock->back()->getExtra<ReqBindJmp>()->offset;
? inst->extra<CheckStk>()->offset
: inst->extra<CheckLoc>()->locId;
data.taken = exitBlock->back()->extra<ReqBindJmp>()->offset;
auto const block = inst->getBlock();
auto const block = inst->block();
block->insert(block->iteratorTo(inst),
irFactory->cloneInstruction(syncABI));
irFactory->replace(
inst,
isStack ? SideExitGuardStk : SideExitGuardLoc,
inst->getTypeParam(),
inst->typeParam(),
data,
isStack ? sp : fp
);
hphp/runtime/vm/translator/hopt/layout.cpp
+4 -4
Ver Arquivo
@@ -32,8 +32,8 @@ void postorderWalk(smart::vector<Block*>& out,
Block* block) {
if (visited[block]) return;
visited[block] = true;
if (auto t = block->getTaken()) postorderWalk(out, visited, t);
if (auto n = block->getNext()) postorderWalk(out, visited, n);
if (auto t = block->taken()) postorderWalk(out, visited, t);
if (auto n = block->next()) postorderWalk(out, visited, n);
out.push_back(block);
}
@@ -57,7 +57,7 @@ smart::vector<Block*> rpoForCodegen(const IRFactory& factory, Block* head) {
*/
LayoutInfo layoutBlocks(Trace* trace, const IRFactory& irFactory) {
LayoutInfo ret;
ret.blocks = rpoForCodegen(irFactory, trace->getBlocks().front());
ret.blocks = rpoForCodegen(irFactory, trace->blocks().front());
// Optionally stress test by randomizing the positions.
if (RuntimeOption::EvalHHIRStressCodegenBlocks) {
@@ -71,7 +71,7 @@ LayoutInfo layoutBlocks(Trace* trace, const IRFactory& irFactory) {
ret.astubsIt = std::stable_partition(
ret.blocks.begin(), ret.blocks.end(),
[&] (Block* b) {
return b->isMain() && b->getHint() != Block::Unlikely;
return b->isMain() && b->hint() != Block::Unlikely;
}
);
hphp/runtime/vm/translator/hopt/linearscan.cpp
+44 -44
Ver Arquivo
@@ -156,8 +156,8 @@ private:
RegNumber getJmpPreColor(SSATmp* tmp, uint32_t regIndx, bool isReload);
void computePreColoringHint();
void findFullXMMCandidates();
IRInstruction* getNextNative() const;
uint32_t getNextNativeId() const;
IRInstruction* nextNative() const;
uint32_t nextNativeId() const;
void pushFreeReg(RegState* reg);
RegState* popFreeReg(smart::list<RegState*>& freeList);
@@ -397,7 +397,7 @@ void LinearScan::allocRegToInstruction(InstructionList::iterator it) {
// Insert the Reload instruction.
SSATmp* spillTmp = m_slots[slotId].spillTmp;
IRInstruction* reload = m_irFactory->gen(Reload, spillTmp);
inst->getBlock()->insert(it, reload);
inst->block()->insert(it, reload);
// Create <reloadTmp> which inherits <tmp>'s slot ID and
// <spillTmp>'s last use ID.
@@ -420,7 +420,7 @@ void LinearScan::allocRegToInstruction(InstructionList::iterator it) {
freeRegsAtId(m_linear[inst]);
// Update next native.
if (getNextNative() == inst) {
if (nextNative() == inst) {
assert(!m_natives.empty());
m_natives.pop_front();
computePreColoringHint();
@@ -498,7 +498,7 @@ void LinearScan::allocRegToInstruction(InstructionList::iterator it) {
}
bool LinearScan::crossNativeCall(const SSATmp* tmp) const {
return m_uses[tmp].lastUse > getNextNativeId();
return m_uses[tmp].lastUse > nextNativeId();
}
/*
@@ -574,7 +574,7 @@ int LinearScan::allocRegToTmp(SSATmp* ssaTmp, uint32_t index) {
if (m_spillSlots[ssaTmp] == -1) {
createSpillSlot(ssaTmp);
}
m_uses[ssaTmp].lastUse = getNextNativeId();
m_uses[ssaTmp].lastUse = nextNativeId();
}
assignRegToTmp(reg, ssaTmp, index);
@@ -661,7 +661,7 @@ uint32_t LinearScan::assignSpillLoc() {
spillLocManager.setNextSpillLoc(it->second);
}
for (IRInstruction& inst : *block) {
if (getNextNative() == &inst) {
if (nextNative() == &inst) {
assert(!m_natives.empty());
m_natives.pop_front();
}
@@ -706,9 +706,9 @@ uint32_t LinearScan::assignSpillLoc() {
}
uint32_t totalSpillLocs = spillLocManager.getNumSpillLocs();
if (totalSpillLocs > maxSpillLoc) maxSpillLoc = totalSpillLocs;
if (block->getTrace()->isMain()) {
if (Block* taken = block->getTaken()) {
if (!taken->getTrace()->isMain()) {
if (block->trace()->isMain()) {
if (Block* taken = block->taken()) {
if (!taken->trace()->isMain()) {
exitLocMap[taken] = totalSpillLocs;
}
}
@@ -724,10 +724,10 @@ void LinearScan::collectInfo(BlockList::iterator it, Trace* trace) {
while (it != m_blocks.end()) {
Block* block = *it++;
bool offTrace = block->getTrace() != trace;
bool offTrace = block->trace() != trace;
if (offTrace) {
if (!trace->isMain()) return;
int lastId = block->getTrace()->getData();
int lastId = block->trace()->getData();
for (IRInstruction& inst : *block) {
for (auto* src : inst.srcs()) {
if (lastId > m_uses[src].lastUse) {
@@ -755,7 +755,7 @@ void LinearScan::collectInfo(BlockList::iterator it, Trace* trace) {
void LinearScan::computePreColoringHint() {
m_preColoringHint.clear();
IRInstruction* inst = getNextNative();
IRInstruction* inst = nextNative();
if (inst == nullptr) {
return;
}
@@ -874,9 +874,9 @@ void LinearScan::computePreColoringHint() {
static RegNumber findLabelSrcReg(const RegAllocInfo& regs, IRInstruction* label,
unsigned dstIdx, uint32_t regIndex) {
assert(label->op() == DefLabel);
SSATmp* withReg = label->getBlock()->findSrc(dstIdx, [&](SSATmp* src) {
SSATmp* withReg = label->block()->findSrc(dstIdx, [&](SSATmp* src) {
return regs[src].getReg(regIndex) != InvalidReg &&
src->inst()->getBlock()->getHint() != Block::Unlikely;
src->inst()->block()->hint() != Block::Unlikely;
});
return withReg ? regs[withReg].getReg(regIndex) : reg::noreg;
}
@@ -912,7 +912,7 @@ RegNumber LinearScan::getJmpPreColor(SSATmp* tmp, uint32_t regIndex,
// block is unreachable.
const DEBUG_ONLY bool unreachable =
std::find(m_blocks.begin(), m_blocks.end(),
srcInst->getBlock()) == m_blocks.end();
srcInst->block()) == m_blocks.end();
always_assert(reg != reg::noreg || unreachable);
return reg;
}
@@ -925,7 +925,7 @@ RegNumber LinearScan::getJmpPreColor(SSATmp* tmp, uint32_t regIndex,
// same procedure as above.
for (unsigned ji = 0, jn = jmps.size(); ji < jn; ++ji) {
IRInstruction* jmp = jmps[ji];
IRInstruction* label = jmp->getTaken()->front();
IRInstruction* label = jmp->taken()->front();
// Figure out which src of the Jmp_ is tmp
for (unsigned si = 0, sn = jmp->numSrcs(); si < sn; ++si) {
@@ -984,10 +984,10 @@ void LinearScan::numberInstructions(const BlockList& blocks) {
m_uses[tmp].count++;
}
}
if (block->getTaken() && block->isMain() && !block->getTaken()->isMain()) {
if (block->taken() && block->isMain() && !block->taken()->isMain()) {
// reserve a spot for the lastUseId when we're processing the main
// trace, if the last use is really in an exit trace.
block->getTaken()->getTrace()->setData(nextId++);
block->taken()->trace()->setData(nextId++);
}
}
}
@@ -1005,13 +1005,13 @@ void LinearScan::genSpillStats(Trace* trace, int numSpillLocs) {
m_blocks,
[&](IRInstruction* inst) {
if (inst->op() == Spill) {
if (inst->getBlock()->isMain()) {
if (inst->block()->isMain()) {
numMainSpills++;
} else {
numExitSpills++;
}
} else if (inst->op() == Reload) {
if (inst->getBlock()->isMain()) {
if (inst->block()->isMain()) {
numMainReloads++;
} else {
numExitReloads++;
@@ -1123,7 +1123,7 @@ RegAllocInfo LinearScan::allocRegs(Trace* trace, LifetimeInfo* lifetime) {
void LinearScan::allocRegsOneTrace(BlockList::iterator& blockIt,
ExitTraceMap& etm) {
auto const trace = (*blockIt)->getTrace();
auto const trace = (*blockIt)->trace();
collectInfo(blockIt, trace);
computePreColoringHint();
@@ -1143,7 +1143,7 @@ void LinearScan::allocRegsOneTrace(BlockList::iterator& blockIt,
size_t sz = m_slots.size();
while (blockIt != m_blocks.end()) {
Block* block = *blockIt;
if (block->getTrace() != trace) {
if (block->trace() != trace) {
if (!isMain) {
break;
} else {
@@ -1158,7 +1158,7 @@ void LinearScan::allocRegsOneTrace(BlockList::iterator& blockIt,
// clear remembered reloads that don't dominate this block
for (SlotInfo& slot : m_slots) {
if (SSATmp* reload = slot.latestReload) {
if (!dominates(reload->inst()->getBlock(), block, m_idoms)) {
if (!dominates(reload->inst()->block(), block, m_idoms)) {
slot.latestReload = nullptr;
}
}
@@ -1168,10 +1168,10 @@ void LinearScan::allocRegsOneTrace(BlockList::iterator& blockIt,
dumpIR<IRInstruction, kExtraLevel>(&*it, "allocated to instruction ");
}
if (isMain) {
assert(block->getTrace()->isMain());
if (block->getTaken() &&
!block->getTaken()->getTrace()->isMain()) {
etm[block->getTaken()].save(this);
assert(block->trace()->isMain());
if (block->taken() &&
!block->taken()->trace()->isMain()) {
etm[block->taken()].save(this);
}
}
++blockIt;
@@ -1192,18 +1192,18 @@ void LinearScan::allocRegsOneTrace(BlockList::iterator& blockIt,
SlotInfo& slot = m_slots[begin++];
IRInstruction* spill = slot.spillTmp->inst();
IRInstruction* inst = spill->src(0)->inst();
Block* block = inst->getBlock();
if (!isMain && block->getTrace()->isMain()) {
Block* block = inst->block();
if (!isMain && block->trace()->isMain()) {
// We're on an exit trace, but the def is on the
// main trace, so put it at the start of this trace
if (spill->getBlock()) {
if (spill->block()) {
// its already been inserted in another exit trace
assert(!spill->getBlock()->getTrace()->isMain());
assert(!spill->block()->trace()->isMain());
spill = spill->clone(m_irFactory);
}
block->getTrace()->front()->prepend(spill);
block->trace()->front()->prepend(spill);
} else if (inst->isBlockEnd()) {
block->getNext()->prepend(spill);
block->next()->prepend(spill);
} else {
auto pos = block->iteratorTo(inst);
if (inst->op() == DefLabel) {
@@ -1248,7 +1248,7 @@ void LinearScan::allocRegsToTrace() {
void LinearScan::rematerialize() {
numberInstructions(m_blocks);
dumpTrace(kExtraLevel, m_blocks.front()->getTrace(),
dumpTrace(kExtraLevel, m_blocks.front()->trace(),
" before rematerialization ", &m_allocInfo, &m_lifetime);
rematerializeAux();
numberInstructions(m_blocks);
@@ -1378,7 +1378,7 @@ void LinearScan::rematerializeAux() {
newInst->setDst(dst);
dst->setInstruction(newInst);
assert(outputType(newInst) == oldType);
auto* block = inst.getBlock();
auto* block = inst.block();
auto newIt = block->insert(it, newInst);
block->erase(it);
it = newIt;
@@ -1392,7 +1392,7 @@ void LinearScan::rematerializeAux() {
}
if (opc == LdLoc || opc == StLoc || opc == StLocNT) {
setLocal(inst.getExtra<LocalId>()->locId,
setLocal(inst.extra<LocalId>()->locId,
opc == LdLoc ? inst.dst() : inst.src(1));
}
// Other instructions that may have side effects on locals must
@@ -1409,8 +1409,8 @@ void LinearScan::rematerializeAux() {
killLocal(inst, 3);
}
}
if (Block* taken = block->getTaken()) saveState(taken);
if (Block* next = block->getNext()) saveState(next);
if (Block* taken = block->taken()) saveState(taken);
if (Block* next = block->next()) saveState(next);
}
}
@@ -1418,7 +1418,7 @@ void LinearScan::removeUnusedSpills() {
for (SlotInfo& slot : m_slots) {
IRInstruction* spill = slot.spillTmp->inst();
if (m_uses[spill->dst()].count == 0) {
Block* block = spill->getBlock();
Block* block = spill->block();
block->erase(block->iteratorTo(spill));
SSATmp* src = spill->src(0);
auto uses = m_uses[src].count - 1;
@@ -1593,13 +1593,13 @@ uint32_t LinearScan::createSpillSlot(SSATmp* tmp) {
return slotId;
}
IRInstruction* LinearScan::getNextNative() const {
IRInstruction* LinearScan::nextNative() const {
return m_natives.empty() ? nullptr : m_natives.front();
}
uint32_t LinearScan::getNextNativeId() const {
IRInstruction* nextNative = getNextNative();
return nextNative ? m_linear[nextNative] : -1;
uint32_t LinearScan::nextNativeId() const {
IRInstruction* next = nextNative();
return next ? m_linear[next] : -1;
}
SSATmp* LinearScan::getSpilledTmp(SSATmp* tmp) {
hphp/runtime/vm/translator/hopt/memelim.cpp
+9 -9
Ver Arquivo
@@ -419,7 +419,7 @@ void MemMap::processInstruction(IRInstruction* inst, bool isPseudoMain) {
// access info for any refs that may alias
case LdLoc: {
auto id = inst->getExtra<LdLoc>()->locId;
auto id = inst->extra<LdLoc>()->locId;
// locals never alias, so no access info needs to be killed
if (m_locs.count(id) > 0) {
@@ -497,7 +497,7 @@ void MemMap::processInstruction(IRInstruction* inst, bool isPseudoMain) {
case StLoc:
case StLocNT: {
storeLocal(inst->getExtra<LocalId>()->locId, inst->src(1));
storeLocal(inst->extra<LocalId>()->locId, inst->src(1));
break;
}
case StRef:
@@ -675,10 +675,10 @@ void MemMap::optimizeMemoryAccesses(Trace* trace) {
const Func* curFunc = nullptr;
for (Block* block : trace->getBlocks()) {
for (Block* block : trace->blocks()) {
for (IRInstruction& inst : *block) {
if (inst.op() == Marker) {
curFunc = inst.getExtra<Marker>()->func;
curFunc = inst.extra<Marker>()->func;
}
// initialize each instruction as live
setLive(inst, true);
@@ -702,7 +702,7 @@ void MemMap::optimizeMemoryAccesses(Trace* trace) {
// if we see a store, first check if its last available access is a store
// if it is, then the last access is a dead store
auto access = inst.op() == StLoc || inst.op() == StLocNT
? lastLocalAccess(inst.getExtra<LocalId>()->locId)
? lastLocalAccess(inst.extra<LocalId>()->locId)
: getLastAccess(inst.src(0), offset);
if (access && isStore(access->op())) {
// if a dead St* is followed by a St*NT, then the second store needs to
@@ -737,7 +737,7 @@ void MemMap::optimizeMemoryAccesses(Trace* trace) {
// if the current instruction is guarded, make sure all of our stores that
// are not yet dead know about it
if (inst.getTaken()) {
if (inst.taken()) {
for (auto& entry : tracking) {
if (isLive(entry.first)) {
entry.second.push_back(&inst);
@@ -759,7 +759,7 @@ void MemMap::optimizeLoad(IRInstruction* inst, int offset) {
// check if we still know the value at this memory location. if we do,
// then replace the load with a Mov
auto value = inst->op() == LdLoc
? getLocalValue(inst->getExtra<LocalId>()->locId)
? getLocalValue(inst->extra<LocalId>()->locId)
: getValue(inst->src(0), offset);
if (value == nullptr) {
return;
@@ -769,7 +769,7 @@ void MemMap::optimizeLoad(IRInstruction* inst, int offset) {
Type valTy = value->type();
// check for loads that have a guard that will definitely fail
if (inst->getTaken() && instTy.not(valTy)) {
if (inst->taken() && instTy.not(valTy)) {
return inst->convertToJmp();
}
@@ -799,7 +799,7 @@ void MemMap::sinkStores(StoreList& stores) {
if (isLive(store)) continue;
for (IRInstruction* guard : it->second) {
Block* exit = guard->getTaken();
Block* exit = guard->taken();
exit->prepend(store->clone(m_factory));
}
hphp/runtime/vm/translator/hopt/mutation.cpp
+2 -2
Ver Arquivo
@@ -77,7 +77,7 @@ void moveToBlock(Block::iterator const first,
Block* const target) {
if (first == last) return;
auto const srcBlock = first->getBlock();
auto const srcBlock = first->block();
auto targetIt = target->skipLabel();
for (auto it = first; it != last;) {
@@ -106,7 +106,7 @@ void reflowTypes(Block* const changed, const BlockList& blocks) {
*/
if (inst->op() == DefLabel) {
Type type = Type::Bottom;
inst->getBlock()->forEachSrc(num, [&](IRInstruction*, SSATmp* tmp) {
inst->block()->forEachSrc(num, [&](IRInstruction*, SSATmp* tmp) {
type = Type::unionOf(type, tmp->type());
});
ssa->setType(type);
hphp/runtime/vm/translator/hopt/opt.cpp
+2 -2
Ver Arquivo
@@ -26,7 +26,7 @@ namespace JIT {
// insert inst after the point dst is defined
static void insertAfter(IRInstruction* definer, IRInstruction* inst) {
assert(!definer->isBlockEnd());
Block* block = definer->getBlock();
Block* block = definer->block();
auto pos = block->iteratorTo(definer);
if (pos->op() == DefLabel) {
++pos;
@@ -57,7 +57,7 @@ static void insertRefCountAsserts(IRInstruction& inst, IRFactory* factory) {
static void insertSpillStackAsserts(IRInstruction& inst, IRFactory* factory) {
SSATmp* sp = inst.dst();
auto const vals = inst.srcs().subpiece(2);
auto* block = inst.getBlock();
auto* block = inst.block();
auto pos = block->iteratorTo(&inst); ++pos;
for (unsigned i = 0, n = vals.size(); i < n; ++i) {
Type t = vals[i]->type();
hphp/runtime/vm/translator/hopt/predictionopts.cpp
+9 -9
Ver Arquivo
@@ -87,15 +87,15 @@ void optimizePredictions(Trace* const trace, IRFactory* const irFactory) {
auto const ldMem = incRef->src(0)->inst();
if (ldMem->op() != LdMem) return;
if (ldMem->src(1)->getValInt() != 0) return;
if (!ldMem->getTypeParam().equals(Type::Cell)) return;
if (!ldMem->typeParam().equals(Type::Cell)) return;
FTRACE(5, "candidate: {}\n", ldMem->toString());
auto const mainBlock = ldMem->getBlock();
auto const exit = checkType->getTaken();
auto const specialized = checkType->getBlock()->getNext();
auto const mainBlock = ldMem->block();
auto const exit = checkType->taken();
auto const specialized = checkType->block()->next();
if (mainBlock != checkType->getBlock()) return;
if (mainBlock != checkType->block()) return;
if (exit->numPreds() != 1) return;
if (exit->isMain()) return;
@@ -115,8 +115,8 @@ void optimizePredictions(Trace* const trace, IRFactory* const irFactory) {
*/
auto const newCheckType = irFactory->gen(
CheckTypeMem,
checkType->getTypeParam(),
checkType->getTaken(),
checkType->typeParam(),
checkType->taken(),
ldMem->src(0)
);
mainBlock->insert(mainBlock->iteratorTo(ldMem), newCheckType);
@@ -130,7 +130,7 @@ void optimizePredictions(Trace* const trace, IRFactory* const irFactory) {
* generic version to the exit. We'll reflowTypes in a sec to get
* everything downstream specialized.
*/
ldMem->setTypeParam(checkType->getTypeParam());
ldMem->setTypeParam(checkType->typeParam());
/*
* Replace the old CheckType with a Mov from the result of the
@@ -160,7 +160,7 @@ void optimizePredictions(Trace* const trace, IRFactory* const irFactory) {
* visiting.
*/
if (!trace->isMain()) return;
for (Block* b : trace->getBlocks()) {
for (Block* b : trace->blocks()) {
IRInstruction* lastMarker = nullptr;
for (auto& inst : *b) {
if (inst.op() == Marker) {
hphp/runtime/vm/translator/hopt/print.cpp
+20 -20
Ver Arquivo
@@ -41,7 +41,7 @@ void printOpcode(std::ostream& os, const IRInstruction* inst) {
<< color(ANSI_COLOR_END)
;
auto type_param = inst->getTypeParam();
auto type_param = inst->typeParam();
if (type_param == Type::None && !inst->hasExtra()) {
return;
}
@@ -118,7 +118,7 @@ void printSrcs(std::ostream& os, const IRInstruction* inst,
void printLabel(std::ostream& os, const Block* block) {
os << color(ANSI_COLOR_MAGENTA);
os << "L" << block->id();
switch (block->getHint()) {
switch (block->hint()) {
case Block::Unlikely: os << "<Unlikely>"; break;
case Block::Likely: os << "<Likely>"; break;
default:
@@ -130,7 +130,7 @@ void printLabel(std::ostream& os, const Block* block) {
void print(std::ostream& ostream, const IRInstruction* inst,
const RegAllocInfo* regs, const LifetimeInfo* lifetime) {
if (inst->op() == Marker) {
auto* marker = inst->getExtra<Marker>();
auto* marker = inst->extra<Marker>();
ostream << color(ANSI_COLOR_BLUE)
<< folly::format("--- bc {}, spOff {} ({})",
marker->bcOff,
@@ -154,7 +154,7 @@ void print(std::ostream& ostream, const IRInstruction* inst,
printOpcode(ostream, inst);
printSrcs(ostream, inst, regs, lifetime);
if (Block* taken = inst->getTaken()) {
if (Block* taken = inst->taken()) {
ostream << punc(" -> ");
printLabel(ostream, taken);
}
@@ -169,8 +169,8 @@ static void printConst(std::ostream& os, IRInstruction* inst) {
os << color(ANSI_COLOR_LIGHT_BLUE);
SCOPE_EXIT { os << color(ANSI_COLOR_END); };
auto t = inst->getTypeParam();
auto c = inst->getExtra<DefConst>();
auto t = inst->typeParam();
auto c = inst->extra<DefConst>();
if (t == Type::Int) {
os << c->as<int64_t>();
} else if (t == Type::Dbl) {
@@ -183,7 +183,7 @@ static void printConst(std::ostream& os, IRInstruction* inst) {
<< Util::escapeStringForCPP(str->data(), str->size())
<< "\"";
} else if (t.isArray()) {
auto arr = inst->getExtra<DefConst>()->as<const ArrayData*>();
auto arr = inst->extra<DefConst>()->as<const ArrayData*>();
if (arr->empty()) {
os << "array()";
} else {
@@ -272,14 +272,14 @@ void print(const Trace* trace) {
// Print unlikely blocks at the end in normal generation. If we have
// asmInfo, order the blocks based on how they were layed out.
static smart::vector<Block*> getBlocks(const Trace* trace,
const AsmInfo* asmInfo) {
static smart::vector<Block*> blocks(const Trace* trace,
const AsmInfo* asmInfo) {
smart::vector<Block*> blocks;
if (!asmInfo) {
smart::vector<Block*> unlikely;
for (Block* block : trace->getBlocks()) {
if (block->getHint() == Block::Unlikely) {
for (Block* block : trace->blocks()) {
if (block->hint() == Block::Unlikely) {
unlikely.push_back(block);
} else {
blocks.push_back(block);
@@ -287,16 +287,16 @@ static smart::vector<Block*> getBlocks(const Trace* trace,
}
for (Trace* e : trace->getExitTraces()) {
unlikely.insert(unlikely.end(),
e->getBlocks().begin(),
e->getBlocks().end());
e->blocks().begin(),
e->blocks().end());
}
blocks.insert(blocks.end(), unlikely.begin(), unlikely.end());
return blocks;
}
blocks.assign(trace->getBlocks().begin(), trace->getBlocks().end());
blocks.assign(trace->blocks().begin(), trace->blocks().end());
for (Trace* e : trace->getExitTraces()) {
blocks.insert(blocks.end(), e->getBlocks().begin(), e->getBlocks().end());
blocks.insert(blocks.end(), e->blocks().begin(), e->blocks().end());
}
std::sort(
blocks.begin(),
@@ -316,7 +316,7 @@ void print(std::ostream& os, const Trace* trace, const RegAllocInfo* regs,
.printEncoding(dumpIREnabled(kExtraLevel))
.color(color(ANSI_COLOR_BROWN)));
for (Block* block : getBlocks(trace, asmInfo)) {
for (Block* block : blocks(trace, asmInfo)) {
if (!block->isMain()) {
os << "\n" << color(ANSI_COLOR_GREEN)
<< " ------- Exit Trace -------"
@@ -336,7 +336,7 @@ void print(std::ostream& os, const Trace* trace, const RegAllocInfo* regs,
// Don't print bytecode in a non-main trace.
if (!trace->isMain()) continue;
auto* marker = inst.getExtra<Marker>();
auto* marker = inst.extra<Marker>();
uint32_t bcOffset = marker->bcOff;
if (const auto* func = marker->func) {
std::ostringstream uStr;
@@ -356,7 +356,7 @@ void print(std::ostream& os, const Trace* trace, const RegAllocInfo* regs,
if (inst.op() == DefLabel) {
os << std::string(kIndent - 2, ' ');
printLabel(os, inst.getBlock());
printLabel(os, inst.block());
os << punc(":") << "\n";
// print phi pseudo-instructions
for (unsigned i = 0, n = inst.numDsts(); i < n; ++i) {
@@ -367,12 +367,12 @@ void print(std::ostream& os, const Trace* trace, const RegAllocInfo* regs,
os << punc(" = ") << color(ANSI_COLOR_CYAN) << "phi "
<< color(ANSI_COLOR_END);
bool first = true;
inst.getBlock()->forEachSrc(i, [&](IRInstruction* jmp, SSATmp*) {
inst.block()->forEachSrc(i, [&](IRInstruction* jmp, SSATmp*) {
if (!first) os << punc(", ");
first = false;
printSrc(os, jmp, i, regs, lifetime);
os << punc("@");
printLabel(os, jmp->getBlock());
printLabel(os, jmp->block());
});
os << '\n';
}
hphp/runtime/vm/translator/hopt/simplifier.cpp
+33 -33
Ver Arquivo
@@ -60,8 +60,8 @@ StackValueInfo getStackValue(SSATmp* sp, uint32_t index) {
case GuardStk:
// We don't have a value, but we may know the type due to guarding
// on it.
if (inst->getExtra<StackOffset>()->offset == index) {
return StackValueInfo { inst->getTypeParam() };
if (inst->extra<StackOffset>()->offset == index) {
return StackValueInfo { inst->typeParam() };
}
return getStackValue(inst->src(0), index);
@@ -121,7 +121,7 @@ StackValueInfo getStackValue(SSATmp* sp, uint32_t index) {
case InterpOne: {
SSATmp* prevSp = inst->src(1);
int64_t spAdjustment = inst->src(3)->getValInt(); // # popped - # pushed
Type resultType = inst->getTypeParam();
Type resultType = inst->typeParam();
if (index == 0 && !resultType.equals(Type::None)) {
return StackValueInfo { resultType };
}
@@ -139,7 +139,7 @@ StackValueInfo getStackValue(SSATmp* sp, uint32_t index) {
// vectorBaseIdx if not.
auto const base = inst->src(vectorBaseIdx(inst));
assert(base->inst()->op() == LdStackAddr);
if (base->inst()->getExtra<LdStackAddr>()->offset == index) {
if (base->inst()->extra<LdStackAddr>()->offset == index) {
VectorEffects ve(inst);
assert(ve.baseTypeChanged || ve.baseValChanged);
return StackValueInfo { ve.baseType.derefIfPtr() };
@@ -365,7 +365,7 @@ SSATmp* Simplifier::simplifySpillStack(IRInstruction* inst) {
const int64_t offset = cellOff + adjustment;
auto* srcInst = spillVals[i]->inst();
if (srcInst->op() == LdStack && srcInst->src(0) == sp &&
srcInst->getExtra<LdStack>()->offset == offset) {
srcInst->extra<LdStack>()->offset == offset) {
spillVals[i] = m_tb->genDefNone();
}
cellOff++;
@@ -394,7 +394,7 @@ SSATmp* Simplifier::simplifyCall(IRInstruction* inst) {
// If our value came from a LdStack on the same sp and offset,
// we don't need to spill it.
if (srcInst->op() == LdStack && srcInst->src(0) == sp &&
srcInst->getExtra<LdStack>()->offset == offset) {
srcInst->extra<LdStack>()->offset == offset) {
spillVals[i] = m_tb->genDefNone();
}
}
@@ -468,7 +468,7 @@ SSATmp* Simplifier::simplifyLdCls(IRInstruction* inst) {
}
SSATmp* Simplifier::simplifyCheckType(IRInstruction* inst) {
Type type = inst->getTypeParam();
Type type = inst->typeParam();
SSATmp* src = inst->src(0);
Type srcType = src->type();
@@ -526,7 +526,7 @@ SSATmp* Simplifier::simplifyQueryJmp(IRInstruction* inst) {
return nullptr;
},
JmpNZero,
inst->getTaken(),
inst->taken(),
newCmp);
if (!newQueryJmp) return nullptr;
return newQueryJmp;
@@ -1178,7 +1178,7 @@ SSATmp* Simplifier::simplifyJmpIsType(IRInstruction* inst) {
assert(res->isConst());
if (res->getValBool()) {
// Taken jump
return gen(Jmp_, inst->getTaken());
return gen(Jmp_, inst->taken());
} else {
// Not taken jump; turn jump into a nop
inst->convertToNop();
@@ -1189,7 +1189,7 @@ SSATmp* Simplifier::simplifyJmpIsType(IRInstruction* inst) {
SSATmp* Simplifier::simplifyIsType(IRInstruction* inst) {
bool trueSense =
inst->op() == IsType || inst->op() == JmpIsType;
auto type = inst->getTypeParam();
auto type = inst->typeParam();
auto src = inst->src(0);
auto srcType = src->type();
@@ -1420,7 +1420,7 @@ SSATmp* Simplifier::simplifyLdClsPropAddr(IRInstruction* inst) {
const StringData* clsNameStr = findClassName(cls);
return gen(LdClsPropAddrCached,
inst->getTaken(),
inst->taken(),
cls,
propName,
cns(clsNameStr),
@@ -1462,7 +1462,7 @@ SSATmp* Simplifier::simplifyUnbox(IRInstruction* inst) {
if (srcType.isBoxed()) {
srcType = srcType.innerType();
assert(type.equals(srcType));
return gen(LdRef, type, inst->getTaken()->getTrace(), src);
return gen(LdRef, type, inst->taken()->trace(), src);
}
return nullptr;
}
@@ -1479,7 +1479,7 @@ SSATmp* Simplifier::simplifyCheckInit(IRInstruction* inst) {
Type srcType = inst->src(0)->type();
srcType = inst->op() == CheckInitMem ? srcType.deref() : srcType;
assert(srcType.notPtr());
assert(inst->getTaken());
assert(inst->taken());
if (srcType.isInit()) {
inst->convertToNop();
}
@@ -1526,7 +1526,7 @@ SSATmp* Simplifier::simplifyCondJmp(IRInstruction* inst) {
val = !val;
}
if (val) {
return gen(Jmp_, inst->getTaken());
return gen(Jmp_, inst->taken());
}
inst->convertToNop();
return nullptr;
@@ -1535,7 +1535,7 @@ SSATmp* Simplifier::simplifyCondJmp(IRInstruction* inst) {
// Pull negations into the jump.
if (src->inst()->op() == OpNot) {
return gen(inst->op() == JmpZero ? JmpNZero : JmpZero,
inst->getTaken(),
inst->taken(),
srcInst->src(0));
}
@@ -1552,7 +1552,7 @@ SSATmp* Simplifier::simplifyCondJmp(IRInstruction* inst) {
// If the source is conversion of an int or pointer to boolean, we
// can test the int/ptr value directly.
if (isConvIntOrPtrToBool(srcInst)) {
return gen(inst->op(), inst->getTaken(), srcInst->src(0));
return gen(inst->op(), inst->taken(), srcInst->src(0));
}
// Fuse jumps with query operators.
@@ -1563,8 +1563,8 @@ SSATmp* Simplifier::simplifyCondJmp(IRInstruction* inst) {
inst->op() == JmpZero
? negateQueryOp(srcOpcode)
: srcOpcode),
srcInst->getTypeParam(), // if it had a type param
inst->getTaken(),
srcInst->typeParam(), // if it had a type param
inst->taken(),
std::make_pair(ssas.size(), ssas.begin())
);
}
@@ -1574,8 +1574,8 @@ SSATmp* Simplifier::simplifyCondJmp(IRInstruction* inst) {
SSATmp* Simplifier::simplifyCastStk(IRInstruction* inst) {
auto const info = getStackValue(inst->src(0),
inst->getExtra<CastStk>()->offset);
if (info.knownType.subtypeOf(inst->getTypeParam())) {
inst->extra<CastStk>()->offset);
if (info.knownType.subtypeOf(inst->typeParam())) {
// No need to cast---the type was as good or better.
inst->convertToNop();
}
@@ -1584,13 +1584,13 @@ SSATmp* Simplifier::simplifyCastStk(IRInstruction* inst) {
SSATmp* Simplifier::simplifyAssertStk(IRInstruction* inst) {
auto const info = getStackValue(inst->src(0),
inst->getExtra<AssertStk>()->offset);
inst->extra<AssertStk>()->offset);
// AssertStk indicated that we knew the type from static analysis,
// so this assert just double checks.
if (info.value) assert(info.value->isA(inst->getTypeParam()));
if (info.value) assert(info.value->isA(inst->typeParam()));
if (info.knownType.subtypeOf(inst->getTypeParam())) {
if (info.knownType.subtypeOf(inst->typeParam())) {
inst->convertToNop();
}
return nullptr;
@@ -1598,7 +1598,7 @@ SSATmp* Simplifier::simplifyAssertStk(IRInstruction* inst) {
SSATmp* Simplifier::simplifyLdStack(IRInstruction* inst) {
auto const info = getStackValue(inst->src(0),
inst->getExtra<LdStack>()->offset);
inst->extra<LdStack>()->offset);
// We don't want to extend live ranges of tmps across calls, so we
// don't get the value if spansCall is true; however, we can use
@@ -1609,22 +1609,22 @@ SSATmp* Simplifier::simplifyLdStack(IRInstruction* inst) {
}
if (!info.knownType.equals(Type::None)) {
inst->setTypeParam(
Type::mostRefined(inst->getTypeParam(), info.knownType)
Type::mostRefined(inst->typeParam(), info.knownType)
);
}
return nullptr;
}
SSATmp* Simplifier::simplifyDecRefLoc(IRInstruction* inst) {
if (inst->getTypeParam().notCounted()) {
if (inst->typeParam().notCounted()) {
inst->convertToNop();
}
return nullptr;
}
SSATmp* Simplifier::simplifyLdLoc(IRInstruction* inst) {
if (inst->getTypeParam().isNull()) {
return cns(inst->getTypeParam());
if (inst->typeParam().isNull()) {
return cns(inst->typeParam());
}
return nullptr;
}
@@ -1643,29 +1643,29 @@ SSATmp* Simplifier::simplifyStRef(IRInstruction* inst) {
SSATmp* Simplifier::simplifyLdStackAddr(IRInstruction* inst) {
auto const info = getStackValue(inst->src(0),
inst->getExtra<StackOffset>()->offset);
inst->extra<StackOffset>()->offset);
if (!info.knownType.equals(Type::None)) {
inst->setTypeParam(
Type::mostRefined(inst->getTypeParam(), info.knownType.ptr())
Type::mostRefined(inst->typeParam(), info.knownType.ptr())
);
}
return nullptr;
}
SSATmp* Simplifier::simplifyDecRefStack(IRInstruction* inst) {
if (inst->getTypeParam().notCounted()) {
if (inst->typeParam().notCounted()) {
inst->convertToNop();
return nullptr;
}
auto const info = getStackValue(inst->src(0),
inst->getExtra<StackOffset>()->offset);
inst->extra<StackOffset>()->offset);
if (info.value && !info.spansCall) {
inst->convertToNop();
return gen(DecRef, info.knownType, info.value);
}
if (!info.knownType.equals(Type::None)) {
inst->setTypeParam(
Type::mostRefined(inst->getTypeParam(), info.knownType)
Type::mostRefined(inst->typeParam(), info.knownType)
);
}
return nullptr;
hphp/runtime/vm/translator/hopt/trace.h
+8 -8
Ver Arquivo
@@ -43,20 +43,20 @@ struct Trace : private boost::noncopyable {
boost::checked_deleter<Trace>());
}
std::list<Block*>& getBlocks() { return m_blocks; }
const std::list<Block*>& getBlocks() const { return m_blocks; }
std::list<Block*>& blocks() { return m_blocks; }
const std::list<Block*>& blocks() const { return m_blocks; }
Block* front() { return *m_blocks.begin(); }
Block* back() { auto it = m_blocks.end(); return *(--it); }
const Block* front() const { return *m_blocks.begin(); }
const Block* back() const { auto it = m_blocks.end(); return *(--it); }
const_iterator cbegin() const { return getBlocks().cbegin(); }
const_iterator cend() const { return getBlocks().cend(); }
const_iterator begin() const { return getBlocks().begin(); }
const_iterator end() const { return getBlocks().end(); }
iterator begin() { return getBlocks().begin(); }
iterator end() { return getBlocks().end(); }
const_iterator cbegin() const { return blocks().cbegin(); }
const_iterator cend() const { return blocks().cend(); }
const_iterator begin() const { return blocks().begin(); }
const_iterator end() const { return blocks().end(); }
iterator begin() { return blocks().begin(); }
iterator end() { return blocks().end(); }
/*
* Unlink a block from a trace. Updates any successor blocks that
hphp/runtime/vm/translator/hopt/tracebuilder.cpp
+31 -32
Ver Arquivo
@@ -104,8 +104,8 @@ SSATmp* TraceBuilder::genDefNone() {
}
void TraceBuilder::trackDefInlineFP(IRInstruction* inst) {
auto const target = inst->getExtra<DefInlineFP>()->target;
auto const savedSPOff = inst->getExtra<DefInlineFP>()->retSPOff;
auto const target = inst->extra<DefInlineFP>()->target;
auto const savedSPOff = inst->extra<DefInlineFP>()->retSPOff;
auto const calleeFP = inst->dst();
auto const calleeSP = inst->src(0);
auto const savedSP = inst->src(1);
@@ -172,7 +172,7 @@ void TraceBuilder::updateTrackedState(IRInstruction* inst) {
case InlineReturn: trackInlineReturn(inst); break;
case Marker:
m_lastMarker = *inst->getExtra<Marker>();
m_lastMarker = *inst->extra<Marker>();
break;
case Call:
@@ -208,7 +208,7 @@ void TraceBuilder::updateTrackedState(IRInstruction* inst) {
case DefSP:
case ReDefSP:
m_spValue = inst->dst();
m_spOffset = inst->getExtra<StackOffset>()->offset;
m_spOffset = inst->extra<StackOffset>()->offset;
break;
case AssertStk:
@@ -267,25 +267,24 @@ void TraceBuilder::updateTrackedState(IRInstruction* inst) {
case StLocNT:
case StLoc:
setLocalValue(inst->getExtra<LocalId>()->locId,
inst->src(1));
setLocalValue(inst->extra<LocalId>()->locId, inst->src(1));
break;
case LdLoc:
setLocalValue(inst->getExtra<LdLoc>()->locId, inst->dst());
setLocalValue(inst->extra<LdLoc>()->locId, inst->dst());
break;
case OverrideLoc:
// If changing the inner type of a boxed local, also drop the
// information about inner types for any other boxed locals.
if (inst->getTypeParam().isBoxed()) {
if (inst->typeParam().isBoxed()) {
dropLocalRefsInnerTypes();
}
// fallthrough
case AssertLoc:
case GuardLoc:
setLocalType(inst->getExtra<LocalId>()->locId,
inst->getTypeParam());
setLocalType(inst->extra<LocalId>()->locId,
inst->typeParam());
break;
case IterInitK:
@@ -348,7 +347,7 @@ void TraceBuilder::updateTrackedState(IRInstruction* inst) {
}
// save a copy of the current state for each successor.
if (Block* target = inst->getTaken()) saveState(target);
if (Block* target = inst->taken()) saveState(target);
}
std::unique_ptr<TraceBuilder::State> TraceBuilder::createState() const {
@@ -536,12 +535,12 @@ SSATmp* TraceBuilder::cseLookup(IRInstruction* inst) {
//////////////////////////////////////////////////////////////////////
SSATmp* TraceBuilder::preOptimizeCheckLoc(IRInstruction* inst) {
auto const locId = inst->getExtra<CheckLoc>()->locId;
auto const locId = inst->extra<CheckLoc>()->locId;
if (auto const prevValue = getLocalValue(locId)) {
always_assert(false && "WTF");
return gen(
CheckType, inst->getTypeParam(), inst->getTaken(), prevValue
CheckType, inst->typeParam(), inst->taken(), prevValue
);
}
@@ -550,7 +549,7 @@ SSATmp* TraceBuilder::preOptimizeCheckLoc(IRInstruction* inst) {
always_assert(false && "WTF2");
// It doesn't make sense to be checking something that's deemed to
// fail.
assert(prevType == inst->getTypeParam());
assert(prevType == inst->typeParam());
inst->convertToNop();
}
@@ -558,9 +557,9 @@ SSATmp* TraceBuilder::preOptimizeCheckLoc(IRInstruction* inst) {
}
SSATmp* TraceBuilder::preOptimizeAssertLoc(IRInstruction* inst) {
auto const locId = inst->getExtra<AssertLoc>()->locId;
auto const locId = inst->extra<AssertLoc>()->locId;
auto const prevType = getLocalType(locId);
auto const typeParam = inst->getTypeParam();
auto const typeParam = inst->typeParam();
if (!prevType.equals(Type::None) && !typeParam.strictSubtypeOf(prevType)) {
assert(prevType.subtypeOf(typeParam));
@@ -637,7 +636,7 @@ SSATmp* TraceBuilder::preOptimizeDecRefThis(IRInstruction* inst) {
}
SSATmp* TraceBuilder::preOptimizeDecRefLoc(IRInstruction* inst) {
auto const locId = inst->getExtra<DecRefLoc>()->locId;
auto const locId = inst->extra<DecRefLoc>()->locId;
/*
* Refine the type if we can.
@@ -652,7 +651,7 @@ SSATmp* TraceBuilder::preOptimizeDecRefLoc(IRInstruction* inst) {
}
if (knownType != Type::None) { // TODO(#2135185)
inst->setTypeParam(
Type::mostRefined(knownType, inst->getTypeParam())
Type::mostRefined(knownType, inst->typeParam())
);
}
@@ -669,33 +668,33 @@ SSATmp* TraceBuilder::preOptimizeDecRefLoc(IRInstruction* inst) {
}
SSATmp* TraceBuilder::preOptimizeLdLoc(IRInstruction* inst) {
auto const locId = inst->getExtra<LdLoc>()->locId;
auto const locId = inst->extra<LdLoc>()->locId;
if (auto tmp = getLocalValue(locId)) {
return tmp;
}
if (getLocalType(locId) != Type::None) { // TODO(#2135185)
inst->setTypeParam(
Type::mostRefined(getLocalType(locId), inst->getTypeParam())
Type::mostRefined(getLocalType(locId), inst->typeParam())
);
}
return nullptr;
}
SSATmp* TraceBuilder::preOptimizeLdLocAddr(IRInstruction* inst) {
auto const locId = inst->getExtra<LdLocAddr>()->locId;
auto const locId = inst->extra<LdLocAddr>()->locId;
if (getLocalType(locId) != Type::None) { // TODO(#2135185)
inst->setTypeParam(
Type::mostRefined(getLocalType(locId).ptr(), inst->getTypeParam())
Type::mostRefined(getLocalType(locId).ptr(), inst->typeParam())
);
}
return nullptr;
}
SSATmp* TraceBuilder::preOptimizeStLoc(IRInstruction* inst) {
auto const curType = getLocalType(inst->getExtra<StLoc>()->locId);
auto const curType = getLocalType(inst->extra<StLoc>()->locId);
auto const newType = inst->src(1)->type();
assert(inst->getTypeParam().equals(Type::None));
assert(inst->typeParam().equals(Type::None));
// There's no need to store the type if it's going to be the same
// KindOfFoo. We still have to store string types because we don't
@@ -797,7 +796,7 @@ SSATmp* TraceBuilder::optimizeInst(IRInstruction* inst) {
void CSEHash::filter(Block* block, IdomVector& idoms) {
for (auto it = map.begin(), end = map.end(); it != end;) {
auto next = it; ++next;
if (!dominates(it->second->inst()->getBlock(), block, idoms)) {
if (!dominates(it->second->inst()->block(), block, idoms)) {
map.erase(it);
}
it = next;
@@ -833,7 +832,7 @@ void TraceBuilder::reoptimize() {
m_enableCse = RuntimeOption::EvalHHIRCse;
m_enableSimplification = RuntimeOption::EvalHHIRSimplification;
if (!m_enableCse && !m_enableSimplification) return;
if (m_trace->getBlocks().size() >
if (m_trace->blocks().size() >
RuntimeOption::EvalHHIRSimplificationMaxBlocks) {
// TODO CSEHash::filter is very slow for large block sizes
// t2135219 should address that
@@ -844,12 +843,12 @@ void TraceBuilder::reoptimize() {
IdomVector idoms = findDominators(sortedBlocks);
clearTrackedState();
auto blocks = std::move(m_trace->getBlocks());
assert(m_trace->getBlocks().empty());
auto blocks = std::move(m_trace->blocks());
assert(m_trace->blocks().empty());
while (!blocks.empty()) {
Block* block = blocks.front();
blocks.pop_front();
assert(block->getTrace() == m_trace.get());
assert(block->trace() == m_trace.get());
FTRACE(5, "Block: {}\n", block->id());
m_trace->push_back(block);
@@ -858,7 +857,7 @@ void TraceBuilder::reoptimize() {
m_cseHash.filter(block, idoms);
}
auto instructions = std::move(block->getInstrs());
auto instructions = std::move(block->instrs());
assert(block->empty());
while (!instructions.empty()) {
auto *inst = &instructions.front();
@@ -883,7 +882,7 @@ void TraceBuilder::reoptimize() {
updateTrackedState(mov);
}
// Not re-adding inst; remove the inst->taken edge
if (inst->getTaken()) inst->setTaken(nullptr);
if (inst->taken()) inst->setTaken(nullptr);
}
if (block->back()->isTerminal()) {
// Could have converted a conditional branch to Jmp; clear next.
@@ -892,7 +891,7 @@ void TraceBuilder::reoptimize() {
// if the last instruction was a branch, we already saved state
// for the target in updateTrackedState(). Now save state for
// the fall-through path.
saveState(block->getNext());
saveState(block->next());
}
}
}
hphp/runtime/vm/translator/hopt/tracebuilder.h
+3 -3
Ver Arquivo
@@ -98,7 +98,7 @@ struct TraceBuilder {
void setEnableCse(bool val) { m_enableCse = val; }
void setEnableSimplification(bool val) { m_enableSimplification = val; }
Trace* getTrace() const { return m_trace.get(); }
Trace* trace() const { return m_trace.get(); }
IRFactory* getIrFactory() { return &m_irFactory; }
int32_t getSpOffset() { return m_spOffset; }
SSATmp* getSp() const { return m_spValue; }
@@ -200,7 +200,7 @@ struct TraceBuilder {
SSATmp* v2 = taken();
gen(Jmp_, done_block, v2);
appendBlock(done_block);
SSATmp* result = done_block->getLabel()->dst(0);
SSATmp* result = done_block->label()->dst(0);
result->setType(Type::unionOf(v1->type(), v2->type()));
return result;
}
@@ -216,7 +216,7 @@ struct TraceBuilder {
Block* done_block = m_irFactory.defBlock(func);
DisableCseGuard guard(*this);
branch(taken_block);
assert(!m_trace->back()->getNext());
assert(!m_trace->back()->next());
m_trace->back()->setNext(done_block);
appendBlock(taken_block);
taken();
hphp/runtime/vm/translator/hopt/type.cpp
+4 -4
Ver Arquivo
@@ -51,7 +51,7 @@ Type vectorReturn(const IRInstruction* inst) {
Type builtinReturn(const IRInstruction* inst) {
assert(inst->op() == CallBuiltin);
Type t = inst->getTypeParam();
Type t = inst->typeParam();
if (t.isSimpleType() || t.equals(Type::Cell)) {
return t;
}
@@ -112,7 +112,7 @@ Type outputType(const IRInstruction* inst, int dstId) {
#define DofS(n) return inst->src(n)->type();
#define DUnbox(n) return inst->src(n)->type().unbox();
#define DBox(n) return boxReturn(inst, n);
#define DParam return inst->getTypeParam();
#define DParam return inst->typeParam();
#define DMulti return Type::None;
#define DStk(in) return stkReturn(inst, dstId, \
[&]() -> Type { in not_reached(); });
@@ -289,10 +289,10 @@ void assertOperandTypes(const IRInstruction* inst) {
"invalid src num");
#define DofS(src) checkDst(src < inst->numSrcs(), \
"invalid src num");
#define DParam checkDst(inst->getTypeParam() != Type::None || \
#define DParam checkDst(inst->typeParam() != Type::None || \
inst->op() == DefConst /* for DefNone */, \
"DParam with paramType None");
#define DArith checkDst(inst->getTypeParam() == Type::None, \
#define DArith checkDst(inst->typeParam() == Type::None, \
"DArith should have no type parameter");
#define O(opcode, dstinfo, srcinfo, flags) \
hphp/runtime/vm/translator/hopt/vectortranslator.cpp
+2 -2
Ver Arquivo
@@ -54,7 +54,7 @@ void VectorEffects::get(const IRInstruction* inst,
UNUSED Type baseType = locInstr->dst()->type();
assert(baseType.equals(base->type()));
assert(baseType.isPtr() || baseType.isKnownDataType());
int loc = locInstr->getExtra<LdLocAddr>()->locId;
int loc = locInstr->extra<LdLocAddr>()->locId;
VectorEffects ve(inst);
if (ve.baseTypeChanged || ve.baseValChanged) {
@@ -2049,7 +2049,7 @@ void HhbcTranslator::VectorTranslator::emitMPost() {
gen(CheckType,
m_predictedResult->type(),
m_ht.getExitTrace(m_ht.getNextSrcKey().offset(), spillValues),
m_ht.getExitTrace(m_ht.nextSrcKey().offset(), spillValues),
m_result);
}
}