static int disassemble(RAsm *a, RAsmOp *op, const ut8 *buf, int len) {
static char *oldcpu = NULL;
static int oldcpucode = 0;
int opsize, cpucode = 0;
struct disassemble_info obj;
char *options = (a->bits==16)? "force-thumb": "no-force-thumb";
if (len<2) return -1;
memset (bytes, 0, sizeof (bytes));
memcpy (bytes, buf, R_MIN (len, 4));
if (a->bits<64 && len<(a->bits/8)) return -1;
buf_global = op->buf_asm;
Offset = a->pc;
/* prepare disassembler */
memset (&obj,'\0', sizeof (struct disassemble_info));
arm_mode = a->bits;
cpucode = oldcpucode;
/* select cpu */
if (a->cpu) {
if (oldcpu != a->cpu) {
cpucode = atoi (a->cpu);
if (!strcmp ("v5j", a->cpu))
cpucode = 9;
}
}
obj.arch = 0;
obj.mach = cpucode;
oldcpucode = cpucode;
obj.buffer = bytes;
obj.read_memory_func = &arm_buffer_read_memory;
obj.symbol_at_address_func = &symbol_at_address;
obj.memory_error_func = &memory_error_func;
obj.print_address_func = &print_address;
obj.endian = !a->big_endian;
obj.fprintf_func = &buf_fprintf;
obj.stream = stdout;
obj.bytes_per_chunk =
obj.bytes_per_line = (a->bits/8);
op->buf_asm[0]='\0';
if (a->bits==64) {
obj.disassembler_options = NULL;
memcpy (bytes, buf, 4);
op->size = print_insn_aarch64 ((bfd_vma)Offset, &obj);
} else {
obj.disassembler_options = options;
op->size = (obj.endian == BFD_ENDIAN_LITTLE)?
print_insn_little_arm ((bfd_vma)Offset, &obj):
print_insn_big_arm ((bfd_vma)Offset, &obj);
}
opsize = op->size;
if (op->size == -1) {
strncpy (op->buf_asm, " (data)", R_ASM_BUFSIZE);
op->size = 4;
}
return opsize;
}
// disassemble one instruction at laddr relative to memory, but at most memory+byteSize
int
disassembleForAtInSize(void *cpu, ulong laddr,
void *memory, ulong byteSize)
{
gdblog_index = 0;
// ignore the cpu
disassemble_info* dis = (disassemble_info*) calloc(1, sizeof(disassemble_info));
init_disassemble_info ( dis, NULL, gdb_log_printf);
dis->arch = bfd_arch_arm;
dis->mach = bfd_mach_arm_unknown;
// sets some fields in the structure dis to architecture specific values
disassemble_init_for_target( dis );
dis->buffer_vma = 0;
dis->buffer = memory;
dis->buffer_length = byteSize;
//prepend the address
gdb_log_printf(NULL, "0x%p: ", laddr);
//other possible functions are listed in opcodes/dissassemble.c
unsigned int size = print_insn_little_arm((bfd_vma) laddr, dis);
free(dis);
// zero terminate the string
gdb_log[gdblog_index+1] = 0;
return size;
}
void
print_insn (ARMword instr)
{
int size;
opbuf[0] = 0;
info.application_data = & instr;
size = print_insn_little_arm (0, & info);
fprintf (stderr, " %*s\n", size, opbuf);
}
int cm3_print_insn(cm3ice_ctrl_t * ctrl, uint32_t addr,
struct disassemble_info * info)
{
info->endian_code = BFD_ENDIAN_LITTLE;
info->mach = bfd_mach_arm_unknown;
info->flags = USER_SPECIFIED_MACHINE_TYPE;
info->disassembler_options = "force-thumb";
info->read_memory_func = core_read_memory;
info->application_data = ctrl;
return print_insn_little_arm(addr, info);
};
int
main ()
{
unsigned int data[3] = {0xE3A01080,
0xE2810001,
0xE1A01001};
bfd_byte* buf = (bfd_byte*) &data[0];
disassemble_info* c = (struct disassemble_info*) calloc(1, sizeof(disassemble_info));
// void init_disassemble_info (struct disassemble_info *dinfo, void *stream, fprintf_ftype fprintf_func)
init_disassemble_info ( c, stdout, my_fprintf);
//c->application_data
//c->memory_error_func
// set architecture
c->arch = bfd_arch_arm;
// set the specific machine: unknown allows all instructions in the libraries database
c->mach = bfd_mach_arm_unknown;
// should set the disassembler field of c to the right function
disassemble_init_for_target( c );
// given a bfd, the disassembler can find the arch by itself.
//disassemble = disassembler( c );
c->buffer_vma = 0;
c->buffer = buf;
c->buffer_length = 12;
// while-loop for calling single instruction decoding:
unsigned int count = 0;
size_t pos = 0;
size_t length = c->buffer_length;
size_t max_pos = c->buffer_vma+length;
while(pos < max_pos)
{
//disassembler-function: print_insn_big_arm
//other possible functions are listed in opcodes/dissassemble.c
unsigned int size = print_insn_little_arm((bfd_vma) pos, c);
pos += size;
count++;
fprintf(stdout, "\n");
}
return 0;
}
static int disassemble(struct r_asm_t *a, struct r_asm_op_t *op, const ut8 *buf, ut64 len) {
static struct disassemble_info disasm_obj;
/* fetching is 4 byte aligned */
if (len<4) return -1;
buf_global = op->buf_asm;
Offset = a->pc;
memcpy (bytes, buf, 4); // TODO handle thumb
/* prepare disassembler */
memset (&disasm_obj,'\0', sizeof(struct disassemble_info));
arm_mode = a->bits;
//disasm_obj.arch = ARM_EXT_V1|ARM_EXT_V4T|ARM_EXT_V5;
/* TODO: set arch */
disasm_obj.arch =0xffffffff;
disasm_obj.mach =0xffffffff;
disasm_obj.buffer = bytes;
disasm_obj.read_memory_func = &arm_buffer_read_memory;
disasm_obj.symbol_at_address_func = &symbol_at_address;
disasm_obj.memory_error_func = &memory_error_func;
disasm_obj.print_address_func = &print_address;
disasm_obj.endian = !a->big_endian;
disasm_obj.fprintf_func = &buf_fprintf;
disasm_obj.stream = stdout;
disasm_obj.bytes_per_chunk =
disasm_obj.bytes_per_line = (a->bits/8);
op->buf_asm[0]='\0';
if (disasm_obj.endian)
op->inst_len = print_insn_little_arm (
(bfd_vma)Offset, &disasm_obj);
else
op->inst_len = print_insn_big_arm (
(bfd_vma)Offset, &disasm_obj);
if (op->inst_len == -1)
strncpy (op->buf_asm, " (data)", R_ASM_BUFSIZE);
return op->inst_len; //(a->bits/8); //op->inst_len;
}
