Function queueFlush

src/e9patch/e9api.cpp:57–109

* Flush the patching queue up to the new cursor. */

 * Flush the patching queue up to the new cursor.
 */
static void queueFlush(Binary *B, intptr_t cursor)
{
    if (B->cursor <= cursor)
        error("failed to patch instruction at address 0x%lx; \"patch\" "
            "messages were not send in reverse order", cursor);
    B->cursor = cursor;

    cursor += std::max(
        T0_LIMIT * /*max instruction size=*/15,
        /*max short jmp=*/ INT8_MAX + 2 + /*max instruction size=*/15) +
            /*a bit extra=*/32;
    while (!B->Q.empty() &&
            (B->Q.back().options || B->Q.back().I->addr > cursor))
    {
        const auto &entry = B->Q.back();
        if (!entry.options)
        {
            // Patch entry
            Instr *I            = entry.I;
            const Trampoline *T = entry.T;
            switch (I->STATE[0])
            {
                case STATE_QUEUED:
                    for (unsigned i = 0; i < I->size; i++)
                    {
                        assert(I->STATE[i] == STATE_QUEUED);
                        I->STATE[i] = STATE_INSTRUCTION;
                    }
                    I->debug = (option_trap_all ||
                        option_trap.find(I->addr) != option_trap.end());
                    if (patch(*B, I, T))
                        stat_num_patched++;
                    else
                        stat_num_failed++;
                    break;
                default:
                    // For other states we assume T0 was applies:
                    stat_num_patched++;
                    stat_num_T0++;
                    log(COLOR_GREEN, '.');
                    break;
            }
        }
        else
        {
            // Options entry
            char * const *argv = entry.argv;
            parseOptions(B, argv);
            delete[] argv;
        }
        B->Q.pop_back();
    }
}

/*
 * Queue an instruction for patching.