/*
* Returns true iff `block' ends the IR unit after finishing execution
* of the bytecode instruction at `sk'.
*/
static bool endsUnitAtSrcKey(const Block* block, SrcKey sk) {
if (!block->isExitNoThrow()) return false;
const auto& inst = block->back();
const auto instSk = inst.marker().sk();
switch (inst.op()) {
// These instructions end a unit after executing the bytecode
// instruction they correspond to.
case InterpOneCF:
case JmpSSwitchDest:
case JmpSwitchDest:
case RaiseError:
return instSk == sk;;
// The RetCtrl is generally ending a bytecode instruction, with the
// exception being in an Await bytecode instruction, where we consider the
// end of the bytecode instruction to be the non-suspending path.
case RetCtrl:
case AsyncRetCtrl:
return inst.marker().sk().op() != Op::Await;
// A ReqBindJmp ends a unit and it jumps to the next instruction
// to execute.
case ReqBindJmp: {
auto destOffset = inst.extra<ReqBindJmp>()->dest.offset();
return sk.succOffsets().count(destOffset);
}
default:
return false;
}
}
/*
* Returns true iff `block' ends the IR unit after finishing execution
* of the bytecode instruction at `sk'.
*/
static bool endsUnitAtSrcKey(const Block* block, SrcKey sk) {
if (!block->isExitNoThrow()) return false;
const auto& inst = block->back();
const auto instSk = inst.marker().sk();
switch (inst.op()) {
// These instructions end a unit after executing the bytecode
// instruction they correspond to.
case InterpOneCF:
case JmpSSwitchDest:
case JmpSwitchDest:
case RaiseError:
case ThrowOutOfBounds:
case ThrowInvalidArrayKey:
case ThrowInvalidOperation:
case ThrowArithmeticError:
case ThrowDivisionByZeroError:
case VerifyParamFailHard:
case VerifyRetFailHard:
case Unreachable:
case EndBlock:
case FatalMissingThis:
return instSk == sk;
// The RetCtrl is generally ending a bytecode instruction, with the
// exception being in an Await bytecode instruction, where we consider the
// end of the bytecode instruction to be the non-suspending path.
case RetCtrl:
case AsyncRetCtrl:
case AsyncRetFast:
case AsyncSwitchFast:
return inst.marker().sk().op() != Op::Await;
// A ReqBindJmp ends a unit and it jumps to the next instruction to
// execute.
case ReqBindJmp: {
auto destOffset = inst.extra<ReqBindJmp>()->target.offset();
return sk.succOffsets().count(destOffset);
}
default:
return false;
}
}
/*
* Checks if the given region is well-formed, which entails the
* following properties:
*
* 1) The region has at least one block.
*
* 2) Each block in the region has a different id.
*
* 3) All arcs involve blocks within the region.
*
* 4) For each arc, the bytecode offset of the dst block must
* possibly follow the execution of the src block.
*
* 5) Each block contains at most one successor corresponding to a
* given SrcKey.
*
* 6) The region doesn't contain any loops, unless JitLoops is
* enabled.
*
* 7) All blocks are reachable from the entry block.
*
* 8) For each block, there must be a path from the entry to it that
* includes only earlier blocks in the region.
*
* 9) The region is topologically sorted unless loops are enabled.
*
* 10) The block-retranslation chains cannot have cycles.
*
*/
bool check(const RegionDesc& region, std::string& error) {
auto bad = [&](const std::string& errorMsg) {
error = errorMsg;
return false;
};
// 1) The region has at least one block.
if (region.empty()) return bad("empty region");
RegionDesc::BlockIdSet blockSet;
for (auto b : region.blocks()) {
auto bid = b->id();
// 2) Each block in the region has a different id.
if (blockSet.count(bid)) {
return bad(folly::sformat("many blocks with id {}", bid));
}
blockSet.insert(bid);
}
for (auto b : region.blocks()) {
auto bid = b->id();
SrcKey lastSk = region.block(bid)->last();
OffsetSet validSuccOffsets = lastSk.succOffsets();
OffsetSet succOffsets;
for (auto succ : region.succs(bid)) {
SrcKey succSk = region.block(succ)->start();
Offset succOffset = succSk.offset();
// 3) All arcs involve blocks within the region.
if (blockSet.count(succ) == 0) {
return bad(folly::sformat("arc with dst not in the region: {} -> {}",
bid, succ));
}
// Checks 4) and 5) below don't make sense for arcs corresponding
// to inlined calls and returns, so skip them in such cases.
// This won't be possible once task #4076399 is done.
if (lastSk.func() != succSk.func()) continue;
// 4) For each arc, the bytecode offset of the dst block must
// possibly follow the execution of the src block.
if (validSuccOffsets.count(succOffset) == 0) {
return bad(folly::sformat("arc with impossible control flow: {} -> {}",
bid, succ));
}
// 5) Each block contains at most one successor corresponding to a
// given SrcKey.
if (succOffsets.count(succOffset) > 0) {
return bad(folly::sformat("block {} has multiple successors with SK {}",
bid, show(succSk)));
}
succOffsets.insert(succOffset);
}
for (auto pred : region.preds(bid)) {
if (blockSet.count(pred) == 0) {
return bad(folly::sformat("arc with src not in the region: {} -> {}",
pred, bid));
}
}
}
// 6) is checked by dfsCheck.
DFSChecker dfsCheck(region);
if (!dfsCheck.check(region.entry()->id())) {
return bad("region is cyclic");
}
// 7) All blocks are reachable from the entry (first) block.
if (dfsCheck.numVisited() != blockSet.size()) {
return bad("region has unreachable blocks");
}
// 8) and 9) are checked below.
RegionDesc::BlockIdSet visited;
auto& blocks = region.blocks();
for (unsigned i = 0; i < blocks.size(); i++) {
auto bid = blocks[i]->id();
unsigned nVisited = 0;
for (auto pred : region.preds(bid)) {
nVisited += visited.count(pred);
}
// 8) For each block, there must be a path from the entry to it that
// includes only earlier blocks in the region.
if (nVisited == 0 && i != 0) {
return bad(folly::sformat("block {} appears before all its predecessors",
bid));
}
// 9) The region is topologically sorted unless loops are enabled.
if (!RuntimeOption::EvalJitLoops && nVisited != region.preds(bid).size()) {
return bad(folly::sformat("non-topological order (bid: {})", bid));
}
visited.insert(bid);
}
// 10) The block-retranslation chains cannot have cycles.
for (auto b : blocks) {
auto bid = b->id();
RegionDesc::BlockIdSet chainSet;
chainSet.insert(bid);
while (auto next = region.nextRetrans(bid)) {
auto nextId = next.value();
if (chainSet.count(nextId)) {
return bad(folly::sformat("cyclic retranslation chain for block {}",
bid));
}
chainSet.insert(nextId);
bid = nextId;
}
}
return true;
}