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()); }