static cs_err init(cs_struct *ud)
{
MCRegisterInfo *mri;
// verify if requested mode is valid
if (ud->mode & ~(CS_MODE_LITTLE_ENDIAN | CS_MODE_32 | CS_MODE_64 |
CS_MODE_MICRO | CS_MODE_N64 | CS_MODE_BIG_ENDIAN))
return CS_ERR_MODE;
mri = cs_mem_malloc(sizeof(*mri));
Mips_init(mri);
ud->printer = Mips_printInst;
ud->printer_info = mri;
ud->getinsn_info = mri;
ud->reg_name = Mips_reg_name;
ud->insn_id = Mips_get_insn_id;
ud->insn_name = Mips_insn_name;
if (ud->mode & CS_MODE_32)
ud->disasm = Mips_getInstruction;
else
ud->disasm = Mips64_getInstruction;
return CS_ERR_OK;
}
static cs_err init(cs_struct *ud)
{
MCRegisterInfo *mri;
// verify if requested mode is valid
if (ud->mode & ~(CS_MODE_LITTLE_ENDIAN | CS_MODE_ARM | CS_MODE_V8 |
CS_MODE_MCLASS | CS_MODE_THUMB | CS_MODE_BIG_ENDIAN))
return CS_ERR_MODE;
mri = cs_mem_malloc(sizeof(*mri));
ARM_init(mri);
ARM_getRegName(ud, 0); // use default get_regname
ud->printer = ARM_printInst;
ud->printer_info = mri;
ud->reg_name = ARM_reg_name;
ud->insn_id = ARM_get_insn_id;
ud->insn_name = ARM_insn_name;
ud->group_name = ARM_group_name;
ud->post_printer = ARM_post_printer;
if (ud->mode & CS_MODE_THUMB)
ud->disasm = Thumb_getInstruction;
else
ud->disasm = ARM_getInstruction;
return CS_ERR_OK;
}
void cs_sys_log(const cs_int8 *String, ...)
{
va_list ptr;
cs_int8 msg_buffer [4*CS_LOG_SIZE];
cs_log_t *log;
cs_int32 len=0;
log = (cs_log_t *)cs_mem_malloc(sys_log_ctrl.mempool_id);
if(log == NULL)
return;
memset(log , 0 , sizeof(cs_log_t));
log->time = 0;
log->log_type = CS_SYS_LOG_TYPE;
memset(msg_buffer , 0 , sizeof(msg_buffer));
va_start(ptr,String);
vsprintf(msg_buffer , String, ptr);
va_end(ptr);
len = (strlen(msg_buffer) >= CS_LOG_SIZE)?CS_LOG_SIZE-1:strlen(msg_buffer);
memcpy(log->a.log_buf , msg_buffer , len);
if(CS_E_OSAL_OK != cs_queue_put(sys_log_ctrl.log_queue_id, (void *)&log, sizeof(cs_uint32) , CS_OSAL_NO_WAIT , 0))
{
cs_mem_free((cs_uint8 *)log);
return;
}
return;
}
static cs_err init(cs_struct *ud)
{
MCRegisterInfo *mri;
// verify if requested mode is valid
if (ud->mode & ~(CS_MODE_LITTLE_ENDIAN | CS_MODE_32 | CS_MODE_64 | CS_MODE_16))
return CS_ERR_MODE;
mri = cs_mem_malloc(sizeof(*mri));
X86_init(mri);
// by default, we use Intel syntax
ud->printer = X86_Intel_printInst;
ud->syntax = CS_OPT_SYNTAX_INTEL;
ud->printer_info = mri;
ud->disasm = X86_getInstruction;
ud->reg_name = X86_reg_name;
ud->insn_id = X86_get_insn_id;
ud->insn_name = X86_insn_name;
ud->group_name = X86_group_name;
ud->post_printer = NULL;;
#ifndef CAPSTONE_DIET
ud->reg_access = X86_reg_access;
#endif
if (ud->mode == CS_MODE_64)
ud->regsize_map = regsize_map_64;
else
ud->regsize_map = regsize_map_32;
return CS_ERR_OK;
}
static cs_err init(cs_struct *ud)
{
MCRegisterInfo *mri;
// verify if requested mode is valid
if (ud->mode & ~(CS_MODE_LITTLE_ENDIAN | CS_MODE_32 | CS_MODE_64 |
CS_MODE_BIG_ENDIAN | CS_MODE_QPX))
return CS_ERR_MODE;
mri = (MCRegisterInfo *) cs_mem_malloc(sizeof(*mri));
PPC_init(mri);
ud->printer = PPC_printInst;
ud->printer_info = mri;
ud->getinsn_info = mri;
ud->disasm = PPC_getInstruction;
ud->post_printer = PPC_post_printer;
ud->reg_name = PPC_reg_name;
ud->insn_id = PPC_get_insn_id;
ud->insn_name = PPC_insn_name;
ud->group_name = PPC_group_name;
return CS_ERR_OK;
}
void cs_buffer_dump(cs_int8 *comment , cs_int8 *buf , cs_int32 len)
{
#ifdef HAVE_LOG_THREAD
cs_log_t *log;
cs_int32 comment_len=0;
cs_int32 buf_len = 0;
log = (cs_log_t *)cs_mem_malloc(sys_log_ctrl.mempool_id);
if(log == NULL)
return;
memset(log , 0 , sizeof(cs_log_t));
log->log_level = -1;
log->module_id = -1;
log->time = cs_current_time();
log->log_type = CS_LOG_HEX_TYPE;
comment_len = (strlen(comment) >= CS_LOG_COMMENT_LEN)?CS_LOG_COMMENT_LEN-1:strlen(comment);
buf_len = (len >= CS_LOG_SIZE-CS_LOG_COMMENT_LEN-4)?CS_LOG_SIZE-CS_LOG_COMMENT_LEN-4-1:len;
log->a.b.len = buf_len;
memcpy(log->a.b.comment , comment , comment_len);
memcpy(log->a.b.buf , buf , buf_len);
if(CS_E_OSAL_OK != cs_queue_put(sys_log_ctrl.log_queue_id, (void *)&log, sizeof(cs_uint32) , CS_OSAL_NO_WAIT , 0))
{
cs_mem_free((cs_uint8 *)log);
return;
}
#else
int i;
cs_printf("\n\n#%s ",comment);
for(i = 0 ; i < len ; i++)
{
if(i%16 == 0)
{
cs_printf("\n");
cs_printf("%06x ", i);
}
cs_printf("%02x ",buf[i]);
}
#endif
return;
}
static cs_err init(cs_struct *ud)
{
MCRegisterInfo *mri;
mri = cs_mem_malloc(sizeof(*mri));
XCore_init(mri);
ud->printer = XCore_printInst;
ud->printer_info = mri;
ud->getinsn_info = mri;
ud->disasm = XCore_getInstruction;
ud->post_printer = XCore_post_printer;
ud->reg_name = XCore_reg_name;
ud->insn_id = XCore_get_insn_id;
ud->insn_name = XCore_insn_name;
return CS_ERR_OK;
}
cs_err AArch64_global_init(cs_struct *ud)
{
MCRegisterInfo *mri;
mri = cs_mem_malloc(sizeof(*mri));
AArch64_init(mri);
ud->printer = AArch64_printInst;
ud->printer_info = mri;
ud->getinsn_info = mri;
ud->disasm = AArch64_getInstruction;
ud->reg_name = AArch64_reg_name;
ud->insn_id = AArch64_get_insn_id;
ud->insn_name = AArch64_insn_name;
ud->group_name = AArch64_group_name;
ud->post_printer = AArch64_post_printer;
#ifndef CAPSTONE_DIET
ud->reg_access = AArch64_reg_access;
#endif
return CS_ERR_OK;
}
void cs_sys_log(const cs_int8 *String, ...)
{
va_list ptr;
cs_int8 msg_buffer [2*CS_LOG_SIZE];
cs_log_t *log;
cs_int32 len=0;
cs_int32 hour=0,min=0,sec=0;
log = (cs_log_t *)cs_mem_malloc(sys_log_ctrl.mempool_id);
if(log == NULL)
return;
memset(log , 0 , sizeof(cs_log_t));
log->time = cs_current_time();
log->log_type = CS_SYS_LOG_TYPE;
memset(msg_buffer , 0 , sizeof(msg_buffer));
va_start(ptr,String);
vsprintf(msg_buffer , String, ptr);
va_end(ptr);
/*12 bytes for timestamp*/
len = (strlen(msg_buffer) >= CS_LOG_SIZE-12)?CS_LOG_SIZE-12-1:strlen(msg_buffer);
#if 1
hour = log->time/(100*3600);
min = (log->time/(100*60))%60;
sec = (log->time/100)%60;
memset(log->a.log_buf , 0 , CS_LOG_SIZE);
sprintf(log->a.log_buf,"[%dh%dm%ds] ",hour,min,sec);
#endif
memcpy(log->a.log_buf+strlen(log->a.log_buf) , msg_buffer , len);
if(CS_E_OSAL_OK != cs_queue_put(sys_log_ctrl.log_queue_id, (void *)&log, sizeof(cs_uint32) , CS_OSAL_NO_WAIT , 0))
{
cs_mem_free((cs_uint8 *)log);
return;
}
return;
}
static cs_err init(cs_struct *ud)
{
MCRegisterInfo *mri;
// verify if requested mode is valid
if (ud->mode & ~(CS_MODE_BIG_ENDIAN | CS_MODE_V9))
return CS_ERR_MODE;
mri = cs_mem_malloc(sizeof(*mri));
Sparc_init(mri);
ud->printer = Sparc_printInst;
ud->printer_info = mri;
ud->getinsn_info = mri;
ud->disasm = Sparc_getInstruction;
ud->post_printer = Sparc_post_printer;
ud->reg_name = Sparc_reg_name;
ud->insn_id = Sparc_get_insn_id;
ud->insn_name = Sparc_insn_name;
return CS_ERR_OK;
}
void cs_log_msg(cs_uint32 level , cs_uint32 module_id , const cs_int8 *String, ...)
{
va_list ptr;
cs_int8 msg_buffer [4*CS_LOG_SIZE];
#ifdef HAVE_LOG_THREAD
cs_log_t *log;
cs_int32 len=0;
cs_int32 time_str_len=0;
#endif
if(module_id >= CS_MAX_MODULE_NUMBER || level >= MAX_LOG_LEVEL)
return;
#ifdef HAVE_LOG_THREAD
if(level < sys_log_ctrl.mod_info[module_id].record_level &&
level < sys_log_ctrl.mod_info[module_id].print_level)
return;
log = (cs_log_t *)cs_mem_malloc(sys_log_ctrl.mempool_id);
if(log == NULL)
return;
memset(log , 0 , sizeof(cs_log_t));
log->log_level = level;
log->module_id = module_id;
log->time = cs_current_time();
log->log_type = CS_LOG_MSG_TYPE;
#endif
memset(msg_buffer , 0 , sizeof(msg_buffer));
va_start(ptr,String);
vsprintf(msg_buffer , String, ptr);
va_end(ptr);
#ifdef HAVE_LOG_THREAD
if(log->log_level == IROS_LOG_LEVEL_CRI)
{
cs_int32 hour,min,sec;
hour = log->time/(100*3600);
min = (log->time/(100*60))%60;
sec = (log->time/100)%60;
sprintf(log->a.log_buf,"[%dh%dm%ds] ",hour,min,sec);
}
time_str_len = strlen(log->a.log_buf);
#if 1
len = (strlen(msg_buffer) >= CS_LOG_SIZE-time_str_len)?CS_LOG_SIZE-time_str_len-1:strlen(msg_buffer);
#else
len = (strlen(msg_buffer) >= MAX_SYS_LOG_LEN-time_str_len)?MAX_SYS_LOG_LEN-time_str_len-1:strlen(msg_buffer);
#endif
memcpy(log->a.log_buf+time_str_len , msg_buffer , len);
if(CS_E_OSAL_OK != cs_queue_put(sys_log_ctrl.log_queue_id, (void *)&log, sizeof(cs_uint32) , CS_OSAL_NO_WAIT , 0))
{
cs_mem_free((cs_uint8 *)log);
return;
}
#else
if(level >= sys_log_ctrl.mod_info[module_id].print_level)
cs_printf("\r\n[%lld:%s:%d] %s",cs_current_time(),cs_sys_mod_desc_get(module_id),level, msg_buffer);
#endif
return;
}
