propeller_disas.c

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2014 Fedor Sakharov <fedor.sakharov@gmail.com>
// SPDX-License-Identifier: LGPL-3.0-only
 
#include <rz_types.h>
#include <rz_util.h>
 
#include "propeller_disas.h"
 
static const char *instrs[] = {
    [PROP_ABS] = "abs",
    [PROP_ABSNEG] = "absneg",
    [PROP_ADD] = "add",
    [PROP_ADDABS] = "addabs",
    [PROP_ADDS] = "adds",
    [PROP_ADDSX] = "addsx",
    [PROP_ADDX] = "addx",
    [PROP_AND] = "and", // or TEST
    [PROP_ANDN] = "andn", // or TESTN
    [PROP_CALL] = "call", // or JMP JMPRET RET
    [PROP_CMP] = "cmp",
    [PROP_CMPS] = "cmps",
    [PROP_CMPSUB] = "cmpsub",
    [PROP_CMPSX] = "cmpsx",
    [PROP_CMPX] = "cmpx",
    [PROP_DJNZ] = "djnz",
    [PROP_HUBOP] = "hubop",
    [PROP_MOV] = "mov",
    [PROP_MAX] = "max",
    [PROP_MAXS] = "maxs",
    [PROP_MIN] = "min",
    [PROP_MINS] = "mins",
    [PROP_MOVD] = "movd",
    [PROP_MOVI] = "movi",
    [PROP_MOVS] = "movs",
    [PROP_MUXC] = "muxc",
    [PROP_MUXNC] = "muxnc",
    [PROP_MUXNZ] = "muxnz",
    [PROP_MUXZ] = "muxz",
    [PROP_NEG] = "neg",
    [PROP_NEGC] = "negc",
    [PROP_NEGNC] = "negnc",
    [PROP_NEGNZ] = "negnz",
    [PROP_NEGZ] = "negz",
    [PROP_OR] = "or",
    [PROP_RCL] = "rcl",
    [PROP_RCR] = "rcr",
    [PROP_RDBYTE] = "rdbyte",
    [PROP_RDLONG] = "rdlong",
    [PROP_RDWORD] = "rdword",
    [PROP_REV] = "rev",
    [PROP_ROL] = "rol",
    [PROP_ROR] = "ror",
    [PROP_SAR] = "sar",
    [PROP_SHL] = "shl",
    [PROP_SHR] = "shr",
    [PROP_SUBABS] = "subabs",
    [PROP_SUBS] = "subs",
    [PROP_SUBSX] = "subsx",
    [PROP_SUMC] = "sumc",
    [PROP_SUMNC] = "sumnc",
    [PROP_SUMNZ] = "sumnz",
    [PROP_SUMZ] = "sumz",
    [PROP_TJZ] = "tjz",
    [PROP_WAITCNT] = "waitcnt",
    [PROP_WAITVID] = "waitvid",
    [PROP_XOR] = "xor",
};
 
static const char *ext_instrs[] = {
    [PROP_CLKSET] = "clkset",
    [PROP_COGID] = "cogid",
    [PROP_COGINIT] = "coginit",
    [PROP_COGSTOP] = "cogstop",
    [PROP_LOCKCLR] = "lockclr",
    [PROP_LOCKNEW] = "locknew",
    [PROP_LOCKRET] = "lockret",
    [PROP_LOCKSET] = "lockset",
};
 
static const char *conditions[] = {
    [PROP_IF_ALWAYS] = "",
    [PROP_IF_NEVER] = "",
    [PROP_IF_E] = "if_e",
    [PROP_IF_NE] = "if_ne",
    [PROP_IF_A] = "if_a",
    [PROP_IF_B] = "if_b",
    [PROP_IF_AE] = "if_ae",
    [PROP_IF_BE] = "if_be",
    [PROP_IF_C_EQ_Z] = "if_c_eq_z",
    [PROP_IF_C_NE_Z] = "if_c_ne_z",
    [PROP_IF_C_AND_Z] = "if_c_and_z",
    [PROP_IF_C_AND_NZ] = "if_c_and_nz",
    [PROP_IF_NC_AND_Z] = "if_nc_and_z",
    [PROP_IF_NZ_OR_NC] = "if_nc_or_nz",
    [PROP_IF_NZ_OR_C] = "if_nz_or_c",
    [PROP_IF_Z_OR_NC] = "if_z_or_c",
};
 
