#include <rz_analysis.h>
#include <rz_asm.h>
#include <rz_lib.h>
#include <rz_types.h>
#include <rz_util.h>
#include <stdio.h>
#include <string.h>
#include <rz_main.h>
#include <rz_core.h>

Classes
struct	RzAsmState

Enumerations
enum	DisasmMode { DISASM_MODE_DONT = 0 , DISASM_MODE_DEFAULT , DISASM_MODE_WITH_BYTES , DISASM_MODE_ESIL , DISASM_MODE_IL }

Functions
static void	__load_plugins (RzAsmState *as)

static void	__as_set_archbits (RzAsmState *as)

static RzAsmState *	__as_new (void)

static void	__as_free (RzAsmState *as)

static char *	stackop2str (int type)

static void	showanalysis (RzAsmState as, RzAnalysisOp op, ut64 offset, ut8 buf, int len, PJ pj)

static int	show_analinfo (RzAsmState as, const char arg, ut64 offset)

static int	rasm_show_help (int v)

static bool	print_and_check_il (RzAsmState as, RzAnalysisOp op)

static int	rasm_disasm (RzAsmState as, ut64 addr, const char buf, int len, int bits, int bin, DisasmMode mode)

static void	print_buf (RzAsmState as, char str)

static bool	print_label (void user, const void k, const void *v)

static int	rasm_asm (RzAsmState as, const char buf, ut64 offset, ut64 len, int bits, int bin, bool use_spp, bool hexwords)

static int	__lib_asm_cb (RzLibPlugin pl, void user, void *data)

static int	__lib_analysis_cb (RzLibPlugin pl, void user, void *data)

static int	print_assembly_output (RzAsmState as, const char buf, ut64 offset, ut64 len, int bits, int bin, bool use_spp, bool rad, bool hexwords, const char *arch)

RZ_API int	rz_main_rz_asm (int argc, const char *argv[])

Enumeration Type Documentation

◆ DisasmMode

enum DisasmMode

Enumerator
DISASM_MODE_DONT
DISASM_MODE_DEFAULT
DISASM_MODE_WITH_BYTES
DISASM_MODE_ESIL
DISASM_MODE_IL

Definition at line 219 of file rz-asm.c.

              {
     DISASM_MODE_DONT = 0,
     DISASM_MODE_DEFAULT,
     DISASM_MODE_WITH_BYTES,
     DISASM_MODE_ESIL,
     DISASM_MODE_IL
 } DisasmMode;

Function Documentation

◆ __as_free()

static void __as_free ( RzAsmState * as )

static

Definition at line 51 of file rz-asm.c.

                                       {
     if (as->a) {
         rz_num_free(as->a->num);
     }
     rz_asm_free(as->a);
     rz_analysis_free(as->analysis);
     rz_lib_free(as->l);
     free(as);
 }

References RzAsmState::a, RzAsmState::analysis, free(), RzAsmState::l, rz_asm_t::num, rz_analysis_free(), rz_asm_free(), rz_lib_free(), and rz_num_free().

Referenced by rz_main_rz_asm().

◆ __as_new()

static RzAsmState* __as_new ( void )

static

Definition at line 36 of file rz-asm.c.

                                   {
     RzAsmState *as = RZ_NEW0(RzAsmState);
     if (as) {
         as->l = rz_lib_new(NULL, NULL);
         as->a = rz_asm_new();
         if (as->a) {
             as->a->num = rz_num_new(NULL, NULL, NULL);
         }
         as->analysis = rz_analysis_new();
         __load_plugins(as);
         __as_set_archbits(as);
     }
     return as;
 }

References __as_set_archbits(), __load_plugins(), RzAsmState::a, RzAsmState::analysis, RzAsmState::l, NULL, rz_asm_t::num, rz_analysis_new(), rz_asm_new(), rz_lib_new(), RZ_NEW0, and rz_num_new().

Referenced by rz_main_rz_asm().

◆ __as_set_archbits()

static void __as_set_archbits ( RzAsmState * as )

static

Definition at line 28 of file rz-asm.c.

                                               {
     rz_asm_use(as->a, RZ_SYS_ARCH);
     rz_analysis_use(as->analysis, RZ_SYS_ARCH);
     int sysbits = (RZ_SYS_BITS & RZ_SYS_BITS_64) ? 64 : 32;
     rz_asm_set_bits(as->a, sysbits);
     rz_analysis_set_bits(as->analysis, sysbits);
 }

References RzAsmState::a, RzAsmState::analysis, rz_analysis_set_bits(), rz_analysis_use(), rz_asm_set_bits(), rz_asm_use(), RZ_SYS_ARCH, RZ_SYS_BITS, and RZ_SYS_BITS_64.

Referenced by __as_new().

◆ __lib_analysis_cb()

static int __lib_analysis_cb	(	RzLibPlugin *	pl,
		void *	user,
		void *	data
	)

static

Definition at line 454 of file rz-asm.c.

                                                                       {
     RzAnalysisPlugin *hand = (RzAnalysisPlugin *)data;
     RzAsmState *as = (RzAsmState *)user;
     return rz_analysis_add(as->analysis, hand);
 }

References RzAsmState::analysis, and rz_analysis_add().

Referenced by __load_plugins().

