lua_arch.h File Reference

#include <rz_types.h>
#include <rz_asm.h>

Go to the source code of this file.

Macros
#define	LUA_REG_PREF   "R"
#define	LUA_CONST_PREF   "CONST"
#define	LUA_KR_PREF   "R/CONST"
#define	LUA_UPVALUE_PREF   "UPV"
#define	LUA_EVENT_PREF   "EVENT"
#define	LUA_KPROTO_PREF   "KPROTO"
#define	LUA_NO_PREFIX   ""
#define	LUA_EXTRAARG_MARK   "#Ex"
#define	LUA_KFLAG_MARK   "#Kflag"
#define	LUA_JMP_MARK   "#To"
#define	LUA_CLOSURE_MARK   "#CLOSURE"
#define	LUA_KX_MARK   " CONST[#Ex]"

Typedefs
typedef ut32	LuaInstruction
typedef char **	LuaOpNameList

Functions
LuaInstruction	lua_build_instruction (const ut8 *buf)
void	lua_set_instruction (LuaInstruction instruction, ut8 *data)
int	lua_load_next_arg_start (const char *raw_string, char *recv_buf)
bool	lua_is_valid_num_value_string (const char *str)
int	lua_convert_str_to_num (const char *str)
char *	luaop_new_str_3arg (char *opname, int a, int b, int c)
char *	luaop_new_str_2arg (char *opname, int a, int b)
char *	luaop_new_str_1arg (char *opname, int a)
char *	luaop_new_str_3arg_ex (char *opname, int a, int b, int c, int isk)
char *	luaop_new_str_2arg_ex (char *opname, int a, int b, int isk)
char *	luaop_new_str_1arg_ex (char *opname, int a, int isk)
bool	free_lua_opnames (LuaOpNameList list)
int	lua54_disasm (RzAsmOp *op, const ut8 *buf, int len, LuaOpNameList oplist)
int	lua54_anal_op (RzAnalysis *analysis, RzAnalysisOp *op, ut64 addr, const ut8 *data, int len)
bool	lua54_assembly (const char *input, st32 input_size, LuaInstruction *instruction)
LuaOpNameList	get_lua54_opnames (void)
ut8	get_lua54_opcode_by_name (const char *name, int len)
int	lua53_disasm (RzAsmOp *op, const ut8 *buf, int len, LuaOpNameList oplist)
int	lua53_anal_op (RzAnalysis *analysis, RzAnalysisOp *op, ut64 addr, const ut8 *data, int len)
bool	lua53_assembly (const char *input, st32 input_size, LuaInstruction *instruction)
LuaOpNameList	get_lua53_opnames (void)
ut8	get_lua53_opcode_by_name (const char *name, int len)

Macro Definition Documentation

LUA_CLOSURE_MARK

#define LUA_CLOSURE_MARK   "#CLOSURE"

Definition at line 23 of file lua_arch.h.

LUA_CONST_PREF

#define LUA_CONST_PREF   "CONST"

Definition at line 12 of file lua_arch.h.

LUA_EVENT_PREF

#define LUA_EVENT_PREF   "EVENT"

Definition at line 15 of file lua_arch.h.

LUA_EXTRAARG_MARK

#define LUA_EXTRAARG_MARK   "#Ex"

Definition at line 20 of file lua_arch.h.

LUA_JMP_MARK

#define LUA_JMP_MARK   "#To"

Definition at line 22 of file lua_arch.h.

LUA_KFLAG_MARK

#define LUA_KFLAG_MARK   "#Kflag"

Definition at line 21 of file lua_arch.h.

LUA_KPROTO_PREF

#define LUA_KPROTO_PREF   "KPROTO"

Definition at line 16 of file lua_arch.h.

LUA_KR_PREF

#define LUA_KR_PREF   "R/CONST"

Definition at line 13 of file lua_arch.h.

LUA_KX_MARK

#define LUA_KX_MARK   " CONST[#Ex]"

Definition at line 24 of file lua_arch.h.

LUA_NO_PREFIX

#define LUA_NO_PREFIX   ""

Definition at line 17 of file lua_arch.h.

LUA_REG_PREF

#define LUA_REG_PREF   "R"

Definition at line 11 of file lua_arch.h.

LUA_UPVALUE_PREF

#define LUA_UPVALUE_PREF   "UPV"

Definition at line 14 of file lua_arch.h.

Typedef Documentation

LuaInstruction

typedef ut32 LuaInstruction

Definition at line 27 of file lua_arch.h.

LuaOpNameList

typedef char** LuaOpNameList

Definition at line 30 of file lua_arch.h.

Function Documentation

free_lua_opnames()

bool free_lua_opnames

(

LuaOpNameList

list

)

Definition at line 22 of file lua_arch.c.

                                          {
    if (list != NULL) {
        RZ_FREE(list);
        return true;
    }
    return false;
}

References list(), NULL, and RZ_FREE.

Referenced by rz_luac_disasm().

get_lua53_opcode_by_name()

ut8 get_lua53_opcode_by_name	(	const char *	name,
		int	len
	)

Definition at line 69 of file opcode_53.c.

                                                          {
    lua_strcase("move") return OP_MOVE;
    lua_strcase("loadk") return OP_LOADK;
    lua_strcase("loadkx") return OP_LOADKX;
    lua_strcase("loadbool") return OP_LOADBOOL;
    lua_strcase("loadnil") return OP_LOADNIL;
    lua_strcase("getupval") return OP_GETUPVAL;
    lua_strcase("gettabup") return OP_GETTABUP;
    lua_strcase("gettable") return OP_GETTABLE;
    lua_strcase("settabup") return OP_SETTABUP;
    lua_strcase("setupval") return OP_SETUPVAL;
    lua_strcase("settable") return OP_SETTABLE;
    lua_strcase("newtable") return OP_NEWTABLE;
 
    lua_strcase("self") return OP_SELF;
    lua_strcase("add") return OP_ADD;
    lua_strcase("sub") return OP_SUB;
    lua_strcase("mul") return OP_MUL;
    lua_strcase("mod") return OP_MOD;
    lua_strcase("pow") return OP_POW;
    lua_strcase("div") return OP_DIV;
    lua_strcase("idiv") return OP_IDIV;
    lua_strcase("band") return OP_BAND;
    lua_strcase("bor") return OP_BOR;
    lua_strcase("bxor") return OP_BXOR;
    lua_strcase("shl") return OP_SHL;
    lua_strcase("shr") return OP_SHR;
    lua_strcase("unm") return OP_UNM;
    lua_strcase("bnot") return OP_BNOT;
    lua_strcase("not") return OP_NOT;
 
    lua_strcase("len") return OP_LEN;
    lua_strcase("concat") return OP_CONCAT;
    lua_strcase("jmp") return OP_JMP;
    lua_strcase("eq") return OP_EQ;
    lua_strcase("lt") return OP_LT;
    lua_strcase("le") return OP_LE;
    lua_strcase("test") return OP_TEST;
    lua_strcase("testset") return OP_TESTSET;
 
    lua_strcase("call") return OP_CALL;
    lua_strcase("tailcall") return OP_TAILCALL;
    lua_strcase("return") return OP_RETURN;
    lua_strcase("forloop") return OP_FORLOOP;
    lua_strcase("forprep") return OP_FORPREP;
    lua_strcase("tforcall") return OP_TFORCALL;
    lua_strcase("tforloop") return OP_TFORLOOP;
    lua_strcase("setlist") return OP_SETLIST;
    lua_strcase("closure") return OP_CLOSURE;
    lua_strcase("vararg") return OP_VARARG;
    lua_strcase("extraarg") return OP_EXTRAARG;
 
    return OP_EXTRAARG + 1; // invalid
}

References lua_strcase, OP_ADD, OP_BAND, OP_BNOT, OP_BOR, OP_BXOR, OP_CALL, OP_CLOSURE, OP_CONCAT, OP_DIV, OP_EQ, OP_EXTRAARG, OP_FORLOOP, OP_FORPREP, OP_GETTABLE, OP_GETTABUP, OP_GETUPVAL, OP_IDIV, OP_JMP, OP_LE, OP_LEN, OP_LOADBOOL, OP_LOADK, OP_LOADKX, OP_LOADNIL, OP_LT, OP_MOD, OP_MOVE, OP_MUL, OP_NEWTABLE, OP_NOT, OP_POW, OP_RETURN, OP_SELF, OP_SETLIST, OP_SETTABLE, OP_SETTABUP, OP_SETUPVAL, OP_SHL, OP_SHR, OP_SUB, OP_TAILCALL, OP_TEST, OP_TESTSET, OP_TFORCALL, OP_TFORLOOP, OP_UNM, and OP_VARARG.

Referenced by lua53_assembly().

get_lua53_opnames()

LuaOpNameList get_lua53_opnames

(

void

)

