asm_arc.c File Reference

#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <rz_types.h>
#include <rz_lib.h>
#include <rz_util.h>
#include <rz_asm.h>
#include "disas-asm.h"
#include <mybfd.h>

Go to the source code of this file.

Functions
int	decodeInstr (bfd_vma address, disassemble_info *info)
int	ARCTangent_decodeInstr (bfd_vma address, disassemble_info *info)
int	ARCompact_decodeInstr (bfd_vma address, disassemble_info *info)
static int	arc_buffer_read_memory (bfd_vma memaddr, bfd_byte *myaddr, unsigned int length, struct disassemble_info *info)
static int	symbol_at_address (bfd_vma addr, struct disassemble_info *info)
static void	memory_error_func (int status, bfd_vma memaddr, struct disassemble_info *info)
static int	disassemble (RzAsm *a, RzAsmOp *op, const ut8 *buf, int len)

Variables
static ut32	Offset = 0
static RzStrBuf *	buf_global = NULL
static int	buf_len = 0
static ut8	bytes [32] = { 0 }
RzAsmPlugin	rz_asm_plugin_arc
RZ_API RzLibStruct	rizin_plugin

Function Documentation

arc_buffer_read_memory()

static int arc_buffer_read_memory ( bfd_vma  memaddr, bfd_byte *  myaddr, unsigned int  length, struct disassemble_info *  info  )

static

Definition at line 25 of file asm_arc.c.

                                                                                                                         {
    int delta = (memaddr - Offset);
    if (delta < 0) {
        return -1; // disable backward reads
    }
    if ((delta + length) > sizeof(bytes)) {
        return -1;
    }
    memcpy(myaddr, bytes + delta, RZ_MIN(buf_len - delta, length));
    return 0;
}

References buf_len, bytes, delta, length, memcpy(), Offset, and RZ_MIN.

Referenced by disassemble().

ARCompact_decodeInstr()

int ARCompact_decodeInstr	(	bfd_vma	address,
		disassemble_info *	info
	)

Definition at line 3722 of file arcompact-dis.c.

                            {
    int status;
    bfd_byte buffer[4];
    struct arcDisState s; /* ARC Disassembler state */
    void *stream = info->stream; /* output stream */
    fprintf_ftype func = info->fprintf_func;
    int bytes;
    int lowbyte, highbyte;
    char buf[256];
 
    if (info->disassembler_options) {
        parse_disassembler_options(info->disassembler_options);
 
        /* To avoid repeated parsing of these options, we remove them here.  */
        info->disassembler_options = NULL;
    }
 
    lowbyte = ((info->endian == BFD_ENDIAN_LITTLE) ? 1 : 0);
    highbyte = ((info->endian == BFD_ENDIAN_LITTLE) ? 0 : 1);
 
    memset(&s, 0, sizeof(struct arcDisState));
 
    /* read first instruction */
    status = (*info->read_memory_func)(address, buffer, 2, info);
 
    if (status != 0) {
        (*info->memory_error_func)(status, address, info);
        return -1;
    }
 
    if (((buffer[lowbyte] & 0xf8) > 0x38) && ((buffer[lowbyte] & 0xf8) != 0x48)) {
        s.instructionLen = 2;
        s.words[0] = (buffer[lowbyte] << 8) | buffer[highbyte];
        (*info->read_memory_func)(address + 2, buffer, 4, info);
        if (info->endian == BFD_ENDIAN_LITTLE) {
            s.words[1] = bfd_getl32(buffer);
        } else {
            s.words[1] = bfd_getb32(buffer);
        }
    } else {
        s.instructionLen = 4;
        status = (*info->read_memory_func)(address + 2, &buffer[2], 2, info);
        if (status != 0) {
            (*info->memory_error_func)(status, address + 2, info);
            return -1;
        }
        if (info->endian == BFD_ENDIAN_LITTLE) {
            s.words[0] = bfd_getl32(buffer);
        } else {
            s.words[0] = bfd_getb32(buffer);
        }
 
        /* always read second word in case of limm */
        /* we ignore the result since last insn may not have a limm */
        (*info->read_memory_func)(address + 4, buffer, 4, info);
        if (info->endian == BFD_ENDIAN_LITTLE) {
            s.words[1] = bfd_getl32(buffer);
        } else {
            s.words[1] = bfd_getb32(buffer);
        }
    }
 
    s._this = &s;
    s.coreRegName = _coreRegName;
    s.auxRegName = _auxRegName;
    s.condCodeName = _condCodeName;
    s.instName = _instName;
 
    /* disassemble */
    bytes = dsmOneArcInst(address, (void *)&s, info);
 
    /* display the disassembled instruction */
    {
        char *instr = s.instrBuffer;
        char *operand = s.operandBuffer;
        char *space = strchr(instr, ' ');
 
        if (enable_insn_stream) {
            /* Show instruction stream from MSB to LSB*/
 
            if (s.instructionLen == 2) {
                (*func)(stream, "    %04x ", (unsigned int)s.words[0]);
            } else {
                (*func)(stream, "%08x ", (unsigned int)s.words[0]);
            }
 
            (*func)(stream, "    ");
        }
 
        /* if the operand is actually in the instruction buffer */
        if ((space != NULL) && (operand[0] == '\0')) {
            *space = '\0';
            operand = space + 1;
        }
 
        (*func)(stream, "%s ", instr);
 
        if (__TRANSLATION_REQUIRED(s)) {
            bfd_vma addr;
            char *tmpBuffer;
            int i = 1;
 
            if (operand[0] != '@') {
                /* Branch instruction with 3 operands, Translation is required
                   only for the third operand. Print the first 2 operands */
                strncpy(buf, operand, sizeof(buf));
                buf[sizeof(buf) - 1] = '\0';
                tmpBuffer = strtok(buf, "@");
                (*func)(stream, "%s", tmpBuffer);
                i = strlen(tmpBuffer) + 1;
            }
 
            addr = s.addresses[operand[i] - '0'];
            (*info->print_address_func)((bfd_vma)addr, info);
            //(*func) (stream, "\n");
        } else {
            (*func)(stream, "%s", operand);
        }
    }
 
    /* We print max bytes for instruction */
    info->bytes_per_line = 8;
 
    return bytes; // s.instructionLen;
}