◆ __lib_asm_cb()

static int __lib_asm_cb	(	RzLibPlugin *	pl,
		void *	user,
		void *	data
	)

static

Definition at line 447 of file rz-asm.c.

                                                                  {
     RzAsmPlugin *hand = (RzAsmPlugin *)data;
     RzAsmState *as = (RzAsmState *)user;
     return rz_asm_add(as->a, hand);
 }

References RzAsmState::a, and rz_asm_add().

Referenced by __load_plugins().

◆ __load_plugins()

static void __load_plugins ( RzAsmState * as )

static

Definition at line 479 of file rz-asm.c.

                                            {
     char *tmp = rz_sys_getenv("RZ_ASM_NOPLUGINS");
     if (tmp) {
         free(tmp);
         return;
     }
     rz_lib_add_handler(as->l, RZ_LIB_TYPE_ASM, "(dis)assembly plugins", &__lib_asm_cb, NULL, as);
     rz_lib_add_handler(as->l, RZ_LIB_TYPE_ANALYSIS, "analysis/emulation plugins", &__lib_analysis_cb, NULL, as);
  
     char *path = rz_sys_getenv(RZ_LIB_ENV);
     if (!RZ_STR_ISEMPTY(path)) {
         rz_lib_opendir(as->l, path, false);
     }
  
     char *homeplugindir = rz_path_home_prefix(RZ_PLUGINS);
     // TODO: remove after 0.4.0 is released
     char *oldhomeplugindir = rz_path_home_prefix(RZ_HOME_OLD_PLUGINS);
     char *sysplugindir = rz_path_system(RZ_PLUGINS);
     rz_lib_opendir(as->l, homeplugindir, false);
     rz_lib_opendir(as->l, oldhomeplugindir, false);
     rz_lib_opendir(as->l, sysplugindir, false);
     free(homeplugindir);
     free(oldhomeplugindir);
     free(sysplugindir);
  
     free(tmp);
     free(path);
 }

References __lib_analysis_cb(), __lib_asm_cb(), free(), RzAsmState::l, NULL, path, RZ_HOME_OLD_PLUGINS, rz_lib_add_handler(), RZ_LIB_ENV, rz_lib_opendir(), RZ_LIB_TYPE_ANALYSIS, RZ_LIB_TYPE_ASM, rz_path_home_prefix(), rz_path_system(), RZ_PLUGINS, RZ_STR_ISEMPTY, rz_sys_getenv(), and autogen_x86imm::tmp.

Referenced by __as_new().

◆ print_and_check_il()

static bool print_and_check_il	(	RzAsmState *	as,
		RzAnalysisOp *	op
	)

static

Definition at line 227 of file rz-asm.c.

                                                                  {
     if (op->size < 1 || !op->il_op) {
         eprintf("Invalid instruction of lifting not implemented.\n");
         return false;
     }
     RzAnalysisILVM *vm = rz_analysis_il_vm_new(as->analysis, NULL);
     if (!vm) {
         eprintf("Failed to initialize IL VM for this architecture.\n");
         return false;
     }
     bool ret = true;
     RzILValidateGlobalContext *ctx = rz_il_validate_global_context_new_from_vm(vm->vm);
     if (!ctx) {
         eprintf("Failed to derive context from IL VM.\n");
         ret = false;
         goto error_vm;
     }
     RzILOpEffect *il_op = op->il_op;
     if (il_op) {
         RzStrBuf sb;
         rz_strbuf_init(&sb);
         rz_il_op_effect_stringify(il_op, &sb);
         printf("%s\n", rz_strbuf_get(&sb));
         fflush(stdout); // to appear before validation report
         rz_strbuf_fini(&sb);
     }
     char *report;
     if (!rz_il_validate_effect(il_op, ctx, NULL, NULL, &report)) {
         ret = false;
         eprintf("IL Validation failed%c\n", report ? ':' : '.');
     }
     if (report) {
         eprintf("%s\n", report);
         free(report);
     }
     rz_il_validate_global_context_free(ctx);
 error_vm:
     rz_analysis_il_vm_free(vm);
     return ret;
 }

References RzAsmState::analysis, eprintf, free(), NULL, printf(), rz_analysis_il_vm_free(), rz_analysis_il_vm_new(), rz_il_op_effect_stringify(), rz_il_validate_effect(), rz_il_validate_global_context_free(), rz_il_validate_global_context_new_from_vm(), rz_strbuf_fini(), rz_strbuf_get(), rz_strbuf_init(), sb, and rz_analysis_il_vm_t::vm.

Referenced by rasm_disasm().

◆ print_assembly_output()

static int print_assembly_output	(	RzAsmState *	as,
		const char *	buf,
		ut64	offset,
		ut64	len,
		int	bits,
		int	bin,
		bool	use_spp,
		bool	rad,
		bool	hexwords,
		const char *	arch
	)

static

Definition at line 460 of file rz-asm.c.

                                                                       {
     if (rad) {
         printf("e asm.arch=%s\n", arch ? arch : RZ_SYS_ARCH);
         printf("e asm.bits=%d\n", bits);
         if (offset) {
             printf("s 0x%" PFMT64x "\n", offset);
         }
         printf("wx ");
     }
     int ret = rasm_asm(as, (char *)buf, offset, len, as->a->bits, bin, use_spp, hexwords);
     if (rad) {
         printf("f entry @ $$\n");
         printf("f label.main @ $$ + 1\n");
         ht_pp_foreach(as->a->flags, print_label, NULL);
     }
     return ret;
 }

