Adding support for Z80?

[tstih]

Hi Everyone,
I'd like to help adding a support for Z80, but:

1. I don't know if it is architecturally possible,
2. Is anyone already working on this,
3. I don't know where to start, is there a document available for porting REDasm or is code the only document?
   Regards,
   Tom

[Dax89]

Hi!

Yes it's possible to add Z80 support (you can even integrate your own Z80 disassembler: https://github.com/tstih/bugz)
This is a skeleton code for a possible Z80 assembler plugin, I hope it's clear:

// z80.cpp
#include <rdapi/rdapi.h>

namespace {

// Instruct the engine how to disassemble the data 
void emulate(RDContext* ctx, RDEmulateResult* result) 
{
    // Current address
    rd_address address = RDEmulateResult_GetAddress(result);

    /* 
     * Get a view of the data to be analyzed
     * RDBufferView is a struct with:
     * - data: pointer to data
     * - size: size of the view
     */
    const RDBufferView* view = RDEmulateResult_GetView(result);
    z80_instr* instr = /* decode the instruction ("z80_instr" is a placeholder type) */;

    /*
     * Mark view + instr->length bytes as instruction.
     * This information is used to move RDBufferView too, so the next instruction can be analyzed
     */    
    RDEmulateResult_SetSize(result, instr->length);

    // Handle the control flow, if needed:
    switch(instr->type) {
        case Z80_RETURN:
            RDEmulateResult_AddReturn(result); // Don't analyze next bytes
            break;

        case Z80_COND_JUMP:
            RDEmulateResult_AddBranchTrue(result, instr->operands[0].imm);  // Enqueue analysis and mark it as "jump if true"
            RDEmulateResult_AddBranchFalse(result,  address + instr->length); // Enqueue analysis and mark it as "jump if false"
            break;

        case Z80_JUMP:
            RDEmulateResult_AddBranch(result, instr->operands[0].imm); // Enqueue analysis and mark it as jump
            break;

        case Z80_CALL:
            RDEmulateResult_AddCall(result, instr->operands[0].imm); // Enqueue analysis and mark it as function
            break;

        /*
         * You can handle more instruction types
         */

        default:
            break;
    }
}

// Instruction rendering on screen
void render_instruction(RDContext* ctx, const RDRendererParams* rp)
{
    RDBufferView view = rp->view;
    z80_instr* instr = /* decode the instruction ("z80_instr" is a placeholder type) */;

    // Render instruction's mnemonic
    RDRenderer_Mnemonic(rp->renderer, instr->mnemonic, Theme_Default);

   for(size_t i = 0; i < instr->operands_count; i++) {
        if(instr->operands[i] == Z80_OP_IMM) {
             // If the value is just an integer constant you can use "RDRenderer_Unsigned" function
             RDRenderer_Reference(rp->renderer, instr->operands[i].imm);
        }
        else if(instr->operands[i] == Z80_OP_REG)
            RDRenderer_Register(rp->renderer, instr->operands[i].reg_name);
        else
             // ... more operand types ...
   }

}

} // namespace

void rdplugin_init(RDContext*, RDPluginModule* m)
{
    /* Plugin initialization function */
    RD_PLUGIN_ENTRY(RDEntryAssembler, z80, "z80");
    z80.renderinstruction = &render_instruction;
    z80.emulate = &emulate;
    z80.bits = 8; // I don't remember if Z80 architecture is 8 bits
    RDAssembler_Register(m, &z80);
}

void rdplugin_free(RDContext* ctx) { /* Free our own data here (optional) */ }

# CMakeLists.txt

cmake_minimum_required(VERSION 3.12)

project(Z80)
find_package(REDasm REQUIRED)

file(GLOB_RECURSE HEADERS *.h*)
file(GLOB_RECURSE SOURCES *.cpp)

redasm_plugin(${PROJECT_NAME} ${ASSEMBLER_TYPE} ${HEADERS} ${SOURCES})

I'm working on my spare time on this project, so there isn't any documentation available and currently REDasm is going to a massive rewrite in order to make these things simpler to understand and easy to learn for users/plugin developers.
The new plugin structure will remain more or less the same, but it can be done with scripting languages too, C/C++ knowledge are not mandatory.