static ut16 get_opcode(ut32 instr) {
    return instr >> 26;
}
 
static ut16 get_opcode_ext(ut32 instr) {
    return (instr & 0x7) | (instr >> 23);
}
 
static ut16 get_src(ut32 instr) {
    return instr & 0x1FF;
}
 
static ut16 get_dst(ut32 instr) {
    return ((instr >> 9) & 0x1FF) << 2;
}
 
static int is_immediate(ut32 instr) {
    return instr & 0x00400000;
}
 
static int decode_ext_cmd(struct propeller_cmd *cmd, ut32 instr) {
    ut16 opcode;
 
    opcode = get_opcode_ext(instr);
 
    switch (opcode) {
    case PROP_CLKSET:
    case PROP_COGID:
    case PROP_COGINIT:
    case PROP_COGSTOP:
    case PROP_LOCKCLR:
    case PROP_LOCKNEW:
    case PROP_LOCKRET:
    case PROP_LOCKSET:
        snprintf(cmd->instr, PROP_INSTR_MAXLEN - 1,
            "%s", ext_instrs[PROP_CLKSET]);
        snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1,
            "%d", get_dst(instr));
        return 4;
        break;
    }
 
    return -1;
}
 
static ut8 get_zcri(ut32 instr) {
    return (instr >> 22) & 0xf;
}
 
static ut8 get_con(ut32 instr) {
    return (instr >> 18) & 0xf;
}
 
static void decode_prefix(struct propeller_cmd *cmd, ut32 instr) {
    ut8 prefix = (instr >> 18) & 0xF;
 
    snprintf(cmd->prefix, 15, "%s", conditions[prefix]);
    cmd->prefix[15] = '\0';
}
 
static int decode_jmp(struct propeller_cmd *cmd, ut32 instr) {
    ut16 opcode;
    ut8 zcri;
    int ret = 1;
    opcode = get_opcode(instr);
    switch (opcode) {
    case PROP_JMP:
        zcri = get_zcri(instr);
        if (zcri & 0x2) {
            snprintf(cmd->instr, PROP_INSTR_MAXLEN - 1,
                "%s", "jmpret");
            if (zcri & 1) {
                cmd->dst = get_dst(instr) << 2;
                cmd->src = get_src(instr) << 2;
 
                snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1,
                    "0x%x, #0x%x", get_dst(instr), get_src(instr) << 2);
            } else {
                cmd->src = get_src(instr) << 2;
                cmd->dst = get_dst(instr) << 2;
                snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1,
                    "0x%x, 0x%x", get_dst(instr), get_src(instr) << 2);
            }
        } else {
            snprintf(cmd->instr, PROP_INSTR_MAXLEN - 1,
                "%s", "jmp");
            if (zcri & 1) {
                cmd->src = get_src(instr) << 2;
                cmd->immed = 1;
                snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1,
                    "#0x%x", get_src(instr) << 2);
            } else {
                cmd->immed = 0;
                cmd->src = get_src(instr) << 2;
                snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1,
                    "0x%x", get_src(instr) << 2);
            }
        }
 
        ret = 4;
        break;
    }
 
    return ret;
}
 