Referenced by disassemble().

ARCTangent_decodeInstr()

int ARCTangent_decodeInstr	(	bfd_vma	address,
		disassemble_info *	info
	)

Definition at line 1025 of file arc-dis.c.

                                                                    {
    int status;
    bfd_byte buffer[4];
    struct arcDisState s; /* ARC Disassembler state.  */
    void *stream = info->stream; /* Output stream.  */
    fprintf_ftype func = info->fprintf_func;
 
    memset(&s, 0, sizeof(struct arcDisState));
 
    /* Read first instruction.  */
    status = (*info->read_memory_func)(address, buffer, 4, info);
    if (status != 0) {
        (*info->memory_error_func)(status, address, info);
        return -1;
    }
    if (info->endian == BFD_ENDIAN_LITTLE) {
        s.words[0] = bfd_getl32(buffer);
    } else {
        s.words[0] = bfd_getb32(buffer);
    }
    /* Always read second word in case of limm.  */
    /* We ignore the result since last insn may not have a limm.  */
    (*info->read_memory_func)(address + 4, buffer, 4, info);
    if (info->endian == BFD_ENDIAN_LITTLE) {
        s.words[1] = bfd_getl32(buffer);
    } else {
        s.words[1] = bfd_getb32(buffer);
    }
 
    s._this = &s;
    s.coreRegName = _coreRegName;
    s.auxRegName = _auxRegName;
    s.condCodeName = _condCodeName;
    s.instName = _instName;
 
    /* Disassemble.  */
    dsmOneArcInst(address, (void *)&s);
 
    /* Display the disassembly instruction.  */
    /*
      (*func) (stream, "%08lx ", s.words[0]);
      (*func) (stream, "  ");
    */
    (*func)(stream, "%s ", s.instrBuffer);
 
    if (__TRANSLATION_REQUIRED(s)) {
        bfd_vma addr = s.addresses[s.operandBuffer[1] - '0'];
 
        (*info->print_address_func)((bfd_vma)addr, info);
        //(*func) (stream, "\n");
    } else {
        (*func)(stream, "%s", s.operandBuffer);
    }
 
    return s.instructionLen;
}

References __TRANSLATION_REQUIRED, _auxRegName(), _condCodeName(), _coreRegName(), _instName(), addr, BFD_ENDIAN_LITTLE, bfd_getb32(), bfd_getl32(), dsmOneArcInst(), info(), memset(), s, and status.

Referenced by disassemble().

decodeInstr()

int decodeInstr	(	bfd_vma	address,
		disassemble_info *	info
	)

disassemble()