Definition at line 10 of file opcode_53.c.

                                      {
    LuaOpNameList list = RZ_NEWS(char *, LUA_NUM_OPCODES + 1);
    if (list == NULL) {
        RZ_LOG_ERROR("Cannot allocate lua53 opcode list.\n");
        return NULL;
    }
 
    // Do not free the const string
    list[OP_MOVE] = "move";
    list[OP_LOADK] = "loadk";
    list[OP_LOADKX] = "loadkx";
    list[OP_LOADBOOL] = "loadbool";
    list[OP_LOADNIL] = "loadnil";
    list[OP_GETUPVAL] = "getupval";
    list[OP_GETTABUP] = "gettabup";
    list[OP_GETTABLE] = "gettable";
    list[OP_SETTABUP] = "settabup";
    list[OP_SETUPVAL] = "setupval";
    list[OP_SETTABLE] = "settable";
    list[OP_NEWTABLE] = "newtable";
    list[OP_SELF] = "self";
    list[OP_ADD] = "add";
    list[OP_SUB] = "sub";
    list[OP_MUL] = "mul";
    list[OP_MOD] = "mod";
    list[OP_POW] = "pow";
    list[OP_DIV] = "div";
    list[OP_IDIV] = "idiv";
    list[OP_BAND] = "band";
    list[OP_BOR] = "bor";
    list[OP_BXOR] = "bxor";
    list[OP_SHL] = "shl";
    list[OP_SHR] = "shr";
    list[OP_UNM] = "unm";
    list[OP_BNOT] = "bnot";
    list[OP_NOT] = "not";
    list[OP_LEN] = "len";
    list[OP_CONCAT] = "concat";
    list[OP_JMP] = "jmp";
    list[OP_EQ] = "eq";
    list[OP_LT] = "lt";
    list[OP_LE] = "le";
    list[OP_TEST] = "test";
    list[OP_TESTSET] = "testset";
    list[OP_CALL] = "call";
    list[OP_TAILCALL] = "tailcall";
    list[OP_RETURN] = "return";
    list[OP_FORLOOP] = "forloop";
    list[OP_FORPREP] = "forprep";
    list[OP_TFORCALL] = "tforcall";
    list[OP_TFORLOOP] = "tforloop";
    list[OP_SETLIST] = "setlist";
    list[OP_CLOSURE] = "closure";
    list[OP_VARARG] = "vararg";
    list[OP_EXTRAARG] = "extraarg";
 
    return list;
}

References list(), LUA_NUM_OPCODES, NULL, OP_ADD, OP_BAND, OP_BNOT, OP_BOR, OP_BXOR, OP_CALL, OP_CLOSURE, OP_CONCAT, OP_DIV, OP_EQ, OP_EXTRAARG, OP_FORLOOP, OP_FORPREP, OP_GETTABLE, OP_GETTABUP, OP_GETUPVAL, OP_IDIV, OP_JMP, OP_LE, OP_LEN, OP_LOADBOOL, OP_LOADK, OP_LOADKX, OP_LOADNIL, OP_LT, OP_MOD, OP_MOVE, OP_MUL, OP_NEWTABLE, OP_NOT, OP_POW, OP_RETURN, OP_SELF, OP_SETLIST, OP_SETTABLE, OP_SETTABUP, OP_SETUPVAL, OP_SHL, OP_SHR, OP_SUB, OP_TAILCALL, OP_TEST, OP_TESTSET, OP_TFORCALL, OP_TFORLOOP, OP_UNM, OP_VARARG, RZ_LOG_ERROR, and RZ_NEWS.

Referenced by rz_luac_disasm().

get_lua54_opcode_by_name()

ut8 get_lua54_opcode_by_name	(	const char *	name,
		int	len
	)

Definition at line 105 of file opcode_54.c.

                                                          {
    lua_strcase("move") return OP_MOVE;
    lua_strcase("loadi") return OP_LOADI;
    lua_strcase("loadf") return OP_LOADF;
    lua_strcase("loadk") return OP_LOADK;
    lua_strcase("loadkx") return OP_LOADKX;
    lua_strcase("loadfalse") return OP_LOADFALSE;
    lua_strcase("lfalseskip") return OP_LFALSESKIP;
    lua_strcase("loadtrue") return OP_LOADTRUE;
    lua_strcase("loadnil") return OP_LOADNIL;
    lua_strcase("getupval") return OP_GETUPVAL;
    lua_strcase("setupval") return OP_SETUPVAL;
 
    lua_strcase("gettabup") return OP_GETTABUP;
    lua_strcase("gettable") return OP_GETTABLE;
    lua_strcase("geti") return OP_GETI;
    lua_strcase("getfield") return OP_GETFIELD;
 
    lua_strcase("settabup") return OP_SETTABUP;
    lua_strcase("settable") return OP_SETTABLE;
    lua_strcase("seti") return OP_SETI;
    lua_strcase("setfield") return OP_SETFIELD;
 
    lua_strcase("newtable") return OP_NEWTABLE;
 
    lua_strcase("self") return OP_SELF;
 
    lua_strcase("addi") return OP_ADDI;
 
    lua_strcase("addk") return OP_ADDK;
    lua_strcase("subk") return OP_SUBK;
    lua_strcase("mulk") return OP_MULK;
    lua_strcase("modk") return OP_MODK;
    lua_strcase("powk") return OP_POWK;
    lua_strcase("divk") return OP_DIVK;
    lua_strcase("idivk") return OP_IDIVK;
 
    lua_strcase("bandk") return OP_BANDK;
    lua_strcase("bork") return OP_BORK;
    lua_strcase("bxork") return OP_BXORK;
 
    lua_strcase("shri") return OP_SHRI;
    lua_strcase("shli") return OP_SHLI;
 
    lua_strcase("add") return OP_ADD;
    lua_strcase("sub") return OP_SUB;
    lua_strcase("mul") return OP_MUL;
    lua_strcase("mod") return OP_MOD;
    lua_strcase("pow") return OP_POW;
    lua_strcase("div") return OP_DIV;
    lua_strcase("idiv") return OP_IDIV;
 
    lua_strcase("band") return OP_BAND;
    lua_strcase("bor") return OP_BOR;
    lua_strcase("bxor") return OP_BXOR;
    lua_strcase("shl") return OP_SHL;
    lua_strcase("shr") return OP_SHR;
 
    lua_strcase("mmbin") return OP_MMBIN;
    lua_strcase("mmbini") return OP_MMBINI;
    lua_strcase("mmbink") return OP_MMBINK;
 
    lua_strcase("unm") return OP_UNM;
    lua_strcase("bnot") return OP_BNOT;
    lua_strcase("not") return OP_NOT;
    lua_strcase("len") return OP_LEN;
    lua_strcase("concat") return OP_CONCAT;
 
    lua_strcase("close") return OP_CLOSE;
    lua_strcase("tbc") return OP_TBC;
    lua_strcase("jmp") return OP_JMP;
    lua_strcase("eq") return OP_EQ;
    lua_strcase("lt") return OP_LT;
    lua_strcase("le") return OP_LE;
 
    lua_strcase("eqk") return OP_EQK;
    lua_strcase("eqi") return OP_EQI;
    lua_strcase("lti") return OP_LTI;
    lua_strcase("lei") return OP_LEI;
    lua_strcase("gti") return OP_GTI;
    lua_strcase("gei") return OP_GEI;
 
    lua_strcase("test") return OP_TEST;
    lua_strcase("testset") return OP_TESTSET;
 
    lua_strcase("call") return OP_CALL;
    lua_strcase("tailcall") return OP_TAILCALL;
 
    lua_strcase("return") return OP_RETURN;
    lua_strcase("return0") return OP_RETURN0;
    lua_strcase("return1") return OP_RETURN1;
 
    lua_strcase("forloop") return OP_FORLOOP;
    lua_strcase("forprep") return OP_FORPREP;
 
    lua_strcase("tforprep") return OP_TFORPREP;
    lua_strcase("tforcall") return OP_TFORCALL;
    lua_strcase("tforloop") return OP_TFORLOOP;
 
    lua_strcase("setlist") return OP_SETLIST;
 
    lua_strcase("closure") return OP_CLOSURE;
 
    lua_strcase("vararg") return OP_VARARG;
 
    lua_strcase("varargprep") return OP_VARARGPREP;
 
    lua_strcase("extraarg") return OP_EXTRAARG;
 
    return OP_EXTRAARG + 1; // invalid
}

References lua_strcase, OP_ADD, OP_ADDI, OP_ADDK, OP_BAND, OP_BANDK, OP_BNOT, OP_BOR, OP_BORK, OP_BXOR, 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_MOD, 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, and OP_VARARGPREP.

Referenced by lua54_assembly().

get_lua54_opnames()

LuaOpNameList get_lua54_opnames

(

void

)