References RzAsmState::a, arch, rz_asm_t::bits, bits(), rz_asm_t::flags, len, NULL, PFMT64x, print_label(), printf(), rasm_asm(), and RZ_SYS_ARCH.

Referenced by rz_main_rz_asm().

◆ print_buf()

static void print_buf	(	RzAsmState *	as,
		char *	str
	)

static

Definition at line 374 of file rz-asm.c.

                                                  {
     int i;
     if (as->coutput) {
         printf("\"");
         for (i = 1; *str; str += 2, i += 2) {
             if (!(i % 41)) {
                 printf("\" \\\n\"");
                 i = 1;
             }
             printf("\\x%c%c", *str, str[1]);
         }
         printf("\"\n");
     } else {
         printf("%s\n", str);
     }
 }

References RzAsmState::coutput, i, printf(), and cmd_descs_generate::str.

Referenced by rasm_asm().

◆ print_label()

static bool print_label	(	void *	user,
		const void *	k,
		const void *	v
	)

static

Definition at line 391 of file rz-asm.c.

                                                                   {
     printf("f label.%s @ %s\n", (const char *)k, (const char *)v);
     return true;
 }

References k, printf(), and v.

Referenced by print_assembly_output().

◆ rasm_asm()

static int rasm_asm	(	RzAsmState *	as,
		const char *	buf,
		ut64	offset,
		ut64	len,
		int	bits,
		int	bin,
		bool	use_spp,
		bool	hexwords
	)

static

Definition at line 396 of file rz-asm.c.

                                                                                                                             {
     RzAsmCode *acode;
     int i, j, ret = 0;
     rz_asm_set_pc(as->a, offset);
     if (!(acode = rz_asm_rasm_assemble(as->a, buf, use_spp))) {
         return 0;
     }
     if (acode->len) {
         ret = acode->len;
         if (bin) {
             if ((ret = write(1, acode->bytes, acode->len)) != acode->len) {
                 eprintf("Failed to write buffer\n");
                 rz_asm_code_free(acode);
                 return 0;
             }
         } else {
             int b = acode->len;
             if (bits == 1) {
                 int bytes = (b / 8) + 1;
                 for (i = 0; i < bytes; i++) {
                     for (j = 0; j < 8 && b--; j++) {
                         printf("%c", (acode->bytes[i] & (1 << j)) ? '1' : '0');
                     }
                 }
                 printf("\n");
             } else {
                 if (hexwords) {
                     size_t i = 0;
                     for (i = 0; i < acode->len; i += sizeof(ut32)) {
                         ut32 dword = rz_read_ble32(acode->bytes + i, RZ_SYS_ENDIAN);
                         printf("0x%08x ", dword);
                         if ((i / 4) == 7) {
                             printf("\n");
                         }
                     }
                     printf("\n");
                 } else {
                     char *str = rz_asm_code_get_hex(acode);
                     if (str) {
                         print_buf(as, str);
                         free(str);
                     }
                 }
             }
         }
     }
     rz_asm_code_free(acode);
     return (ret > 0);
 }

References RzAsmState::a, b, bits(), bytes, rz_asm_code_t::bytes, eprintf, free(), i, rz_asm_code_t::len, print_buf(), printf(), rz_asm_code_free(), rz_asm_code_get_hex(), rz_asm_rasm_assemble(), rz_asm_set_pc(), rz_read_ble32(), RZ_SYS_ENDIAN, cmd_descs_generate::str, and write.

Referenced by print_assembly_output(), and rz_main_rz_asm().

◆ rasm_disasm()

static int rasm_disasm	(	RzAsmState *	as,
		ut64	addr,
		const char *	buf,
		int	len,
		int	bits,
		int	bin,
		DisasmMode	mode
	)

static

