Function tactic_T0

src/e9patch/e9tactics.cpp:802–877

* Tactic T0: Batch instructions that are not jump targets. * Assumes (overapproximate) control-flow-recovery */

 *            Assumes (overapproximate) control-flow-recovery
 */
static Patch *tactic_T0(Binary &B, Instr *I, const Trampoline *T,
    Tactic tactic = TACTIC_T0)
{
    if (!option_tactic_T0 || !option_OCFR || !canPatch(I) || I->T != T)
        return nullptr;

    // Step (1): build batch backwards, up to limit or target reached.
    Instr *J = I;
    size_t size = 0;
    for (unsigned limit = T0_LIMIT; !J->target && limit > 0; limit--)
    {
        size += J->size;
        Instr *K = J->pred();
        if (K == nullptr ||
                (K->STATE[0] != STATE_INSTRUCTION &&
                 K->STATE[0] != STATE_QUEUED))
            break;
        J = K;
    }

    // Step (2): Build batch fowards until sizeof(jmpq), or a CFT.
    Instr *L = I;
    bool cft = false;   // isUnconditionalCFT(I);
    while (!cft && size < /*sizeof(jmpq)=*/5)
    {
        Instr *K = L->succ();
        if (K == nullptr || K->target || !canPatch(K) ||
                (K->is_patched && !K->is_evicted))
            break;
        L = K;
        size += L->size;
        cft = isCFT(L->ORIG, L->size, CFT_CALL | CFT_RET | CFT_JMP);
    }
    if (J == L)
        return nullptr; // Batch is a single instruction == T0 failed

    // Step (3): "Free" all batched instructions.
    Patch *P = nullptr;
    for (Instr *K = L; K != nullptr && K->addr >= J->addr; K = K->pred())
    {
        Patch *Q = new Patch(K, TACTIC_T0, nullptr);
        patchUnused(Q, /*offset=*/0);
        Q->next = P;
        P = Q;
    }

    // Step (4): Build batch trampoline.
    Trampoline *U = nullptr;
    {
        size_t num_entries = 1;
        uint8_t *ptr =
            new uint8_t[sizeof(Trampoline) + num_entries * sizeof(Entry)];
        U                    = (Trampoline *)ptr;
        U->prot              = PROT_READ | PROT_EXEC;
        U->num_entries       = num_entries;
        U->preload           = false;
        U->entries[0].kind   = ENTRY_BATCH;
        U->entries[0].length = 0;