Definition at line 9 of file opcode_54.c.

                                      {
    LuaOpNameList list = RZ_NEWS(char *, LUA_NUM_OPCODES + 1);
    if (list == NULL) {
        RZ_LOG_ERROR("Cannot allocate lua54 opcode list.\n");
        return NULL;
    }
 
    // Do not free the const string
    list[OP_MOVE] = "move";
    list[OP_LOADI] = "loadi",
    list[OP_LOADF] = "loadf",
    list[OP_LOADK] = "loadk",
    list[OP_LOADKX] = "loadkx",
    list[OP_LOADFALSE] = "loadfalse",
    list[OP_LFALSESKIP] = "lfalseskip",
    list[OP_LOADTRUE] = "loadtrue",
    list[OP_LOADNIL] = "loadnil",
    list[OP_GETUPVAL] = "getupval",
    list[OP_SETUPVAL] = "setupval",
    list[OP_GETTABUP] = "gettabup",
    list[OP_GETTABLE] = "gettable",
    list[OP_GETI] = "geti",
    list[OP_GETFIELD] = "getfield",
    list[OP_SETTABUP] = "settabup",
    list[OP_SETTABLE] = "settable",
    list[OP_SETI] = "seti",
    list[OP_SETFIELD] = "setfield",
    list[OP_NEWTABLE] = "newtable",
    list[OP_SELF] = "self",
    list[OP_ADDI] = "addi",
    list[OP_ADDK] = "addk",
    list[OP_SUBK] = "subk",
    list[OP_MULK] = "mulk",
    list[OP_MODK] = "modk",
    list[OP_POWK] = "powk",
    list[OP_DIVK] = "divk",
    list[OP_IDIVK] = "idivk",
    list[OP_BANDK] = "bandk",
    list[OP_BORK] = "bork",
    list[OP_BXORK] = "bxork",
    list[OP_SHRI] = "shri",
    list[OP_SHLI] = "shli",
    list[OP_ADD] = "add",
    list[OP_SUB] = "sub",
    list[OP_MUL] = "mul",
    list[OP_MOD] = "mod",
    list[OP_POW] = "pow",
    list[OP_DIV] = "div",
    list[OP_IDIV] = "idiv",
    list[OP_BAND] = "band",
    list[OP_BOR] = "bor",
    list[OP_BXOR] = "bxor",
    list[OP_SHL] = "shl",
    list[OP_SHR] = "shr",
    list[OP_MMBIN] = "mmbin",
    list[OP_MMBINI] = "mmbini",
    list[OP_MMBINK] = "mmbink",
    list[OP_UNM] = "unm",
    list[OP_BNOT] = "bnot",
    list[OP_NOT] = "not",
    list[OP_LEN] = "len",
    list[OP_CONCAT] = "concat",
    list[OP_CLOSE] = "close",
    list[OP_TBC] = "tbc",
    list[OP_JMP] = "jmp",
    list[OP_EQ] = "eq",
    list[OP_LT] = "lt",
    list[OP_LE] = "le",
    list[OP_EQK] = "eqk",
    list[OP_EQI] = "eqi",
    list[OP_LTI] = "lti",
    list[OP_LEI] = "lei",
    list[OP_GTI] = "gti",
    list[OP_GEI] = "gei",
    list[OP_TEST] = "test",
    list[OP_TESTSET] = "testset",
    list[OP_CALL] = "call",
    list[OP_TAILCALL] = "tailcall",
    list[OP_RETURN] = "return",
    list[OP_RETURN0] = "return0",
    list[OP_RETURN1] = "return1",
    list[OP_FORLOOP] = "forloop",
    list[OP_FORPREP] = "forprep",
    list[OP_TFORPREP] = "tforprep",
    list[OP_TFORCALL] = "tforcall",
    list[OP_TFORLOOP] = "tforloop",
    list[OP_SETLIST] = "setlist",
    list[OP_CLOSURE] = "closure",
    list[OP_VARARG] = "vararg",
    list[OP_VARARGPREP] = "varargprep",
    list[OP_EXTRAARG] = "extraarg",
    list[LUA_NUM_OPCODES] = NULL;
 
    return list;
}

References list(), LUA_NUM_OPCODES, NULL, OP_ADD, OP_ADDI, OP_ADDK, OP_BAND, OP_BANDK, OP_BNOT, OP_BOR, OP_BORK, OP_BXOR, 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_MOD, 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, RZ_LOG_ERROR, and RZ_NEWS.

Referenced by rz_luac_disasm().

lua53_anal_op()

int lua53_anal_op	(	RzAnalysis *	analysis,
		RzAnalysisOp *	op,
		ut64	addr,
		const ut8 *	data,
		int	len
	)

Definition at line 7 of file analysis_53.c.

                                                                                           {
    if (!op) {
        return 0;
    }
 
    memset(op, 0, sizeof(RzAnalysisOp));
    const ut32 instruction = lua_build_instruction(data);
 
    ut32 extra_arg = 0;
    op->addr = addr;
    op->size = 4;
    op->type = RZ_ANALYSIS_OP_TYPE_UNK;
    op->eob = false;
 
    if (GET_OPCODE(instruction) > OP_EXTRAARG) {
        return op->size;
    }
    // op->mnemonic = strdup ();
 
    switch (GET_OPCODE(instruction)) {
    case OP_MOVE: /*      A B     R(A) := R(B)                                    */
        op->type = RZ_ANALYSIS_OP_TYPE_MOV;
        break;
    case OP_LOADK: /*     A Bx    R(A) := Kst(Bx)                                 */
        op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
        break;
    case OP_LOADKX: /*    A       R(A) := Kst(extra arg)                          */
        op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
        extra_arg = lua_build_instruction(data + 4);
        if (GET_OPCODE(extra_arg) == OP_EXTRAARG) {
            op->size = 8;
        }
        break;
    case OP_LOADBOOL: /*  A B C   R(A) := (Bool)B; if (C) pc++                    */
        op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
        op->val = !!GETARG_B(instruction);
        op->jump = op->addr + 8;
        op->fail = op->addr + 4;
        break;
    case OP_LOADNIL: /*   A B     R(A), R(A+1), ..., R(A+B) := nil                */
        break;
    case OP_GETUPVAL: /*  A B     R(A) := UpValue[B]                              */
    case OP_GETTABUP: /*  A B C   R(A) := UpValue[B][RK(C)]                       */
        op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
        break;
    case OP_GETTABLE: /*  A B C   R(A) := R(B)[RK(C)]                             */
        break;
 
    case OP_SETTABUP: /*  A B C   UpValue[A][RK(B)] := RK(C)                      */
    case OP_SETUPVAL: /*  A B     UpValue[B] := R(A)                              */
        op->type = RZ_ANALYSIS_OP_TYPE_STORE;
        break;
    case OP_SETTABLE: /*  A B C   R(A)[RK(B)] := RK(C)                            */
        break;
    case OP_NEWTABLE: /*  A B C   R(A) := {} (size = B,C)                         */
        op->type = RZ_ANALYSIS_OP_TYPE_NEW;
        break;
    case OP_SELF: /*      A B C   R(A+1) := R(B); R(A) := R(B)[RK(C)]             */
        break;
    case OP_ADD: /*       A B C   R(A) := RK(B) + RK(C)                           */
        op->type = RZ_ANALYSIS_OP_TYPE_ADD;
        break;
    case OP_SUB: /*       A B C   R(A) := RK(B) - RK(C)                           */
        op->type = RZ_ANALYSIS_OP_TYPE_SUB;
        break;
    case OP_MUL: /*       A B C   R(A) := RK(B) * RK(C)                           */
        op->type = RZ_ANALYSIS_OP_TYPE_MUL;
        break;
    case OP_MOD: /*       A B C   R(A) := RK(B) % RK(C)                           */
        op->type = RZ_ANALYSIS_OP_TYPE_MOD;
        break;
    case OP_POW: /*       A B C   R(A) := RK(B) ^ RK(C)                           */
        break;
    case OP_DIV: /*       A B C   R(A) := RK(B) / RK(C)                           */
    case OP_IDIV: /*      A B C   R(A) := RK(B) // RK(C)                          */
        op->type = RZ_ANALYSIS_OP_TYPE_DIV;
        break;
    case OP_BAND: /*      A B C   R(A) := RK(B) & RK(C)                           */
        op->type = RZ_ANALYSIS_OP_TYPE_AND;
        break;
    case OP_BOR: /*       A B C   R(A) := RK(B) | RK(C)                           */
        op->type = RZ_ANALYSIS_OP_TYPE_OR;
        break;
    case OP_BXOR: /*      A B C   R(A) := RK(B) ~ RK(C)                           */
        op->type = RZ_ANALYSIS_OP_TYPE_XOR;
        break;
    case OP_SHL: /*       A B C   R(A) := RK(B) << RK(C)                          */
        op->type = RZ_ANALYSIS_OP_TYPE_SHL;
        break;
    case OP_SHR: /*       A B C   R(A) := RK(B) >> RK(C)                          */
        op->type = RZ_ANALYSIS_OP_TYPE_SHR;
        break;
    case OP_UNM: /*       A B     R(A) := -R(B)                                   */
        break;
    case OP_BNOT: /*      A B     R(A) := ~R(B)                                   */
        op->type = RZ_ANALYSIS_OP_TYPE_CPL;
        break;
    case OP_NOT: /*       A B     R(A) := not R(B)                                */
        op->type = RZ_ANALYSIS_OP_TYPE_NOT;
        break;
    case OP_LEN: /*       A B     R(A) := length of R(B)                          */
    case OP_CONCAT: /*    A B C   R(A) := R(B).. ... ..R(C)                       */
        break;
    case OP_JMP: /*       A sBx   pc+=sBx; if (A) close all upvalues >= R(A - 1)  */
        op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
        op->jump = op->addr + (st32)(4 * GETARG_sBx(instruction));
        op->fail = op->addr + 4;
        break;
    case OP_EQ: /*        A B C   if ((RK(B) == RK(C)) ~= A) then pc++            */
    case OP_LT: /*        A B C   if ((RK(B) <  RK(C)) ~= A) then pc++            */
    case OP_LE: /*        A B C   if ((RK(B) <= RK(C)) ~= A) then pc++            */
    case OP_TEST: /*      A C     if not (R(A) <=> C) then pc++                   */
        op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
        op->jump = op->addr + 8;
        op->fail = op->addr + 4;
        break;
    case OP_TESTSET: /*   A B C   if (R(B) <=> C) then R(A) := R(B) else pc++     */
        op->type = RZ_ANALYSIS_OP_TYPE_CMOV;
        op->jump = op->addr + 8;
        op->fail = op->addr + 4;
        break;
    case OP_CALL: /*      A B C   R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
        op->type = RZ_ANALYSIS_OP_TYPE_RCALL;
        break;
    case OP_TAILCALL: /*  A B C   return R(A)(R(A+1), ... ,R(A+B-1))              */
        op->type = RZ_ANALYSIS_OP_TYPE_RCALL;
        op->type2 = RZ_ANALYSIS_OP_TYPE_RET;
        op->eob = true;
        op->stackop = RZ_ANALYSIS_STACK_INC;
        op->stackptr = -4;
        break;
    case OP_RETURN: /*    A B     return R(A), ... ,R(A+B-2)      (see note)      */
        op->type = RZ_ANALYSIS_OP_TYPE_RET;
        op->eob = true;
        op->stackop = RZ_ANALYSIS_STACK_INC;
        op->stackptr = -4;
        break;
    case OP_FORLOOP: /*   A sBx   R(A)+=R(A+2); if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
        op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
        op->jump = op->addr + 4 + 4 * (GETARG_sBx(instruction));
        op->fail = op->addr + 4;
        break;
    case OP_FORPREP: /*   A sBx   R(A)-=R(A+2); pc+=sBx                           */
        op->type = RZ_ANALYSIS_OP_TYPE_JMP;
        op->jump = op->addr + 4 + 4 * (GETARG_sBx(instruction));
        op->fail = op->addr + 4;
        break;
    case OP_TFORCALL: /*  A C     R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));  */
        op->type = RZ_ANALYSIS_OP_TYPE_RCALL;
        break;
    case OP_TFORLOOP: /*  A sBx   if R(A+1) ~= nil then { R(A)=R(A+1); pc += sBx }*/
        op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
        op->jump = op->addr + 4 + 4 * (GETARG_sBx(instruction));
        op->fail = op->addr + 4;
        break;
    case OP_SETLIST: /*   A B C   R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B        */
        op->type = RZ_ANALYSIS_OP_TYPE_STORE;
        break;
    case OP_CLOSURE: /*   A Bx    R(A) := closure(KPROTO[Bx])                     */
    case OP_VARARG: /*    A B     R(A), R(A+1), ..., R(A+B-2) = vararg            */
    case OP_EXTRAARG: /*   Ax      extra (larger) argument for previous opcode     */
        break;
    }
    return op->size;
}

