/src/capstonenext/arch/Mips/MipsInstPrinter.c

Source (jump to first uncovered line)
//===-- MipsInstPrinter.cpp - Convert Mips MCInst to assembly syntax ------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This class prints an Mips MCInst to a .s file.
//
//===----------------------------------------------------------------------===//

/* Capstone Disassembly Engine */
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2015 */

#ifdef CAPSTONE_HAS_MIPS

#include <capstone/platform.h>
#include <stdlib.h>
#include <stdio.h>  // debug
#include <string.h>

#include "MipsInstPrinter.h"
#include "../../MCInst.h"
#include "../../utils.h"
#include "../../SStream.h"
#include "../../MCRegisterInfo.h"
#include "MipsMapping.h"

#include "MipsInstPrinter.h"

static void printUnsignedImm(MCInst *MI, int opNum, SStream *O);
static char *printAliasInstr(MCInst *MI, SStream *O, void *info);
static char *printAlias(MCInst *MI, SStream *OS);

// These enumeration declarations were originally in MipsInstrInfo.h but
// had to be moved here to avoid circular dependencies between
// LLVMMipsCodeGen and LLVMMipsAsmPrinter.

// Mips Condition Codes
typedef enum Mips_CondCode {
  // To be used with float branch True
  Mips_FCOND_F,
  Mips_FCOND_UN,
  Mips_FCOND_OEQ,
  Mips_FCOND_UEQ,
  Mips_FCOND_OLT,
  Mips_FCOND_ULT,
  Mips_FCOND_OLE,
  Mips_FCOND_ULE,
  Mips_FCOND_SF,
  Mips_FCOND_NGLE,
  Mips_FCOND_SEQ,
  Mips_FCOND_NGL,
  Mips_FCOND_LT,
  Mips_FCOND_NGE,
  Mips_FCOND_LE,
  Mips_FCOND_NGT,

  // To be used with float branch False
  // This conditions have the same mnemonic as the
  // above ones, but are used with a branch False;
  Mips_FCOND_T,
  Mips_FCOND_OR,
  Mips_FCOND_UNE,
  Mips_FCOND_ONE,
  Mips_FCOND_UGE,
  Mips_FCOND_OGE,
  Mips_FCOND_UGT,
  Mips_FCOND_OGT,
  Mips_FCOND_ST,
  Mips_FCOND_GLE,
  Mips_FCOND_SNE,
  Mips_FCOND_GL,
  Mips_FCOND_NLT,
  Mips_FCOND_GE,
  Mips_FCOND_NLE,
  Mips_FCOND_GT
} Mips_CondCode;

#define GET_INSTRINFO_ENUM
#include "MipsGenInstrInfo.inc"

static const char *getRegisterName(unsigned RegNo);
static void printInstruction(MCInst *MI, SStream *O, const MCRegisterInfo *MRI);

static void set_mem_access(MCInst *MI, bool status)
{
  MI->csh->doing_mem = status;

  if (MI->csh->detail_opt != CS_OPT_ON)
    return;

  if (status) {
    MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_MEM;
    MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].mem.base = MIPS_REG_INVALID;
    MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].mem.disp = 0;
  } else {
    // done, create the next operand slot
    MI->flat_insn->detail->mips.op_count++;
  }
}

static bool isReg(MCInst *MI, unsigned OpNo, unsigned R)
{
  return (MCOperand_isReg(MCInst_getOperand(MI, OpNo)) &&
      MCOperand_getReg(MCInst_getOperand(MI, OpNo)) == R);
}

