assembly_54.c File Reference

#include "arch_54.h"

Go to the source code of this file.

Functions
static LuaInstruction	encode_instruction (ut8 opcode, const char *arg_start, ut16 flag, ut8 arg_num)
bool	lua54_assembly (const char *input, st32 input_size, LuaInstruction *instruction_p)

Function Documentation

encode_instruction()

static LuaInstruction encode_instruction ( ut8  opcode, const char *  arg_start, ut16  flag, ut8  arg_num  )

static

Definition at line 6 of file assembly_54.c.

                                                                                                    {
    LuaInstruction instruction = 0;
    int args[4];
    char buffer[64]; // buffer for digits
    int cur_cnt = 0;
    int delta_offset;
 
    if (arg_num > sizeof(args)) {
        return -1;
    }
 
    for (int i = 0; i < arg_num; ++i) {
        delta_offset = lua_load_next_arg_start(arg_start, buffer);
        if (delta_offset == 0) {
            return -1;
        }
        if (lua_is_valid_num_value_string(buffer)) {
            args[i] = lua_convert_str_to_num(buffer);
            arg_start += delta_offset;
        } else {
            return -1;
        }
    }
 
    LUA_SET_OPCODE(instruction, opcode);
    if (has_param_flag(flag, PARAM_A)) {
        SETARG_A(instruction, args[cur_cnt++]);
        if (cur_cnt >= arg_num) {
            return instruction;
        }
    }
    if (has_param_flag(flag, PARAM_B)) {
        SETARG_B(instruction, args[cur_cnt++]);
        if (cur_cnt >= arg_num) {
            return instruction;
        }
    }
    if (has_param_flag(flag, PARAM_sB)) {
        SETARG_sB(instruction, args[cur_cnt++]);
        if (cur_cnt >= arg_num) {
            return instruction;
        }
    }
    if (has_param_flag(flag, PARAM_C)) {
        SETARG_C(instruction, args[cur_cnt++]);
        if (cur_cnt >= arg_num) {
            return instruction;
        }
    }
    if (has_param_flag(flag, PARAM_sC)) {
        SETARG_sC(instruction, args[cur_cnt++]);
        if (cur_cnt >= arg_num) {
            return instruction;
        }
    }
    if (has_param_flag(flag, PARAM_Ax)) {
        SETARG_Ax(instruction, args[cur_cnt++]);
        if (cur_cnt >= arg_num) {
            return instruction;
        }
    }
    if (has_param_flag(flag, PARAM_sBx)) {
        SETARG_sBx(instruction, args[cur_cnt++]);
        if (cur_cnt >= arg_num) {
            return instruction;
        }
    }
    if (has_param_flag(flag, PARAM_Bx)) {
        SETARG_Bx(instruction, args[cur_cnt++]);
        if (cur_cnt >= arg_num) {
            return instruction;
        }
    }
    if (has_param_flag(flag, PARAM_sJ)) {
        SETARG_sJ(instruction, args[cur_cnt++]);
        if (cur_cnt >= arg_num) {
            return instruction;
        }
    }
    if (has_param_flag(flag, PARAM_k)) {
        SETARG_k(instruction, args[cur_cnt++]);
        if (cur_cnt >= arg_num) {
            return instruction;
        }
    }
    assert(cur_cnt == arg_num);
 
    return instruction;
}

References args, assert(), has_param_flag, i, lua_convert_str_to_num(), lua_is_valid_num_value_string(), lua_load_next_arg_start(), LUA_SET_OPCODE, PARAM_A, PARAM_Ax, PARAM_B, PARAM_Bx, PARAM_C, PARAM_k, PARAM_sB, PARAM_sBx, PARAM_sC, PARAM_sJ, SETARG_A, SETARG_Ax, SETARG_B, SETARG_Bx, SETARG_C, SETARG_k, SETARG_sB, SETARG_sBx, SETARG_sC, and SETARG_sJ.

Referenced by lua54_assembly().

lua54_assembly()

bool lua54_assembly	(	const char *	input,
		st32	input_size,
		LuaInstruction *	instruction_p
	)