References addr, GET_OPCODE, GETARG_B, GETARG_sBx, lua_build_instruction(), memset(), OP_ADD, OP_BAND, OP_BNOT, OP_BOR, OP_BXOR, OP_CALL, OP_CLOSURE, OP_CONCAT, OP_DIV, OP_EQ, OP_EXTRAARG, OP_FORLOOP, OP_FORPREP, OP_GETTABLE, OP_GETTABUP, OP_GETUPVAL, OP_IDIV, OP_JMP, OP_LE, OP_LEN, OP_LOADBOOL, OP_LOADK, OP_LOADKX, OP_LOADNIL, OP_LT, OP_MOD, OP_MOVE, OP_MUL, OP_NEWTABLE, OP_NOT, OP_POW, OP_RETURN, OP_SELF, OP_SETLIST, OP_SETTABLE, OP_SETTABUP, OP_SETUPVAL, OP_SHL, OP_SHR, OP_SUB, OP_TAILCALL, OP_TEST, OP_TESTSET, OP_TFORCALL, OP_TFORLOOP, OP_UNM, OP_VARARG, RZ_ANALYSIS_OP_TYPE_ADD, RZ_ANALYSIS_OP_TYPE_AND, RZ_ANALYSIS_OP_TYPE_CJMP, RZ_ANALYSIS_OP_TYPE_CMOV, RZ_ANALYSIS_OP_TYPE_CPL, RZ_ANALYSIS_OP_TYPE_DIV, RZ_ANALYSIS_OP_TYPE_JMP, RZ_ANALYSIS_OP_TYPE_LOAD, RZ_ANALYSIS_OP_TYPE_MOD, RZ_ANALYSIS_OP_TYPE_MOV, RZ_ANALYSIS_OP_TYPE_MUL, RZ_ANALYSIS_OP_TYPE_NEW, RZ_ANALYSIS_OP_TYPE_NOT, RZ_ANALYSIS_OP_TYPE_OR, RZ_ANALYSIS_OP_TYPE_RCALL, RZ_ANALYSIS_OP_TYPE_RET, RZ_ANALYSIS_OP_TYPE_SHL, RZ_ANALYSIS_OP_TYPE_SHR, RZ_ANALYSIS_OP_TYPE_STORE, RZ_ANALYSIS_OP_TYPE_SUB, RZ_ANALYSIS_OP_TYPE_UNK, RZ_ANALYSIS_OP_TYPE_XOR, RZ_ANALYSIS_STACK_INC, and st32.

Referenced by rz_lua_analysis_op().

lua53_assembly()

bool lua53_assembly	(	const char *	input,
		st32	input_size,
		LuaInstruction *	instruction
	)

Definition at line 60 of file assembly_53.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_lua53_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_LOADKX:
        instruction = encode_instruction(opcode, arg_start, PARAM_A, 1);
        break;
    case OP_MOVE:
    case OP_SETUPVAL:
    case OP_UNM:
    case OP_BNOT:
    case OP_NOT:
    case OP_LEN:
    case OP_LOADNIL:
    case OP_RETURN:
    case OP_VARARG:
    case OP_GETUPVAL:
        instruction = encode_instruction(opcode, arg_start, PARAM_A | PARAM_B, 2);
        break;
    case OP_TEST:
    case OP_TFORCALL:
        instruction = encode_instruction(opcode, arg_start, PARAM_A | PARAM_C, 2);
        break;
    case OP_LOADK:
    case OP_CLOSURE:
        instruction = encode_instruction(opcode, arg_start, PARAM_A | PARAM_Bx, 2);
        break;
    case OP_CONCAT:
    case OP_TESTSET:
    case OP_CALL:
    case OP_TAILCALL:
    case OP_NEWTABLE:
    case OP_SETLIST:
    case OP_LOADBOOL:
    case OP_SELF:
    case OP_GETTABUP:
    case OP_GETTABLE:
    case OP_SETTABUP:
    case OP_SETTABLE:
    case OP_ADD:
    case OP_SUB:
    case OP_MUL:
    case OP_MOD:
    case OP_POW:
    case OP_DIV:
    case OP_IDIV:
    case OP_BAND:
    case OP_BOR:
    case OP_BXOR:
    case OP_SHL:
    case OP_SHR:
    case OP_EQ:
    case OP_LT:
    case OP_LE:
        instruction = encode_instruction(opcode, arg_start,
            PARAM_A | PARAM_B | PARAM_C,
            3);
        break;
    case OP_JMP:
    case OP_FORLOOP:
    case OP_FORPREP:
    case OP_TFORLOOP:
        instruction = encode_instruction(opcode, arg_start, PARAM_A | PARAM_sBx, 2);
        break;
    case OP_EXTRAARG:
        instruction = encode_instruction(opcode, arg_start, PARAM_Ax, 1);
        break;
    default:
        return false;
    }
 
    if (instruction == -1) {
        return false;
    }
 
    *instruction_p = instruction;
    return true;
}

References encode_instruction(), get_lua53_opcode_by_name(), input(), NULL, OP_ADD, OP_BAND, OP_BNOT, OP_BOR, OP_BXOR, OP_CALL, OP_CLOSURE, OP_CONCAT, OP_DIV, OP_EQ, OP_EXTRAARG, OP_FORLOOP, OP_FORPREP, OP_GETTABLE, OP_GETTABUP, OP_GETUPVAL, OP_IDIV, OP_JMP, OP_LE, OP_LEN, OP_LOADBOOL, OP_LOADK, OP_LOADKX, OP_LOADNIL, OP_LT, OP_MOD, OP_MOVE, OP_MUL, OP_NEWTABLE, OP_NOT, OP_POW, OP_RETURN, OP_SELF, OP_SETLIST, OP_SETTABLE, OP_SETTABUP, OP_SETUPVAL, OP_SHL, OP_SHR, OP_SUB, OP_TAILCALL, OP_TEST, OP_TESTSET, OP_TFORCALL, OP_TFORLOOP, OP_UNM, OP_VARARG, PARAM_A, PARAM_Ax, PARAM_B, PARAM_Bx, PARAM_C, PARAM_sBx, and rz_str_trim_head_ro().

Referenced by rz_luac_asm().

lua53_disasm()

int lua53_disasm	(	RzAsmOp *	op,
		const ut8 *	buf,
		int	len,
		LuaOpNameList	oplist
	)