static const char* MipsFCCToString(Mips_CondCode CC)
{
  switch (CC) {
    default: return 0; // never reach
    case Mips_FCOND_F:
    case Mips_FCOND_T:   return "f";
    case Mips_FCOND_UN:
    case Mips_FCOND_OR:  return "un";
    case Mips_FCOND_OEQ:
    case Mips_FCOND_UNE: return "eq";
    case Mips_FCOND_UEQ:
    case Mips_FCOND_ONE: return "ueq";
    case Mips_FCOND_OLT:
    case Mips_FCOND_UGE: return "olt";
    case Mips_FCOND_ULT:
    case Mips_FCOND_OGE: return "ult";
    case Mips_FCOND_OLE:
    case Mips_FCOND_UGT: return "ole";
    case Mips_FCOND_ULE:
    case Mips_FCOND_OGT: return "ule";
    case Mips_FCOND_SF:
    case Mips_FCOND_ST:  return "sf";
    case Mips_FCOND_NGLE:
    case Mips_FCOND_GLE: return "ngle";
    case Mips_FCOND_SEQ:
    case Mips_FCOND_SNE: return "seq";
    case Mips_FCOND_NGL:
    case Mips_FCOND_GL:  return "ngl";
    case Mips_FCOND_LT:
    case Mips_FCOND_NLT: return "lt";
    case Mips_FCOND_NGE:
    case Mips_FCOND_GE:  return "nge";
    case Mips_FCOND_LE:
    case Mips_FCOND_NLE: return "le";
    case Mips_FCOND_NGT:
    case Mips_FCOND_GT:  return "ngt";
  }
}

static void printRegName(SStream *OS, unsigned RegNo)
{
  SStream_concat(OS, "$%s", getRegisterName(RegNo));
}

void Mips_printInst(MCInst *MI, SStream *O, void *info)
{
  char *mnem;

  switch (MCInst_getOpcode(MI)) {
    default: break;
    case Mips_Save16:
    case Mips_SaveX16:
    case Mips_Restore16:
    case Mips_RestoreX16:
      return;
  }

  // Try to print any aliases first.
  mnem = printAliasInstr(MI, O, info);
  if (!mnem) {
    mnem = printAlias(MI, O);
    if (!mnem) {
      printInstruction(MI, O, NULL);
    }
  }

  if (mnem) {
    // fixup instruction id due to the change in alias instruction
    MCInst_setOpcodePub(MI, Mips_map_insn(mnem));
    cs_mem_free(mnem);
  }
}

static void printOperand(MCInst *MI, unsigned OpNo, SStream *O)
{
  MCOperand *Op;

  if (OpNo >= MI->size)
    return;

  Op = MCInst_getOperand(MI, OpNo);
  if (MCOperand_isReg(Op)) {
    unsigned int reg = MCOperand_getReg(Op);
    printRegName(O, reg);
    reg = Mips_map_register(reg);
    if (MI->csh->detail_opt) {
      if (MI->csh->doing_mem) {
        MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].mem.base = reg;
      } else {
        MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_REG;
        MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].reg = reg;
        MI->flat_insn->detail->mips.op_count++;
      }
    }
  } else if (MCOperand_isImm(Op)) {
    int64_t imm = MCOperand_getImm(Op);
    if (MI->csh->doing_mem) {
      if (imm) { // only print Imm offset if it is not 0
        printInt64(O, imm);
      }
      if (MI->csh->detail_opt)
        MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].mem.disp = imm;
    } else {
      printInt64(O, imm);

      if (MI->csh->detail_opt) {
        MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_IMM;
        MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].imm = imm;
        MI->flat_insn->detail->mips.op_count++;
      }
    }
  }
}

static void printUnsignedImm(MCInst *MI, int opNum, SStream *O)
{
  MCOperand *MO = MCInst_getOperand(MI, opNum);
  if (MCOperand_isImm(MO)) {
    int64_t imm = MCOperand_getImm(MO);
    printInt64(O, imm);

    if (MI->csh->detail_opt) {
      MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_IMM;
      MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].imm = (unsigned short int)imm;
      MI->flat_insn->detail->mips.op_count++;
    }
  } else
    printOperand(MI, opNum, O);
}

static void printUnsignedImm8(MCInst *MI, int opNum, SStream *O)
{
  MCOperand *MO = MCInst_getOperand(MI, opNum);
  if (MCOperand_isImm(MO)) {
    uint8_t imm = (uint8_t)MCOperand_getImm(MO);
    if (imm > HEX_THRESHOLD)
      SStream_concat(O, "0x%x", imm);
    else
      SStream_concat(O, "%u", imm);
    if (MI->csh->detail_opt) {
      MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_IMM;
      MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].imm = imm;
      MI->flat_insn->detail->mips.op_count++;
    }
  } else
    printOperand(MI, opNum, O);
}

