R_API RList *r_core_asm_bwdisassemble (RCore *core, ut64 addr, int n, int len) {
RList *hits = r_core_asm_hit_list_new();
RAsmOp op;
// len = n * 32;
// if (n > core->blocksize) n = core->blocksize;
ut8 *buf;
ut64 instrlen = 0, at = 0;
ut32 idx = 0, hit_count = 0;
int numinstr, asmlen, ii;
RAsmCode *c;
if (len<1) return NULL;
buf = (ut8 *)malloc (len);
if (hits == NULL || buf == NULL ){
if (hits) {
r_list_free (hits);
}
free (buf);
return NULL;
}
if (r_io_read_at (core->io, addr-len, buf, len) != len) {
if (hits) {
r_list_free (hits);
}
free (buf);
return NULL;
}
for (idx = 1; idx < len; ++idx) {
if (r_cons_singleton ()->breaked) break;
at = addr - idx; hit_count = 0;
c = r_asm_mdisassemble (core->assembler, buf+(len-idx), idx);
if (strstr(c->buf_asm, "invalid") || strstr(c->buf_asm, ".byte")) {
r_asm_code_free(c);
continue;
}
numinstr = 0;
asmlen = strlen(c->buf_asm);
for(ii = 0; ii < asmlen; ++ii) {
if (c->buf_asm[ii] == '\n') ++numinstr;
}
r_asm_code_free(c);
if (numinstr >= n || idx > 32 * n) {
break;
}
}
at = addr - idx;
hit_count = 0;
r_asm_set_pc (core->assembler, at);
at = addr-idx;
for ( hit_count = 0; hit_count < n; hit_count++) {
instrlen = r_asm_disassemble (core->assembler, &op, buf+(len-(addr-at)), addr-at);
add_hit_to_hits(hits, at, instrlen, true);
at += instrlen;
}
free (buf);
return hits;
}
R_API RList *r_core_asm_bwdisassemble (RCore *core, ut64 addr, int n, int len) {
RList *hits = r_core_asm_hit_list_new();
RCoreAsmHit dummy_value;
RAsmOp op;
ut8 *buf = (ut8 *)malloc (len);
ut64 instrlen = 0,
at = 0;
ut32
idx = 0,
hit_count = 0;
memset (&dummy_value, 0, sizeof (RCoreAsmHit));
if (hits == NULL || buf == NULL ){
if (hits) r_list_destroy (hits);
if (buf) free (buf);
return NULL;
}
if (r_io_read_at (core->io, addr-len, buf, len) != len) {
if (hits) r_list_destroy (hits);
if (buf) free (buf);
return NULL;
}
for (idx = 1; idx < len; idx++) {
ut32 current_buf_pos;
if (r_cons_singleton ()->breaked) break;
at = addr - idx; hit_count = 0;
// XXX - buf here. at may be greater than addr if near boundary.
for (current_buf_pos = len - idx, hit_count = 0;
current_buf_pos < len && hit_count <= n;
current_buf_pos += instrlen, at += instrlen, hit_count++) {
r_asm_set_pc (core->assembler, at);
//XXX HACK We need another way to detect invalid disasm!!
if (!(instrlen = r_asm_disassemble (core->assembler, &op, buf+(len-(addr-at)), addr-at)) || strstr (op.buf_asm, "invalid")) {
break;
}
}
if (hit_count >= n) break;
}
if (hit_count == n) {
at = addr - idx;
hit_count = 0;
r_asm_set_pc (core->assembler, at);
for ( hit_count = 0; hit_count < n; hit_count++) {
instrlen = r_asm_disassemble (core->assembler, &op, buf+(len-(addr-at)), addr-at);
add_hit_to_hits(hits, at, instrlen, R_TRUE);
at += instrlen;
}
}
r_asm_set_pc (core->assembler, addr);
free (buf);
return hits;
}
R_API RList *r_core_asm_bwdisassemble (RCore *core, ut64 addr, int n, int len) {
RList *hits = r_core_asm_hit_list_new();
RAsmOp op;
ut8 *buf;
ut64 buf_addr, instrlen = 0, at = 0;
ut32 idx = 0, hit_count = 0, buf_len = 0;
int numinstr, ii;
RAsmCode *c;
if (!hits)
return NULL;
buf_addr = addr - len;
buf_len = len;
buf = (ut8 *)malloc (buf_len);
if (!buf) {
r_list_free (hits);
return NULL;
}
if (r_io_read_at (core->io, buf_addr, buf, buf_len) != buf_len) {
r_list_free (hits);
free (buf);
return NULL;
}
if (!memcmp (buf, "\xff\xff\xff\xff", R_MIN (4, buf_len))) {
eprintf ("error reading at 0x%08"PFMT64x"\n", buf_addr);
r_list_free (hits);
free (buf);
return NULL;
}
if (n<0) n = -n;
for (idx = 1; idx < len; idx++) {
if (r_cons_singleton ()->breaked)
break;
at = addr - idx;
hit_count = 0;
r_asm_set_pc (core->assembler, at);
// XXX: the disassemble errors are because of this line. mdisasm must not be used here
//c = r_asm_mdisassemble (core->assembler, buf+idx, buf_len-idx); //+buf_len-idx, idx);
c = r_asm_mdisassemble (core->assembler, buf+buf_len-idx, idx);
// XXX: relaying on string contents in the buf_asm is a bad idea
if (strstr (c->buf_asm, "invalid") || strstr (c->buf_asm, ".byte")) {
r_asm_code_free (c);
continue;
}
//eprintf ("-->(%x)(%s)\n", at, c->buf_asm);
for (numinstr = ii = 0; c->buf_asm[ii] ; ii++) {
if (c->buf_asm[ii] == '\n')
numinstr++;
}
//eprintf ("mdisasm worked! for 0x%llx with %d\n", addr-len+idx, numinstr);
r_asm_code_free (c);
if (numinstr >= n || idx > 32 * n) {
//eprintf ("idx = %d len = %d ninst = %d n = %d\n", idx, len, numinstr, n);
break;
}
//eprintf ("idx = %d len = %d\n", idx, len);
}
at = addr - idx;
hit_count = 0;
for (hit_count = 0; hit_count < n; hit_count++) {
if (r_cons_singleton ()->breaked)
break;
r_asm_set_pc (core->assembler, at);
instrlen = r_asm_disassemble (core->assembler,
&op, buf+buf_len-(addr-at), addr-at); //addr-at);
// eprintf ("INST LEN = %d\n", instrlen);
if (instrlen<1) {
eprintf ("dissasm failed at %llx\n", at);
instrlen = 1;
// break;
}
add_hit_to_hits (hits, at, instrlen, R_TRUE);
at += instrlen;
}
free (buf);
return hits;
}
R_API RList *r_core_asm_bwdisassemble(RCore *core, ut64 addr, int n, int len) {
RAsmOp op;
// len = n * 32;
// if (n > core->blocksize) n = core->blocksize;
ut8 *buf;
ut64 at;
ut32 idx = 0, hit_count;
int numinstr, asmlen, ii;
int addrbytes = core->assembler->addrbytes;
RAsmCode *c;
RList *hits = r_core_asm_hit_list_new();
if (!hits) return NULL;
len = R_MIN (len - len % addrbytes, addrbytes * addr);
if (len < 1) {
r_list_free (hits);
return NULL;
}
buf = (ut8 *)malloc (len);
if (!buf) {
if (hits) {
r_list_free (hits);
}
return NULL;
} else if (!hits) {
free (buf);
return NULL;
}
len = len > addr ? addr : len;
if (!r_io_read_at (core->io, addr - len, buf, len)) {
r_list_free (hits);
free (buf);
return NULL;
}
for (idx = addrbytes; idx < len; idx += addrbytes) {
if (r_cons_singleton ()->breaked) break;
c = r_asm_mdisassemble (core->assembler, buf+(len-idx), idx);
if (strstr (c->buf_asm, "invalid") || strstr (c->buf_asm, ".byte")) {
r_asm_code_free(c);
continue;
}
numinstr = 0;
asmlen = strlen (c->buf_asm);
for(ii = 0; ii < asmlen; ++ii) {
if (c->buf_asm[ii] == '\n') ++numinstr;
}
r_asm_code_free(c);
if (numinstr >= n || idx > 16 * n) { // assume average instruction length <= 16
break;
}
}
at = addr - idx / addrbytes;
r_asm_set_pc (core->assembler, at);
for (hit_count = 0; hit_count < n; hit_count++) {
int instrlen = r_asm_disassemble (core->assembler, &op,
buf + len - addrbytes*(addr-at), addrbytes * (addr-at));
add_hit_to_hits (hits, at, instrlen, true);
at += instrlen;
}
free (buf);
return hits;
}