Definition at line 7 of file disassembly_53.c.

                                                                              {
    if (len < 4) {
        RZ_LOG_DEBUG("Cannot disassemble lua53 opcode (truncated).\n");
        return 0;
    }
    ut32 instruction = lua_build_instruction(buf);
    LuaOpCode opcode = GET_OPCODE(instruction);
 
    /* Pre fetch some args */
    int a = GETARG_A(instruction);
    int b = GETARG_B(instruction);
    int c = GETARG_C(instruction);
    int ax = GETARG_Ax(instruction);
    int bx = GETARG_Bx(instruction);
    int sbx = GETARG_sBx(instruction);
 
    // simplify test flag
    int is_special_B = b & 0x100;
    int is_special_C = c & 0x100;
 
    int special_c = 0xFF - c;
    int special_b = 0xFF - b;
 
    char *asm_string;
 
    switch (opcode) {
    case OP_LOADKX: /*    A       R(A) := Kst(extra arg)                          */
        asm_string = luaop_new_str_1arg(opnames[opcode], a);
        break;
    case OP_MOVE: /*      A B     R(A) := R(B)                                    */
    case OP_SETUPVAL: /*  A B     UpValue[B] := R(A)                              */
    case OP_UNM: /*       A B     R(A) := -R(B)                                   */
    case OP_BNOT: /*      A B     R(A) := ~R(B)                                   */
    case OP_NOT: /*       A B     R(A) := not R(B)                                */
    case OP_LEN: /*       A B     R(A) := length of R(B)                          */
    case OP_LOADNIL: /*   A B     R(A), R(A+1), ..., R(A+B) := nil                */
    case OP_RETURN: /*    A B     return R(A), ... ,R(A+B-2)      (see note)      */
    case OP_VARARG: /*    A B     R(A), R(A+1), ..., R(A+B-2) = vararg            */
    case OP_GETUPVAL: /*  A B     R(A) := UpValue[B]                              */
        asm_string = luaop_new_str_2arg(opnames[opcode], a, b);
        break;
    case OP_TEST: /*      A C     if not (R(A) <=> C) then pc++                   */
    case OP_TFORCALL: /*  A C     R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));  */
        asm_string = luaop_new_str_2arg(opnames[opcode], a, c);
        break;
    case OP_LOADK: /*     A Bx    R(A) := Kst(Bx)                                 */
    case OP_CLOSURE: /*   A Bx    R(A) := closure(KPROTO[Bx])                     */
        asm_string = luaop_new_str_2arg(opnames[opcode], a, bx);
        break;
    case OP_CONCAT: /*    A B C   R(A) := R(B).. ... ..R(C)                       */
    case OP_TESTSET: /*   A B C   if (R(B) <=> C) then R(A) := R(B) else pc++     */
    case OP_CALL: /*      A B C   R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
    case OP_TAILCALL: /*  A B C   return R(A)(R(A+1), ... ,R(A+B-1))              */
    case OP_NEWTABLE: /*  A B C   R(A) := {} (size = B,C)                         */
    case OP_SETLIST: /*   A B C   R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B        */
    case OP_LOADBOOL: /*  A B C   R(A) := (Bool)B; if (C) pc++                    */
    case OP_SELF: /*      A B C   R(A+1) := R(B); R(A) := R(B)[RK(C)]             */
        asm_string = luaop_new_str_3arg(opnames[opcode], a, b, c);
        break;
    case OP_GETTABUP: /*  A B C   R(A) := UpValue[B][RK(C)]                       */
    case OP_GETTABLE: /*  A B C   R(A) := R(B)[RK(C)]                             */
        if (is_special_C) {
            asm_string = luaop_new_str_3arg(opnames[opcode], a, b, special_c);
        } else {
            asm_string = luaop_new_str_3arg(opnames[opcode], a, b, c);
        }
        break;
    case OP_SETTABUP: /*  A B C   UpValue[A][RK(B)] := RK(C)                      */
    case OP_SETTABLE: /*  A B C   R(A)[RK(B)] := RK(C)                            */
    case OP_ADD: /*       A B C   R(A) := RK(B) + RK(C)                           */
    case OP_SUB: /*       A B C   R(A) := RK(B) - RK(C)                           */
    case OP_MUL: /*       A B C   R(A) := RK(B) * RK(C)                           */
    case OP_MOD: /*       A B C   R(A) := RK(B) % RK(C)                           */
    case OP_POW: /*       A B C   R(A) := RK(B) ^ RK(C)                           */
    case OP_DIV: /*       A B C   R(A) := RK(B) / RK(C)                           */
    case OP_IDIV: /*      A B C   R(A) := RK(B) // RK(C)                          */
    case OP_BAND: /*      A B C   R(A) := RK(B) & RK(C)                           */
    case OP_BOR: /*       A B C   R(A) := RK(B) | RK(C)                           */
    case OP_BXOR: /*      A B C   R(A) := RK(B) ~ RK(C)                           */
    case OP_SHL: /*       A B C   R(A) := RK(B) << RK(C)                          */
    case OP_SHR: /*       A B C   R(A) := RK(B) >> RK(C)                          */
    case OP_EQ: /*        A B C   if ((RK(B) == RK(C)) ~= A) then pc++            */
    case OP_LT: /*        A B C   if ((RK(B) <  RK(C)) ~= A) then pc++            */
    case OP_LE: /*        A B C   if ((RK(B) <= RK(C)) ~= A) then pc++            */
        if (is_special_B) {
            if (is_special_C) {
                asm_string = luaop_new_str_3arg(
                    opnames[opcode],
                    a, special_b, special_c);
            } else {
                asm_string = luaop_new_str_3arg(
                    opnames[opcode],
                    a, special_b, c);
            }
        } else {
            if (is_special_C) {
                asm_string = luaop_new_str_3arg(
                    opnames[opcode],
                    a, b, special_c);
            } else {
                asm_string = luaop_new_str_3arg(
                    opnames[opcode],
                    a, b, c);
            }
        }
        break;
    case OP_JMP: /*       A sBx   pc+=sBx; if (A) close all upvalues >= R(A - 1)  */
    case OP_FORLOOP: /*   A sBx   R(A)+=R(A+2);if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
    case OP_FORPREP: /*   A sBx   R(A)-=R(A+2); pc+=sBx                           */
    case OP_TFORLOOP: /*  A sBx   if R(A+1) ~= nil then { R(A)=R(A+1); pc += sBx }*/
        asm_string = luaop_new_str_2arg(opnames[opcode], a, sbx);
        break;
    case OP_EXTRAARG: /*   Ax      extra (larger) argument for previous opcode     */
        asm_string = luaop_new_str_1arg(opnames[opcode], ax);
        break;
    default:
        asm_string = rz_str_new("invalid");
        break;
    }
 
    rz_strbuf_append(&op->buf_asm, asm_string);
    op->size = 4;
    RZ_FREE(asm_string);
    return 4;
}

References a, ax, b, c, GET_OPCODE, GETARG_A, GETARG_Ax, GETARG_B, GETARG_Bx, GETARG_C, GETARG_sBx, len, lua_build_instruction(), luaop_new_str_1arg(), luaop_new_str_2arg(), luaop_new_str_3arg(), OP_ADD, OP_BAND, OP_BNOT, OP_BOR, OP_BXOR, OP_CALL, OP_CLOSURE, OP_CONCAT, OP_DIV, OP_EQ, OP_EXTRAARG, OP_FORLOOP, OP_FORPREP, OP_GETTABLE, OP_GETTABUP, OP_GETUPVAL, OP_IDIV, OP_JMP, OP_LE, OP_LEN, OP_LOADBOOL, OP_LOADK, OP_LOADKX, OP_LOADNIL, OP_LT, OP_MOD, OP_MOVE, OP_MUL, OP_NEWTABLE, OP_NOT, OP_POW, OP_RETURN, OP_SELF, OP_SETLIST, OP_SETTABLE, OP_SETTABUP, OP_SETUPVAL, OP_SHL, OP_SHR, OP_SUB, OP_TAILCALL, OP_TEST, OP_TESTSET, OP_TFORCALL, OP_TFORLOOP, OP_UNM, OP_VARARG, RZ_FREE, RZ_LOG_DEBUG, rz_str_new(), and rz_strbuf_append().

Referenced by rz_luac_disasm().

lua54_anal_op()

int lua54_anal_op	(	RzAnalysis *	analysis,
		RzAnalysisOp *	op,
		ut64	addr,
		const ut8 *	data,
		int	len
	)