Definition at line 268 of file rz-asm.c.

                                                                                                                 {
     RzAsmCode *acode;
     ut8 *data = NULL;
     int ret = 0;
     ut64 clen = 0;
     if (bits == 1) {
         len /= 8;
     }
     if (bin) {
         if (len < 0) {
             return false;
         }
         clen = len; // XXX
         data = (ut8 *)buf;
     } else {
         clen = rz_hex_str2bin(buf, NULL);
         if ((int)clen < 1 || !(data = malloc(clen))) {
             ret = 0;
             goto beach;
         }
         rz_hex_str2bin(buf, data);
         len = clen;
     }
  
     if (!len || clen <= len) {
         len = clen;
     }
  
     switch (mode) {
     case DISASM_MODE_ESIL: {
         RzAnalysisOp aop = { 0 };
         while (ret < len) {
             aop.size = 0;
             if (rz_analysis_op(as->analysis, &aop, addr, data + ret, len - ret, RZ_ANALYSIS_OP_MASK_ESIL) > 0) {
                 printf("%s\n", RZ_STRBUF_SAFEGET(&aop.esil));
             }
             if (aop.size < 1) {
                 eprintf("Invalid\n");
                 break;
             }
             ret += aop.size;
             rz_analysis_op_fini(&aop);
         }
         break;
     }
     case DISASM_MODE_IL: {
         RzAnalysisOp aop = { 0 };
         while (ret < len) {
             aop.size = 0;
             if (rz_analysis_op(as->analysis, &aop, addr, data + ret, len - ret, RZ_ANALYSIS_OP_MASK_IL) <= 0) {
                 eprintf("Invalid\n");
                 ret = 0;
                 break;
             }
             if (!print_and_check_il(as, &aop)) {
                 rz_analysis_op_fini(&aop);
                 ret = 0;
                 break;
             }
             ret += aop.size;
             rz_analysis_op_fini(&aop);
         }
         break;
     }
     case DISASM_MODE_WITH_BYTES: {
         RzAsmOp op;
         rz_asm_set_pc(as->a, addr);
         while ((len - ret) > 0) {
             int dr = rz_asm_disassemble(as->a, &op, data + ret, len - ret);
             if (dr == -1 || op.size < 1) {
                 op.size = 1;
                 rz_asm_op_set_asm(&op, "invalid");
             }
             char *op_hex = rz_asm_op_get_hex(&op);
             printf("0x%08" PFMT64x "  %2d %24s  %s\n",
                 as->a->pc, op.size, op_hex,
                 rz_asm_op_get_asm(&op));
             free(op_hex);
             ret += op.size;
             rz_asm_set_pc(as->a, addr + ret);
         }
         break;
     }
     default: {
         rz_asm_set_pc(as->a, addr);
         if (!(acode = rz_asm_mdisassemble(as->a, data, len))) {
             goto beach;
         }
         if (as->oneliner) {
             rz_str_replace_char(acode->assembly, '\n', ';');
             printf("%s\"\n", acode->assembly);
         } else {
             printf("%s", acode->assembly);
         }
         ret = acode->len;
         rz_asm_code_free(acode);
         break;
     }
     }
 beach:
     if (data && data != (ut8 *)buf) {
         free(data);
     }
     return ret;
 }

References RzAsmState::a, addr, RzAsmState::analysis, rz_asm_code_t::assembly, bits(), DISASM_MODE_ESIL, DISASM_MODE_IL, DISASM_MODE_WITH_BYTES, eprintf, rz_analysis_op_t::esil, free(), len, rz_asm_code_t::len, malloc(), NULL, RzAsmState::oneliner, op, rz_asm_t::pc, PFMT64x, print_and_check_il(), printf(), rz_analysis_op(), rz_analysis_op_fini(), RZ_ANALYSIS_OP_MASK_ESIL, RZ_ANALYSIS_OP_MASK_IL, rz_asm_code_free(), rz_asm_disassemble(), rz_asm_mdisassemble(), rz_asm_op_get_asm(), rz_asm_op_get_hex(), rz_asm_op_set_asm(), rz_asm_set_pc(), rz_hex_str2bin(), rz_str_replace_char(), RZ_STRBUF_SAFEGET, rz_analysis_op_t::size, and ut64().

Referenced by rz_main_rz_asm().

◆ rasm_show_help()

static int rasm_show_help ( int v )

static

Definition at line 170 of file rz-asm.c.

                                  {
     if (v < 2) {
         printf("Usage: rz-asm [-ACdDehLBvw] [-a arch] [-b bits] [-o addr] [-s syntax]\n"
                "             [-f file] [-F fil:ter] [-i skip] [-l len] 'code'|hex|-\n");
     }
     if (v != 1) {
         printf(" -a [arch]    Set architecture to assemble/disassemble (see -L)\n"
                " -A           Show Analysis information from given hexpairs\n"
                " -b [bits]    Set cpu register size (8, 16, 32, 64) (RZ_ASM_BITS)\n"
                " -B           Binary input/output (-l is mandatory for binary input)\n"
                " -c [cpu]     Select specific CPU (depends on arch)\n"
                " -C           Output in C format\n"
                " -d, -D       Disassemble from hexpair bytes (-D show hexpairs)\n"
                " -e           Use big endian instead of little endian\n"
                " -I           Display lifted RzIL code (same input as in -d, IL is also validated)\n"
                " -E           Display ESIL expression (same input as in -d)\n"
                " -f [file]    Read data from file\n"
                " -F [in:out]  Specify input and/or output filters (att2intel, x86.pseudo, ...)\n"
                " -h, -hh      Show this help, -hh for long\n"
                " -i [len]     ignore/skip N bytes of the input buffer\n"
                " -j           output in json format\n"
                " -k [kernel]  Select operating system (linux, windows, darwin, ..)\n"
                " -l [len]     Input/Output length\n"
                " -L           List Asm plugins: (a=asm, d=disasm, A=analyze, e=ESIL)\n"
                " -o,-@ [addr] Set start address for code (default 0)\n"
                " -O [file]    Output file name (rz-asm -Bf a.asm -O a)\n"
                " -p           Run SPP over input for assembly\n"
                " -q           quiet mode\n"
                " -r           output in rizin commands\n"
                " -s [syntax]  Select syntax (intel, att)\n"
                " -v           Show version information\n"
                " -x           Use hex dwords instead of hex pairs when assembling.\n"
                " -w           What's this instruction for? describe opcode\n"
                " If '-l' value is greater than output length, output is padded with nops\n"
                " If the last argument is '-' reads from stdin\n");
         printf("Environment:\n"
                " RZ_ASM_NOPLUGINS  do not load shared plugins (speedup loading)\n"
                " RZ_ASM_ARCH       same as rz-asm -a\n"
                " RZ_ASM_BITS       same as rz-asm -b\n"
                " RZ_DEBUG          if defined, show error messages and crash signal\n"
                "");
     }
     if (v == 2) {
         printf("Supported Assembler directives:\n");
         rz_asm_list_directives();
     }
     return 0;
 }