static int disassemble ( RzAsm *  a, RzAsmOp *  op, const ut8 *  buf, int  len  )

static

Definition at line 48 of file asm_arc.c.

                                                                       {
    static struct disassemble_info disasm_obj;
    if (len < 2) {
        return -1;
    }
    buf_global = &op->buf_asm;
    Offset = a->pc;
    if (len > sizeof(bytes)) {
        len = sizeof(bytes);
    }
    memcpy(bytes, buf, len); // TODO handle compact
    buf_len = len;
    /* prepare disassembler */
    memset(&disasm_obj, '\0', sizeof(struct disassemble_info));
    disasm_obj.buffer = bytes;
    disasm_obj.buffer_length = len;
    disasm_obj.read_memory_func = &arc_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 = &generic_print_address_func;
    disasm_obj.endian = !a->big_endian;
    disasm_obj.fprintf_func = &generic_fprintf_func;
    disasm_obj.stream = stdout;
    disasm_obj.mach = 0;
    rz_strbuf_set(&op->buf_asm, "");
    if (a->bits == 16) {
        op->size = ARCompact_decodeInstr((bfd_vma)Offset, &disasm_obj);
    } else {
        op->size = ARCTangent_decodeInstr((bfd_vma)Offset, &disasm_obj);
    }
    if (op->size == -1) {
        rz_strbuf_set(&op->buf_asm, "(data)");
    }
    return op->size;
}

References a, arc_buffer_read_memory(), ARCompact_decodeInstr(), ARCTangent_decodeInstr(), buf_global, buf_len, disassemble_info::buffer, disassemble_info::buffer_length, bytes, disassemble_info::endian, disassemble_info::fprintf_func, len, disassemble_info::mach, memcpy(), memory_error_func(), disassemble_info::memory_error_func, memset(), Offset, disassemble_info::print_address_func, disassemble_info::read_memory_func, rz_strbuf_set(), disassemble_info::stream, symbol_at_address(), and disassemble_info::symbol_at_address_func.

memory_error_func()

static void memory_error_func ( int  status, bfd_vma  memaddr, struct disassemble_info *  info  )

static

Definition at line 41 of file asm_arc.c.

                                                                                          {
    //--
}

Referenced by disassemble().

symbol_at_address()

static int symbol_at_address ( bfd_vma  addr, struct disassemble_info *  info  )

static

Definition at line 37 of file asm_arc.c.

                                                                          {
    return 0;
}

Referenced by disassemble().

Variable Documentation

buf_global

RzStrBuf* buf_global = NULL

static

Definition at line 21 of file asm_arc.c.

Referenced by disassemble().

buf_len

int buf_len = 0

static

Definition at line 22 of file asm_arc.c.

Referenced by _server_handle_g(), _server_handle_qC(), _server_handle_qfThreadInfo(), arc_buffer_read_memory(), disassemble(), gbAsm(), gdbr_open_file(), iob_read(), iob_write(), kd_data_checksum(), kd_send_data_packet(), slurp(), wasm_dis(), and winkd_send_state_manipulate_req().

bytes

ut8 bytes[32] = { 0 }

static

Definition at line 23 of file asm_arc.c.

