better

1 files changed, 147 insertions, 136 deletions

diff --git a/include/mips.h b/include/mips.h
index ff043cd..b63d631 100644
--- a/include/mips.h
+++ b/include/mips.h
@@ -42,14 +42,6 @@ enum mips_register {
 	MIPS_REG_RA   = 31,
 };
 
-/* mips instruction format */
-enum mips_instruction_format {
-	MIPS_FORMAT_R,
-	MIPS_FORMAT_I,
-	MIPS_FORMAT_J,
-	MIPS_FORMAT_B,
-};
-
 /* mips instructions */
 enum mips_instruction_type {
 	MIPS_INS_ADD,
@@ -77,10 +69,10 @@ enum mips_instruction_type {
 	MIPS_INS_BLTZL,
 	MIPS_INS_BNE,
 	MIPS_INS_BNEL,
-	MIPS_INS_DDIV,
-	MIPS_INS_DDIVU,
 	MIPS_INS_DIV,
+	MIPS_INS_MOD,
 	MIPS_INS_DIVU,
+	MIPS_INS_MODU,
 	MIPS_INS_J,
 	MIPS_INS_JAL,
 	MIPS_INS_JALR,
@@ -98,8 +90,11 @@ enum mips_instruction_type {
 	MIPS_INS_MFLO,
 	MIPS_INS_MTHI,
 	MIPS_INS_MTLO,
+	MIPS_INS_MUL,
+	MIPS_INS_MUH,
+	MIPS_INS_MULU,
+	MIPS_INS_MUHU,
 	MIPS_INS_MULT,
-	MIPS_INS_MULTU,
 	MIPS_INS_SB,
 	MIPS_INS_SH,
 	MIPS_INS_SW,
@@ -127,352 +122,368 @@ enum mips_instruction_type {
 	__MIPS_INS_LEN,
 };
 
-/* mips instruction R TYPE */
-struct mips_instruction_r_data {
-	uint32_t funct : 6;
-	uint32_t shamt : 5;
-	uint32_t rd    : 5;
-	uint32_t rt    : 5;
-	uint32_t rs    : 5;
-	uint32_t op    : 6;
-} __attribute__((packed));
-
-/* mips instruction I TYPE */
-struct mips_instruction_i_data {
-	uint32_t immd : 16;
-	uint32_t rt    : 5;
-	uint32_t rs    : 5;
-	uint32_t op    : 6;
-} __attribute__((packed));
-
-/* mips instruction J TYPE */
-struct mips_instruction_j_data {
-	uint32_t target : 26;
-	uint32_t op      : 6;
-} __attribute__((packed));
-
-/* mips instruction BRANCH TYPE */
-struct mips_instruction_branch_data {
-	 int32_t offset : 16;
-	uint32_t funct  : 5;
-	uint32_t rs     : 5;
-	uint32_t op     : 6;
-} __attribute__((packed));
-
 union mips_instruction_data {
-	uint32_t raw;
-	struct mips_instruction_r_data R;
-	struct mips_instruction_i_data I;
-	struct mips_instruction_j_data J;
-	struct mips_instruction_branch_data B;
+	/* raw ins */
+	uint32_t raw            : 32;
+	/* register type */
+	struct {
+		uint32_t funct  : 6;
+		uint32_t shamt  : 5;
+		uint32_t rd     : 5;
+		uint32_t rt     : 5;
+		uint32_t rs     : 5;
+		uint32_t op     : 6;
+	};
+	/* immediate type */
+	struct {
+		uint32_t immd   : 16;
+		uint32_t        : 16;
+	};
+	/* jump type */
+	struct {
+		uint32_t target : 26;
+		uint32_t        :  6;
+	};
+	/* branch compact */
+	struct {
+		 int32_t offs26 : 26;
+		uint32_t        :  6;
+	};
+	/* branch */
+	struct {
+		 int32_t offset : 16;
+		uint32_t bfunct :  5;
+		uint32_t        : 11;
+	};
 } __attribute__((packed));
 
 /* mips instruction information */
 struct mips_instruction {
 	// metadata
 	enum mips_instruction_type type;
-	enum mips_instruction_format format;
 	const char *name;
 
 	// data
 	union mips_instruction_data data;
 };
 
-
-#define MIPS_INS(ins, format, ...) \
+#define MIPS_INS(ins, ...) \
 	[MIPS_INS_ ##ins] = { \
 		MIPS_INS_ ##ins, \
-		MIPS_FORMAT_ ##format, \
 		#ins, \
-		.data = { .format = { __VA_ARGS__ } } \
+		.data = { __VA_ARGS__ } \
 	}, \
 
 static const struct mips_instruction mips_instructions[] = {
 /* ADD - add */
 #define MIPS_OP_SPECIAL    0b000000
 #define MIPS_FUNCT_ADD     0b100000
-MIPS_INS(ADD, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_ADD)
+MIPS_INS(ADD, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_ADD)
 
 /* ADDI - add immediate */
 #define MIPS_OP_ADDI       0b001000
-MIPS_INS(ADDI, I, .op = MIPS_OP_ADDI)
+MIPS_INS(ADDI, .op = MIPS_OP_ADDI)
 
 /* ADDIU - add immediate unsigned */
 #define MIPS_OP_ADDIU      0b001001
-MIPS_INS(ADDIU, I, .op = MIPS_OP_ADDIU)
+MIPS_INS(ADDIU, .op = MIPS_OP_ADDIU)
 
 /* ADDU - add unsigned */
 #define MIPS_FUNCT_ADDU    0b100001
-MIPS_INS(ADDU, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_ADDU)
+MIPS_INS(ADDU, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_ADDU)
 
 /* AND - and */
 #define MIPS_FUNCT_AND     0b100100
-MIPS_INS(AND, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_AND)
+MIPS_INS(AND, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_AND)
 
 /* ANDI - and immediate */
 #define MIPS_OP_ANDI       0b001100
-MIPS_INS(ANDI, I, .op = MIPS_OP_ANDI)
+MIPS_INS(ANDI, .op = MIPS_OP_ANDI)
 
 /* BAL - branch and link */
 #define MIPS_OP_REGIMM     0b000001
 #define MIPS_FUNCT_BAL     0b10001
-MIPS_INS(BAL, B, .op = MIPS_OP_REGIMM, .funct = MIPS_FUNCT_BAL)
+MIPS_INS(BAL, .op = MIPS_OP_REGIMM, .funct = MIPS_FUNCT_BAL)
 
 /* BALC - branch and link, compact */
 #define MIPS_OP_BALC       0b111010
-MIPS_INS(BALC, J, .op = MIPS_OP_BALC)
+MIPS_INS(BALC, .op = MIPS_OP_BALC)
 
 /* BC - branch, compact */
 #define MIPS_OP_BC         0b110010
-MIPS_INS(BC, J, .op = MIPS_OP_BC)
+MIPS_INS(BC, .op = MIPS_OP_BC)
 
 /* BEQ - branch on equal */
 #define MIPS_OP_BEQ        0b000100
-MIPS_INS(BEQ, I, .op = MIPS_OP_BEQ)
+MIPS_INS(BEQ, .op = MIPS_OP_BEQ)
 
 /* BEQL - branch on equal likely */
 #define MIPS_OP_BEQL       0b010100
-MIPS_INS(BEQL, I, .op = MIPS_OP_BEQL)
+MIPS_INS(BEQL, .op = MIPS_OP_BEQL)
 
 /* BGEZ - branch on greater than or equal to zero */
 #define MIPS_FUNCT_BGEZ    0b00001
-MIPS_INS(BGEZ, B, .op = MIPS_OP_REGIMM, .funct = MIPS_FUNCT_BGEZ)
+MIPS_INS(BGEZ, .op = MIPS_OP_REGIMM, .bfunct = MIPS_FUNCT_BGEZ)
 
 /* BGEZAL - branch on greater than or equal to zero and link */
 #define MIPS_FUNCT_BGEZAL  0b10001
-MIPS_INS(BGEZAL, B, .op = MIPS_OP_REGIMM, .funct = MIPS_FUNCT_BGEZAL)
+MIPS_INS(BGEZAL, .op = MIPS_OP_REGIMM, .bfunct = MIPS_FUNCT_BGEZAL)
 
 /* BGEZAL - branch on greater than or equal to zero and link likely */
 #define MIPS_FUNCT_BGEZALL 0b10011
-MIPS_INS(BGEZALL, B, .op = MIPS_OP_REGIMM, .funct = MIPS_FUNCT_BGEZALL)
+MIPS_INS(BGEZALL, .op = MIPS_OP_REGIMM, .bfunct = MIPS_FUNCT_BGEZALL)
 
 /* BGEZL - branch on greater than or equal to zero likely */
 #define MIPS_FUNCT_BGEZL   0b00011
-MIPS_INS(BGEZL, B, .op = MIPS_OP_REGIMM, .funct = MIPS_FUNCT_BGEZL)
+MIPS_INS(BGEZL, .op = MIPS_OP_REGIMM, .bfunct = MIPS_FUNCT_BGEZL)
 
 /* BGTZ - branch on greater than zero */
 #define MIPS_OP_BGTZ       0b000111
-MIPS_INS(BGTZ, I, .op = MIPS_OP_BGTZ)
+MIPS_INS(BGTZ, .op = MIPS_OP_BGTZ)
 
 /* BGTZL - branch on greater than zero likely */
 #define MIPS_OP_BGTZL      0b010111
-MIPS_INS(BGTZL, I, .op = MIPS_OP_BGTZL)
+MIPS_INS(BGTZL, .op = MIPS_OP_BGTZL)
 
 /* BLEZ - branch on less than or equal to zero */
 #define MIPS_OP_BLEZ       0b000110
-MIPS_INS(BLEZ, I, .op = MIPS_OP_BLEZ)
+MIPS_INS(BLEZ, .op = MIPS_OP_BLEZ)
 
 /* BLEZL - branch on less than or equal to zero likely */
 #define MIPS_OP_BLEZL      0b010110
-MIPS_INS(BLEZL, I, .op = MIPS_OP_BLEZL)
+MIPS_INS(BLEZL, .op = MIPS_OP_BLEZL)
 
 /* BLTZ - branch on less than zero */
 #define MIPS_FUNCT_BLTZ    0b00000
-MIPS_INS(BLTZ, B, .op = MIPS_OP_REGIMM, .funct = MIPS_FUNCT_BLTZ)
+MIPS_INS(BLTZ, .op = MIPS_OP_REGIMM, .bfunct = MIPS_FUNCT_BLTZ)
 
 /* BLTZAL - branch on less than zero and link */
 #define MIPS_FUNCT_BLTZAL  0b10000
-MIPS_INS(BLTZAL, B, .op = MIPS_OP_REGIMM, .funct = MIPS_FUNCT_BLTZAL)
+MIPS_INS(BLTZAL, .op = MIPS_OP_REGIMM, .bfunct = MIPS_FUNCT_BLTZAL)
 
 /* BLTZALL - branch on less than zero and link likely */
 #define MIPS_FUNCT_BLTZALL 0b10010
-MIPS_INS(BLTZALL, B, .op = MIPS_OP_REGIMM, .funct = MIPS_FUNCT_BLTZALL)
+MIPS_INS(BLTZALL, .op = MIPS_OP_REGIMM, .bfunct = MIPS_FUNCT_BLTZALL)
 
 /* BLTZL - branch on less than zero likely */
 #define MIPS_FUNCT_BLTZL   0b00010
-MIPS_INS(BLTZL, B, .op = MIPS_OP_REGIMM, .funct = MIPS_FUNCT_BLTZL)
+MIPS_INS(BLTZL, .op = MIPS_OP_REGIMM, .bfunct = MIPS_FUNCT_BLTZL)
 
 /* BNE - branch on not equal */
 #define MIPS_OP_BNE        0b000101
-MIPS_INS(BNE, I, .op = MIPS_OP_BNE)
+MIPS_INS(BNE, .op = MIPS_OP_BNE)
 
 /* BNEL - branch on not equal likely */
 #define MIPS_OP_BNEL       0b010101
-MIPS_INS(BNEL, I, .op = MIPS_OP_BNEL)
-
-/* DDIV - doubleword divide */
-#define MIPS_FUNCT_DDIV    0b011110
-MIPS_INS(DDIV, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_DDIV)
-
-/* DDIVU - doubleword divide unsigned */
-#define MIPS_FUNCT_DDIVU   0b011111
-MIPS_INS(DDIVU, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_DDIVU)
+MIPS_INS(BNEL, .op = MIPS_OP_BNEL)
 
 /* DIV - divide */
-#define MIPS_FUNCT_DIV     0b011010
-MIPS_INS(DIV, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_DIV)
+#define MIPS_FUNCT_SOP32   0b011010
+#define MIPS_SOP32_DIV     0b00010
+MIPS_INS(DIV, .op = MIPS_OP_SPECIAL, .shamt = MIPS_SOP32_DIV,
+	 .funct = MIPS_FUNCT_SOP32)
+
+/* MOD - modulo */
+#define MIPS_SOP32_MOD     0b00011
+MIPS_INS(MOD, .op = MIPS_OP_SPECIAL, .shamt = MIPS_SOP32_MOD,
+	 .funct = MIPS_FUNCT_SOP32)
 
 /* DIVU - divide unsigned */
-#define MIPS_FUNCT_DIVU    0b011011
-MIPS_INS(DIVU, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_DIVU)
+#define MIPS_FUNCT_SOP33   0b011011
+#define MIPS_SOP33_DIVU    0b00010
+MIPS_INS(DIVU, .op = MIPS_OP_SPECIAL, .shamt = MIPS_SOP33_DIVU,
+	 .funct = MIPS_FUNCT_SOP33)
+
+/* MODU - modulo unsigned */
+#define MIPS_SOP33_MODU    0b00011
+MIPS_INS(MODU, .op = MIPS_OP_SPECIAL, .shamt = MIPS_SOP33_MODU,
+	 .funct = MIPS_FUNCT_SOP33)
 
 /* J - jump */
 #define MIPS_OP_J          0b000010
-MIPS_INS(J, J, .op = MIPS_OP_J)
+MIPS_INS(J, .op = MIPS_OP_J)
 
 /* JAL - jump and link */
 #define MIPS_OP_JAL        0b000011
-MIPS_INS(JAL, J, .op = MIPS_OP_JAL)
+MIPS_INS(JAL, .op = MIPS_OP_JAL)
 
 /* JALR - jump and link register */
 #define MIPS_FUNCT_JALR    0b001001
-MIPS_INS(JALR, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_JALR)
+MIPS_INS(JALR, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_JALR)
 
 /* JALX - jump and link exchange */
 #define MIPS_OP_JALX       0b011101
-MIPS_INS(JALX, J, .op = MIPS_OP_JALX)
+MIPS_INS(JALX, .op = MIPS_OP_JALX)
 
 /* JR - jump register */
 #define MIPS_FUNCT_JR      0b001000
-MIPS_INS(JR, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_JR)
+MIPS_INS(JR, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_JR)
 
 /* LB - load byte */
 #define MIPS_OP_LB         0b100000
-MIPS_INS(LB, I, .op = MIPS_OP_LB)
+MIPS_INS(LB, .op = MIPS_OP_LB)
 
 /* LBU - load byte unsigned */
 #define MIPS_OP_LBU        0b100100
-MIPS_INS(LBU, I, .op = MIPS_OP_LBU)
+MIPS_INS(LBU, .op = MIPS_OP_LBU)
 
 /* LH - load half */
 #define MIPS_OP_LH         0b100001
-MIPS_INS(LH, I, .op = MIPS_OP_LH)
+MIPS_INS(LH, .op = MIPS_OP_LH)
 
 /* LHU - load half unsigned */
 #define MIPS_OP_LHU        0b100101
-MIPS_INS(LHU, I, .op = MIPS_OP_LHU)
+MIPS_INS(LHU, .op = MIPS_OP_LHU)
 
 /* LUI - load upper immediate */
 #define MIPS_OP_LUI        0b001111
-MIPS_INS(LUI, I, .op = MIPS_OP_LUI)
+MIPS_INS(LUI, .op = MIPS_OP_LUI)
 
 /* LW - load word */
 #define MIPS_OP_LW         0b100011
-MIPS_INS(LW, I, .op = MIPS_OP_LW)
+MIPS_INS(LW, .op = MIPS_OP_LW)
 
 /* LWL - load word left */
 #define MIPS_OP_LWL        0b100010
-MIPS_INS(LWL, I, .op = MIPS_OP_LWL)
+MIPS_INS(LWL, .op = MIPS_OP_LWL)
 
 /* LWR - load word right */
 #define MIPS_OP_LWR        0b100110
-MIPS_INS(LWR, I, .op = MIPS_OP_LWR)
+MIPS_INS(LWR, .op = MIPS_OP_LWR)
 
 /* MFHI - move from hi */
 #define MIPS_FUNCT_MFHI    0b010000
-MIPS_INS(MFHI, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_MFHI)
+MIPS_INS(MFHI, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_MFHI)
 
 /* MFLO - move from hi */
 #define MIPS_FUNCT_MFLO    0b010010
-MIPS_INS(MFLO, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_MFLO)
+MIPS_INS(MFLO, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_MFLO)
 
 /* MTHI - move from hi */
 #define MIPS_FUNCT_MTHI    0b010001
-MIPS_INS(MTHI, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_MTHI)
+MIPS_INS(MTHI, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_MTHI)
 
 /* MTLO - move from hi */
 #define MIPS_FUNCT_MTLO    0b010011
-MIPS_INS(MTLO, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_MTLO)
+MIPS_INS(MTLO, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_MTLO)
 
-/* MULT - multiply */
-#define MIPS_FUNCT_MULT    0b011000
-MIPS_INS(MULT, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_MULT)
+/* MUL - multiply low word */
+#define MIPS_FUNCT_SOP30   0b011000
+#define MIPS_SOP30_MUL     0b00010
+MIPS_INS(MUL, .op = MIPS_OP_SPECIAL, .shamt = MIPS_SOP30_MUL,
+	 .funct = MIPS_FUNCT_SOP30)
+
+/* MUH - multiply high word */
+#define MIPS_SOP30_MUH     0b00011
+MIPS_INS(MUH, .op = MIPS_OP_SPECIAL, .shamt = MIPS_SOP30_MUH,
+	 .funct = MIPS_FUNCT_SOP30)
+
+/* MULU - multiply low word unsigned */
+#define MIPS_FUNCT_SOP31   0b011001
+#define MIPS_SOP31_MULU    0b00010
+MIPS_INS(MULU, .op = MIPS_OP_SPECIAL, .shamt = MIPS_SOP31_MULU,
+	 .funct = MIPS_FUNCT_SOP31)
 
-/* MULTU - multiply unsigned */
-#define MIPS_FUNCT_MULTU   0b011001
-MIPS_INS(MULTU, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_MULTU)
+/* MUHU - multiply high word unsgined */
+#define MIPS_SOP31_MUHU    0b00011
+MIPS_INS(MUHU, .op = MIPS_OP_SPECIAL, .shamt = MIPS_SOP31_MUHU,
+	 .funct = MIPS_FUNCT_SOP31)
+
+/* MULT - multiply (OLD) */
+#define MIPS_FUNCT_MULT    0b011000
+MIPS_INS(MULT, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_MULT)
 
 /* SB - store byte */
 #define MIPS_OP_SB         0b101000
-MIPS_INS(SB, I, .op = MIPS_OP_SB)
+MIPS_INS(SB, .op = MIPS_OP_SB)
 
 /* SH - store half */
 #define MIPS_OP_SH         0b101001
-MIPS_INS(SH, I, .op = MIPS_OP_SH)
+MIPS_INS(SH, .op = MIPS_OP_SH)
 
 /* SW - store word */
 #define MIPS_OP_SW         0b101011
-MIPS_INS(SW, I, .op = MIPS_OP_SW)
+MIPS_INS(SW, .op = MIPS_OP_SW)
 
 /* SWL - store word left */
 #define MIPS_OP_SWL        0b101010
-MIPS_INS(SWL, I, .op = MIPS_OP_SWL)
+MIPS_INS(SWL, .op = MIPS_OP_SWL)
 
 /* SWR - store word right */
 #define MIPS_OP_SWR        0b101110
-MIPS_INS(SWR, I, .op = MIPS_OP_SWR)
+MIPS_INS(SWR, .op = MIPS_OP_SWR)
 
 /* SLL - shift left logical */
 #define MIPS_FUNCT_SLL     0b000000
-MIPS_INS(SLL, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SLL)
+MIPS_INS(SLL, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SLL)
 
 /* SLLV - shift left logical variable */
 #define MIPS_FUNCT_SLLV    0b000100
-MIPS_INS(SLLV, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SLLV)
+MIPS_INS(SLLV, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SLLV)
 
 /* SLT - set less then */
 #define MIPS_FUNCT_SLT     0b101010
-MIPS_INS(SLT, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SLT)
+MIPS_INS(SLT, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SLT)
 
 /* SLTI - set less then immediate */
 #define MIPS_OP_SLTI       0b001010
-MIPS_INS(SLTI, I, .op = MIPS_OP_SLTI)
+MIPS_INS(SLTI, .op = MIPS_OP_SLTI)
 
 /* SLTIU - set less then imemdiate unsigned */
 #define MIPS_OP_SLTIU      0b001011
-MIPS_INS(SLTIU, I, .op = MIPS_OP_SLTIU)
+MIPS_INS(SLTIU, .op = MIPS_OP_SLTIU)
 
 /* SLTU - set less than unsigned */
 #define MIPS_FUNCT_SLTU    0b101011
-MIPS_INS(SLTU, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SLTU)
+MIPS_INS(SLTU, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SLTU)
 
 /* SRA - shift right arithmetic */
 #define MIPS_FUNCT_SRA     0b000011
-MIPS_INS(SRA, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SRA)
+MIPS_INS(SRA, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SRA)
 
 /* SRAV - shift right arithmetic variable */
 #define MIPS_FUNCT_SRAV    0b000111
-MIPS_INS(SRAV, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SRAV)
+MIPS_INS(SRAV, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SRAV)
 
 /* SRL - shift right logical */
 #define MIPS_FUNCT_SRL     0b000010
-MIPS_INS(SRL, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SRL)
+MIPS_INS(SRL, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SRL)
 
 /* SRLV - shift right logical variable */
 #define MIPS_FUNCT_SRLV    0b000110
-MIPS_INS(SRLV, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SRLV)
+MIPS_INS(SRLV, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SRLV)
 
 /* SUB - subtract */
 #define MIPS_FUNCT_SUB     0b100010
-MIPS_INS(SUB, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SUB)
+MIPS_INS(SUB, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SUB)
 
 /* SUBU - subtract unsigned */
 #define MIPS_FUNCT_SUBU    0b100011
-MIPS_INS(SUBU, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SUBU)
+MIPS_INS(SUBU, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SUBU)
 
 /* SYSCALL - syscall */
 #define MIPS_FUNCT_SYSCALL 0b001100
-MIPS_INS(SYSCALL, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SYSCALL)
+MIPS_INS(SYSCALL, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_SYSCALL)
 
 /* OR - or */
 #define MIPS_FUNCT_OR      0b100101
-MIPS_INS(OR, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_OR)
+MIPS_INS(OR, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_OR)
 
 /* ORI - or imemdiate */
 #define MIPS_OP_ORI        0b001101
-MIPS_INS(ORI, I, .op = MIPS_OP_ORI)
+MIPS_INS(ORI, .op = MIPS_OP_ORI)
 
 /* NOR - not or */
 #define MIPS_FUNCT_NOR     0b100111
-MIPS_INS(NOR, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_NOR)
+MIPS_INS(NOR, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_NOR)
 
 /* XOR - exclusive or */
 #define MIPS_FUNCT_XOR     0b100110
-MIPS_INS(XOR, R, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_XOR)
+MIPS_INS(XOR, .op = MIPS_OP_SPECIAL, .funct = MIPS_FUNCT_XOR)
 
 /* XORI - exclusive or immediate */
 #define MIPS_OP_XORI       0b001110
-MIPS_INS(XORI, I, .op = MIPS_OP_XORI)
+MIPS_INS(XORI, .op = MIPS_OP_XORI)
 };
 
 #undef MIPS_INS