arcompact-dis.h File Reference

Go to the source code of this file.

Functions
void	arc_print_disassembler_options (FILE *stream)
struct arcDisState	arcAnalyzeInstr (bfd_vma address, disassemble_info *info)
int	ARCompact_decodeInstr (bfd_vma address, disassemble_info *info)

Function Documentation

arc_print_disassembler_options()

void arc_print_disassembler_options

(

FILE *

stream

)

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

                                                  {
    fprintf(stream, "\n\
 ARC-specific disassembler options:\n\
 use with the -M switch, with options separated by commas\n\n");
 
    fprintf(stream, "  insn-stream    Show the instruction byte stream from most\n");
    fprintf(stream, "                 significant byte to least significant byte (excluding LIMM).\n");
    fprintf(stream, "                 This option is useful for viewing the actual encoding of instructions.\n");
 
    fprintf(stream, "  simd           Enable SIMD instructions disassembly.\n\n");
}

arcAnalyzeInstr()

struct arcDisState arcAnalyzeInstr	(	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 */
    int bytes;
    int lowbyte, highbyte;
 
    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);
        s.instructionLen = -1;
        return s;
    }
 
    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);
            s.instructionLen = -1;
            return s;
        }
        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);
    /* We print max bytes for instruction */
    info->bytes_per_line = bytes;
    return s;
}

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

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;
}