Definition at line 6 of file analysis_54.c.

                                                                                               {
    if (!op || len < 4) {
        return 0;
    }
 
    memset(op, 0, sizeof(RzAnalysisOp));
    LuaInstruction instruction = lua_build_instruction(data);
 
    op->size = 4;
    op->addr = addr;
 
    if (LUA_GET_OPCODE(instruction) > OP_EXTRAARG) {
        return op->size;
    }
 
    switch (LUA_GET_OPCODE(instruction)) {
    case OP_MOVE: /*    A B R[A] := R[B]                    */
        op->type = RZ_ANALYSIS_OP_TYPE_MOV;
        break;
    case OP_LOADI: /*   A sBx   R[A] := sBx                 */
    case OP_LOADF: /*   A sBx   R[A] := (lua_Number)sBx             */
    case OP_LOADK: /*   A Bx    R[A] := K[Bx]                   */
    case OP_LOADTRUE: /*    A   R[A] := true                    */
    case OP_LOADNIL: /* A B R[A], R[A+1], ..., R[A+B] := nil        */
    case OP_LOADFALSE: /*   A   R[A] := false                   */
        op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
        break;
    case OP_LOADKX: /*  A   R[A] := K[extra arg]                */
        op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
        op->size = 4;
        break;
    case OP_LFALSESKIP: /*A R[A] := false; pc++             */
        op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
        op->size = 8;
        break;
    case OP_GETTABUP: /*    A B C   R[A] := UpValue[B][K[C]:string]         */
    case OP_GETUPVAL: /*    A B R[A] := UpValue[B]              */
    case OP_GETI: /*    A B C   R[A] := R[B][C]                 */
    case OP_GETFIELD: /*    A B C   R[A] := R[B][K[C]:string]           */
    case OP_GETTABLE: /*    A B C   R[A] := R[B][R[C]]              */
    case OP_SETTABLE: /*    A B C   R[A][R[B]] := RK(C)             */
        op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
        break;
    case OP_SETTABUP: /*    A B C   UpValue[A][K[B]:string] := RK(C)        */
    case OP_SETUPVAL: /*    A B UpValue[B] := R[A]              */
    case OP_SETI: /*    A B C   R[A][B] := RK(C)                */
    case OP_SETFIELD: /*    A B C   R[A][K[B]:string] := RK(C)          */
        op->type = RZ_ANALYSIS_OP_TYPE_STORE;
        break;
    case OP_NEWTABLE: /*    A B C k R[A] := {}                  */
        op->type = RZ_ANALYSIS_OP_TYPE_NEW;
        op->size = 4;
        break;
    case OP_SELF: /*    A B C   R[A+1] := R[B]; R[A] := R[B][RK(C):string]  */
        break;
    case OP_ADDI: /*    A B sC  R[A] := R[B] + sC               */
    case OP_ADDK: /*    A B C   R[A] := R[B] + K[C]             */
    case OP_ADD: /* A B C   R[A] := R[B] + R[C]             */
        op->type = RZ_ANALYSIS_OP_TYPE_ADD;
        break;
    case OP_SUBK: /*    A B C   R[A] := R[B] - K[C]             */
    case OP_SUB: /* A B C   R[A] := R[B] - R[C]             */
        op->type = RZ_ANALYSIS_OP_TYPE_SUB;
        break;
    case OP_MULK: /*    A B C   R[A] := R[B] * K[C]             */
    case OP_MUL: /* A B C   R[A] := R[B] * R[C]             */
        op->type = RZ_ANALYSIS_OP_TYPE_MUL;
        break;
    case OP_MOD: /* A B C   R[A] := R[B] % R[C]             */
    case OP_MODK: /*    A B C   R[A] := R[B] % K[C]             */
        op->type = RZ_ANALYSIS_OP_TYPE_MOD;
        break;
    case OP_POW: /* A B C   R[A] := R[B] ^ R[C]             */
    case OP_POWK: /*    A B C   R[A] := R[B] ^ K[C]             */
        break;
    case OP_DIVK: /*    A B C   R[A] := R[B] / K[C]             */
    case OP_IDIVK: /*   A B C   R[A] := R[B] // K[C]                */
    case OP_DIV: /* A B C   R[A] := R[B] / R[C]             */
    case OP_IDIV: /*    A B C   R[A] := R[B] // R[C]                */
        op->type = RZ_ANALYSIS_OP_TYPE_DIV;
        break;
    case OP_BANDK: /*   A B C   R[A] := R[B] & K[C]:integer         */
    case OP_BAND: /*    A B C   R[A] := R[B] & R[C]             */
        op->type = RZ_ANALYSIS_OP_TYPE_AND;
        break;
    case OP_BOR: /* A B C   R[A] := R[B] | R[C]             */
    case OP_BORK: /*    A B C   R[A] := R[B] | K[C]:integer         */
        op->type = RZ_ANALYSIS_OP_TYPE_OR;
        break;
    case OP_BXOR: /*    A B C   R[A] := R[B] ~ R[C]             */
    case OP_BXORK: /*   A B C   R[A] := R[B] ~ K[C]:integer         */
        op->type = RZ_ANALYSIS_OP_TYPE_XOR;
        break;
    case OP_NOT: /* A B R[A] := not R[B]                */
        op->type = RZ_ANALYSIS_OP_TYPE_NOT;
        break;
    case OP_BNOT: /*    A B R[A] := ~R[B]                   */
        op->type = RZ_ANALYSIS_OP_TYPE_CPL;
        break;
    case OP_SHRI: /*    A B sC  R[A] := R[B] >> sC              */
    case OP_SHR: /* A B C   R[A] := R[B] >> R[C]                */
        op->type = RZ_ANALYSIS_OP_TYPE_SHR;
        break;
    case OP_SHLI: /*    A B sC  R[A] := sC << R[B]              */
    case OP_SHL: /* A B C   R[A] := R[B] << R[C]                */
        op->type = RZ_ANALYSIS_OP_TYPE_SHL;
        break;
    case OP_MMBIN: /*   A B C   call C metamethod over R[A] and R[B]        */
    case OP_MMBINI: /*  A sB C k    call C metamethod over R[A] and sB  */
    case OP_MMBINK: /*  A B C k     call C metamethod over R[A] and K[B]    */
        op->type = RZ_ANALYSIS_OP_TYPE_CALL;
        break;
    case OP_UNM: /* A B R[A] := -R[B]                   */
    case OP_LEN: /* A B R[A] := #R[B] (length operator)         */
    case OP_CONCAT: /*  A B R[A] := R[A].. ... ..R[A + B - 1]       */
    case OP_CLOSE: /*   A   close all upvalues >= R[A]          */
    case OP_TBC: /* A   mark variable A "to be closed"          */
        break;
    case OP_JMP: /* sJ  pc += sJ                    */
        op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
        op->jump = op->addr + (st32)(4 * (LUA_GETARG_sJ(instruction)));
        op->fail = op->addr + 4;
        break;
    case OP_EQ: /*  A B k   if ((R[A] == R[B]) ~= k) then pc++      */
    case OP_LT: /*  A B k   if ((R[A] <  R[B]) ~= k) then pc++      */
    case OP_LE: /*  A B k   if ((R[A] <= R[B]) ~= k) then pc++      */
    case OP_EQK: /* A B k   if ((R[A] == K[B]) ~= k) then pc++      */
    case OP_EQI: /* A sB k  if ((R[A] == sB) ~= k) then pc++        */
    case OP_LTI: /* A sB k  if ((R[A] < sB) ~= k) then pc++         */
    case OP_LEI: /* A sB k  if ((R[A] <= sB) ~= k) then pc++        */
    case OP_GTI: /* A sB k  if ((R[A] > sB) ~= k) then pc++         */
    case OP_GEI: /* A sB k  if ((R[A] >= sB) ~= k) then pc++        */
    case OP_TEST: /*    A k if (not R[A] == k) then pc++            */
        op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
        op->jump = op->addr + 8;
        op->fail = op->addr + 4;
        break;
    case OP_TESTSET: /* A B k   if (not R[B] == k) then pc++ else R[A] := R[B]  */
        op->type = RZ_ANALYSIS_OP_TYPE_CMOV;
        op->jump = op->addr + 8;
        op->fail = op->addr + 4;
        break;
    case OP_CALL: /*    A B C   R[A], ... ,R[A+C-2] := R[A](R[A+1], ... ,R[A+B-1]) */
        op->type = RZ_ANALYSIS_OP_TYPE_RCALL;
        break;
    case OP_TAILCALL: /*    A B C k return R[A](R[A+1], ... ,R[A+B-1])      */
        op->type = RZ_ANALYSIS_OP_TYPE_RCALL;
        op->type2 = RZ_ANALYSIS_ADDR_HINT_TYPE_RET;
        op->eob = true;
        op->stackop = RZ_ANALYSIS_STACK_INC;
        op->stackptr = -4;
        break;
    case OP_RETURN: /*  A B C k return R[A], ... ,R[A+B-2]  (see note)  */
    case OP_RETURN1: /* A   return R[A]                 */
    case OP_RETURN0: /*     return                      */
        op->type = RZ_ANALYSIS_OP_TYPE_RET;
        op->eob = true;
        op->stackop = RZ_ANALYSIS_STACK_INC;
        op->stackptr = -4;
        break;
    case OP_FORLOOP: /* A Bx    update counters; if loop continues then pc-=Bx; */
        op->type = RZ_ANALYSIS_OP_TYPE_JMP;
        op->jump = op->addr + 4 - 4 * (LUA_GETARG_Bx(instruction));
        op->fail = op->addr + 4;
        break;
    case OP_FORPREP: /* A Bx    <check values and prepare counters>;
          if not to run then pc+=Bx+1;          */
        op->type = RZ_ANALYSIS_OP_TYPE_JMP;
        op->jump = op->addr + 4 + 4 * (LUA_GETARG_Bx(instruction) + 1);
        op->fail = op->addr + 4;
        break;
    case OP_TFORPREP: /*    A Bx    create upvalue for R[A + 3]; pc+=Bx     */
        op->type = RZ_ANALYSIS_OP_TYPE_JMP;
        op->jump = op->addr + 4 + 4 * (LUA_GETARG_Bx(instruction));
        op->fail = op->addr + 4;
        break;
    case OP_TFORCALL: /*    A C R[A+4], ... ,R[A+3+C] := R[A](R[A+1], R[A+2]);  */
        op->type = RZ_ANALYSIS_OP_TYPE_RCALL;
        break;
    case OP_TFORLOOP: /*    A Bx    if R[A+2] ~= nil then { R[A]=R[A+2]; pc -= Bx } */
        op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
        op->jump = op->addr + 4 - 4 * (LUA_GETARG_Bx(instruction));
        op->fail = op->addr + 4;
        break;
    case OP_SETLIST: /* A B C k R[A][C+i] := R[A+i], 1 <= i <= B        */
        op->type = RZ_ANALYSIS_OP_TYPE_STORE;
        break;
    case OP_CLOSURE: /* A Bx    R[A] := closure(KPROTO[Bx])         */
    case OP_VARARG: /*  A C R[A], R[A+1], ..., R[A+C-2] = vararg        */
    case OP_VARARGPREP: /*A (adjust vararg parameters)          */
    case OP_EXTRAARG: /*    Ax  extra (larger) argument for previous opcode */
        op->size = 4;
        break;
    }
    return op->size;
}