static void printMemOperand(MCInst *MI, int opNum, SStream *O)
{
  // Load/Store memory operands -- imm($reg)
  // If PIC target the target is loaded as the
  // pattern lw $25,%call16($28)

  // opNum can be invalid if instruction had reglist as operand.
  // MemOperand is always last operand of instruction (base + offset).
  switch (MCInst_getOpcode(MI)) {
    default:
      break;
    case Mips_SWM32_MM:
    case Mips_LWM32_MM:
    case Mips_SWM16_MM:
    case Mips_LWM16_MM:
      opNum = MCInst_getNumOperands(MI) - 2;
      break;
  }

  set_mem_access(MI, true);
  printOperand(MI, opNum + 1, O);
  SStream_concat0(O, "(");
  printOperand(MI, opNum, O);
  SStream_concat0(O, ")");
  set_mem_access(MI, false);
}

// TODO???
static void printMemOperandEA(MCInst *MI, int opNum, SStream *O)
{
  // when using stack locations for not load/store instructions
  // print the same way as all normal 3 operand instructions.
  printOperand(MI, opNum, O);
  SStream_concat0(O, ", ");
  printOperand(MI, opNum + 1, O);
  return;
}

static void printFCCOperand(MCInst *MI, int opNum, SStream *O)
{
  MCOperand *MO = MCInst_getOperand(MI, opNum);
  SStream_concat0(O, MipsFCCToString((Mips_CondCode)MCOperand_getImm(MO)));
}

static void printRegisterPair(MCInst *MI, int opNum, SStream *O)
{
  printRegName(O, MCOperand_getReg(MCInst_getOperand(MI, opNum)));
}

static char *printAlias1(const char *Str, MCInst *MI, unsigned OpNo, SStream *OS)
{
  SStream_concat(OS, "%s\t", Str);
  printOperand(MI, OpNo, OS);
  return cs_strdup(Str);
}

static char *printAlias2(const char *Str, MCInst *MI,
    unsigned OpNo0, unsigned OpNo1, SStream *OS)
{
  char *tmp;

  tmp = printAlias1(Str, MI, OpNo0, OS);
  SStream_concat0(OS, ", ");
  printOperand(MI, OpNo1, OS);

  return tmp;
}

#define GET_REGINFO_ENUM
#include "MipsGenRegisterInfo.inc"

static char *printAlias(MCInst *MI, SStream *OS)
{
  switch (MCInst_getOpcode(MI)) {
    case Mips_BEQ:
    case Mips_BEQ_MM:
      // beq $zero, $zero, $L2 => b $L2
      // beq $r0, $zero, $L2 => beqz $r0, $L2
      if (isReg(MI, 0, Mips_ZERO) && isReg(MI, 1, Mips_ZERO))
        return printAlias1("b", MI, 2, OS);
      if (isReg(MI, 1, Mips_ZERO))
        return printAlias2("beqz", MI, 0, 2, OS);
      return NULL;
    case Mips_BEQ64:
      // beq $r0, $zero, $L2 => beqz $r0, $L2
      if (isReg(MI, 1, Mips_ZERO_64))
        return printAlias2("beqz", MI, 0, 2, OS);
      return NULL;
    case Mips_BNE:
      // bne $r0, $zero, $L2 => bnez $r0, $L2
      if (isReg(MI, 1, Mips_ZERO))
        return printAlias2("bnez", MI, 0, 2, OS);
      return NULL;
    case Mips_BNE64:
      // bne $r0, $zero, $L2 => bnez $r0, $L2
      if (isReg(MI, 1, Mips_ZERO_64))
        return printAlias2("bnez", MI, 0, 2, OS);
      return NULL;
    case Mips_BGEZAL:
      // bgezal $zero, $L1 => bal $L1
      if (isReg(MI, 0, Mips_ZERO))
        return printAlias1("bal", MI, 1, OS);
      return NULL;
    case Mips_BC1T:
      // bc1t $fcc0, $L1 => bc1t $L1
      if (isReg(MI, 0, Mips_FCC0))
        return printAlias1("bc1t", MI, 1, OS);
      return NULL;
    case Mips_BC1F:
      // bc1f $fcc0, $L1 => bc1f $L1
      if (isReg(MI, 0, Mips_FCC0))
        return printAlias1("bc1f", MI, 1, OS);
      return NULL;
    case Mips_JALR:
      // jalr $ra, $r1 => jalr $r1
      if (isReg(MI, 0, Mips_RA))
        return printAlias1("jalr", MI, 1, OS);
      return NULL;
    case Mips_JALR64:
      // jalr $ra, $r1 => jalr $r1
      if (isReg(MI, 0, Mips_RA_64))
        return printAlias1("jalr", MI, 1, OS);
      return NULL;
    case Mips_NOR:
    case Mips_NOR_MM:
      // nor $r0, $r1, $zero => not $r0, $r1
      if (isReg(MI, 2, Mips_ZERO))
        return printAlias2("not", MI, 0, 1, OS);
      return NULL;
    case Mips_NOR64:
      // nor $r0, $r1, $zero => not $r0, $r1
      if (isReg(MI, 2, Mips_ZERO_64))
        return printAlias2("not", MI, 0, 1, OS);
      return NULL;
    case Mips_OR:
      // or $r0, $r1, $zero => move $r0, $r1
      if (isReg(MI, 2, Mips_ZERO))
        return printAlias2("move", MI, 0, 1, OS);
      return NULL;
    default: return NULL;
  }
}

