R_API void r_anal_esil_trace_show(RAnalEsil *esil, int idx) {
PrintfCallback p = esil->anal->printf;
const char *str2;
const char *str;
int trace_idx = esil->trace_idx;
esil->trace_idx = idx;
str2 = sdb_const_get (DB, KEY ("addr"), 0);
if (!str2) {
return;
}
p ("dr pc = %s\n", str2);
/* registers */
str = sdb_const_get (DB, KEY ("reg.read"), 0);
if (str) {
char regname[32];
const char *next, *ptr = str;
if (ptr && *ptr) {
do {
const char *ztr = sdb_const_anext (ptr, &next);
int len = next? (int)(size_t)(next-ztr)-1 : strlen (ztr);
if (len <sizeof(regname)) {
memcpy (regname, ztr, len);
regname[len] = 0;
str2 = sdb_const_get (DB, KEYREG ("reg.read", regname), 0);
p ("dr %s = %s\n", regname, str2);
} else {
eprintf ("Invalid entry in reg.read\n");
}
ptr = next;
} while (next);
}
}
/* memory */
str = sdb_const_get (DB, KEY ("mem.read"), 0);
if (str) {
char addr[64];
const char *next, *ptr = str;
if (ptr && *ptr) {
do {
const char *ztr = sdb_const_anext (ptr, &next);
int len = next? (int)(size_t)(next-ztr)-1 : strlen (ztr);
if (len <sizeof(addr)) {
memcpy (addr, ztr, len);
addr[len] = 0;
str2 = sdb_const_get (DB, KEYAT ("mem.read.data",
r_num_get (NULL, addr)), 0);
p ("wx %s @ %s\n", str2, addr);
} else {
eprintf ("Invalid entry in reg.read\n");
}
ptr = next;
} while (next);
}
}
esil->trace_idx = trace_idx;
}
SDB_API int sdb_array_add_sorted(Sdb *s, const char *key, const char *val, ut32 cas) {
int lstr, lval, i, j;
const char *str_e, *str_lp, *str_p, *str = sdb_const_get_len (s, key, &lstr, 0);
char *nstr, *nstr_p, **vals;
const char null = '\0';
if (!str || !*str) {
str = &null;
lstr = 0;
}
str_e = str + lstr;
str_lp = str_p = str;
if (!val || !*val) {
return 1;
}
lval = strlen (val);
vals = sdb_fmt_array (val);
for (i = 0; vals[i]; i++) {
/* empty */
}
if (i > 1) {
qsort (vals, i, sizeof (ut64*), cstring_cmp);
}
nstr_p = nstr = malloc (lstr + lval + 3);
if (!nstr) {
return 1;
}
for (i = 0; vals[i]; i++) {
while (str_p < str_e) {
if (astrcmp (vals[i], str_p) < 0) {
break;
}
sdb_const_anext (str_p, &str_p);
if (!str_p) {
str_p = str_e;
}
}
memcpy (nstr_p, str_lp, str_p - str_lp);
nstr_p += str_p - str_lp;
if (str_p == str_e && str_lp != str_e) {
*(nstr_p++) = SDB_RS;
}
str_lp = str_p;
j = strlen (vals[i]);
memcpy (nstr_p, vals[i], j);
nstr_p += j;
*(nstr_p++) = SDB_RS;
}
if (str_lp < str_e) {
memcpy (nstr_p, str_lp, str_e - str_lp);
nstr_p += str_e - str_lp;
*(nstr_p) = '\0';
} else {
*(--nstr_p) = '\0';
}
sdb_set_owned (s, key, nstr, cas);
free (vals);
return 0;
}
SDB_API int sdb_array_add_sorted_num(Sdb *s, const char *key, ut64 val, ut32 cas) {
int i;
char valstr[SDB_NUM_BUFSZ];
const char *str = sdb_const_get (s, key, 0);
const char *n = str;
if (!str || !*str) {
return sdb_set (s, key, sdb_itoa (val, valstr, SDB_NUM_BASE), cas);
}
for (i = 0; n; i++) {
if (val <= sdb_atoi (n)) {
break;
}
sdb_const_anext (n, &n);
}
return sdb_array_insert_num (s, key, n? i: -1, val, cas);
}
SDB_API int sdb_array_add_sorted_num(Sdb *s, const char *key, ut64 val, ut32 cas) {
int i;
char valstr[64];
const char *str = sdb_const_get (s, key, 0);
const char *n = str;
if (!str || !*str)
return sdb_set (s, key, sdb_itoa (val, valstr, SDB_NUM_BASE), cas);
for (i=0; n != NULL; i++) {
if (val <= sdb_atoi(n))
break;
sdb_const_anext(n, &n);
}
if (n == NULL)
i = -1;
sdb_array_insert_num (s, key, i, val, cas);
return 0;
}
SDB_API int sdb_array_contains(Sdb *s, const char *key, const char *val, ut32 *cas) {
const char *list = sdb_const_get (s, key, cas);
const char *next, *ptr = list;
const int vlen = strlen (val);
if (list && *list) {
do {
const char *str = sdb_const_anext (ptr, &next);
int len = next? (int)(size_t)(next - str)-1 : (int)strlen (str);
if (len == vlen) {
if (!memcmp (str, val, len)) {
return 1;
}
}
ptr = next;
} while (next);
}
return 0;
}
static ut64 sdb_array_get_closer_num (Sdb *db, const char *key, ut64 addr) {
const char *s = sdb_const_get (db, key, NULL);
const char *next = NULL;
const char *ptr = NULL;
ut64 num, closer = UT64_MAX;
if (!s) return UT64_MAX;
ptr = s;
do {
const char *str = sdb_const_anext (ptr, &next);
num = sdb_atoi (str);
if (addr == num)
return closer;
if (addr>=num) {
if (closer > (addr - num))
closer = num;
}
ptr = next;
} while (next);
return closer;
}
static ut64 getCrossingBlock(Sdb *db, const char *key, ut64 start, ut64 end) {
ut64 block_start, block_end;
ut64 nearest_start = UT64_MAX;
const char *s = sdb_const_get (db, key, NULL);
const char *next = NULL;
const char *ptr = NULL;
if (!s) {
return UT64_MAX;
}
ptr = s;
do {
const char *str = sdb_const_anext (ptr, &next);
block_start = sdb_atoi (str);
if (start == block_start) { // case 5
return start;
}
block_end = sdb_num_get (db, Fbb(block_start), NULL);
if (block_end) {
if (start > block_start && start < block_end) { // case 2
// start is inside the block
return block_start;
}
if (start < block_start && end >= block_end) {
// crossing the start of the block
if (nearest_start > block_start) {
nearest_start = block_start;
}
}
}
ptr = next;
} while (next);
return nearest_start;
}
