M68KInstPrinter.h File Reference

#include "capstone/capstone.h"
#include "../../MCRegisterInfo.h"
#include "../../MCInst.h"

Go to the source code of this file.

Functions
void	M68K_init (MCRegisterInfo *MRI)
void	M68K_printInst (MCInst *MI, struct SStream *O, void *Info)
const char *	M68K_reg_name (csh handle, unsigned int reg)
void	M68K_get_insn_id (cs_struct *h, cs_insn *insn, unsigned int id)
const char *	M68K_insn_name (csh handle, unsigned int id)
const char *	M68K_group_name (csh handle, unsigned int id)
void	M68K_post_printer (csh handle, cs_insn *flat_insn, char *insn_asm, MCInst *mci)

Function Documentation

M68K_get_insn_id()

void M68K_get_insn_id	(	cs_struct *	h,
		cs_insn *	insn,
		unsigned int	id
	)

Definition at line 355 of file M68KInstPrinter.c.

{
    insn->id = id; // These id's matches for 68k
}

References id.

M68K_group_name()

const char* M68K_group_name	(	csh	handle,
		unsigned int	id
	)

Definition at line 379 of file M68KInstPrinter.c.

{
#ifndef CAPSTONE_DIET
    return id2name(group_name_maps, ARR_SIZE(group_name_maps), id);
#else
    return NULL;
#endif
}

References ARR_SIZE, group_name_maps, id2name(), and NULL.

M68K_init()

void M68K_init

(

MCRegisterInfo *

MRI

)

M68K_insn_name()

const char* M68K_insn_name	(	csh	handle,
		unsigned int	id
	)

Definition at line 360 of file M68KInstPrinter.c.

{
#ifdef CAPSTONE_DIET
    return NULL;
#else
    return s_instruction_names[id];
#endif
}

References id, NULL, and s_instruction_names.

M68K_post_printer()

void M68K_post_printer	(	csh	handle,
		cs_insn *	flat_insn,
		char *	insn_asm,
		MCInst *	mci
	)

M68K_printInst()

void M68K_printInst	(	MCInst *	MI,
		struct SStream *	O,
		void *	Info
	)

Definition at line 262 of file M68KInstPrinter.c.

{
#ifndef CAPSTONE_DIET
    m68k_info *info = (m68k_info *)PrinterInfo;
    cs_m68k *ext = &info->extension;
    cs_detail *detail = NULL;
    int i = 0;
 
    detail = MI->flat_insn->detail;
    if (detail) {
        int regs_read_count = m68k_min(m68k_sizeof_array(detail->regs_read), info->regs_read_count);
        int regs_write_count = m68k_min(m68k_sizeof_array(detail->regs_write), info->regs_write_count);
        int groups_count = m68k_min(m68k_sizeof_array(detail->groups), info->groups_count);
 
        memcpy(&detail->m68k, ext, sizeof(cs_m68k));
 
        memcpy(&detail->regs_read, &info->regs_read, regs_read_count * sizeof(uint16_t));
        detail->regs_read_count = regs_read_count;
 
        memcpy(&detail->regs_write, &info->regs_write, regs_write_count * sizeof(uint16_t));
        detail->regs_write_count = regs_write_count;
 
        memcpy(&detail->groups, &info->groups, groups_count);
        detail->groups_count = groups_count;
    }
 
    if (MI->Opcode == M68K_INS_INVALID) {
        if (ext->op_count)
            SStream_concat(O, "dc.w $%x", ext->operands[0].imm);
        else
            SStream_concat(O, "dc.w $<unknown>");
        return;
    }
 
    SStream_concat0(O, (char*)s_instruction_names[MI->Opcode]);
 
    switch (ext->op_size.type) {
        case M68K_SIZE_TYPE_INVALID :
            break;
 
        case M68K_SIZE_TYPE_CPU :
            switch (ext->op_size.cpu_size) {
                case M68K_CPU_SIZE_BYTE: SStream_concat0(O, ".b"); break;
                case M68K_CPU_SIZE_WORD: SStream_concat0(O, ".w"); break;
                case M68K_CPU_SIZE_LONG: SStream_concat0(O, ".l"); break;
                case M68K_CPU_SIZE_NONE: break;
            }
            break;
 
        case M68K_SIZE_TYPE_FPU :
            switch (ext->op_size.fpu_size) {
                case M68K_FPU_SIZE_SINGLE: SStream_concat0(O, ".s"); break;
                case M68K_FPU_SIZE_DOUBLE: SStream_concat0(O, ".d"); break;
                case M68K_FPU_SIZE_EXTENDED: SStream_concat0(O, ".x"); break;
                case M68K_FPU_SIZE_NONE: break;
            }
            break;
    }
 
    SStream_concat0(O, " ");
 
    // this one is a bit spacial so we do special things
 
    if (MI->Opcode == M68K_INS_CAS2) {
        int reg_value_0, reg_value_1;
        printAddressingMode(O, info->pc, ext, &ext->operands[0]); SStream_concat0(O, ",");
        printAddressingMode(O, info->pc, ext, &ext->operands[1]); SStream_concat0(O, ",");
        reg_value_0 = ext->operands[2].register_bits >> 4;
        reg_value_1 = ext->operands[2].register_bits & 0xf;
        SStream_concat(O, "(%s):(%s)", s_reg_names[M68K_REG_D0 + reg_value_0], s_reg_names[M68K_REG_D0 + reg_value_1]);
        return;
    }
 
    for (i  = 0; i < ext->op_count; ++i) {
        printAddressingMode(O, info->pc, ext, &ext->operands[i]);
        if ((i + 1) != ext->op_count)
            SStream_concat(O, ",%s", s_spacing);
    }
#endif
}

References ext, MCInst::flat_insn, i, info(), M68K_CPU_SIZE_BYTE, M68K_CPU_SIZE_LONG, M68K_CPU_SIZE_NONE, M68K_CPU_SIZE_WORD, M68K_FPU_SIZE_DOUBLE, M68K_FPU_SIZE_EXTENDED, M68K_FPU_SIZE_NONE, M68K_FPU_SIZE_SINGLE, M68K_INS_CAS2, M68K_INS_INVALID, m68k_min, M68K_REG_D0, M68K_SIZE_TYPE_CPU, M68K_SIZE_TYPE_FPU, M68K_SIZE_TYPE_INVALID, m68k_sizeof_array, memcpy(), NULL, O, MCInst::Opcode, printAddressingMode(), s_instruction_names, s_reg_names, s_spacing, SStream_concat(), and SStream_concat0().

Referenced by M68K_getInstruction().

M68K_reg_name()

const char* M68K_reg_name	(	csh	handle,
		unsigned int	reg
	)

Definition at line 343 of file M68KInstPrinter.c.

{
#ifdef CAPSTONE_DIET
    return NULL;
#else
    if (reg >= ARR_SIZE(s_reg_names)) {
        return NULL;
    }
    return s_reg_names[(int)reg];
#endif
}

References ARR_SIZE, int, NULL, reg, and s_reg_names.