int propeller_decode_command(const ut8 *instr, struct propeller_cmd *cmd) {
    int ret = -1;
    ut32 in;
    ut16 opcode;
 
    in = rz_read_be32(instr);
 
    opcode = get_opcode(in);
 
    if (!get_con(in)) {
        snprintf(cmd->instr, PROP_INSTR_MAXLEN, "nop");
        cmd->operands[0] = '\0';
        return 4;
    }
 
    switch (opcode) {
    case PROP_ABS:
    case PROP_ABSNEG:
    case PROP_ADD:
    case PROP_ADDABS:
    case PROP_ADDS:
    case PROP_ADDSX:
    case PROP_ADDX:
    case PROP_AND:
    case PROP_ANDN:
    case PROP_CMP:
    case PROP_CMPS:
    case PROP_CMPSUB:
    case PROP_CMPSX:
    case PROP_CMPX:
    case PROP_DJNZ:
    case PROP_MAX:
    case PROP_MAXS:
    case PROP_MIN:
    case PROP_MINS:
    case PROP_MOV:
    case PROP_MOVD:
    case PROP_MOVI:
    case PROP_MOVS:
    case PROP_MUXC:
    case PROP_MUXNC:
    case PROP_MUXNZ:
    case PROP_MUXZ:
    case PROP_NEG:
    case PROP_NEGC:
    case PROP_NEGNC:
    case PROP_NEGNZ:
    case PROP_NEGZ:
    case PROP_OR:
    case PROP_RCL:
    case PROP_RCR:
    case PROP_RDBYTE:
    case PROP_RDLONG:
    case PROP_RDWORD:
        // case PROP_RET:
    case PROP_REV:
    case PROP_ROL:
    case PROP_ROR:
    case PROP_SAR:
    case PROP_SHL:
    case PROP_SHR:
    case PROP_SUBABS:
    case PROP_SUBS:
    case PROP_SUBSX:
        // case PROP_SUBX:
    case PROP_SUMC:
    case PROP_SUMNC:
    case PROP_SUMNZ:
    case PROP_SUMZ:
        // case PROP_TEST:
    case PROP_TJZ:
    case PROP_WAITCNT:
    case PROP_WAITPEQ:
    case PROP_WAITPNE:
    case PROP_WAITVID:
    case PROP_XOR:
        snprintf(cmd->instr, sizeof cmd->instr, "%s", instrs[opcode]);
 
        if ((opcode == PROP_RDBYTE || opcode == PROP_RDLONG ||
                opcode == PROP_RDWORD) &&
            (!(get_zcri(in) & 0x2))) {
            cmd->instr[0] = 'w';
            cmd->instr[1] = 'r';
        }
 
        if (opcode == PROP_SUB && in & 0x08000000) {
            snprintf(cmd->instr, PROP_INSTR_MAXLEN - 1, "sub");
        } else if (opcode == PROP_SUBX && in & 0x08000000) {
            snprintf(cmd->instr, PROP_INSTR_MAXLEN - 1, "subx");
        }
 
        if (is_immediate(in)) {
            cmd->src = get_src(in);
            cmd->dst = get_dst(in);
            snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1, "0x%x, #%d",
                get_dst(in), get_src(in));
        } else {
            cmd->src = get_src(in) << 2;
            cmd->dst = get_dst(in);
            snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1, "0x%x, 0x%x",
                get_dst(in), get_src(in) << 2);
        }
 
        ret = 4;
        break;
    case PROP_HUBOP:
        ret = decode_ext_cmd(cmd, in);
        if (ret == -1) {
            snprintf(cmd->instr, PROP_INSTR_MAXLEN - 1, "%s",
                instrs[opcode]);
 
            if (is_immediate(in)) {
                cmd->src = get_src(in);
                cmd->dst = get_dst(in);
 
                snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1, "0x%x, #%d",
                    get_dst(in) << 2, get_src(in));
            } else {
                cmd->src = get_src(in);
                cmd->dst = get_dst(in);
 
                snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1, "0x%x, 0x%x",
                    get_dst(in), get_src(in));
            }
 
            ret = 4;
        }
        break;
    case PROP_JMP:
        ret = decode_jmp(cmd, in);
        break;
    }
 
    cmd->opcode = opcode;
 
    if (ret > 0) {
        decode_prefix(cmd, in);
    }
 
    return ret;
}