Referenced by __reg_read(), _cb_hit(), _cs_disasm(), annotated_hexdump(), arc_buffer_read_memory(), arcAnalyzeInstr(), bfd_get_bits(), cabd_checksum(), cabd_extract(), cabd_sys_read(), cabd_sys_write(), cabx_alloc(), cabx_copy(), cabx_read(), cabx_write(), carve_kexts(), check_buffer(), chmd_extract(), chmd_sys_write(), core_cmd_pipe(), decode_abs162r16(), decode_abs2r_short(), decode_add(), decode_adds(), decode_andc(), decode_arith(), decode_break(), decode_bsr(), decode_call(), decode_cmp(), decode_cmpeq(), decode_cmpgte(), decode_cmpi(), decode_cmplte(), decode_cmpugte(), decode_cmpulte(), decode_daa(), decode_disp162r16(), decode_div(), decode_divu(), decode_eepmov(), decode_imm162r16(), decode_imm2abs8(), decode_imm2ind16(), decode_imm2r8(), decode_imm2r_short(), decode_ind162r16(), decode_indinc162r16(), decode_jmp(), decode_jmp8(), decode_jmp_abs16(), decode_jmp_abs8(), decode_jmp_ind(), decode_ldc(), decode_loadsp(), decode_mov(), decode_mov_args(), decode_movi(), decode_movin(), decode_movn(), decode_movrel(), decode_movsn(), decode_movsn_args(), decode_mul(), decode_mulu(), decode_neg(), decode_nop(), decode_not(), decode_opcode(), decode_opcode_4bit(), decode_pop(), decode_push_pop(), decode_r162r16(), decode_r2r8(), decode_r82abs16(), decode_r82dispr16(), decode_r82ind16(), decode_r82r16(), decode_r82rdec16(), decode_rzabs8(), decode_rzimm_short(), decode_rzind16(), decode_storesp(), decode_sub(), decode_subs(), deserialize_checkpoints_cb(), disassemble(), disassembly_as_table(), esil_peek_n(), esil_poke_n(), extract_arg(), extract_binobj(), flirt_pat_parse_pattern_mask(), fs__create_junction(), fs__read(), fs__readlink_handle(), fs__write(), FUZ_test(), test-lz4-list::generate_files(), go_is_sign_match(), go_offset(), go_uintptr(), interact_fix_asm(), iterate_rebase_list(), iterator_compare(), load_buffer(), lzxd_set_reference_data(), m_alloc(), m_copy(), m_read(), m_write(), main(), md5_finish_ctx(), mem_alloc(), mem_copy(), mem_read(), mem_write(), msp_alloc(), msp_copy(), msp_free(), msp_read(), msp_write(), noned_decompress(), print_hex_from_base2(), TestM680x::print_ins_detail(), process_kmod_init_term(), rasm_asm(), replace_asm_test(), rz_bin_file_set_bytes(), rz_bin_file_xtr_load_buffer(), rz_bp_add_sw(), rz_buf_new_with_bytes(), rz_buf_new_with_pointers(), rz_bv_set_to_bytes_be(), rz_bv_set_to_bytes_le(), rz_cmd_debug(), rz_cmd_disassemble_ropchain_handler(), rz_cmd_disassembly_function_handler(), rz_core_analysis_resolve_golang_strings(), rz_debug_qnx_reg_write(), rz_file_slurp_hexpairs(), rz_main_rz_gg(), rz_mem_copybits(), RZ_PACKED(), rz_print_hexdump_str(), rz_rebase_info_new_from_mach0(), rz_reg_set_value(), rz_search_pattern(), rz_str_is_utf8(), rz_test_load_asm_test_file(), rz_test_run_asm_test(), rz_type_format_data_internal(), rz_type_format_num(), rz_type_format_num_specifier(), rz_write_extend_hexbytes_handler(), showanalysis(), stack__subtree_is_equivalent(), tar(), test(), ts_parser__can_reuse_first_leaf(), ts_parser__lex(), ts_subtree_get_changed_ranges(), tuklib_mbstr_width(), uv__count_bufs(), uv__pipe_write_data(), uv__poll_wine(), uv__send(), uv__signal_event(), uv__tcp_try_write(), uv__udp_try_send(), uv_get_extension_function(), uv_pipe_writefile_thread_proc(), uv_pipe_zero_readfile_thread_proc(), uv_poll_init_socket(), uv_process_tcp_read_req(), uv_process_tty_read_line_req(), uv_process_udp_recv_req(), uv_tcp_queue_accept(), uv_tcp_queue_read(), uv_tcp_try_cancel_io(), uv_tcp_try_connect(), uv_tcp_write(), uv_tty_line_read_thread(), uv_udp_queue_recv(), uv_wsarecv_workaround(), uv_wsarecvfrom_workaround(), wasm_dis(), and xap_op().

Offset

ut32 Offset = 0

static

Definition at line 20 of file asm_arc.c.

Referenced by arc_buffer_read_memory(), ARM_AM_getAM5Opc(), disassemble(), and getAM3Opc().

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

= {
    .type = RZ_LIB_TYPE_ASM,
    .data = &rz_asm_plugin_arc,
    .version = RZ_VERSION
}

Definition at line 95 of file asm_arc.c.

rz_asm_plugin_arc

RzAsmPlugin rz_asm_plugin_arc

Initial value:

= {
    .name = "arc",
    .arch = "arc",
    .bits = 16 | 32,
    .endian = RZ_SYS_ENDIAN_LITTLE | RZ_SYS_ENDIAN_BIG,
    .desc = "Argonaut RISC Core",
    .disassemble = &disassemble,
    .license = "GPL3"
}

Definition at line 84 of file asm_arc.c.