Definition at line 96 of file assembly_54.c.

                                                                                       {
    const char *opcode_start; // point to the header
    const char *opcode_end; // point to the first white space
    int opcode_len;
 
    const char *arg_start;
 
    ut8 opcode;
    LuaInstruction instruction = 0x00;
 
    /* Find the opcode */
    opcode_start = input;
    opcode_end = strchr(input, ' ');
    if (opcode_end == NULL) {
        opcode_end = input + input_size;
    }
 
    opcode_len = opcode_end - opcode_start;
    opcode = get_lua54_opcode_by_name(opcode_start, opcode_len);
 
    /* Find the arguments */
    arg_start = rz_str_trim_head_ro(opcode_end);
 
    /* Encode opcode and args */
    switch (opcode) {
    case OP_GETI:
    case OP_MMBIN:
    case OP_GETTABUP:
    case OP_CALL:
    case OP_GETTABLE:
    case OP_ADD:
    case OP_SUB:
    case OP_MUL:
    case OP_POW:
    case OP_DIV:
    case OP_IDIV:
    case OP_BAND:
    case OP_BOR:
    case OP_SHL:
    case OP_SHR:
    case OP_ADDK:
    case OP_SUBK:
    case OP_MULK:
    case OP_MODK:
    case OP_POWK:
    case OP_DIVK:
    case OP_IDIVK:
    case OP_BANDK:
    case OP_BORK:
    case OP_BXORK:
    case OP_GETFIELD:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_A | PARAM_B | PARAM_C,
            3);
        break;
    // iABC k instruction
    case OP_TAILCALL:
    case OP_RETURN:
    case OP_NEWTABLE:
    case OP_SETLIST:
    case OP_MMBINK:
    case OP_SETTABUP:
    case OP_SETTABLE:
    case OP_SETI:
    case OP_SETFIELD:
    case OP_SELF:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_A | PARAM_B | PARAM_C | PARAM_k,
            4);
        break;
    // AsBC k instruction
    case OP_MMBINI:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_A | PARAM_sB | PARAM_C | PARAM_k,
            4);
        break;
    // ABsC
    case OP_ADDI:
    case OP_SHRI:
    case OP_SHLI:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_A | PARAM_B | PARAM_sC,
            3);
        break;
    // AB
    case OP_MOVE:
    case OP_UNM:
    case OP_BNOT:
    case OP_NOT:
    case OP_LEN:
    case OP_CONCAT:
    case OP_LOADNIL:
    case OP_GETUPVAL:
    case OP_SETUPVAL:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_A | PARAM_B,
            2);
        break;
    // AB with k
    case OP_EQ:
    case OP_LT:
    case OP_LE:
    case OP_TESTSET:
    case OP_EQK:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_A | PARAM_B | PARAM_k,
            3);
        break;
    // AsB with k
    case OP_EQI:
    case OP_LTI:
    case OP_LEI:
    case OP_GTI:
    case OP_GEI:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_A | PARAM_sB | PARAM_k,
            3);
        break;
    // AC
    case OP_TFORCALL:
    case OP_VARARG:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_A | PARAM_C,
            2);
        break;
    // A
    case OP_LOADKX:
    case OP_LOADFALSE:
    case OP_LFALSESKIP:
    case OP_LOADTRUE:
    case OP_CLOSE:
    case OP_TBC:
    case OP_RETURN1:
    case OP_VARARGPREP:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_A,
            1);
        break;
    // A with k
    case OP_TEST:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_A | PARAM_k,
            2);
        break;
    // no arg
    case OP_RETURN0:
        LUA_SET_OPCODE(instruction, OP_RETURN0);
        break;
    // A Bx
    case OP_LOADK:
    case OP_FORLOOP:
    case OP_FORPREP:
    case OP_TFORLOOP:
    case OP_TFORPREP:
    case OP_CLOSURE:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_A | PARAM_Bx,
            2);
        break;
    // A sBx
    case OP_LOADI:
    case OP_LOADF:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_A | PARAM_sBx,
            2);
        break;
    // Ax
    case OP_EXTRAARG:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_Ax,
            1);
        break;
    // isJ
    case OP_JMP:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_sJ,
            1);
        break;
    default:
        return false;
    }
 
    if (instruction == -1) {
        return false;
    }
 
    *instruction_p = instruction;
    return true;
}

References encode_instruction(), get_lua54_opcode_by_name(), input(), LUA_SET_OPCODE, NULL, OP_ADD, OP_ADDI, OP_ADDK, OP_BAND, OP_BANDK, OP_BNOT, OP_BOR, OP_BORK, OP_BXORK, OP_CALL, OP_CLOSE, OP_CLOSURE, OP_CONCAT, OP_DIV, OP_DIVK, OP_EQ, OP_EQI, OP_EQK, OP_EXTRAARG, OP_FORLOOP, OP_FORPREP, OP_GEI, OP_GETFIELD, OP_GETI, OP_GETTABLE, OP_GETTABUP, OP_GETUPVAL, OP_GTI, OP_IDIV, OP_IDIVK, OP_JMP, OP_LE, OP_LEI, OP_LEN, OP_LFALSESKIP, OP_LOADF, OP_LOADFALSE, OP_LOADI, OP_LOADK, OP_LOADKX, OP_LOADNIL, OP_LOADTRUE, OP_LT, OP_LTI, OP_MMBIN, OP_MMBINI, OP_MMBINK, OP_MODK, OP_MOVE, OP_MUL, OP_MULK, OP_NEWTABLE, OP_NOT, OP_POW, OP_POWK, OP_RETURN, OP_RETURN0, OP_RETURN1, OP_SELF, OP_SETFIELD, OP_SETI, OP_SETLIST, OP_SETTABLE, OP_SETTABUP, OP_SETUPVAL, OP_SHL, OP_SHLI, OP_SHR, OP_SHRI, OP_SUB, OP_SUBK, OP_TAILCALL, OP_TBC, OP_TEST, OP_TESTSET, OP_TFORCALL, OP_TFORLOOP, OP_TFORPREP, OP_UNM, OP_VARARG, OP_VARARGPREP, PARAM_A, PARAM_Ax, PARAM_B, PARAM_Bx, PARAM_C, PARAM_k, PARAM_sB, PARAM_sBx, PARAM_sC, PARAM_sJ, and rz_str_trim_head_ro().

Referenced by rz_luac_asm().