References printf(), rz_asm_list_directives(), and v.

Referenced by rz_main_rz_asm().

◆ rz_main_rz_asm()

RZ_API int rz_main_rz_asm	(	int	argc,
		const char *	argv[]
	)

Definition at line 508 of file rz-asm.c.

                                                         {
     const char *env_arch = rz_sys_getenv("RZ_ASM_ARCH");
     const char *env_bits = rz_sys_getenv("RZ_ASM_BITS");
     const char *arch = NULL;
     const char *cpu = NULL;
     const char *kernel = NULL;
     const char *filters = NULL;
     const char *file = NULL;
     bool isbig = false;
     bool rad = false;
     bool use_spp = false;
     bool hexwords = false;
     ut64 offset = 0;
     int fd = -1, bin = 0, ret = 0, bits = 32, c, whatsop = 0;
     DisasmMode dis = DISASM_MODE_DONT;
     int help = 0;
     ut64 len = 0, idx = 0, skip = 0;
     bool analinfo = false;
  
     if (argc < 2) {
         return rasm_show_help(1);
     }
  
     RzAsmState *as = __as_new();
  
     // TODO set addrbytes
     char *rz_arch = rz_sys_getenv("RZ_ARCH");
     if (rz_arch) {
         arch = rz_arch;
     }
  
     char *r2bits = rz_sys_getenv("RZ_BITS");
     if (r2bits) {
         bits = rz_num_math(NULL, r2bits);
         free(r2bits);
     }
  
     RzGetopt opt;
     rz_getopt_init(&opt, argc, argv, "a:Ab:Bc:CdDeEIf:F:hi:jk:l:L@:o:O:pqrs:vwx");
     while ((c = rz_getopt_next(&opt)) != -1) {
         switch (c) {
         case 'a':
             arch = opt.arg;
             break;
         case 'A':
             analinfo = true;
             break;
         case 'b':
             bits = rz_num_math(NULL, opt.arg);
             break;
         case 'B':
             bin = 1;
             break;
         case 'c':
             cpu = opt.arg;
             break;
         case 'C':
             as->coutput = true;
             break;
         case 'd':
             dis = DISASM_MODE_DEFAULT;
             break;
         case 'D':
             dis = DISASM_MODE_WITH_BYTES;
             break;
         case 'e':
             isbig = true;
             break;
         case 'E':
             dis = DISASM_MODE_ESIL;
             break;
         case 'I':
             dis = DISASM_MODE_IL;
             break;
         case 'f':
             file = opt.arg;
             break;
         case 'F':
             filters = opt.arg;
             break;
         case 'h':
             help++;
             // fallthrough
         case 'i':
             skip = rz_num_math(NULL, opt.arg);
             break;
         case 'j':
             as->json = true;
             break;
         case 'k':
             kernel = opt.arg;
             break;
         case 'l':
             len = rz_num_math(NULL, opt.arg);
             break;
         case 'L': {
             // create a dummy RzCore with the current RzAsm/RzAnalysis
             RzCore *core = rz_core_new();
             RzAsm *tmp_asm = core->rasm;
             RzAnalysis *tmp_analysis = core->analysis;
             core->rasm = as->a;
             core->analysis = as->analysis;
             RzCmdStateOutput state = { 0 };
             rz_cmd_state_output_init(&state, as->json ? RZ_OUTPUT_MODE_JSON : RZ_OUTPUT_MODE_STANDARD);
             rz_core_asm_plugins_print(core, opt.argv[opt.ind], &state);
             rz_cmd_state_output_print(&state);
             rz_cmd_state_output_fini(&state);
             rz_cons_flush();
             core->rasm = tmp_asm;
             core->analysis = tmp_analysis;
             rz_core_free(core);
             ret = 1;
             goto beach;
         }
         case '@':
         case 'o':
             offset = rz_num_math(NULL, opt.arg);
             break;
         case 'O':
             fd = open(opt.arg, O_TRUNC | O_RDWR | O_CREAT, 0644);
             if (fd != -1) {
                 dup2(fd, 1);
             }
             break;
         case 'p':
             use_spp = true;
             break;
         case 'q':
             as->quiet = true;
             break;
         case 'r':
             rad = true;
             break;
         case 's':
             if (*opt.arg == '?') {
                 printf("att\nintel\nmasm\njz\nregnum\n");
                 __as_free(as);
                 return 0;
             } else {
                 int syntax = rz_asm_syntax_from_string(opt.arg);
                 if (syntax == -1) {
                     __as_free(as);
                     return 1;
                 }
                 rz_asm_set_syntax(as->a, syntax);
             }
             break;
         case 'v':
             if (as->quiet) {
                 printf("%s\n", RZ_VERSION);
             } else {
                 ret = rz_main_version_print("rz-asm");
             }
             goto beach;
         case 'w':
             whatsop = true;
             break;
         case 'x':
             hexwords = true;
             break;
         default:
             ret = rasm_show_help(0);
             goto beach;
         }
     }
  
     if (help > 0) {
         ret = rasm_show_help(help > 1 ? 2 : 0);
         goto beach;
     }
  
     if (arch) {
         if (!rz_asm_use(as->a, arch)) {
             eprintf("rz-asm: Unknown asm plugin '%s'\n", arch);
             ret = 0;
             goto beach;
         }
         rz_analysis_use(as->analysis, arch);
     } else if (env_arch) {
         if (!rz_asm_use(as->a, env_arch)) {
             eprintf("rz-asm: Unknown asm plugin '%s'\n", env_arch);
             ret = 0;
             goto beach;
         }
     } else if (!rz_asm_use(as->a, "x86")) {
         eprintf("rz-asm: Cannot find asm.x86 plugin\n");
         ret = 0;
         goto beach;
     }
     rz_asm_set_cpu(as->a, cpu);
     rz_analysis_set_cpu(as->analysis, cpu);
     rz_asm_set_bits(as->a, (env_bits && *env_bits) ? atoi(env_bits) : bits);
     rz_analysis_set_bits(as->analysis, (env_bits && *env_bits) ? atoi(env_bits) : bits);
     as->a->syscall = rz_syscall_new();
     rz_syscall_setup(as->a->syscall, arch, bits, cpu, kernel);
     {
         bool canbebig = rz_asm_set_big_endian(as->a, isbig);
         if (isbig && !canbebig) {
             eprintf("Warning: This architecture can't swap to big endian.\n");
         }
         rz_analysis_set_big_endian(as->analysis, canbebig);
     }
     if (whatsop) {
         const char *s = rz_asm_describe(as->a, opt.argv[opt.ind]);
         ret = 1;
         if (s) {
             printf("%s\n", s);
             ret = 0;
         }
         goto beach;
     }
     if (filters) {
         char *p = strchr(filters, ':');
         if (p) {
             *p = 0;
             if (*filters) {
                 rz_asm_sub_names_input(as->a, filters);
             }
             if (p[1]) {
                 rz_asm_sub_names_output(as->a, p + 1);
             }
             *p = ':';
         } else {
             if (dis) {
                 rz_asm_sub_names_output(as->a, filters);
             } else {
                 rz_asm_sub_names_input(as->a, filters);
             }
         }
     }
  
     if (file) {
         char *content;
         size_t length = 0;
         if (!strcmp(file, "-")) {
             int sz = 0;
             ut8 *buf = (ut8 *)rz_stdin_slurp(&sz);
             if (!buf || sz < 1) {
                 eprintf("Nothing to do.\n");
                 goto beach;
             }
             len = (ut64)sz;
             if (dis) {
                 if (skip && length > skip) {
                     if (bin) {
                         memmove(buf, buf + skip, length - skip);
                         length -= skip;
                     }
                 }
                 ret = rasm_disasm(as, offset, (char *)buf, len, as->a->bits, bin, dis);
             } else if (analinfo) {
                 ret = show_analinfo(as, (const char *)buf, offset);
             } else {
                 ret = print_assembly_output(as, (char *)buf, offset, len,
                     as->a->bits, bin, use_spp, rad, hexwords, arch);
             }
             ret = !ret;
             free(buf);
         } else {
             content = rz_file_slurp(file, &length);
             if (content) {
                 if (length > ST32_MAX) {
                     eprintf("rz-asm: File %s is too big\n", file);
                     ret = 1;
                 } else {
                     if (len && len > 0 && len < length) {
                         length = len;
                     }
                     content[length] = '\0';
                     if (skip && length > skip) {
                         if (bin) {
                             memmove(content, content + skip, length - skip);
                             length -= skip;
                         }
                     }
                     if (dis) {
                         ret = rasm_disasm(as, offset, content,
                             length, as->a->bits, bin, dis);
                     } else if (analinfo) {
                         ret = show_analinfo(as, (const char *)content, offset);
                     } else {
                         ret = print_assembly_output(as, content, offset, length,
                             as->a->bits, bin, use_spp, rad, hexwords, arch);
                     }
                     ret = !ret;
                 }
                 free(content);
             } else {
                 eprintf("rz-asm: Cannot open file %s\n", file);
                 ret = 1;
             }
         }
     } else if (opt.argv[opt.ind]) {
         if (!strcmp(opt.argv[opt.ind], "-")) {
             int length;
             do {
                 char buf[1024]; // TODO: use(implement) rz_stdin_line() or so
                 length = read(0, buf, sizeof(buf) - 1);
                 if (length < 1) {
                     break;
                 }
                 if (len > 0 && len < length) {
                     length = len;
                 }
                 buf[length] = 0;
                 if ((!bin || !dis) && feof(stdin)) {
                     break;
                 }
                 if (skip && length > skip) {
                     if (bin) {
                         memmove(buf, buf + skip, length - skip + 1);
                         length -= skip;
                     }
                 }
                 if (!bin || !dis) {
                     int buflen = strlen((const char *)buf);
                     if (buf[buflen] == '\n') {
                         buf[buflen - 1] = '\0';
                     }
                 }
                 if (dis) {
                     ret = rasm_disasm(as, offset, (char *)buf, length, as->a->bits, bin, dis);
                 } else if (analinfo) {
                     ret = show_analinfo(as, (const char *)buf, offset);
                 } else {
                     ret = rasm_asm(as, (const char *)buf, offset, length, as->a->bits, bin, use_spp, hexwords);
                 }
                 idx += ret;
                 offset += ret;
                 if (!ret) {
                     goto beach;
                 }
             } while (!len || idx < length);
             ret = idx;
             goto beach;
         }
         if (dis) {
             char *usrstr = strdup(opt.argv[opt.ind]);
             len = strlen(usrstr);
             if (skip && len > skip) {
                 skip *= 2;
                 // eprintf ("SKIP (%s) (%lld)\n", usrstr, skip);
                 memmove(usrstr, usrstr + skip, len - skip);
                 len -= skip;
                 usrstr[len] = 0;
             }
             // XXX this is a wrong usage of endianness
             if (!strncmp(usrstr, "0x", 2)) {
                 memmove(usrstr, usrstr + 2, strlen(usrstr + 2) + 1);
             }
             if (rad) {
                 as->oneliner = true;
                 printf("e asm.arch=%s\n", arch ? arch : RZ_SYS_ARCH);
                 printf("e asm.bits=%d\n", bits);
                 printf("\"wa ");
             }
             ret = rasm_disasm(as, offset, (char *)usrstr, len, as->a->bits, bin, dis);
             free(usrstr);
         } else if (analinfo) {
             ret = show_analinfo(as, (const char *)opt.argv[opt.ind], offset);
         } else {
             ret = print_assembly_output(as, opt.argv[opt.ind], offset, len, as->a->bits,
                 bin, use_spp, rad, hexwords, arch);
         }
         ret = !ret;
     }
 beach:
     __as_free(as);
  
     free(rz_arch);
     if (fd != -1) {
         close(fd);
     }
     return ret;
 }