static void printRegisterList(MCInst *MI, int opNum, SStream *O)
{
  int i, e, reg;

  // - 2 because register List is always first operand of instruction and it is
  // always followed by memory operand (base + offset).
  for (i = opNum, e = MCInst_getNumOperands(MI) - 2; i != e; ++i) {
    if (i != opNum)
      SStream_concat0(O, ", ");
    reg = MCOperand_getReg(MCInst_getOperand(MI, i));
    printRegName(O, reg);
    if (MI->csh->detail_opt) {
      MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_REG;
      MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].reg = reg;
      MI->flat_insn->detail->mips.op_count++;
    }
  }
}

#define PRINT_ALIAS_INSTR
#include "MipsGenAsmWriter.inc"

#endif

Coverage Report

Created: 2023-09-25 06:24

Line	Count	Source (jump to first uncovered line)
1		//===-- MipsInstPrinter.cpp - Convert Mips MCInst to assembly syntax ------===//
2		//
3		// The LLVM Compiler Infrastructure
4		//
5		// This file is distributed under the University of Illinois Open Source
6		// License. See LICENSE.TXT for details.
7		//
8		//===----------------------------------------------------------------------===//
9		//
10		// This class prints an Mips MCInst to a .s file.
11		//
12		//===----------------------------------------------------------------------===//
13
14		/* Capstone Disassembly Engine */
15		/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2015 */
16
17		#ifdef CAPSTONE_HAS_MIPS
18
19		#include <capstone/platform.h>
20		#include <stdlib.h>
21		#include <stdio.h> // debug
22		#include <string.h>
23
24		#include "MipsInstPrinter.h"
25		#include "../../MCInst.h"
26		#include "../../utils.h"
27		#include "../../SStream.h"
28		#include "../../MCRegisterInfo.h"
29		#include "MipsMapping.h"
30
31		#include "MipsInstPrinter.h"
32
33		static void printUnsignedImm(MCInst MI, int opNum, SStream O);
34		static char printAliasInstr(MCInst MI, SStream O, void info);
35		static char printAlias(MCInst MI, SStream *OS);
36
37		// These enumeration declarations were originally in MipsInstrInfo.h but
38		// had to be moved here to avoid circular dependencies between
39		// LLVMMipsCodeGen and LLVMMipsAsmPrinter.
40
41		// Mips Condition Codes
42		typedef enum Mips_CondCode {
43		// To be used with float branch True
44		Mips_FCOND_F,
45		Mips_FCOND_UN,
46		Mips_FCOND_OEQ,
47		Mips_FCOND_UEQ,
48		Mips_FCOND_OLT,
49		Mips_FCOND_ULT,
50		Mips_FCOND_OLE,
51		Mips_FCOND_ULE,
52		Mips_FCOND_SF,
53		Mips_FCOND_NGLE,
54		Mips_FCOND_SEQ,
55		Mips_FCOND_NGL,
56		Mips_FCOND_LT,
57		Mips_FCOND_NGE,
58		Mips_FCOND_LE,
59		Mips_FCOND_NGT,
60
61		// To be used with float branch False
62		// This conditions have the same mnemonic as the
63		// above ones, but are used with a branch False;
64		Mips_FCOND_T,
65		Mips_FCOND_OR,
66		Mips_FCOND_UNE,
67		Mips_FCOND_ONE,
68		Mips_FCOND_UGE,
69		Mips_FCOND_OGE,
70		Mips_FCOND_UGT,
71		Mips_FCOND_OGT,
72		Mips_FCOND_ST,
73		Mips_FCOND_GLE,
74		Mips_FCOND_SNE,
75		Mips_FCOND_GL,
76		Mips_FCOND_NLT,
77		Mips_FCOND_GE,
78		Mips_FCOND_NLE,
79		Mips_FCOND_GT
80		} Mips_CondCode;
81
82		#define GET_INSTRINFO_ENUM
83		#include "MipsGenInstrInfo.inc"
84
85		static const char *getRegisterName(unsigned RegNo);
86		static void printInstruction(MCInst MI, SStream O, const MCRegisterInfo *MRI);
87
88		static void set_mem_access(MCInst *MI, bool status)
89	47.5k	{
90	47.5k	MI->csh->doing_mem = status;
91
92	47.5k	if (MI->csh->detail_opt != CS_OPT_ON)
93	0	return;
94
95	47.5k	if (status) {
96	23.7k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_MEM;
97	23.7k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].mem.base = MIPS_REG_INVALID;
98	23.7k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].mem.disp = 0;
99	23.7k	} else {
100		// done, create the next operand slot
101	23.7k	MI->flat_insn->detail->mips.op_count++;
102	23.7k	}
103	47.5k	}
104
105		static bool isReg(MCInst *MI, unsigned OpNo, unsigned R)
106	7.29k	{
107	7.29k	return (MCOperand_isReg(MCInst_getOperand(MI, OpNo)) &&
108	7.29k	MCOperand_getReg(MCInst_getOperand(MI, OpNo)) == R);
109	7.29k	}
110
111		static const char* MipsFCCToString(Mips_CondCode CC)
112	0	{
113	0	switch (CC) {
114	0	default: return 0; // never reach
115	0	case Mips_FCOND_F:
116	0	case Mips_FCOND_T: return "f";
117	0	case Mips_FCOND_UN:
118	0	case Mips_FCOND_OR: return "un";
119	0	case Mips_FCOND_OEQ:
120	0	case Mips_FCOND_UNE: return "eq";
121	0	case Mips_FCOND_UEQ:
122	0	case Mips_FCOND_ONE: return "ueq";
123	0	case Mips_FCOND_OLT:
124	0	case Mips_FCOND_UGE: return "olt";
125	0	case Mips_FCOND_ULT:
126	0	case Mips_FCOND_OGE: return "ult";
127	0	case Mips_FCOND_OLE:
128	0	case Mips_FCOND_UGT: return "ole";
129	0	case Mips_FCOND_ULE:
130	0	case Mips_FCOND_OGT: return "ule";
131	0	case Mips_FCOND_SF:
132	0	case Mips_FCOND_ST: return "sf";
133	0	case Mips_FCOND_NGLE:
134	0	case Mips_FCOND_GLE: return "ngle";
135	0	case Mips_FCOND_SEQ:
136	0	case Mips_FCOND_SNE: return "seq";
137	0	case Mips_FCOND_NGL:
138	0	case Mips_FCOND_GL: return "ngl";
139	0	case Mips_FCOND_LT:
140	0	case Mips_FCOND_NLT: return "lt";
141	0	case Mips_FCOND_NGE:
142	0	case Mips_FCOND_GE: return "nge";
143	0	case Mips_FCOND_LE:
144	0	case Mips_FCOND_NLE: return "le";
145	0	case Mips_FCOND_NGT:
146	0	case Mips_FCOND_GT: return "ngt";
147	0	}
148	0	}
149
150		static void printRegName(SStream *OS, unsigned RegNo)
151	167k	{
152	167k	SStream_concat(OS, "$%s", getRegisterName(RegNo));
153	167k	}
154
155		void Mips_printInst(MCInst MI, SStream O, void *info)
156	98.1k	{
157	98.1k	char *mnem;
158
159	98.1k	switch (MCInst_getOpcode(MI)) {
160	98.1k	default: break;
161	98.1k	case Mips_Save16:
162	0	case Mips_SaveX16:
163	0	case Mips_Restore16:
164	0	case Mips_RestoreX16:
165	0	return;
166	98.1k	}
167
168		// Try to print any aliases first.
169	98.1k	mnem = printAliasInstr(MI, O, info);
170	98.1k	if (!mnem) {
171	90.4k	mnem = printAlias(MI, O);
172	90.4k	if (!mnem) {
173	89.2k	printInstruction(MI, O, NULL);
174	89.2k	}
175	90.4k	}
176
177	98.1k	if (mnem) {
178		// fixup instruction id due to the change in alias instruction
179	8.95k	MCInst_setOpcodePub(MI, Mips_map_insn(mnem));
180	8.95k	cs_mem_free(mnem);
181	8.95k	}
182	98.1k	}
183
184		static void printOperand(MCInst MI, unsigned OpNo, SStream O)
185	220k	{
186	220k	MCOperand *Op;
187
188	220k	if (OpNo >= MI->size)
189	0	return;
190
191	220k	Op = MCInst_getOperand(MI, OpNo);
192	220k	if (MCOperand_isReg(Op)) {
193	159k	unsigned int reg = MCOperand_getReg(Op);
194	159k	printRegName(O, reg);
195	159k	reg = Mips_map_register(reg);
196	159k	if (MI->csh->detail_opt) {
197	159k	if (MI->csh->doing_mem) {
198	23.7k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].mem.base = reg;
199	135k	} else {
200	135k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_REG;
201	135k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].reg = reg;
202	135k	MI->flat_insn->detail->mips.op_count++;
203	135k	}
204	159k	}
205	159k	} else if (MCOperand_isImm(Op)) {
206	61.3k	int64_t imm = MCOperand_getImm(Op);
207	61.3k	if (MI->csh->doing_mem) {
208	23.7k	if (imm) { // only print Imm offset if it is not 0
209	22.5k	printInt64(O, imm);
210	22.5k	}
211	23.7k	if (MI->csh->detail_opt)
212	23.7k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].mem.disp = imm;
213	37.5k	} else {
214	37.5k	printInt64(O, imm);
215
216	37.5k	if (MI->csh->detail_opt) {
217	37.5k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_IMM;
218	37.5k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].imm = imm;
219	37.5k	MI->flat_insn->detail->mips.op_count++;
220	37.5k	}
221	37.5k	}
222	61.3k	}
223	220k	}
224
225		static void printUnsignedImm(MCInst MI, int opNum, SStream O)
226	13.4k	{
227	13.4k	MCOperand *MO = MCInst_getOperand(MI, opNum);
228	13.4k	if (MCOperand_isImm(MO)) {
229	13.4k	int64_t imm = MCOperand_getImm(MO);
230	13.4k	printInt64(O, imm);
231
232	13.4k	if (MI->csh->detail_opt) {
233	13.4k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_IMM;
234	13.4k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].imm = (unsigned short int)imm;
235	13.4k	MI->flat_insn->detail->mips.op_count++;
236	13.4k	}
237	13.4k	} else
238	0	printOperand(MI, opNum, O);
239	13.4k	}
240
241		static void printUnsignedImm8(MCInst MI, int opNum, SStream O)
242	3.98k	{
243	3.98k	MCOperand *MO = MCInst_getOperand(MI, opNum);
244	3.98k	if (MCOperand_isImm(MO)) {
245	3.98k	uint8_t imm = (uint8_t)MCOperand_getImm(MO);
246	3.98k	if (imm > HEX_THRESHOLD)
247	1.80k	SStream_concat(O, "0x%x", imm);
248	2.18k	else
249	2.18k	SStream_concat(O, "%u", imm);
250	3.98k	if (MI->csh->detail_opt) {
251	3.98k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_IMM;
252	3.98k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].imm = imm;
253	3.98k	MI->flat_insn->detail->mips.op_count++;
254	3.98k	}
255	3.98k	} else
256	0	printOperand(MI, opNum, O);
257	3.98k	}
258
259		static void printMemOperand(MCInst MI, int opNum, SStream O)
260	23.7k	{
261		// Load/Store memory operands -- imm($reg)
262		// If PIC target the target is loaded as the
263		// pattern lw $25,%call16($28)
264
265		// opNum can be invalid if instruction had reglist as operand.
266		// MemOperand is always last operand of instruction (base + offset).
267	23.7k	switch (MCInst_getOpcode(MI)) {
268	22.3k	default:
269	22.3k	break;
270	22.3k	case Mips_SWM32_MM:
271	852	case Mips_LWM32_MM:
272	1.11k	case Mips_SWM16_MM:
273	1.38k	case Mips_LWM16_MM:
274	1.38k	opNum = MCInst_getNumOperands(MI) - 2;
275	1.38k	break;
276	23.7k	}
277
278	23.7k	set_mem_access(MI, true);
279	23.7k	printOperand(MI, opNum + 1, O);
280	23.7k	SStream_concat0(O, "(");
281	23.7k	printOperand(MI, opNum, O);
282	23.7k	SStream_concat0(O, ")");
283	23.7k	set_mem_access(MI, false);
284	23.7k	}
285
286		// TODO???
287		static void printMemOperandEA(MCInst MI, int opNum, SStream O)
288	0	{
289		// when using stack locations for not load/store instructions
290		// print the same way as all normal 3 operand instructions.
291	0	printOperand(MI, opNum, O);
292	0	SStream_concat0(O, ", ");
293	0	printOperand(MI, opNum + 1, O);
294	0	return;
295	0	}
296
297		static void printFCCOperand(MCInst MI, int opNum, SStream O)
298	0	{
299	0	MCOperand *MO = MCInst_getOperand(MI, opNum);
300	0	SStream_concat0(O, MipsFCCToString((Mips_CondCode)MCOperand_getImm(MO)));
301	0	}
302
303		static void printRegisterPair(MCInst MI, int opNum, SStream O)
304	272	{
305	272	printRegName(O, MCOperand_getReg(MCInst_getOperand(MI, opNum)));
306	272	}
307
308		static char printAlias1(const char Str, MCInst MI, unsigned OpNo, SStream OS)
309	1.20k	{
310	1.20k	SStream_concat(OS, "%s\t", Str);
311	1.20k	printOperand(MI, OpNo, OS);
312	1.20k	return cs_strdup(Str);
313	1.20k	}
314
315		static char printAlias2(const char Str, MCInst *MI,
316		unsigned OpNo0, unsigned OpNo1, SStream *OS)
317	832	{
318	832	char *tmp;
319
320	832	tmp = printAlias1(Str, MI, OpNo0, OS);
321	832	SStream_concat0(OS, ", ");
322	832	printOperand(MI, OpNo1, OS);
323
324	832	return tmp;
325	832	}
326
327		#define GET_REGINFO_ENUM
328		#include "MipsGenRegisterInfo.inc"
329
330		static char printAlias(MCInst MI, SStream *OS)
331	90.4k	{
332	90.4k	switch (MCInst_getOpcode(MI)) {
333	2.20k	case Mips_BEQ:
334	2.40k	case Mips_BEQ_MM:
335		// beq $zero, $zero, $L2 => b $L2
336		// beq $r0, $zero, $L2 => beqz $r0, $L2
337	2.40k	if (isReg(MI, 0, Mips_ZERO) && isReg(MI, 1, Mips_ZERO))
338	272	return printAlias1("b", MI, 2, OS);
339	2.13k	if (isReg(MI, 1, Mips_ZERO))
340	618	return printAlias2("beqz", MI, 0, 2, OS);
341	1.51k	return NULL;
342	0	case Mips_BEQ64:
343		// beq $r0, $zero, $L2 => beqz $r0, $L2
344	0	if (isReg(MI, 1, Mips_ZERO_64))
345	0	return printAlias2("beqz", MI, 0, 2, OS);
346	0	return NULL;
347	813	case Mips_BNE:
348		// bne $r0, $zero, $L2 => bnez $r0, $L2
349	813	if (isReg(MI, 1, Mips_ZERO))
350	99	return printAlias2("bnez", MI, 0, 2, OS);
351	714	return NULL;
352	0	case Mips_BNE64:
353		// bne $r0, $zero, $L2 => bnez $r0, $L2
354	0	if (isReg(MI, 1, Mips_ZERO_64))
355	0	return printAlias2("bnez", MI, 0, 2, OS);
356	0	return NULL;
357	291	case Mips_BGEZAL:
358		// bgezal $zero, $L1 => bal $L1
359	291	if (isReg(MI, 0, Mips_ZERO))
360	68	return printAlias1("bal", MI, 1, OS);
361	223	return NULL;
362	69	case Mips_BC1T:
363		// bc1t $fcc0, $L1 => bc1t $L1
364	69	if (isReg(MI, 0, Mips_FCC0))
365	0	return printAlias1("bc1t", MI, 1, OS);
366	69	return NULL;
367	777	case Mips_BC1F:
368		// bc1f $fcc0, $L1 => bc1f $L1
369	777	if (isReg(MI, 0, Mips_FCC0))
370	0	return printAlias1("bc1f", MI, 1, OS);
371	777	return NULL;
372	104	case Mips_JALR:
373		// jalr $ra, $r1 => jalr $r1
374	104	if (isReg(MI, 0, Mips_RA))
375	34	return printAlias1("jalr", MI, 1, OS);
376	70	return NULL;
377	0	case Mips_JALR64:
378		// jalr $ra, $r1 => jalr $r1
379	0	if (isReg(MI, 0, Mips_RA_64))
380	0	return printAlias1("jalr", MI, 1, OS);
381	0	return NULL;
382	53	case Mips_NOR:
383	77	case Mips_NOR_MM:
384		// nor $r0, $r1, $zero => not $r0, $r1
385	77	if (isReg(MI, 2, Mips_ZERO))
386	43	return printAlias2("not", MI, 0, 1, OS);
387	34	return NULL;
388	0	case Mips_NOR64:
389		// nor $r0, $r1, $zero => not $r0, $r1
390	0	if (isReg(MI, 2, Mips_ZERO_64))
391	0	return printAlias2("not", MI, 0, 1, OS);
392	0	return NULL;
393	108	case Mips_OR:
394		// or $r0, $r1, $zero => move $r0, $r1
395	108	if (isReg(MI, 2, Mips_ZERO))
396	72	return printAlias2("move", MI, 0, 1, OS);
397	36	return NULL;
398	85.8k	default: return NULL;
399	90.4k	}
400	90.4k	}
401
402		static void printRegisterList(MCInst MI, int opNum, SStream O)
403	1.65k	{
404	1.65k	int i, e, reg;
405
406		// - 2 because register List is always first operand of instruction and it is
407		// always followed by memory operand (base + offset).
408	9.41k	for (i = opNum, e = MCInst_getNumOperands(MI) - 2; i != e; ++i) {
409	7.75k	if (i != opNum)
410	6.10k	SStream_concat0(O, ", ");
411	7.75k	reg = MCOperand_getReg(MCInst_getOperand(MI, i));
412	7.75k	printRegName(O, reg);
413	7.75k	if (MI->csh->detail_opt) {
414	7.75k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].type = MIPS_OP_REG;
415	7.75k	MI->flat_insn->detail->mips.operands[MI->flat_insn->detail->mips.op_count].reg = reg;
416	7.75k	MI->flat_insn->detail->mips.op_count++;
417	7.75k	}
418	7.75k	}
419	1.65k	}
420
421		#define PRINT_ALIAS_INSTR
422		#include "MipsGenAsmWriter.inc"
423
424		#endif