wiring up more reg/memifs to esil

Author: radare

libr/anal/anal.c

@@ -117,7 +117,10 @@ static bool anal_esil_reg_read (void *user, const char *name, ut64 *val) {
 	if (!ri) {
 		return false;
 	}
-	*val = r_reg_get_value (((RAnal *)user)->reg, ri);
+	ut64 v = r_reg_get_value (((RAnal *)user)->reg, ri);
+	if (val) {
+		*val = v;
+	}
 	r_unref (ri);
 	return true;
 }

libr/core/cmd_anal.inc.c

@@ -2452,6 +2452,49 @@ static bool mw(int *ec, ut64 addr, const ut8 *old, const ut8 *buf, int len) {
 	return true;
 }
 
+static bool anal_rr(void *_reg, const char *name, ut64 *val) {
+	RReg *reg = _reg;
+	RRegItem *ri = r_reg_get (reg, name, -1);
+	if (ri) {
+#if 0
+		if (len) {
+			*len = ri->size;
+		}
+#endif
+		if (val) {
+			*val = r_reg_get_value (reg, ri);
+		}
+		return true;
+	}
+	return false;
+}
+
+static bool anal_rw(void *_reg, const char *name, ut64 val) {
+	RReg *reg = _reg;
+	return r_reg_setv (reg, name, val);
+}
+
+static bool anal_mw(void *user, ut64 addr, const ut8 *buf, int len) {
+	RCore *core = user;
+	r_io_write_at (core->io, addr, buf, len);
+	return true;
+}
+
+static bool anal_mr(void *user, ut64 addr, ut8 *buf, int len) {
+	RCore *core = user;
+	(void)r_io_read_at (core->io, addr, (ut8 *)buf, len);
+	return true;
+}
+
+static bool anal_ir(void *_reg, const char *name) {
+	RReg *reg = _reg;
+	RRegItem *ri = r_reg_get (reg, name, -1);
+	if (ri) {
+		return true;
+	}
+	return false;
+}
+
 #if 0
 static bool rw(void *null, const char *regname, ut64 old, ut64 num) {
 	return true;
@@ -2544,6 +2587,20 @@ static inline REsil *esil_new_setup(RCore *core) {
 		const char *et = r_config_get (core->config, "cmd.esil.trap");
 		esil->cmd_trap = R_STR_ISNOTEMPTY (et)? strdup (et): NULL;
 	}
+	esil->user = core;
+	// reg
+	esil->reg_if.reg = core->anal->reg;
+	esil->reg_if.reg_write = anal_rw;
+	esil->reg_if.reg_read = anal_rr;
+	esil->reg_if.is_reg = anal_ir;
+	// mem
+	esil->mem_if.user = core;
+	esil->mem_if.mem_read = anal_mr;
+	esil->mem_if.mem_write = anal_mw;
+#if 0
+	esil->cb.hook_mem_write = anal_mw;
+	esil->cb.hook_mem_read = anal_mr;
+#endif
 	// run the esilcb from arch
 	if (core->anal->arch) {
 		r_arch_esilcb (core->anal->arch, R_ARCH_ESIL_ACTION_INIT);
@@ -8046,11 +8103,9 @@ static bool mymemread(REsil *esil, ut64 addr, ut8 *buf, int len) {
 		return false;
 	}
 	n = R_NEW (AeaMemItem);
-	if (n) {
-		n->addr = addr;
-		n->size = len;
-		r_list_push (mymemxsr, n);
-	}
+	n->addr = addr;
+	n->size = len;
+	r_list_push (mymemxsr, n);
 	return true;
 }
 
@@ -8415,6 +8470,7 @@ static void cmd_aespc(RCore *core, ut64 addr, ut64 until_addr, int ninstr) {
 			break;
 		default:
 			r_reg_setv (core->anal->reg, "PC", aop.addr + aop.size);
+eprintf ("%p\n", esil->cb.hook_reg_write);
 			r_reg_setv (core->dbg->reg, "PC", aop.addr + aop.size);
 			const char *e = R_STRBUF_SAFEGET (&aop.esil);
 			if (R_STR_ISNOTEMPTY (e)) {

libr/core/core_esil.c

@@ -434,7 +434,11 @@ R_API bool r_core_esil_single_step(RCore *core) {
 					//this is like r_list_pop_head + r_list_push,
 					//but without expensive calls to malloc and free
 					RListIter *iter = core->esil.stepback.head;
-					iter->p->n = NULL;
+					if (iter->p) {
+						iter->p->n = NULL;
+					} else {
+						R_LOG_ERROR ("iter->p shouldnt be null");
+					}
 					core->esil.stepback.head = iter->p;
 					iter->p = NULL;
 					iter->n = core->esil.stepback.tail;

libr/esil/esil.c

@@ -1,4 +1,4 @@
-/* radare - LGPL - Copyright 2014-2024 - pancake, condret */
+/* radare - LGPL - Copyright 2014-2025 - pancake, condret */
 
 #define R_LOG_ORIGIN "esil"
 
@@ -135,7 +135,10 @@ static bool default_reg_read(void *reg, const char *name, ut64 *val) {
 	if (!ri) {
 		return false;
 	}
-	*val = r_reg_get_value ((RReg *)reg, ri);
+	ut64 v = r_reg_get_value ((RReg *)reg, ri);
+	if (val) {
+		*val = v;
+	}
 	r_unref (ri);
 	return true;
 }
@@ -578,7 +581,7 @@ R_API int r_esil_get_parm_type(REsil *esil, const char *str) {
 	if (r_str_startswith (str, "0x")) {
 		return R_ESIL_PARM_NUM;
 	}
-	if (!((isdigit(str[0])) || str[0] == '-')) {
+	if (!((isdigit (str[0])) || str[0] == '-')) {
 		return not_a_number (esil, str);
 	}
 	size_t i;
@@ -667,7 +670,7 @@ R_API bool r_esil_reg_read_nocallback(REsil *esil, const char *regname, ut64 *nu
 
 R_API bool r_esil_reg_read(REsil *esil, const char *regname, ut64 *val, ut32 *size) {
 #if USE_NEW_ESIL
-	R_RETURN_VAL_IF_FAIL (esil && regname && val, false);
+	R_RETURN_VAL_IF_FAIL (esil && regname, false);
 	if (R_UNLIKELY (!r_esil_reg_read_silent (esil, regname, val, size))) {
 		return false;
 	}
@@ -702,7 +705,7 @@ R_API bool r_esil_reg_read(REsil *esil, const char *regname, ut64 *val, ut32 *si
 }
 
 R_API bool r_esil_reg_read_silent(REsil *esil, const char *name, ut64 *val, ut32 *size) {
-	R_RETURN_VAL_IF_FAIL (esil && esil->reg_if.reg_read && name && val, false);
+	R_RETURN_VAL_IF_FAIL (esil && esil->reg_if.reg_read && name, false);
 	if (!esil->reg_if.reg_read (esil->reg_if.reg, name, val)) {
 		return false;
 	}

libr/esil/esil_ops.c

@@ -1,4 +1,4 @@
-/* radare - LGPL - Copyright 2024 - pancake, condret */
+/* radare - LGPL - Copyright 2024-2025 - pancake, condret */
 
 #include <r_esil.h>
 #include <r_anal.h>
@@ -23,6 +23,9 @@
 #define	OT_FLAG R_ESIL_OP_TYPE_FLAG
 #define	OT_TRAP R_ESIL_OP_TYPE_TRAP
 
+static bool isreg(REsil *esil, const char* name) {
+	return r_esil_reg_read (esil, name, NULL, NULL);
+}
 static ut64 reg_getv(REsil *esil, const char* name) {
 	ut64 v = UT64_MAX;
 	if (r_esil_reg_read (esil, name, &v, NULL)) {
@@ -616,8 +619,8 @@ static bool esil_bits(REsil *esil) {
 	if (popRN (esil, &s)) {
 		if (esil->anal && esil->anal->coreb.setArchBits) {
 			esil->anal->coreb.setArchBits (esil->anal->coreb.core, NULL, s);
+			return true;
 		}
-		return true;
 	}
 	R_LOG_DEBUG ("esil_bits: missing parameters in stack");
 	return false;
@@ -642,9 +645,11 @@ static bool esil_syscall(REsil *esil) {
 static bool esil_cmd(REsil *esil) {
 	char *str = r_esil_pop (esil);
 	if (str) {
-		if (esil->anal && esil->anal->coreb.setArchBits) {
+		if (esil->anal && esil->anal->coreb.core) {
 			esil->anal->coreb.cmd (esil->anal->coreb.core, str);
+			return true;
 		}
+		R_LOG_WARN ("Cannot run RCoreBind.cmd");
 	}
 	return false;
 }
@@ -678,20 +683,13 @@ static void pushnums(REsil *esil, const char *src, ut64 num2, const char *dst, u
 	R_RETURN_IF_FAIL (esil);
 	esil->old = num;
 	esil->cur = num - num2;
-	RReg *reg = esil->anal->reg;
-	RRegItem *ri = r_reg_get (reg, dst, -1);
-	if (ri) {
+	if (isreg (esil, dst)) {
 		esil->lastsz = esil_internal_sizeof_reg (esil, dst);
-		r_unref (ri);
-		return;
-	}
-	if (ri = r_reg_get (reg, src, -1), ri) {
+	} else if (isreg (esil, src)) {
 		esil->lastsz = esil_internal_sizeof_reg (esil, src);
-		r_unref (ri);
-		return;
+	} else {
+		esil->lastsz = 64;
 	}
-	// default size is set to 64 as internally operands are ut64
-	esil->lastsz = 64;
 }
 
 // This function also sets internal vars which is used in flag calculations.

libr/include/r_esil.h

@@ -266,7 +266,7 @@ typedef struct r_esil_t {
 	char *cmd_ioer; // r2 (external) command to run when esil fails to IO
 	char *mdev_range; // string containing the r_str_range to match for read/write accesses
 	bool (*cmd)(ESIL *esil, const char *name, ut64 a0, ut64 a1);
-	void *user;
+	void *user; // RCore *
 	int stack_fd;	// ahem, let's not do this
 	bool in_cmd_step;
 #if 0