RegionDescPtr selectTraceletLegacy(Offset initSpOffset,
const Tracelet& tlet) {
typedef RegionDesc::Block Block;
auto const region = std::make_shared<RegionDesc>();
SrcKey sk(tlet.m_sk);
auto const unit = tlet.func()->unit();
const Func* topFunc = nullptr;
Block* curBlock = nullptr;
auto newBlock = [&](SrcKey start, Offset spOff) {
assert(curBlock == nullptr || curBlock->length() > 0);
region->blocks.push_back(
std::make_shared<Block>(
start.func(), start.resumed(), start.offset(), 0, spOff));
Block* newCurBlock = region->blocks.back().get();
if (curBlock) {
region->addArc(curBlock->id(), newCurBlock->id());
}
curBlock = newCurBlock;
};
newBlock(sk, initSpOffset);
for (auto ni = tlet.m_instrStream.first; ni; ni = ni->next) {
assert(sk == ni->source);
assert(ni->unit() == unit);
Offset curSpOffset = initSpOffset + ni->stackOffset;
curBlock->addInstruction();
if ((curBlock->length() == 1 && ni->funcd != nullptr) ||
ni->funcd != topFunc) {
topFunc = ni->funcd;
curBlock->setKnownFunc(sk, topFunc);
}
if (ni->calleeTrace && !ni->calleeTrace->m_inliningFailed) {
assert(ni->op() == Op::FCall || ni->op() == Op::FCallD);
assert(ni->funcd == ni->calleeTrace->func());
// This should be translated as an inlined call. Insert the blocks of the
// callee in the region.
auto const& callee = *ni->calleeTrace;
curBlock->setInlinedCallee(ni->funcd);
SrcKey cSk = callee.m_sk;
auto const cUnit = callee.func()->unit();
// Note: the offsets of the inlined blocks aren't currently read
// for anything, so it's unclear whether they should be relative
// to the main function entry or the inlined function. We're
// just doing this for now.
auto const initInliningSpOffset = curSpOffset;
newBlock(cSk,
initInliningSpOffset + callee.m_instrStream.first->stackOffset);
for (auto cni = callee.m_instrStream.first; cni; cni = cni->next) {
// Sometimes inlined callees trace through jumps that have a
// known taken/non-taken state based on the calling context:
if (cni->nextOffset != kInvalidOffset) {
curBlock->addInstruction();
cSk.setOffset(cni->nextOffset);
newBlock(cSk, initInliningSpOffset + ni->stackOffset);
continue;
}
assert(cSk == cni->source);
assert(cni->op() == OpRetC ||
cni->op() == OpRetV ||
cni->op() == OpCreateCont ||
cni->op() == OpAwait ||
cni->op() == OpNativeImpl ||
!instrIsNonCallControlFlow(cni->op()));
curBlock->addInstruction();
cSk.advance(cUnit);
}
if (ni->next) {
sk.advance(unit);
newBlock(sk, curSpOffset);
}
continue;
}
if (!ni->noOp && isFPassStar(ni->op())) {
curBlock->setParamByRef(sk, ni->preppedByRef);
}
if (ni->next && isUnconditionalJmp(ni->op())) {
// A Jmp that isn't the final instruction in a Tracelet means we traced
// through a forward jump in analyze. Update sk to point to the next NI
// in the stream.
auto dest = ni->offset() + ni->imm[0].u_BA;
assert(dest > sk.offset()); // We only trace for forward Jmps for now.
sk.setOffset(dest);
// The Jmp terminates this block.
newBlock(sk, curSpOffset);
} else {
sk.advance(unit);
}
}
auto& frontBlock = *region->blocks.front();
// Add tracelet guards as predictions on the first instruction. Predictions
// and known types from static analysis will be applied by
// Translator::translateRegion.
for (auto const& dep : tlet.m_dependencies) {
if (dep.second->rtt.isVagueValue() ||
dep.second->location.isThis()) continue;
typedef RegionDesc R;
auto addPred = [&](const R::Location& loc) {
auto type = Type(dep.second->rtt);
frontBlock.addPredicted(tlet.m_sk, {loc, type});
};
switch (dep.first.space) {
case Location::Stack: {
uint32_t offsetFromSp = uint32_t(-dep.first.offset - 1);
uint32_t offsetFromFp = initSpOffset - offsetFromSp;
addPred(R::Location::Stack{offsetFromSp, offsetFromFp});
break;
}
case Location::Local:
addPred(R::Location::Local{uint32_t(dep.first.offset)});
break;
default: not_reached();
}
}
// Add reffiness dependencies as predictions on the first instruction.
for (auto const& dep : tlet.m_refDeps.m_arMap) {
RegionDesc::ReffinessPred pred{dep.second.m_mask,
dep.second.m_vals,
dep.first};
frontBlock.addReffinessPred(tlet.m_sk, pred);
}
FTRACE(2, "Converted Tracelet:\n{}\nInto RegionDesc:\n{}\n",
tlet.toString(), show(*region));
return region;
}