References addr, len, lua_build_instruction(), LUA_GET_OPCODE, LUA_GETARG_Bx, LUA_GETARG_sJ, memset(), OP_ADD, OP_ADDI, OP_ADDK, OP_BAND, OP_BANDK, OP_BNOT, OP_BOR, OP_BORK, OP_BXOR, 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_MOD, 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, RZ_ANALYSIS_ADDR_HINT_TYPE_RET, RZ_ANALYSIS_OP_TYPE_ADD, RZ_ANALYSIS_OP_TYPE_AND, RZ_ANALYSIS_OP_TYPE_CALL, RZ_ANALYSIS_OP_TYPE_CJMP, RZ_ANALYSIS_OP_TYPE_CMOV, RZ_ANALYSIS_OP_TYPE_CPL, RZ_ANALYSIS_OP_TYPE_DIV, RZ_ANALYSIS_OP_TYPE_JMP, RZ_ANALYSIS_OP_TYPE_LOAD, RZ_ANALYSIS_OP_TYPE_MOD, RZ_ANALYSIS_OP_TYPE_MOV, RZ_ANALYSIS_OP_TYPE_MUL, RZ_ANALYSIS_OP_TYPE_NEW, RZ_ANALYSIS_OP_TYPE_NOT, RZ_ANALYSIS_OP_TYPE_OR, RZ_ANALYSIS_OP_TYPE_RCALL, RZ_ANALYSIS_OP_TYPE_RET, RZ_ANALYSIS_OP_TYPE_SHL, RZ_ANALYSIS_OP_TYPE_SHR, RZ_ANALYSIS_OP_TYPE_STORE, RZ_ANALYSIS_OP_TYPE_SUB, RZ_ANALYSIS_OP_TYPE_XOR, RZ_ANALYSIS_STACK_INC, and st32.

Referenced by rz_lua_analysis_op().

lua54_assembly()

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

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().

lua54_disasm()

int lua54_disasm	(	RzAsmOp *	op,
		const ut8 *	buf,
		int	len,
		LuaOpNameList	oplist
	)

Definition at line 6 of file disassembly_54.c.

                                                                              {
    if (len < 4) {
        RZ_LOG_DEBUG("Cannot disassemble lua54 opcode (truncated).\n");
        return 0;
    }
 
    LuaInstruction instruction = lua_build_instruction(buf);
    LuaOpCode opcode = LUA_GET_OPCODE(instruction);
 
    /* Pre-fetch arguments */
    int a = LUA_GETARG_A(instruction);
    int b = LUA_GETARG_B(instruction);
    int c = LUA_GETARG_C(instruction);
    int ax = LUA_GETARG_Ax(instruction);
    int bx = LUA_GETARG_Bx(instruction);
    int sb = LUA_GETARG_sB(instruction);
    int sc = LUA_GETARG_sC(instruction);
    int sbx = LUA_GETARG_sBx(instruction);
    int isk = LUA_GETARG_k(instruction);
    int sj = LUA_GETARG_sJ(instruction);
 
    char *asm_string;
 
    switch (opcode) {
        /* iABC Instruction */
    case OP_GETI: /*    A B C   R[A] := R[B][C]                 */
    case OP_MMBIN: /*   A B C   call C metamethod over R[A] and R[B]        */
    case OP_GETTABUP: /*    A B C   R[A] := UpValue[B][K[C]:string]         */
    case OP_CALL: /*    A B C   R[A], ... ,R[A+C-2] := R[A](R[A+1], ... ,R[A+B-1]) */
    case OP_GETTABLE: /*    A B C   R[A] := R[B][R[C]]              */
    case OP_ADD: /*         A B C   R[A] := R[B] + R[C]             */
    case OP_SUB: /*         A B C   R[A] := R[B] - R[C]             */
    case OP_MUL: /*         A B C   R[A] := R[B] * R[C]             */
    case OP_MOD: /*         A B C   R[A] := R[B] % R[C]             */
    case OP_POW: /*     A B C   R[A] := R[B] ^ R[C]             */
    case OP_DIV: /*         A B C   R[A] := R[B] / R[C]             */
    case OP_IDIV: /*    A B C   R[A] := R[B] // R[C]                */
    case OP_BAND: /*    A B C   R[A] := R[B] & R[C]             */
    case OP_BOR: /*     A B C   R[A] := R[B] | R[C]             */
    case OP_BXOR: /*    A B C   R[A] := R[B] ~ R[C]             */
    case OP_SHL: /*         A B C   R[A] := R[B] << R[C]                */
    case OP_SHR: /*         A B C   R[A] := R[B] >> R[C]                */
    case OP_ADDK: /*    A B C   R[A] := R[B] + K[C]             */
    case OP_SUBK: /*    A B C   R[A] := R[B] - K[C]             */
    case OP_MULK: /*    A B C   R[A] := R[B] * K[C]             */
    case OP_MODK: /*    A B C   R[A] := R[B] % K[C]             */
    case OP_POWK: /*    A B C   R[A] := R[B] ^ K[C]             */
    case OP_DIVK: /*    A B C   R[A] := R[B] / K[C]             */
    case OP_IDIVK: /*   A B C   R[A] := R[B] // K[C]                */
    case OP_BANDK: /*   A B C   R[A] := R[B] & K[C]:integer         */
    case OP_BORK: /*    A B C   R[A] := R[B] | K[C]:integer         */
    case OP_BXORK: /*   A B C   R[A] := R[B] ~ K[C]:integer         */
    case OP_GETFIELD: /*    A B C   R[A] := R[B][K[C]:string]           */
        asm_string = luaop_new_str_3arg(opnames[opcode], a, b, c);
        break;
        /* iABC - k instructions */
    case OP_TAILCALL: /*    A B C k return R[A](R[A+1], ... ,R[A+B-1])      */
    case OP_RETURN: /*  A B C k return R[A], ... ,R[A+B-2]  (see note)  */
    case OP_NEWTABLE: /*    A B C k R[A] := {}                  */
    case OP_SETLIST: /* A B C k R[A][C+i] := R[A+i], 1 <= i <= B        */
    case OP_MMBINK: /*  A B C k     call C metamethod over R[A] and K[B]    */
    case OP_SETTABUP: /*    A B C   UpValue[A][K[B]:string] := RK(C)        */
    case OP_SETTABLE: /*    A B C   R[A][R[B]] := RK(C)             */
    case OP_SETI: /*    A B C   R[A][B] := RK(C)                */
    case OP_SETFIELD: /*    A B C   R[A][K[B]:string] := RK(C)          */
    case OP_SELF: /*    A B C   R[A+1] := R[B]; R[A] := R[B][RK(C):string]  */
        asm_string = luaop_new_str_3arg_ex(opnames[opcode], a, b, c, isk);
        break;
        /* iABC - signed B with k instruction */
    case OP_MMBINI: /*  A sB C k    call C metamethod over R[A] and sB  */
        asm_string = luaop_new_str_3arg_ex(opnames[opcode], a, sb, c, isk);
        break;
        /* iABC - c signed instructions */
    case OP_ADDI: /*    A B sC  R[A] := R[B] + sC               */
    case OP_SHRI: /*    A B sC  R[A] := R[B] >> sC              */
    case OP_SHLI: /*    A B sC  R[A] := sC << R[B]              */
        asm_string = luaop_new_str_3arg(opnames[opcode], a, b, sc);
        break;
        /* iABC - A & B instructions */
    case OP_MOVE: /*    A B R[A] := R[B]                    */
    case OP_UNM: /*         A B R[A] := -R[B]                   */
    case OP_BNOT: /*    A B R[A] := ~R[B]                   */
    case OP_NOT: /*     A B R[A] := not R[B]                */
    case OP_LEN: /*         A B R[A] := #R[B] (length operator)         */
    case OP_CONCAT: /*  A B R[A] := R[A].. ... ..R[A + B - 1]       */
    case OP_LOADNIL: /* A B R[A], R[A+1], ..., R[A+B] := nil        */
    case OP_GETUPVAL: /*    A B R[A] := UpValue[B]              */
    case OP_SETUPVAL: /*    A B UpValue[B] := R[A]              */
        asm_string = luaop_new_str_2arg(opnames[opcode], a, b);
        break;
 
        /* iABC - A & B with k instructions */
    case OP_EQ: /*          A B k   if ((R[A] == R[B]) ~= k) then pc++      */
    case OP_LT: /*          A B k   if ((R[A] <  R[B]) ~= k) then pc++      */
    case OP_LE: /*          A B k   if ((R[A] <= R[B]) ~= k) then pc++      */
    case OP_TESTSET: /* A B k   if (not R[B] == k) then pc++ else R[A] := R[B]  */
    case OP_EQK: /*         A B k   if ((R[A] == K[B]) ~= k) then pc++      */
        asm_string = luaop_new_str_2arg_ex(opnames[opcode], a, b, isk);
        break;
        /* iABC - A & sB with k instructions */
    case OP_EQI: /*         A sB k  if ((R[A] == sB) ~= k) then pc++        */
    case OP_LTI: /*         A sB k  if ((R[A] < sB) ~= k) then pc++         */
    case OP_LEI: /*         A sB k  if ((R[A] <= sB) ~= k) then pc++        */
    case OP_GTI: /*         A sB k  if ((R[A] > sB) ~= k) then pc++         */
    case OP_GEI: /*         A sB k  if ((R[A] >= sB) ~= k) then pc++        */
        asm_string = luaop_new_str_2arg_ex(opnames[opcode], a, sb, isk);
        break;
 
        /* iABC - A & C instructions */
    case OP_TFORCALL: /*    A C R[A+4], ... ,R[A+3+C] := R[A](R[A+1], R[A+2]);  */
    case OP_VARARG: /*  A C R[A], R[A+1], ..., R[A+C-2] = vararg        */
        asm_string = luaop_new_str_2arg(opnames[opcode], a, c);
        break;
 
        /* iABC - single A instructions */
    case OP_LOADKX: /*  A   R[A] := K[extra arg] */
    case OP_LOADFALSE: /*   A   R[A] := false                   */
    case OP_LFALSESKIP: /*  A   R[A] := false; pc++             */
    case OP_LOADTRUE: /*    A   R[A] := true                    */
    case OP_CLOSE: /*   A   close all upvalues >= R[A]          */
    case OP_TBC: /*         A   mark variable A "to be closed"          */
    case OP_RETURN1: /* A   return R[A]                 */
    case OP_VARARGPREP: /*  A   (adjust vararg parameters)          */
        asm_string = luaop_new_str_1arg(opnames[opcode], a);
        break;
 
        /* iABC - special instructions */
    case OP_TEST: /*    A k if (not R[A] == k) then pc++            */
        asm_string = luaop_new_str_1arg_ex(opnames[opcode], a, isk);
        break;
 
    case OP_RETURN0: /*     return                      */
        asm_string = rz_str_newf("RETURN0");
        break;
 
        /* iABx instructions */
    case OP_LOADK: /*   A Bx    R[A] := K[Bx]                   */
    case OP_FORLOOP: /* A Bx    update counters; if loop continues then pc-=Bx; */
    case OP_FORPREP: /* A Bx    <check values and prepare counters>;
             if not to run then pc+=Bx+1;           */
    case OP_TFORPREP: /*    A Bx    create upvalue for R[A + 3]; pc+=Bx     */
    case OP_TFORLOOP: /*    A Bx    if R[A+2] ~= nil then { R[A]=R[A+2]; pc -= Bx } */
    case OP_CLOSURE: /* A Bx    R[A] := closure(KPROTO[Bx])         */
        asm_string = luaop_new_str_2arg(opnames[opcode], a, bx);
        break;
 
        /* iAsBx instructions */
    case OP_LOADI: /*   A sBx   R[A] := sBx                 */
    case OP_LOADF: /*   A sBx   R[A] := (lua_Number)sBx             */
        asm_string = luaop_new_str_2arg(opnames[opcode], a, sbx);
        break;
 
        /* iAx instructions */
    case OP_EXTRAARG: /*    Ax  extra (larger) argument for previous opcode */
        asm_string = luaop_new_str_1arg(opnames[opcode], ax);
        break;
 
        /* isJ instructions */
    case OP_JMP: /*         sJ  pc += sJ                    */
        asm_string = luaop_new_str_1arg(opnames[opcode], sj);
        break;
 
    default:
        asm_string = rz_str_newf("invalid");
    }
 
    rz_strbuf_append(&op->buf_asm, asm_string);
    op->size = 4;
    RZ_FREE(asm_string);
    return 4;
}

