Method Split

Source/Libraries/Backend/Source/IL/BasicBlock.cpp:122–341

}

IL::BasicBlock::Iterator IL::BasicBlock::Split(IL::BasicBlock *destBlock, const IL::BasicBlock::Iterator &splitIterator, BasicBlockSplitFlagSet splitFlags) {
    ASSERT(destBlock->IsEmpty(), "Cannot split into a filled basic block");

    // The actual split iterator
    Iterator splitIteratorPhi = splitIterator;

    // Redirect backedges?
    if (splitFlags & BasicBlockSplitFlag::RedirectLoopBackedge) {
        // Are we splitting the terminator too?
        if (splitIteratorPhi != end()) {
            Iterator terminator = GetTerminator();

            // Is this a loop header we're splitting?
            BranchControlFlow controlFlow;
            if (Backend::IL::GetControlFlow(terminator.Get(), controlFlow) && controlFlow._continue != InvalidID) {
                BasicBlock* continueBlock = map.GetBasicBlock(controlFlow._continue);

                // Get the terminator in the continue block
                auto* continueBranch = continueBlock->GetTerminator().GetMutable()->Cast<BranchInstruction>();
                ASSERT(continueBranch, "Continue blocks must contain a single branch");

                // Remap the back-edge to the new loop header
                continueBranch->branch = destBlock->GetID();
            }
        }
    }

    bool hasUnresolvedBackEdgePhis = false;

    // Splitting phis?
    if (splitIteratorPhi->Is<PhiInstruction>() && splitFlags & BasicBlockSplitFlag::SplitPhiEdges) {
        BranchControlFlow controlFlow;
        Backend::IL::GetControlFlow(GetTerminator(), controlFlow);

        // Does the phi operation reference a backedge?
        bool hasBackEdge = IsAnyPhiBranchBackEdge(splitIterator->As<PhiInstruction>(), controlFlow);
        hasUnresolvedBackEdgePhis = hasBackEdge;

        // Validate that all phi operations have the same status
        // We're making quite a few assumptions on this, so it must hold true
#ifndef NDEBUG
        for (auto it = splitIteratorPhi; it != destBlock->end() && it->Is<PhiInstruction>(); ++it) {
            ASSERT(IsAnyPhiBranchBackEdge(it->As<PhiInstruction>(), controlFlow) == hasBackEdge, "Mismatch in back-edge status");
        }
#endif // !NDEBUG

        // If there's no back edges, preserve the phi operations, do not split with them
        if (!hasBackEdge) {
            splitIteratorPhi = Backend::IL::FirstNonPhi(this, splitIteratorPhi);
        }
    }

    // Byte offset to the split point
    uint32_t splitPointRelocationOffset = relocationTable[splitIteratorPhi.relocationIndex]->offset;

    // Redirect all branch users if requested
    if (splitFlags & BasicBlockSplitFlag::RedirectBranchUsers) {
        TrivialStackVector<IL::OpaqueInstructionRef, 128> removed(allocators);