void TraceBuilder::setMarker(BCMarker marker) {
if (m_curMarker == marker) return;
FTRACE(2, "TraceBuilder changing current marker from {} to {}\n",
m_curMarker.func ? m_curMarker.show() : "<invalid>", marker.show());
assert(marker.valid());
m_curMarker = marker;
}
static void genBlock(IRUnit& unit, CodeBlock& cb, CodeBlock& stubsCode,
MCGenerator* mcg, CodegenState& state, Block* block,
std::vector<TransBCMapping>* bcMap) {
FTRACE(6, "genBlock: {}\n", block->id());
std::unique_ptr<CodeGenerator> cg(mcg->backEnd().newCodeGenerator(unit, cb,
stubsCode,
mcg,
state));
BCMarker prevMarker;
for (IRInstruction& instr : *block) {
IRInstruction* inst = &instr;
// If we're on the first instruction of the block or we have a new
// marker since the last instruction, update the bc mapping.
if ((!prevMarker.valid() || inst->marker() != prevMarker) &&
(mcg->tx().isTransDBEnabled() ||
RuntimeOption::EvalJitUseVtuneAPI) && bcMap) {
bcMap->push_back(TransBCMapping{inst->marker().func()->unit()->md5(),
inst->marker().bcOff(),
cb.frontier(),
stubsCode.frontier()});
prevMarker = inst->marker();
}
auto* addr = cg->cgInst(inst);
if (state.asmInfo && addr) {
state.asmInfo->updateForInstruction(inst, addr, cb.frontier());
}
}
}
void IRBuilder::setMarker(BCMarker marker) {
auto const oldMarker = m_state.marker();
if (marker == oldMarker) return;
FTRACE(2, "IRBuilder changing current marker from {} to {}\n",
oldMarker.func ? oldMarker.show() : "<invalid>", marker.show());
assert(marker.valid());
m_state.setMarker(marker);
}
Fixup makeFixup(const BCMarker& marker, SyncOptions sync) {
assertx(marker.valid());
auto const stackOff = [&] {
switch (sync) {
case SyncOptions::SyncAdjustOne:
return marker.spOff() -= 1;
case SyncOptions::None:
// We can get here if we are memory profiling, since we override the
// normal sync settings and sync anyway.
always_assert(RuntimeOption::HHProfEnabled);
// fallthru
case SyncOptions::Sync:
return marker.spOff();
}
not_reached();
}();
auto const bcOff = marker.fixupBcOff() - marker.fixupFunc()->base();
return Fixup{bcOff, stackOff.offset};
}
void CodeGenerator::cgBlock(Block* block, vector<TransBCMapping>* bcMap) {
FTRACE(6, "cgBlock: {}\n", block->id());
BCMarker prevMarker;
for (IRInstruction& instr : *block) {
IRInstruction* inst = &instr;
// If we're on the first instruction of the block or we have a new
// marker since the last instruction, update the bc mapping.
if ((!prevMarker.valid() || inst->marker() != prevMarker) &&
m_tx64->isTransDBEnabled() && bcMap) {
bcMap->push_back(TransBCMapping{inst->marker().func->unit()->md5(),
inst->marker().bcOff,
m_as.frontier(),
m_astubs.frontier()});
prevMarker = inst->marker();
}
auto* addr = cgInst(inst);
if (m_state.asmInfo && addr) {
m_state.asmInfo->updateForInstruction(inst, addr, m_as.frontier());
}
}
}
void TraceBuilder::pushTrace(IRTrace* t, BCMarker marker, Block* b,
const boost::optional<Block::iterator>& where) {
FTRACE(2, "TraceBuilder saving {}@{} and using {}@{}\n",
m_curTrace, m_state.marker().show(), t, marker.show());
assert(t);
assert(bool(b) == bool(where));
assert(IMPLIES(b, b->trace() == t));
m_savedTraces.push(
TraceState{ m_curTrace, m_curBlock, m_state.marker(), m_curWhere });
m_curTrace = t;
m_curBlock = b;
setMarker(marker);
m_curWhere = where;
}
void TraceBuilder::pushBlock(BCMarker marker, Block* b,
const boost::optional<Block::iterator>& where) {
FTRACE(2, "TraceBuilder saving {}@{} and using {}@{}\n",
m_curBlock, m_state.marker().show(), b, marker.show());
assert(b);
m_savedBlocks.push_back(
BlockState{ m_curBlock, m_state.marker(), m_curWhere });
m_curBlock = b;
setMarker(marker);
m_curWhere = where ? where : b->end();
if (do_assert) {
for (UNUSED auto const& state : m_savedBlocks) {
assert(state.block != b &&
"Can't push a block that's already in the saved stack");
}
}
}
FrameState::FrameState(IRUnit& unit, BCMarker marker)
: FrameState(unit, marker.spOff(), marker.func(), marker.func()->numLocals())
{
assert(!marker.isDummy());
}