References a, ax, b, c, len, lua_build_instruction(), LUA_GET_OPCODE, LUA_GETARG_A, LUA_GETARG_Ax, LUA_GETARG_B, LUA_GETARG_Bx, LUA_GETARG_C, LUA_GETARG_k, LUA_GETARG_sB, LUA_GETARG_sBx, LUA_GETARG_sC, LUA_GETARG_sJ, luaop_new_str_1arg(), luaop_new_str_1arg_ex(), luaop_new_str_2arg(), luaop_new_str_2arg_ex(), luaop_new_str_3arg(), luaop_new_str_3arg_ex(), OP_ADD, OP_ADDI, OP_ADDK, OP_BAND, OP_BANDK, OP_BNOT, OP_BOR, OP_BORK, OP_BXOR, 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_MOD, 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, RZ_FREE, RZ_LOG_DEBUG, rz_str_newf(), rz_strbuf_append(), sb, and sc.

Referenced by rz_luac_disasm().

lua_build_instruction()

LuaInstruction lua_build_instruction

(

const ut8 *

buf

)

Definition at line 6 of file lua_arch.c.

                                                     {
    LuaInstruction ret = 0;
    ret |= buf[3] << 24;
    ret |= buf[2] << 16;
    ret |= buf[1] << 8;
    ret |= buf[0];
    return ret;
}

Referenced by lua53_anal_op(), lua53_disasm(), lua54_anal_op(), and lua54_disasm().

lua_convert_str_to_num()

int lua_convert_str_to_num

(

const char *

str

)

Definition at line 137 of file lua_arch.c.

                                            {
    return strtoll(str, NULL, 0);
}

References NULL, and cmd_descs_generate::str.

Referenced by encode_instruction().

lua_is_valid_num_value_string()

bool lua_is_valid_num_value_string

(

const char *

str

)

Definition at line 129 of file lua_arch.c.

                                                    {
    if (!rz_is_valid_input_num_value(NULL, str)) {
        RZ_LOG_ERROR("assembler: lua: %s is not a valid number argument\n", str);
        return false;
    }
    return true;
}

References NULL, rz_is_valid_input_num_value(), RZ_LOG_ERROR, and cmd_descs_generate::str.

Referenced by encode_instruction().

lua_load_next_arg_start()

int lua_load_next_arg_start	(	const char *	raw_string,
		char *	recv_buf
	)

Definition at line 98 of file lua_arch.c.

                                                                    {
    if (!raw_string) {
        return 0;
    }
 
    const char *arg_start = NULL;
    const char *arg_end = NULL;
    int arg_len = 0;
 
    /* locate the start point */
    arg_start = rz_str_trim_head_ro(raw_string);
    if (strlen(arg_start) == 0) {
        return 0;
    }
 
    arg_end = strchr(arg_start, ' ');
    if (arg_end == NULL) {
        /* is last arg */
        arg_len = strlen(arg_start);
    } else {
        arg_len = arg_end - arg_start;
    }
 
    /* Set NUL */
    memcpy(recv_buf, arg_start, arg_len);
    recv_buf[arg_len] = 0x00;
 
    /* Calculate offset */
    return arg_start - raw_string + arg_len;
}

References memcpy(), NULL, and rz_str_trim_head_ro().

Referenced by encode_instruction().

lua_set_instruction()

void lua_set_instruction	(	LuaInstruction	instruction,
		ut8 *	data
	)

Definition at line 15 of file lua_arch.c.

                                                                {
    data[3] = instruction >> 24;
    data[2] = instruction >> 16;
    data[1] = instruction >> 8;
    data[0] = instruction >> 0;
}

Referenced by rz_luac_asm().

luaop_new_str_1arg()

char* luaop_new_str_1arg	(	char *	opname,
		int	a
	)

Definition at line 53 of file lua_arch.c.

                                              {
    char *asm_string;
 
    asm_string = rz_str_newf(
        "%s %d",
        opname,
        a);
 
    return asm_string;
}

References a, and rz_str_newf().

Referenced by lua53_disasm(), and lua54_disasm().

luaop_new_str_1arg_ex()

char* luaop_new_str_1arg_ex	(	char *	opname,
		int	a,
		int	isk
	)

Definition at line 87 of file lua_arch.c.

                                                          {
    char *asm_string;
 
    asm_string = rz_str_newf(
        "%s %d %d",
        opname,
        a, isk);
 
    return asm_string;
}

References a, and rz_str_newf().

Referenced by lua54_disasm().

luaop_new_str_2arg()

char* luaop_new_str_2arg	(	char *	opname,
		int	a,
		int	b
	)

Definition at line 42 of file lua_arch.c.

                                                     {
    char *asm_string;
 
    asm_string = rz_str_newf(
        "%s %d %d",
        opname,
        a, b);
 
    return asm_string;
}

References a, b, and rz_str_newf().

Referenced by lua53_disasm(), and lua54_disasm().

luaop_new_str_2arg_ex()

char* luaop_new_str_2arg_ex	(	char *	opname,
		int	a,
		int	b,
		int	isk
	)

Definition at line 76 of file lua_arch.c.

                                                                 {
    char *asm_string;
 
    asm_string = rz_str_newf(
        "%s %d %d %d",
        opname,
        a, b, isk);
 
    return asm_string;
}

References a, b, and rz_str_newf().

Referenced by lua54_disasm().

luaop_new_str_3arg()

char* luaop_new_str_3arg	(	char *	opname,
		int	a,
		int	b,
		int	c
	)

Definition at line 31 of file lua_arch.c.

                                                            {
    char *asm_string;
 
    asm_string = rz_str_newf(
        "%s %d %d %d",
        opname,
        a, b, c);
 
    return asm_string;
}

References a, b, c, and rz_str_newf().

Referenced by lua53_disasm(), and lua54_disasm().

luaop_new_str_3arg_ex()

char* luaop_new_str_3arg_ex	(	char *	opname,
		int	a,
		int	b,
		int	c,
		int	isk
	)

Definition at line 65 of file lua_arch.c.

                                                                        {
    char *asm_string;
 
    asm_string = rz_str_newf(
        "%s %d %d %d %d",
        opname,
        a, b, c, isk);
 
    return asm_string;
}

References a, b, c, and rz_str_newf().

Referenced by lua54_disasm().