static RList* sections(RBinFile *arch) {
RList *ret = NULL;
RBinSection *ptr9 = NULL, *ptr7 = NULL;
if (!(ret = r_list_new ()))
return NULL;
if (!(ptr9 = R_NEW0 (RBinSection))) {
r_list_free (ret);
return NULL;
}
if (!(ptr7 = R_NEW0 (RBinSection))) {
r_list_free (ret);
free (ptr9);
return NULL;
}
strncpy (ptr9->name, "arm9", 5);
ptr9->size = loaded_header.arm9_size;
ptr9->vsize = loaded_header.arm9_size;
ptr9->paddr = loaded_header.arm9_rom_offset;
ptr9->vaddr = loaded_header.arm9_ram_address;
ptr9->srwx = r_str_rwx ("rwx");
r_list_append (ret, ptr9);
strncpy (ptr7->name, "arm7", 5);
ptr7->size = loaded_header.arm7_size;
ptr7->vsize = loaded_header.arm7_size;
ptr7->paddr = loaded_header.arm7_rom_offset;
ptr7->vaddr = loaded_header.arm7_ram_address;
ptr7->srwx = r_str_rwx ("rwx");
r_list_append (ret, ptr7);
return ret;
}
static RList* sections(RBinFile *bf){
ut8 bank;
int i;
RList *ret;
if (!bf) {
return NULL;
}
ret = r_list_new();
if (!ret) {
return NULL;
}
r_buf_read_at (bf->buf, 0x148, &bank, 1);
bank = gb_get_rombanks(bank);
#ifdef _MSC_VER
RBinSection **rombank = (RBinSection**) malloc (sizeof (RBinSection*) * bank);
#else
RBinSection *rombank[bank];
#endif
if (!bf->buf) {
free (ret);
#ifdef _MSC_VER
free (rombank);
#endif
return NULL;
}
ret->free = free;
rombank[0] = R_NEW0 (RBinSection);
rombank[0]->name = strdup ("rombank00");
rombank[0]->paddr = 0;
rombank[0]->size = 0x4000;
rombank[0]->vsize = 0x4000;
rombank[0]->vaddr = 0;
rombank[0]->perm = r_str_rwx ("rx");
rombank[0]->add = true;
r_list_append (ret, rombank[0]);
for (i = 1; i < bank; i++) {
rombank[i] = R_NEW0 (RBinSection);
rombank[i]->name = r_str_newf ("rombank%02x", i);
rombank[i]->paddr = i*0x4000;
rombank[i]->vaddr = i*0x10000-0xc000; //spaaaaaaaaaaaaaaaace!!!
rombank[i]->size = rombank[i]->vsize = 0x4000;
rombank[i]->perm = r_str_rwx ("rx");
rombank[i]->add = true;
r_list_append (ret,rombank[i]);
}
#ifdef _MSC_VER
free (rombank);
#endif
return ret;
}
static RList* sections(RBinFile *arch) {
int i;
RList *ret;
RBinSection *s;
DolHeader *dol;
if (!arch || !arch->o || !arch->o->bin_obj)
return NULL;
dol = arch->o->bin_obj;
if (!(ret = r_list_new ())) {
return NULL;
}
/* text sections */
for (i=0; i<N_TEXT; i++) {
if (!dol->text_paddr[i] || !dol->text_vaddr[i])
continue;
s = R_NEW0 (RBinSection);
snprintf (s->name, sizeof (s->name), "text_%d", i);
s->paddr = dol->text_paddr[i];
s->vaddr = dol->text_vaddr[i];
s->size = dol->text_size[i];
s->vsize = s->size;
s->srwx = r_str_rwx ("mr-x");
s->add = true;
r_list_append (ret, s);
}
/* data sections */
for (i=0; i<N_DATA; i++) {
if (!dol->data_paddr[i] || !dol->data_vaddr[i])
continue;
s = R_NEW0 (RBinSection);
snprintf (s->name, sizeof (s->name), "data_%d", i);
s->paddr = dol->data_paddr[i];
s->vaddr = dol->data_vaddr[i];
s->size = dol->data_size[i];
s->vsize = s->size;
s->srwx = r_str_rwx ("mr--");
s->add = true;
r_list_append (ret, s);
}
/* bss section */
s = R_NEW0 (RBinSection);
strcpy (s->name, "bss");
s->paddr = 0;
s->vaddr = dol->bss_addr;
s->size = dol->bss_size;
s->vsize = s->size;
s->srwx = r_str_rwx ("-rw-");
s->add = true;
r_list_append (ret, s);
return ret;
}
static RList * sections(RBinFile *arch) {
RList *ret = NULL;
RBinSection *ptr = NULL;
const struct r_bin_mz_segment_t *segments = NULL;
int i;
if (!(ret = r_list_new ()))
return NULL;
ret->free = free;
if (!(segments = r_bin_mz_get_segments (arch->o->bin_obj))){
r_list_free (ret);
return NULL;
}
for (i = 0; !segments[i].last; i++) {
if (!(ptr = R_NEW0 (RBinSection))) {
free ((void *)segments);
r_list_free (ret);
return NULL;
}
sprintf ((char*)ptr->name, "seg_%03d", i);
ptr->size = segments[i].size;
ptr->vsize = segments[i].size;
ptr->paddr = segments[i].paddr;
ptr->vaddr = segments[i].paddr;
ptr->srwx = r_str_rwx ("mrwx");
r_list_append (ret, ptr);
}
free ((void *)segments);
return ret;
}
static RList* sections(RBinFile *arch){
ut8 bank;
int i;
RList *ret;
if (!arch)
return NULL;
ret = r_list_new();
if (!ret )
return NULL;
r_buf_read_at (arch->buf, 0x148, &bank, 1);
bank = gb_get_rombanks(bank);
RBinSection *rombank[bank];
if (!arch->buf) {
free (ret);
return NULL;
}
ret->free = free;
rombank[0] = R_NEW0 (RBinSection);
strncpy (rombank[0]->name, "rombank00", R_BIN_SIZEOF_STRINGS);
rombank[0]->paddr = 0;
rombank[0]->size = 0x4000;
rombank[0]->vsize = 0x4000;
rombank[0]->vaddr = 0;
rombank[0]->srwx = r_str_rwx ("mrx");
rombank[0]->add = true;
r_list_append (ret, rombank[0]);
for (i = 1; i < bank; i++) {
rombank[i] = R_NEW0 (RBinSection);
sprintf (rombank[i]->name,"rombank%02x",i);
rombank[i]->paddr = i*0x4000;
rombank[i]->vaddr = i*0x10000-0xc000; //spaaaaaaaaaaaaaaaace!!!
rombank[i]->size = rombank[i]->vsize = 0x4000;
rombank[i]->srwx = r_str_rwx ("mrx");
rombank[i]->add = true;
r_list_append (ret,rombank[i]);
}
return ret;
}
static char *__system(RIO *io, RIODesc *fd, const char *cmd) {
if (!io || !fd || !cmd || !fd->data) {
return NULL;
}
RIODescData *iodd = fd->data;
if (iodd->magic != R_MACH_MAGIC) {
return NULL;
}
task_t task = pid_to_task (fd, iodd->tid);
/* XXX ugly hack for testing purposes */
if (!strncmp (cmd, "perm", 4)) {
int perm = r_str_rwx (cmd + 4);
if (perm) {
int pagesize = tsk_pagesize (fd);
tsk_setperm (io, task, io->off, pagesize, perm);
} else {
eprintf ("Usage: =!perm [rwx]\n");
}
return NULL;
}
if (!strncmp (cmd, "pid", 3)) {
RIODescData *iodd = fd->data;
RIOMach *riom = iodd->data;
const char *pidstr = cmd + 3;
int pid = -1;
if (*pidstr) {
pid = __get_pid (fd);
//return NULL;
} else {
eprintf ("%d\n", iodd->pid);
return NULL;
}
if (!strcmp (pidstr, "0")) {
pid = 0;
} else {
pid = atoi (pidstr);
if (!pid) {
pid = -1;
}
}
if (pid != -1) {
task_t task = pid_to_task (fd, pid);
if (task != -1) {
riom->task = task;
iodd->pid = pid;
iodd->tid = pid;
return NULL;
}
}
eprintf ("io_mach_system: Invalid pid %d\n", pid);
} else {
eprintf ("Try: '=!pid' or '=!perm'\n");
}
return NULL;
}
static RList *sections(RBinFile *bf) {
RList *ret = NULL;
RBinSection *sections[4] = {
NULL, NULL, NULL, NULL
};
int i, corrupt = false;
if (!(ret = r_list_new ())) {
return NULL;
}
/* FIRM has always 4 sections, normally the 4th section is not used */
for (i = 0; i < 4; i++) {
/* Check if section is used */
if (loaded_header.sections[i].size) {
sections[i] = R_NEW0 (RBinSection);
/* Firmware Type ('0'=ARM9/'1'=ARM11) */
if (loaded_header.sections[i].type == 0x0) {
strncpy (sections[i]->name, "arm9", 4);
} else if (loaded_header.sections[i].type == 0x1) {
strncpy (sections[i]->name, "arm11", 5);
} else {
corrupt = true;
break;
}
sections[i]->size = loaded_header.sections[i].size;
sections[i]->vsize = loaded_header.sections[i].size;
sections[i]->paddr = loaded_header.sections[i].offset;
sections[i]->vaddr = loaded_header.sections[i].address;
sections[i]->srwx = r_str_rwx ("mrwx");
sections[i]->add = true;
}
}
/* Append sections or free them if file is corrupt to avoid memory leaks */
for (i = 0; i < 4; i++) {
if (sections[i]) {
if (corrupt) {
free (sections[i]);
} else {
r_list_append (ret, sections[i]);
}
}
}
if (corrupt) {
r_list_free (ret);
return NULL;
}
return ret;
}
static int __system(RIO *io, RIODesc *fd, const char *cmd) {
RIOMach *riom;
if (!io || !fd || cmd || !fd->data) {
return 0;
}
riom = (RIOMach*)fd->data;
/* XXX ugly hack for testing purposes */
if (!strncmp (cmd, "perm", 4)) {
int perm = r_str_rwx (cmd + 4);
if (perm) {
int pagesize = tsk_pagesize(riom);
tsk_setperm (io, riom->task, io->off, pagesize, perm);
} else {
eprintf ("Usage: =!perm [rwx]\n");
}
return 0;
}
if (!strncmp (cmd, "pid", 3)) {
const char *pidstr = cmd + 3;
int pid = -1;
if (*pidstr) {
int pid = RIOMACH_PID (fd->data);
eprintf ("%d\n", pid);
return 0;
}
if (!strcmp (pidstr, "0")) {
pid = 0;
} else {
pid = atoi (pidstr);
if (!pid) pid = -1;
}
if (pid != -1) {
task_t task = pid_to_task (pid);
if (task != -1) {
eprintf ("PID=%d\n", pid);
riom->pid = pid;
riom->task = task;
return 0;
}
}
eprintf ("io_mach_system: Invalid pid %d\n", pid);
} else {
eprintf ("Try: '=!pid' or '=!perm'\n");
}
return 1;
}
static RList *__io_maps(RDebug *dbg) {
RList *list = r_list_new ();
dbg->iob.system (dbg->iob.io, "dm");
char *ostr, *str = strdup (r_cons_get_buffer ());
ut64 map_start, map_end;
char perm[32];
char name[512];
ostr = str;
while (true) {
char *nl = strchr (str, '\n');
if (nl) {
*nl = 0;
*name = 0;
*perm = 0;
map_start = map_end = 0LL;
if (!strncmp (str, "sys ", 4)) {
char *sp = strchr (str + 4, ' ');
if (sp) {
str = sp + 1;
} else {
str += 4;
}
}
char *_s_ = strstr (str, " s ");
if (_s_) {
memmove (_s_, _s_ + 2, strlen (_s_));
}
_s_ = strstr (str, " ? ");
if (_s_) {
memmove (_s_, _s_ + 2, strlen (_s_));
}
sscanf (str, "0x%"PFMT64x" - 0x%"PFMT64x" %s %s",
&map_start, &map_end, perm, name);
if (map_end != 0LL) {
RDebugMap *map = r_debug_map_new (name, map_start, map_end, r_str_rwx (perm), 0);
r_list_append (list, map);
}
str = nl + 1;
} else {
break;
}
}
free (ostr);
r_cons_reset();
return list;
}
bool test_r_str_rwx(void) {
int rwx = r_str_rwx ("-rwx");
int rw = r_str_rwx ("-rw-");
int rx = r_str_rwx ("rx");
int mx = r_str_rwx ("m--x");
int none = r_str_rwx ("----");
int number = r_str_rwx ("9999");
int rx_number = r_str_rwx ("5");
int rwx_number = r_str_rwx ("7");
mu_assert_eq (rwx, 7, "rwx");
mu_assert_eq (rw, 6, "rw");
mu_assert_eq (rx, 5, "rx");
mu_assert_eq (mx, 17, "mx");
mu_assert_eq (none, 0, "no permissions");
mu_assert_eq (number, 0, "large input number string");
mu_assert_eq (rx_number, 5, "rx number");
mu_assert_eq (rwx_number, 7, "rwx number");
mu_end;
}
bool test_r_str_rwx(void) {
int rwx = r_str_rwx ("-rwx");
int rw = r_str_rwx ("-rw-");
int rx = r_str_rwx ("rx");
int mx = r_str_rwx ("m--x");
int none = r_str_rwx ("----");
int number = r_str_rwx ("9999");
mu_assert_eq (rwx, 7, "rwx");
mu_assert_eq (rw, 6, "rw");
mu_assert_eq (rx, 5, "rx");
mu_assert_eq (mx, 17, "mx");
mu_assert_eq (none, 0, "no permissions");
//XXX this test fails because the underlying behavior is wrong
mu_test_status = MU_TEST_BROKEN; // Only for this next assert.
mu_assert_eq (number, 0, "large input number string");
mu_end;
}
static RList *mem (RBinFile *bf) {
RList *ret;
RBinMem *m;
RBinMem *m_bak;
if (!(ret = r_list_new())) {
return NULL;
}
ret->free = free;
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
m->name = strdup ("LOWRAM");
m->addr = LOWRAM_START_ADDRESS;
m->size = LOWRAM_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem))) {
return ret;
}
m->mirrors = r_list_new ();
m->name = strdup ("LOWRAM_MIRROR");
m->addr = LOWRAM_MIRROR_START_ADDRESS;
m->size = LOWRAM_MIRROR_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (m->mirrors, m);
m_bak = m;
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (m_bak->mirrors);
return ret;
}
m->name = strdup ("HIRAM");
m->addr = HIRAM_START_ADDRESS;
m->size = HIRAM_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem))) {
return ret;
}
m->name = strdup ("EXTRAM");
m->addr = EXTRAM_START_ADDRESS;
m->size = EXTRAM_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem))) {
return ret;
}
m->name = strdup ("PPU1_REG");
m->addr = PPU1_REG_ADDRESS;
m->size = PPU1_REG_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
m->name = strdup ("DSP_REG");
m->addr = DSP_REG_ADDRESS;
m->size = DSP_REG_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
m->name = strdup ("OLDJOY_REG");
m->addr = OLDJOY_REG_ADDRESS;
m->size = OLDJOY_REG_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
m->name = strdup ("PPU2_REG");
m->addr = PPU2_REG_ADDRESS;
m->size = PPU2_REG_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
return ret;
}
RList *mem (RBinFile *bf) {
RList *ret;
RBinMem *m, *n;
if (!(ret = r_list_new()))
return NULL;
ret->free = free;
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
m->name = strdup ("fastram");
m->addr = 0xff80LL;
m->size = 0x80;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem)))
return ret;
m->name = strdup ("ioports");
m->addr = 0xff00LL;
m->size = 0x4c;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem)))
return ret;
m->name = strdup ("oam");
m->addr = 0xfe00LL;
m->size = 0xa0;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem)))
return ret;
m->name = strdup ("videoram");
m->addr = 0x8000LL;
m->size = 0x2000;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem)))
return ret;
m->name = strdup ("iram");
m->addr = 0xc000LL;
m->size = 0x2000;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m->mirrors = r_list_new()))
return ret;
if (!(n = R_NEW0 (RBinMem))) {
r_list_free (m->mirrors);
m->mirrors = NULL;
return ret;
}
n->name = strdup ("iram_echo");
n->addr = 0xe000LL;
n->size = 0x1e00;
n->perms = r_str_rwx ("rx");
r_list_append (m->mirrors, n);
return ret;
}
static RList *mem (RBinFile *arch) {
RList *ret;
RBinMem *m, *n;
if (!(ret = r_list_new()))
return NULL;
ret->free = free;
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
strncpy (m->name, "RAM", R_BIN_SIZEOF_STRINGS);
m->addr = RAM_START_ADDRESS;
m->size = RAM_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(n = R_NEW0 (RBinMem))) {
r_list_free (m->mirrors);
m->mirrors = NULL;
return ret;
}
strncpy (n->name, "RAM_MIRROR_2", R_BIN_SIZEOF_STRINGS);
n->addr = RAM_MIRROR_2_ADDRESS;
n->size = RAM_MIRROR_2_SIZE;
n->perms = r_str_rwx ("rwx");
r_list_append (m->mirrors, n);
if (!(n = R_NEW0 (RBinMem))) {
r_list_free (m->mirrors);
m->mirrors = NULL;
return ret;
}
strncpy (n->name, "RAM_MIRROR_3", R_BIN_SIZEOF_STRINGS);
n->addr = RAM_MIRROR_3_ADDRESS;
n->size = RAM_MIRROR_3_SIZE;
n->perms = r_str_rwx ("rwx");
r_list_append (m->mirrors, n);
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
strncpy (m->name, "PPU_REG", R_BIN_SIZEOF_STRINGS);
m->addr = PPU_REG_ADDRESS;
m->size = PPU_REG_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
int i;
for (i = 1; i < 1024; i++) {
if (!(n = R_NEW0 (RBinMem))) {
r_list_free (m->mirrors);
m->mirrors = NULL;
return ret;
}
strncpy (m->name, "PPU_REG_MIRROR_", R_BIN_SIZEOF_STRINGS);
sprintf(m->name, "%d",i);
m->addr = PPU_REG_ADDRESS+i*PPU_REG_SIZE;
m->size = PPU_REG_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (m->mirrors, n);
}
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
strncpy (m->name, "APU_AND_IOREGS", R_BIN_SIZEOF_STRINGS);
m->addr = APU_AND_IOREGS_START_ADDRESS;
m->size = APU_AND_IOREGS_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
strncpy (m->name, "SRAM", R_BIN_SIZEOF_STRINGS);
m->addr = SRAM_START_ADDRESS;
m->size = SRAM_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
return ret;
}
static RList *mem (RBinFile *arch) {
RList *ret;
RBinMem *m, *n;
if (!(ret = r_list_new()))
return NULL;
ret->free = free;
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
m->name = strdup ("RAM");
m->addr = RAM_START_ADDRESS;
m->size = RAM_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(n = R_NEW0 (RBinMem))) {
r_list_free (m->mirrors);
m->mirrors = NULL;
return ret;
}
n->name = strdup ("RAM_MIRROR_2");
n->addr = RAM_MIRROR_2_ADDRESS;
n->size = RAM_MIRROR_2_SIZE;
n->perms = r_str_rwx ("rwx");
r_list_append (m->mirrors, n);
if (!(n = R_NEW0 (RBinMem))) {
r_list_free (m->mirrors);
m->mirrors = NULL;
return ret;
}
n->name = strdup ("RAM_MIRROR_3");
n->addr = RAM_MIRROR_3_ADDRESS;
n->size = RAM_MIRROR_3_SIZE;
n->perms = r_str_rwx ("rwx");
r_list_append (m->mirrors, n);
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
m->name = strdup ("PPU_REG");
m->addr = PPU_REG_ADDRESS;
m->size = PPU_REG_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
int i;
for (i = 1; i < 1024; i++) {
if (!(n = R_NEW0 (RBinMem))) {
r_list_free (m->mirrors);
m->mirrors = NULL;
return ret;
}
m->name = r_str_newf ("PPU_REG_MIRROR_%d", i);
m->addr = PPU_REG_ADDRESS+i*PPU_REG_SIZE;
m->size = PPU_REG_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (m->mirrors, n);
}
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
m->name = strdup ("APU_AND_IOREGS");
m->addr = APU_AND_IOREGS_START_ADDRESS;
m->size = APU_AND_IOREGS_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
m->name = strdup ("SRAM");
m->addr = SRAM_START_ADDRESS;
m->size = SRAM_SIZE;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
return ret;
}
RList *mem (RBinFile *arch) {
RList *ret;
RBinMem *m, *n;
if (!(ret = r_list_new()))
return NULL;
ret->free = free;
if (!(m = R_NEW0 (RBinMem))) {
r_list_free (ret);
return NULL;
}
strncpy (m->name, "fastram", R_BIN_SIZEOF_STRINGS);
m->addr = 0xff80LL;
m->size = 0x80;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem)))
return ret;
strncpy (m->name, "ioports", R_BIN_SIZEOF_STRINGS);
m->addr = 0xff00LL;
m->size = 0x4c;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem)))
return ret;
strncpy (m->name, "oam", R_BIN_SIZEOF_STRINGS);
m->addr = 0xfe00LL;
m->size = 0xa0;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem)))
return ret;
strncpy (m->name, "videoram", R_BIN_SIZEOF_STRINGS);
m->addr = 0x8000LL;
m->size = 0x2000;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m = R_NEW0 (RBinMem)))
return ret;
strncpy (m->name, "iram", R_BIN_SIZEOF_STRINGS);
m->addr = 0xc000LL;
m->size = 0x2000;
m->perms = r_str_rwx ("rwx");
r_list_append (ret, m);
if (!(m->mirrors = r_list_new()))
return ret;
if (!(n = R_NEW0 (RBinMem))) {
r_list_free (m->mirrors);
m->mirrors = NULL;
return ret;
}
strncpy (n->name, "iram_echo", R_BIN_SIZEOF_STRINGS);
n->addr = 0xe000LL;
n->size = 0x1e00;
n->perms = r_str_rwx ("rx");
r_list_append (m->mirrors, n);
return ret;
}