References __as_free(), __as_new(), RzAsmState::a, rz_core_t::analysis, RzAsmState::analysis, arch, rz_getopt_t::arg, rz_getopt_t::argv, argv, rz_asm_t::bits, bits(), buflen, c, close, RzAsmState::coutput, cpu, dis(), DISASM_MODE_DEFAULT, DISASM_MODE_DONT, DISASM_MODE_ESIL, DISASM_MODE_IL, DISASM_MODE_WITH_BYTES, dup2, eprintf, fd, filters, free(), cmd_descs_generate::help, setup::idx, rz_getopt_t::ind, RzAsmState::json, len, length, NULL, O_CREAT, O_RDWR, O_TRUNC, RzAsmState::oneliner, p, print_assembly_output(), printf(), RzAsmState::quiet, rz_core_t::rasm, rasm_asm(), rasm_disasm(), rasm_show_help(), read(), rz_analysis_set_big_endian(), rz_analysis_set_bits(), rz_analysis_set_cpu(), rz_analysis_use(), rz_asm_describe(), rz_asm_set_big_endian(), rz_asm_set_bits(), rz_asm_set_cpu(), rz_asm_set_syntax(), rz_asm_sub_names_input(), rz_asm_sub_names_output(), rz_asm_syntax_from_string(), rz_asm_use(), rz_cmd_state_output_fini(), rz_cmd_state_output_init(), rz_cmd_state_output_print(), rz_cons_flush(), rz_core_asm_plugins_print(), rz_core_free(), rz_core_new(), rz_file_slurp(), rz_getopt_init(), rz_getopt_next(), rz_main_version_print(), rz_num_math(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_STANDARD, rz_stdin_slurp(), RZ_SYS_ARCH, rz_sys_getenv(), rz_syscall_new(), rz_syscall_setup(), RZ_VERSION, s, show_analinfo(), skip(), ST32_MAX, strdup(), benchmark::syntax, rz_asm_t::syscall, and ut64().

Referenced by MAIN_NAME().

◆ show_analinfo()

static int show_analinfo	(	RzAsmState *	as,
		const char *	arg,
		ut64	offset
	)

static

Definition at line 123 of file rz-asm.c.

                                                                        {
     ut8 *buf = (ut8 *)strdup((const char *)arg);
     int ret, len = rz_hex_str2bin((char *)buf, buf);
     PJ *pj = NULL;
     if (as->json) {
         pj = pj_new();
         if (!pj) {
             free(buf);
             return 0;
         }
     }
  
     RzAnalysisOp aop = { 0 };
  
     if (pj) {
         pj_a(pj);
     }
     for (ret = 0; ret < len;) {
         aop.size = 0;
         if (rz_analysis_op(as->analysis, &aop, offset, buf + ret, len - ret, RZ_ANALYSIS_OP_MASK_BASIC | RZ_ANALYSIS_OP_MASK_ESIL) < 1) {
             eprintf("Error analyzing instruction at 0x%08" PFMT64x "\n", offset);
             break;
         }
         if (aop.size < 1) {
             if (pj) {
                 pj_o(pj);
                 pj_ks(pj, "bytes", rz_hex_bin2strdup(buf, ret));
                 pj_ks(pj, "type", "Invalid");
                 pj_end(pj);
             } else {
                 eprintf("Invalid\n");
             }
             break;
         }
         showanalysis(as, &aop, offset, buf + ret, len - ret, pj);
         ret += aop.size;
         rz_analysis_op_fini(&aop);
     }
     if (pj) {
         pj_end(pj);
         printf("%s\n", pj_string(pj));
         pj_free(pj);
     }
     free(buf);
     return ret;
 }

References RzAsmState::analysis, arg(), eprintf, free(), RzAsmState::json, len, NULL, PFMT64x, pj_a(), pj_end(), pj_free(), pj_ks(), pj_new(), pj_o(), pj_string(), printf(), rz_analysis_op(), rz_analysis_op_fini(), RZ_ANALYSIS_OP_MASK_BASIC, RZ_ANALYSIS_OP_MASK_ESIL, rz_hex_bin2strdup(), rz_hex_str2bin(), showanalysis(), rz_analysis_op_t::size, and strdup().

Referenced by rz_main_rz_asm().

◆ showanalysis()

static void showanalysis	(	RzAsmState *	as,
		RzAnalysisOp *	op,
		ut64	offset,
		ut8 *	buf,
		int	len,
		PJ *	pj
	)

static

Definition at line 72 of file rz-asm.c.

                                                                                                    {
     char *stackop = stackop2str(op->stackop);
     const char *optype = rz_analysis_optype_to_string(op->type);
     char *bytes = rz_hex_bin2strdup(buf, RZ_MIN(len, op->size));
     if (as->json) {
         pj_o(pj);
         pj_kn(pj, "opcode", offset);
         pj_ks(pj, "bytes", bytes);
         pj_ks(pj, "type", optype);
         if (op->jump != UT64_MAX) {
             pj_kn(pj, "jump", op->jump);
         }
         if (op->fail != UT64_MAX) {
             pj_kn(pj, "fail", op->fail);
         }
         if (op->val != UT64_MAX) {
             pj_kn(pj, "val", op->val);
         }
         if (op->ptr != UT64_MAX) {
             pj_kn(pj, "ptr", op->ptr);
         }
         pj_ks(pj, "stackop", stackop);
         pj_ks(pj, "esil", rz_strbuf_get(&op->esil));
         pj_kn(pj, "stackptr", op->stackptr);
         pj_end(pj);
     } else {
         printf("offset:   0x%08" PFMT64x "\n", offset);
         printf("bytes:    %s\n", bytes);
         printf("type:     %s\n", optype);
         if (op->jump != -1LL) {
             printf("jump:     0x%08" PFMT64x "\n", op->jump);
         }
         if (op->fail != -1LL) {
             printf("fail:     0x%08" PFMT64x "\n", op->fail);
         }
         // if (op->ref != -1LL)
         //       printf ("ref:      0x%08"PFMT64x"\n", op->ref);
         if (op->val != -1LL) {
             printf("value:    0x%08" PFMT64x "\n", op->val);
         }
         printf("stackop:  %s\n", stackop);
         printf("esil:     %s\n", rz_strbuf_get(&op->esil));
         printf("stackptr: %" PFMT64d "\n", op->stackptr);
         // produces (null) printf ("decode str: %s\n", rz_analysis_op_to_string (analysis, op));
         printf("\n");
     }
     free(stackop);
     free(bytes);
 }

References bytes, free(), RzAsmState::json, len, PFMT64d, PFMT64x, pj_end(), pj_kn(), pj_ks(), pj_o(), printf(), rz_analysis_optype_to_string(), rz_hex_bin2strdup(), RZ_MIN, rz_strbuf_get(), stackop2str(), and UT64_MAX.

Referenced by show_analinfo().

◆ stackop2str()

static char* stackop2str ( int type )

static

Definition at line 61 of file rz-asm.c.

                                    {
     switch (type) {
     case RZ_ANALYSIS_STACK_NULL: return strdup("null");
     case RZ_ANALYSIS_STACK_NOP: return strdup("nop");
     // case RZ_ANALYSIS_STACK_INCSTACK: return strdup ("incstack");
     case RZ_ANALYSIS_STACK_GET: return strdup("get");
     case RZ_ANALYSIS_STACK_SET: return strdup("set");
     }
     return strdup("unknown");
 }

References RZ_ANALYSIS_STACK_GET, RZ_ANALYSIS_STACK_NOP, RZ_ANALYSIS_STACK_NULL, RZ_ANALYSIS_STACK_SET, strdup(), and type.

Referenced by showanalysis().

Classes

Enumerations

Functions

Enumeration Type Documentation

◆ DisasmMode

Function Documentation

◆ __as_free()

◆ __as_new()

◆ __as_set_archbits()

◆ __lib_analysis_cb()

◆ __lib_asm_cb()

◆ __load_plugins()

◆ print_and_check_il()

◆ print_assembly_output()

◆ print_buf()

◆ print_label()

◆ rasm_asm()

◆ rasm_disasm()

◆ rasm_show_help()

◆ rz_main_rz_asm()

◆ show_analinfo()

◆ showanalysis()

◆ stackop2str()