Merge pull request #11 from Decompollaborate/develop

1.3.0:

Makefile

@@ -3,26 +3,35 @@ DEBUG           ?= 0
 WERROR          ?= 0
 ASAN            ?= 0
 EXPERIMENTAL    ?= 0
+SANITY_CHECKS   ?= 1
 
 CC              := clang
+CXX             := clang++
 AR              := ar
 IINC            := -I include
+IINC_XX         := -I include -I cplusplus/include
 CSTD            := -std=c11
+CXXSTD          := -std=c++17
 CFLAGS          := -fPIC
+CXXFLAGS        := -fPIC
 LDFLAGS         := -Lbuild -lrabbitizer
+LDXXFLAGS       := -Lbuild -lrabbitizerpp
 WARNINGS        := -Wall -Wextra -Wpedantic
 # WARNINGS        := -Wall -Wextra -Wpedantic -Wpadded
-WARNINGS        += -Werror=implicit-function-declaration -Werror=incompatible-pointer-types -Werror=vla -Werror=switch -Werror=implicit-fallthrough -Werror=unused-function -Werror=unused-parameter -Werror=shadow
+WARNINGS        += -Werror=vla -Werror=switch -Werror=implicit-fallthrough -Werror=unused-function -Werror=unused-parameter -Werror=shadow
+WARNINGS_C      := -Werror=implicit-function-declaration -Werror=incompatible-pointer-types
+WARNINGS_CXX    :=
 
 ifeq ($(CC),gcc)
     WARNINGS    += -Wno-cast-function-type
 endif
 
 ifeq ($(DEBUG),0)
-	OPTFLAGS    := -O2 -g
+	OPTFLAGS    := -Os -g
 else
 	OPTFLAGS    := -O0 -g3
 	CFLAGS      += -DDEVELOPMENT=1
+	CXXFLAGS    += -DDEVELOPMENT=1
 endif
 
 ifneq ($(WERROR),0)
@@ -31,10 +40,17 @@ endif
 
 ifneq ($(ASAN),0)
 	CFLAGS      += -fsanitize=address -fsanitize=pointer-compare -fsanitize=pointer-subtract -fsanitize=undefined
+	CXXFLAGS    += -fsanitize=address -fsanitize=pointer-compare -fsanitize=pointer-subtract -fsanitize=undefined
 endif
 
 ifneq ($(EXPERIMENTAL),0)
 	CFLAGS      += -DEXPERIMENTAL
+	CXXFLAGS    += -DEXPERIMENTAL
+endif
+
+ifneq ($(SANITY_CHECKS),0)
+	CFLAGS      += -DRAB_SANITY_CHECKS=1
+	CXXFLAGS    += -DRAB_SANITY_CHECKS=1
 endif
 
 
@@ -42,21 +58,44 @@ SRC_DIRS        := $(shell find src -type d)
 C_FILES         := $(foreach dir,$(SRC_DIRS),$(wildcard $(dir)/*.c))
 H_FILES         := $(foreach dir,$(IINC),$(wildcard $(dir)/**/*.h))
 O_FILES         := $(foreach f,$(C_FILES:.c=.o),build/$f)
-DEP_FILES       := $(O_FILES:%.o=%.d)
+
+SRCXX_DIRS      := $(shell find cplusplus/src -type d)
+CXX_FILES       := $(foreach dir,$(SRCXX_DIRS),$(wildcard $(dir)/*.cpp))
+HXX_FILES       := $(foreach dir,$(IINC_XX),$(wildcard $(dir)/**/*.hpp))
+OXX_FILES       := $(foreach f,$(CXX_FILES:.cpp=.o),build/$f)
+
+DEP_FILES       := $(O_FILES:%.o=%.d) $(OXX_FILES:%.o=%.d)
+
+TESTS_DIRS      := $(shell find tests -type d)
+TESTS_C         := $(foreach dir,$(TESTS_DIRS),$(wildcard $(dir)/*.c))
+TESTS_CXX       := $(foreach dir,$(TESTS_DIRS),$(wildcard $(dir)/*.cpp))
+TESTS_ELFS      := $(foreach f,$(TESTS_C:.c=.elf) $(TESTS_CXX:.cpp=.elf),build/$f)
 
 STATIC_LIB      := build/librabbitizer.a
 DYNAMIC_LIB     := build/librabbitizer.so
 
+STATIC_LIB_XX   := build/librabbitizerpp.a
+DYNAMIC_LIB_XX  := build/librabbitizerpp.so
+
 # create build directories
-$(shell mkdir -p $(foreach dir,$(SRC_DIRS),build/$(dir)))
+$(shell mkdir -p $(foreach dir,$(SRC_DIRS) $(SRCXX_DIRS) $(TESTS_DIRS),build/$(dir)))
+
+
+# Dependencies of libraries
+
+$(STATIC_LIB):  $(O_FILES)
+$(DYNAMIC_LIB): $(O_FILES)
+
+$(STATIC_LIB_XX):  $(O_FILES) $(OXX_FILES)
+$(DYNAMIC_LIB_XX): $(O_FILES) $(OXX_FILES)
 
 
 #### Main Targets ###
 
 all: static tests
 
-static: $(STATIC_LIB)
-dynamic: $(DYNAMIC_LIB)
+static: $(STATIC_LIB) $(STATIC_LIB_XX)
+dynamic: $(DYNAMIC_LIB) $(DYNAMIC_LIB_XX)
 
 clean:
 	$(RM) -rf build
@@ -66,11 +105,12 @@ distclean: clean
 
 format:
 	clang-format-11 -i -style=file $(C_FILES)
+	clang-format-11 -i -style=file $(CXX_FILES)
 
 tidy:
-	clang-tidy-11 -p . --fix --fix-errors $(C_FILES) $(H_FILES) -- $(CSTD) $(OPTFLAGS) $(IINC) $(WARNINGS) $(CFLAGS)
+	clang-tidy-11 -p . --fix --fix-errors $(C_FILES) $(H_FILES) -- $(CSTD) $(OPTFLAGS) $(IINC) $(WARNINGS) $(WARNINGS_C) $(CFLAGS)
 
-tests: build/test.elf build/rsptest.elf build/r5900test.elf build/registersTrackerTest.elf
+tests: $(TESTS_ELFS)
 
 .PHONY: all clean distclean format tidy tests
 .DEFAULT_GOAL := all
@@ -80,17 +120,27 @@ tests: build/test.elf build/rsptest.elf build/r5900test.elf build/registersTrack
 #### Various Recipes ####
 
 build/%.elf: %.c | $(STATIC_LIB)
-	$(CC) -MMD $(CSTD) $(OPTFLAGS) $(IINC) $(WARNINGS) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+	$(CC) -MMD $(CSTD) $(OPTFLAGS) $(IINC) $(WARNINGS) $(WARNINGS_C) $(CFLAGS) -o $@ $^ $(LDFLAGS)
 
-build/%.a: $(O_FILES)
+build/%.elf: %.cpp | $(STATIC_LIB_XX)
+	$(CXX) -MMD $(CXXSTD) $(OPTFLAGS) $(IINC_XX) $(WARNINGS) $(WARNINGS_CXX) $(CXXFLAGS) -o $@ $^ $(LDXXFLAGS)
+
+build/%.a:
 	$(AR) rcs $@ $^
 
-build/%.so: $(O_FILES)
+build/%.so:
 	$(CC) -shared -o $@ $^
 
 build/%.o: %.c
 #	The -MMD flags additionaly creates a .d file with the same name as the .o file.
-	$(CC) -MMD -c $(CSTD) $(OPTFLAGS) $(IINC) $(WARNINGS) $(CFLAGS) -o $@ $<
+	$(CC) -MMD -c $(CSTD) $(OPTFLAGS) $(IINC) $(WARNINGS) $(WARNINGS_C) $(CFLAGS) -o $@ $<
+
+build/%.o: %.cpp
+#	The -MMD flags additionaly creates a .d file with the same name as the .o file.
+	$(CXX) -MMD -c $(CXXSTD) $(OPTFLAGS) $(IINC_XX) $(WARNINGS) $(WARNINGS_CXX) $(CXXFLAGS) -o $@ $<
 
 
 -include $(DEP_FILES)
+
+# Print target for debugging
+print-% : ; $(info $* is a $(flavor $*) variable set to [$($*)]) @true

cplusplus/include/analysis/LoPairingInfo.hpp

@@ -0,0 +1,36 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#ifndef RABBITIZER_LO_PAIRING_INFO_HPP
+#define RABBITIZER_LO_PAIRING_INFO_HPP
+#pragma once
+
+#include "analysis/RabbitizerLoPairingInfo.h"
+
+
+namespace rabbitizer {
+    class LoPairingInfo {
+    protected:
+        RabbitizerLoPairingInfo pairingInfo;
+
+    public:
+        LoPairingInfo();
+        LoPairingInfo(const RabbitizerLoPairingInfo &pairingInfo);
+
+        /**
+         * Returns a pointer to the inner RabbitizerLoPairingInfo.
+         * It is recommended to not mess with it unless you know what you are doing.
+         */
+        RabbitizerLoPairingInfo *getCPtr();
+        const RabbitizerLoPairingInfo *getCPtr() const;
+
+        int getInstrOffset() const;
+        int64_t getValue() const;
+        bool shouldProcess() const;
+        bool isGpRel() const;
+        bool isGpGot() const;
+    };
+};
+
+
+#endif

cplusplus/include/analysis/RegistersTracker.hpp

@@ -0,0 +1,49 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#ifndef RABBITIZER_REGISTERS_TRACKER_HPP
+#define RABBITIZER_REGISTERS_TRACKER_HPP
+#pragma once
+
+#include "analysis/RabbitizerRegistersTracker.h"
+
+#include "analysis/LoPairingInfo.hpp"
+#include "instructions/InstructionBase.hpp"
+
+
+namespace rabbitizer {
+    class RegistersTracker {
+    protected:
+        RabbitizerRegistersTracker tracker;
+
+    public:
+        RegistersTracker();
+        RegistersTracker(const RegistersTracker &other);
+        virtual ~RegistersTracker();
+
+        /**
+         * Returns a pointer to the inner RabbitizerRegistersTracker.
+         * It is recommended to not mess with it unless you know what you are doing.
+         */
+        RabbitizerRegistersTracker *getCPtr();
+        const RabbitizerRegistersTracker *getCPtr() const;
+
+        bool moveRegisters(const InstructionBase &instr);
+        void overwriteRegisters(const InstructionBase &instr, int instrOffset);
+        void unsetRegistersAfterFuncCall(const InstructionBase &instr, const InstructionBase &prevInstr);
+        bool getAddressIfCanSetType(const InstructionBase &instr, int instrOffset, uint32_t *dstAddress) const;
+        bool getJrInfo(const InstructionBase &instr, int *dstOffset, uint32_t *dstAddress) const;
+
+        void processLui(const InstructionBase &instr, int instrOffset);
+        void processLui(const InstructionBase &instr, int instrOffset, const InstructionBase &prevInstr);
+        void processGpLoad(const InstructionBase &instr, int instrOffset);
+        bool getLuiOffsetForConstant(const InstructionBase &instr, int *dstOffset) const;
+        void processConstant(const InstructionBase &instr, uint32_t value, int offset);
+        LoPairingInfo preprocessLoAndGetInfo(const InstructionBase &instr, int instrOffset);
+        void processLo(const InstructionBase &instr, uint32_t value, int offset);
+        bool hasLoButNoHi(const InstructionBase &instr) const;
+    };
+};
+
+
+#endif

cplusplus/include/instructions/AccessType.hpp

@@ -0,0 +1,22 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#ifndef RABBITIZER_ACCESS_TYPE_HPP
+#define RABBITIZER_ACCESS_TYPE_HPP
+#pragma once
+
+
+namespace rabbitizer {
+    #define RAB_DEF_ACCESSTYPE(name) name,
+
+    enum class AccessType {
+        #include "instructions/AccessType.inc"
+
+        RAB_DEF_ACCESSTYPE(MAX)
+    };
+
+    #undef RAB_DEF_ACCESSTYPE
+};
+
+
+#endif

cplusplus/include/instructions/InstrId.hpp

@@ -0,0 +1,38 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#ifndef RABBITIZER_INSTRID_HPP
+#define RABBITIZER_INSTRID_HPP
+#pragma once
+
+#include <string>
+
+
+namespace rabbitizer {
+    namespace InstrId {
+        #define RABBITIZER_DEF_INSTR_ID(prefix, caseBits, name, ...) \
+            prefix##_##name,
+
+        #define RABBITIZER_DEF_INSTR_ID_ALTNAME(prefix, caseBits, name, altname, ...) \
+            RABBITIZER_DEF_INSTR_ID(prefix, caseBits, name, __VA_ARGS__)
+
+        enum class UniqueId {
+            #include "instructions/instr_id/RabbitizerInstrId_cpu.inc"
+
+            #include "instructions/instr_id/RabbitizerInstrId_rsp.inc"
+
+            #include "instructions/instr_id/RabbitizerInstrId_r5900.inc"
+
+            ALL_MAX = RABBITIZER_DEF_INSTR_ID(r5900, , MAX, )
+        };
+
+        #undef RABBITIZER_DEF_INSTR_ID
+        #undef RABBITIZER_DEF_INSTR_ID_ALTNAME
+
+
+        std::string getOpcodeName(UniqueId uniqueId);
+    };
+};
+
+
+#endif

cplusplus/include/instructions/InstructionBase.hpp

@@ -0,0 +1,267 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#ifndef RABBITIZER_INSTRUCTION_BASE_HPP
+#define RABBITIZER_INSTRUCTION_BASE_HPP
+#pragma once
+
+#include <string>
+#include <string_view>
+
+#include "instructions/RabbitizerInstruction.h"
+
+#include "instructions/Registers.hpp"
+#include "instructions/OperandType.hpp"
+#include "instructions/InstrId.hpp"
+#include "instructions/AccessType.hpp"
+
+
+namespace rabbitizer {
+    class InstructionBase {
+    protected:
+        RabbitizerInstruction instr;
+
+        InstructionBase() = default;
+        virtual ~InstructionBase() = default;
+
+    public:
+        /**
+         * Returns a pointer to the inner RabbitizerInstruction.
+         * It is recommended to not mess with it unless you know what you are doing.
+         */
+        RabbitizerInstruction *getCPtr();
+        const RabbitizerInstruction *getCPtr() const;
+
+        /* getters */
+
+        uint8_t Get_opcode() const;
+        uint8_t Get_sa() const;
+        uint8_t Get_function() const;
+
+        Registers::Cpu::GprO32 GetO32_rs() const;
+        Registers::Cpu::GprO32 GetO32_rt() const;
+        Registers::Cpu::GprO32 GetO32_rd() const;
+
+        Registers::Cpu::GprN32 GetN32_rs() const;
+        Registers::Cpu::GprN32 GetN32_rt() const;
+        Registers::Cpu::GprN32 GetN32_rd() const;
+
+        Registers::Cpu::Cop0 Get_cop0d() const;
+
+        uint32_t Get_instr_index() const;
+        uint16_t Get_immediate() const;
+
+        Registers::Cpu::Cop1O32 GetO32_fs() const;
+        Registers::Cpu::Cop1O32 GetO32_ft() const;
+        Registers::Cpu::Cop1O32 GetO32_fd() const;
+
+        Registers::Cpu::Cop1N32 GetN32_fs() const;
+        Registers::Cpu::Cop1N32 GetN32_ft() const;
+        Registers::Cpu::Cop1N32 GetN32_fd() const;
+
+        Registers::Cpu::Cop1N64 GetN64_fs() const;
+        Registers::Cpu::Cop1N64 GetN64_ft() const;
+        Registers::Cpu::Cop1N64 GetN64_fd() const;
+
+        Registers::Cpu::Cop1Control Get_cop1cs() const;
+
+        Registers::Cpu::Cop2 Get_cop2t() const;
+
+        uint8_t Get_op() const;
+
+        uint32_t Get_code() const;
+        uint32_t Get_code_upper() const;
+        uint32_t Get_code_lower() const;
+
+        uint32_t Get_copraw() const;
+
+        uint8_t Get_fmt() const;
+        uint8_t Get_fc() const;
+        uint8_t Get_cond() const;
+
+        uint8_t Get_tf() const;
+        uint8_t Get_nd() const;
+        uint8_t Get_bc_fmt() const;
+
+        uint8_t Get_stype() const;
+
+        /* getters */
+
+
+        /* setters */
+
+        void Set_opcode(uint8_t val);
+        void Set_sa(uint8_t val);
+        void Set_function(uint8_t val);
+
+        void Set_rs(Registers::Cpu::GprO32 val);
+        void Set_rt(Registers::Cpu::GprO32 val);
+        void Set_rd(Registers::Cpu::GprO32 val);
+
+        void Set_rs(Registers::Cpu::GprN32 val);
+        void Set_rt(Registers::Cpu::GprN32 val);
+        void Set_rd(Registers::Cpu::GprN32 val);
+
+        void Set_cop0d(Registers::Cpu::Cop0 val);
+
+        void Set_instr_index(uint32_t val);
+        void Set_immediate(uint16_t val);
+
+        void Set_fs(Registers::Cpu::Cop1O32 val);
+        void Set_ft(Registers::Cpu::Cop1O32 val);
+        void Set_fd(Registers::Cpu::Cop1O32 val);
+
+        void Set_fs(Registers::Cpu::Cop1N32 val);
+        void Set_ft(Registers::Cpu::Cop1N32 val);
+        void Set_fd(Registers::Cpu::Cop1N32 val);
+
+        void Set_fs(Registers::Cpu::Cop1N64 val);
+        void Set_ft(Registers::Cpu::Cop1N64 val);
+        void Set_fd(Registers::Cpu::Cop1N64 val);
+
+        void Set_cop1cs(Registers::Cpu::Cop1Control val);
+
+        void Set_cop2t(Registers::Cpu::Cop2 val);
+
+        void Set_op(uint8_t val);
+
+        void Set_code(uint32_t val);
+        void Set_code_upper(uint32_t val);
+        void Set_code_lower(uint32_t val);
+
+        void Set_copraw(uint32_t val);
+
+        void Set_fmt(uint8_t val);
+        void Set_fc(uint8_t val);
+        void Set_cond(uint8_t val);
+
+        void Set_tf(uint8_t val);
+        void Set_nd(uint8_t val);
+        void Set_bc_fmt(uint8_t val);
+
+        void Set_stype(uint8_t val);
+
+        /* setters */
+
+
+        /* more getters */
+
+        uint32_t getRaw() const;
+
+        InstrId::UniqueId getUniqueId() const;
+        uint32_t getVram() const;
+        bool isInHandwrittenFunction() const;
+
+        int32_t getProcessedImmediate() const;
+        uint32_t getInstrIndexAsVram() const;
+
+        int32_t getBranchOffset() const;
+        //! @deprecated
+        int32_t getGenericBranchOffset(uint32_t currentVram) const;
+        int32_t getBranchOffsetGeneric() const;
+        int32_t getBranchVramGeneric() const;
+        int8_t getDestinationGpr() const;
+
+
+        std::string getOpcodeName() const;
+
+        /* more getters */
+
+
+        /* */
+
+        void blankOut();
+
+
+        /* Instruction examination */
+
+        bool isImplemented() const;
+        bool isLikelyHandwritten() const;
+        bool isNop() const;
+        bool isUnconditionalBranch() const;
+        bool isJrRa() const;
+        bool isJrNotRa() const;
+        bool hasDelaySlot() const;
+
+        //! @deprecated
+        std::string mapInstrToType() const;
+
+        bool sameOpcode(const InstructionBase &other) const;
+        bool sameOpcodeButDifferentArguments(const InstructionBase &other) const;
+
+        bool hasOperand(OperandType operand) const;
+        bool hasOperandAlias(OperandType operand) const;
+
+        uint32_t getValidBits() const;
+        bool isValid() const;
+
+        /* Instruction examination */
+
+
+        /* Instruction descriptor */
+
+        bool isUnknownType() const;
+        bool isJType() const;
+        bool isIType() const;
+        bool isRType() const;
+        bool isRegimmType() const;
+
+        // TODO
+        // RabbitizerInstrSuffix instrSuffix() const;
+
+        bool isBranch() const;
+        bool isBranchLikely() const;
+        bool isJump() const;
+        bool isJumpWithAddress() const;
+        bool isTrap() const;
+
+        bool isFloat() const;
+        bool isDouble() const;
+
+        bool isUnsigned() const;
+
+        bool modifiesRt() const;
+        bool modifiesRd() const;
+
+        bool readsHI() const;
+        bool readsLO() const;
+        bool modifiesHI() const;
+        bool modifiesLO() const;
+
+        bool notEmitedByCompilers() const;
+
+        bool canBeHi() const;
+        bool canBeLo() const;
+        bool doesLink() const;
+        bool doesDereference() const;
+        bool doesLoad() const;
+        bool doesStore() const;
+        bool maybeIsMove() const;
+
+        bool isPseudo() const;
+
+        AccessType getAccessType() const;
+
+        /* Instruction descriptor */
+
+
+        /* Disassembly */
+
+        bool mustDisasmAsData() const;
+
+        std::string disassembleOperands() const;
+        std::string disassembleOperands(std::string_view immOverride) const;
+
+        std::string disassembleInstruction(int extraLJust) const;
+        std::string disassembleInstruction(int extraLJust, std::string_view immOverride) const;
+
+        std::string disassembleAsData(int extraLJust) const;
+
+        std::string disassemble(int extraLJust) const;
+        std::string disassemble(int extraLJust, std::string_view immOverride) const;
+
+        /* Disassembly */
+    };
+};
+
+#endif

cplusplus/include/instructions/InstructionCpu.hpp

@@ -0,0 +1,20 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#ifndef RABBITIZER_INSTRUCTION_CPU_HPP
+#define RABBITIZER_INSTRUCTION_CPU_HPP
+#pragma once
+
+#include "InstructionBase.hpp"
+
+
+namespace rabbitizer {
+    class InstructionCpu : public InstructionBase {
+    public:
+        InstructionCpu(uint32_t word, uint32_t vram);
+        virtual ~InstructionCpu();
+    };
+};
+
+
+#endif

cplusplus/include/instructions/InstructionR5900.hpp

@@ -0,0 +1,41 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#ifndef RABBITIZER_INSTRUCTION_R5900_HPP
+#define RABBITIZER_INSTRUCTION_R5900_HPP
+#pragma once
+
+#include "InstructionBase.hpp"
+
+
+namespace rabbitizer {
+    class InstructionR5900 : public InstructionBase {
+    public:
+        InstructionR5900(uint32_t word, uint32_t vram);
+        virtual ~InstructionR5900();
+
+        Registers::R5900::VF GetR5900_vfs() const;
+        Registers::R5900::VF GetR5900_vft() const;
+        Registers::R5900::VF GetR5900_vfd() const;
+
+        Registers::R5900::VI GetR5900_vis() const;
+        Registers::R5900::VI GetR5900_vit() const;
+        Registers::R5900::VI GetR5900_vid() const;
+
+        uint8_t GetR5900_mmi_function() const;
+        uint8_t GetR5900_fhi_flo() const;
+
+        uint8_t GetR5900_xyzw_x() const;
+        uint8_t GetR5900_xyzw_y() const;
+        uint8_t GetR5900_xyzw_z() const;
+        uint8_t GetR5900_xyzw_w() const;
+        uint8_t GetR5900_n() const;
+        uint8_t GetR5900_l() const;
+        uint8_t GetR5900_m() const;
+
+        uint8_t GetR5900_imm5() const;
+    };
+};
+
+
+#endif

cplusplus/include/instructions/InstructionRsp.hpp

@@ -0,0 +1,40 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#ifndef RABBITIZER_INSTRUCTION_RSP_HPP
+#define RABBITIZER_INSTRUCTION_RSP_HPP
+#pragma once
+
+#include "InstructionBase.hpp"
+
+
+namespace rabbitizer {
+    class InstructionRsp : public InstructionBase {
+    public:
+        InstructionRsp(uint32_t word, uint32_t vram);
+        virtual ~InstructionRsp();
+
+        Registers::Rsp::Gpr GetRsp_rs() const;
+        Registers::Rsp::Gpr GetRsp_rt() const;
+        Registers::Rsp::Gpr GetRsp_rd() const;
+
+        Registers::Rsp::Cop0 GetRsp_cop0d() const;
+
+        Registers::Rsp::Cop2 GetRsp_cop2t() const;
+
+        Registers::Rsp::Cop2Control GetRsp_cop2cd() const;
+
+        Registers::Rsp::Vector GetRsp_vs() const;
+        Registers::Rsp::Vector GetRsp_vt() const;
+        Registers::Rsp::Vector GetRsp_vd() const;
+
+        uint8_t GetRsp_elementhigh() const;
+        uint8_t GetRsp_elementlow() const;
+
+        uint8_t GetRsp_index() const;
+        uint8_t GetRsp_de() const;
+    };
+};
+
+
+#endif

cplusplus/include/instructions/OperandType.hpp

@@ -0,0 +1,27 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#ifndef RABBITIZER_OPERAND_TYPE_HPP
+#define RABBITIZER_OPERAND_TYPE_HPP
+#pragma once
+
+
+namespace rabbitizer {
+    #define RAB_DEF_OPERAND(prefix, operand) \
+        prefix##_##operand,
+
+    enum class OperandType {
+        RAB_DEF_OPERAND(ALL, INVALID)
+
+    #include "instructions/operands/RabbitizerOperandType_cpu.inc"
+    #include "instructions/operands/RabbitizerOperandType_rsp.inc"
+    #include "instructions/operands/RabbitizerOperandType_r5900.inc"
+
+        RAB_DEF_OPERAND(ALL, MAX)
+    };
+
+    #undef RAB_DEF_OPERAND
+};
+
+
+#endif

cplusplus/include/instructions/Registers.hpp

@@ -0,0 +1,94 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#ifndef RABBITIZER_REGISTER_HPP
+#define RABBITIZER_REGISTER_HPP
+#pragma once
+
+
+namespace rabbitizer {
+
+    namespace Registers {
+    #define RABBITIZER_DEF_REG(prefix, name, numeric) \
+        prefix##_##name
+
+    #define RABBITIZER_DEF_REG_NODOLLAR(prefix, name, numeric) \
+        prefix##_##name
+
+        namespace Cpu {
+            enum class GprO32 {
+                #include "instructions/registers/RabbitizerRegister_GprO32.inc"
+            };
+
+            enum class GprN32 {
+                #include "instructions/registers/RabbitizerRegister_GprN32.inc"
+            };
+
+
+            enum class Cop0 {
+                #include "instructions/registers/RabbitizerRegister_Cop0.inc"
+            };
+
+            // Float registers
+            enum class Cop1O32 {
+                #include "instructions/registers/RabbitizerRegister_Cop1O32.inc"
+            };
+
+            enum class Cop1N32 {
+                #include "instructions/registers/RabbitizerRegister_Cop1N32.inc"
+            };
+
+            enum class Cop1N64 {
+                #include "instructions/registers/RabbitizerRegister_Cop1N64.inc"
+            };
+
+            enum class Cop1Control {
+                #include "instructions/registers/RabbitizerRegister_Cop1Control.inc"
+            };
+
+            enum class Cop2 {
+                #include "instructions/registers/RabbitizerRegister_Cop2.inc"
+            };
+        };
+
+
+        namespace Rsp {
+            enum class Gpr {
+                #include "instructions/registers/RabbitizerRegister_RspGpr.inc"
+            };
+
+            enum class Cop0 {
+                #include "instructions/registers/RabbitizerRegister_RspCop0.inc"
+            };
+
+            enum class Cop2 {
+                #include "instructions/registers/RabbitizerRegister_RspCop2.inc"
+            };
+
+            enum class Cop2Control {
+                #include "instructions/registers/RabbitizerRegister_RspCop2Control.inc"
+            };
+
+            enum class Vector {
+                #include "instructions/registers/RabbitizerRegister_RspVector.inc"
+            };
+        };
+
+
+        namespace R5900 {
+            enum class VF {
+                #include "instructions/registers/RabbitizerRegister_R5900VF.inc"
+            };
+
+            enum class VI {
+                #include "instructions/registers/RabbitizerRegister_R5900VI.inc"
+            };
+        };
+
+    #undef RABBITIZER_DEF_REG
+    #undef RABBITIZER_DEF_REG_NODOLLAR
+    };
+};
+
+
+#endif

cplusplus/include/rabbitizer.hpp

@@ -0,0 +1,26 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#ifndef RABBITIZER_HPP
+#define RABBITIZER_HPP
+#pragma once
+
+
+#include "common/RabbitizerVersion.h"
+#include "common/RabbitizerConfig.h"
+
+#include "instructions/OperandType.hpp"
+#include "instructions/InstrId.hpp"
+//#include "instructions/InstrSuffix.hpp"
+//#include "instructions/InstrDescriptor.hpp"
+#include "instructions/Registers.hpp"
+#include "instructions/InstructionBase.hpp"
+#include "instructions/InstructionCpu.hpp"
+#include "instructions/InstructionRsp.hpp"
+#include "instructions/InstructionR5900.hpp"
+
+#include "analysis/LoPairingInfo.hpp"
+#include "analysis/RegistersTracker.hpp"
+
+
+#endif

cplusplus/src/analysis/LoPairingInfo.cpp

@@ -0,0 +1,34 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#include "analysis/LoPairingInfo.hpp"
+
+using namespace rabbitizer;
+
+LoPairingInfo::LoPairingInfo() : pairingInfo{} {
+}
+LoPairingInfo::LoPairingInfo(const RabbitizerLoPairingInfo &newPairingInfo) : pairingInfo{ newPairingInfo } {
+}
+
+RabbitizerLoPairingInfo *LoPairingInfo::getCPtr() {
+    return &this->pairingInfo;
+}
+const RabbitizerLoPairingInfo *LoPairingInfo::getCPtr() const {
+    return &this->pairingInfo;
+}
+
+int LoPairingInfo::getInstrOffset() const {
+    return this->pairingInfo.instrOffset;
+}
+int64_t LoPairingInfo::getValue() const {
+    return this->pairingInfo.value;
+}
+bool LoPairingInfo::shouldProcess() const {
+    return this->pairingInfo.shouldProcess;
+}
+bool LoPairingInfo::isGpRel() const {
+    return this->pairingInfo.isGpRel;
+}
+bool LoPairingInfo::isGpGot() const {
+    return this->pairingInfo.isGpGot;
+}

cplusplus/src/analysis/RegistersTracker.cpp

@@ -0,0 +1,64 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#include "analysis/RegistersTracker.hpp"
+
+using namespace rabbitizer;
+
+RegistersTracker::RegistersTracker() {
+    RabbitizerRegistersTracker_init(&this->tracker, NULL);
+}
+RegistersTracker::RegistersTracker(const RegistersTracker &other) {
+    RabbitizerRegistersTracker_init(&this->tracker, &other.tracker);
+}
+RegistersTracker::~RegistersTracker() {
+    RabbitizerRegistersTracker_destroy(&this->tracker);
+}
+
+RabbitizerRegistersTracker *RegistersTracker::getCPtr() {
+    return &this->tracker;
+}
+const RabbitizerRegistersTracker *RegistersTracker::getCPtr() const {
+    return &this->tracker;
+}
+
+bool RegistersTracker::moveRegisters(const InstructionBase &instr) {
+    return RabbitizerRegistersTracker_moveRegisters(&this->tracker, instr.getCPtr());
+}
+void RegistersTracker::overwriteRegisters(const InstructionBase &instr, int instrOffset) {
+    RabbitizerRegistersTracker_overwriteRegisters(&this->tracker, instr.getCPtr(), instrOffset);
+}
+void RegistersTracker::unsetRegistersAfterFuncCall(const InstructionBase &instr, const InstructionBase &prevInstr) {
+    RabbitizerRegistersTracker_unsetRegistersAfterFuncCall(&this->tracker, instr.getCPtr(), prevInstr.getCPtr());
+}
+bool RegistersTracker::getAddressIfCanSetType(const InstructionBase &instr, int instrOffset, uint32_t *dstAddress) const {
+    return RabbitizerRegistersTracker_getAddressIfCanSetType(&this->tracker, instr.getCPtr(), instrOffset, dstAddress);
+}
+bool RegistersTracker::getJrInfo(const InstructionBase &instr, int *dstOffset, uint32_t *dstAddress) const {
+    return RabbitizerRegistersTracker_getJrInfo(&this->tracker, instr.getCPtr(), dstOffset, dstAddress);
+}
+
+void RegistersTracker::processLui(const InstructionBase &instr, int instrOffset) {
+    RabbitizerRegistersTracker_processLui(&this->tracker, instr.getCPtr(), instrOffset, NULL);
+}
+void RegistersTracker::processLui(const InstructionBase &instr, int instrOffset, const InstructionBase &prevInstr) {
+    RabbitizerRegistersTracker_processLui(&this->tracker, instr.getCPtr(), instrOffset, prevInstr.getCPtr());
+}
+void RegistersTracker::processGpLoad(const InstructionBase &instr, int instrOffset) {
+    RabbitizerRegistersTracker_processGpLoad(&this->tracker, instr.getCPtr(), instrOffset);
+}
+bool RegistersTracker::getLuiOffsetForConstant(const InstructionBase &instr, int *dstOffset) const {
+    return RabbitizerRegistersTracker_getLuiOffsetForConstant(&this->tracker, instr.getCPtr(), dstOffset);
+}
+void RegistersTracker::processConstant(const InstructionBase &instr, uint32_t value, int offset) {
+    RabbitizerRegistersTracker_processConstant(&this->tracker, instr.getCPtr(), value, offset);
+}
+LoPairingInfo RegistersTracker::preprocessLoAndGetInfo(const InstructionBase &instr, int instrOffset) {
+    return RabbitizerRegistersTracker_preprocessLoAndGetInfo(&this->tracker, instr.getCPtr(), instrOffset);
+}
+void RegistersTracker::processLo(const InstructionBase &instr, uint32_t value, int offset) {
+    RabbitizerRegistersTracker_processLo(&this->tracker, instr.getCPtr(), value, offset);
+}
+bool RegistersTracker::hasLoButNoHi(const InstructionBase &instr) const {
+    return RabbitizerRegistersTracker_hasLoButNoHi(&this->tracker, instr.getCPtr());
+}

cplusplus/src/instructions/InstrId.cpp

@@ -0,0 +1,14 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#include "instructions/InstrId.hpp"
+
+#include "instructions/RabbitizerInstrId.h"
+
+using namespace rabbitizer;
+
+std::string InstrId::getOpcodeName(InstrId::UniqueId uniqueId) {
+    RabbitizerInstrId id = static_cast<RabbitizerInstrId>(uniqueId);
+
+    return std::string(RabbitizerInstrId_getOpcodeName(id));
+}

cplusplus/src/instructions/InstructionCpu.cpp

@@ -0,0 +1,15 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#include "instructions/InstructionCpu.hpp"
+
+using namespace rabbitizer;
+
+InstructionCpu::InstructionCpu(uint32_t word, uint32_t vram) : InstructionBase() {
+    RabbitizerInstruction_init(&this->instr, word, vram);
+    RabbitizerInstruction_processUniqueId(&this->instr);
+}
+
+InstructionCpu::~InstructionCpu() {
+    RabbitizerInstruction_destroy(&this->instr);
+}

cplusplus/src/instructions/InstructionR5900.cpp

@@ -0,0 +1,118 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#include "instructions/InstructionR5900.hpp"
+
+#include <stdexcept>
+
+#include "instructions/RabbitizerInstructionR5900.h"
+
+using namespace rabbitizer;
+
+InstructionR5900::InstructionR5900(uint32_t word, uint32_t vram) : InstructionBase() {
+    RabbitizerInstructionR5900_init(&this->instr, word, vram);
+    RabbitizerInstructionR5900_processUniqueId(&this->instr);
+}
+
+InstructionR5900::~InstructionR5900() {
+    RabbitizerInstructionR5900_destroy(&this->instr);
+}
+
+Registers::R5900::VF InstructionR5900::GetR5900_vfs() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_rs)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'vfs' operand.");
+    }
+#endif
+
+    return static_cast<Registers::R5900::VF>(RAB_INSTR_R5900_GET_vfs(&this->instr));
+}
+
+Registers::R5900::VF InstructionR5900::GetR5900_vft() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_rt)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'vft' operand.");
+    }
+#endif
+
+    return static_cast<Registers::R5900::VF>(RAB_INSTR_R5900_GET_vft(&this->instr));
+}
+
+Registers::R5900::VF InstructionR5900::GetR5900_vfd() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_rd)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'vfd' operand.");
+    }
+#endif
+
+    return static_cast<Registers::R5900::VF>(RAB_INSTR_R5900_GET_vfd(&this->instr));
+}
+
+Registers::R5900::VI InstructionR5900::GetR5900_vis() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_rs)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'vis' operand.");
+    }
+#endif
+
+    return static_cast<Registers::R5900::VI>(RAB_INSTR_R5900_GET_vis(&this->instr));
+}
+
+Registers::R5900::VI InstructionR5900::GetR5900_vit() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_rt)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'vit' operand.");
+    }
+#endif
+
+    return static_cast<Registers::R5900::VI>(RAB_INSTR_R5900_GET_vit(&this->instr));
+}
+
+Registers::R5900::VI InstructionR5900::GetR5900_vid() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_rd)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'vid' operand.");
+    }
+#endif
+
+    return static_cast<Registers::R5900::VI>(RAB_INSTR_R5900_GET_vid(&this->instr));
+}
+
+uint8_t InstructionR5900::GetR5900_mmi_function() const {
+    return RAB_INSTR_R5900_GET_mmi_function(&this->instr);
+}
+uint8_t InstructionR5900::GetR5900_fhi_flo() const {
+    return RAB_INSTR_R5900_GET_fhi_flo(&this->instr);
+}
+
+uint8_t InstructionR5900::GetR5900_xyzw_x() const {
+    return RAB_INSTR_R5900_GET_xyzw_x(&this->instr);
+}
+uint8_t InstructionR5900::GetR5900_xyzw_y() const {
+    return RAB_INSTR_R5900_GET_xyzw_y(&this->instr);
+}
+uint8_t InstructionR5900::GetR5900_xyzw_z() const {
+    return RAB_INSTR_R5900_GET_xyzw_z(&this->instr);
+}
+uint8_t InstructionR5900::GetR5900_xyzw_w() const {
+    return RAB_INSTR_R5900_GET_xyzw_w(&this->instr);
+}
+uint8_t InstructionR5900::GetR5900_n() const {
+    return RAB_INSTR_R5900_GET_n(&this->instr);
+}
+uint8_t InstructionR5900::GetR5900_l() const {
+    return RAB_INSTR_R5900_GET_l(&this->instr);
+}
+uint8_t InstructionR5900::GetR5900_m() const {
+    return RAB_INSTR_R5900_GET_m(&this->instr);
+}
+
+uint8_t InstructionR5900::GetR5900_imm5() const {
+    return RAB_INSTR_R5900_GET_imm5(&this->instr);
+}

cplusplus/src/instructions/InstructionRsp.cpp

@@ -0,0 +1,128 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#include "instructions/InstructionRsp.hpp"
+
+#include <stdexcept>
+
+#include "instructions/RabbitizerInstructionRsp.h"
+
+using namespace rabbitizer;
+
+InstructionRsp::InstructionRsp(uint32_t word, uint32_t vram) : InstructionBase() {
+    RabbitizerInstructionRsp_init(&this->instr, word, vram);
+    RabbitizerInstructionRsp_processUniqueId(&this->instr);
+}
+
+InstructionRsp::~InstructionRsp() {
+    RabbitizerInstructionRsp_destroy(&this->instr);
+}
+
+Registers::Rsp::Gpr InstructionRsp::GetRsp_rs() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_rs)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'rs' operand.");
+    }
+#endif
+
+    return static_cast<Registers::Rsp::Gpr>(RAB_INSTR_GET_rs(&this->instr));
+}
+Registers::Rsp::Gpr InstructionRsp::GetRsp_rt() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_rt)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'rt' operand.");
+    }
+#endif
+
+    return static_cast<Registers::Rsp::Gpr>(RAB_INSTR_GET_rt(&this->instr));
+}
+Registers::Rsp::Gpr InstructionRsp::GetRsp_rd() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_rd)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'rd' operand.");
+    }
+#endif
+
+    return static_cast<Registers::Rsp::Gpr>(RAB_INSTR_GET_rd(&this->instr));
+}
+
+Registers::Rsp::Cop0 InstructionRsp::GetRsp_cop0d() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_cop0d)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'cop0d' operand.");
+    }
+#endif
+
+    return static_cast<Registers::Rsp::Cop0>(RAB_INSTR_GET_cop0d(&this->instr));
+}
+
+Registers::Rsp::Cop2 InstructionRsp::GetRsp_cop2t() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_cop2t)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'cop2t' operand.");
+    }
+#endif
+
+    return static_cast<Registers::Rsp::Cop2>(RAB_INSTR_RSP_GET_cop2t(&this->instr));
+}
+
+Registers::Rsp::Cop2Control InstructionRsp::GetRsp_cop2cd() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_cop2t)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'cop2cd' operand.");
+    }
+#endif
+
+    return static_cast<Registers::Rsp::Cop2Control>(RAB_INSTR_RSP_GET_cop2cd(&this->instr));
+}
+
+Registers::Rsp::Vector InstructionRsp::GetRsp_vs() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_vs)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'vs' operand.");
+    }
+#endif
+
+    return static_cast<Registers::Rsp::Vector>(RAB_INSTR_RSP_GET_vs(&this->instr));
+}
+Registers::Rsp::Vector InstructionRsp::GetRsp_vt() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_vt)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'vt' operand.");
+    }
+#endif
+
+    return static_cast<Registers::Rsp::Vector>(RAB_INSTR_RSP_GET_vt(&this->instr));
+}
+Registers::Rsp::Vector InstructionRsp::GetRsp_vd() const {
+#ifdef RAB_SANITY_CHECKS
+    if (!hasOperandAlias(OperandType::rsp_vd)) {
+        // TODO: make a rabbitizer exception class
+        throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have 'vd' operand.");
+    }
+#endif
+
+    return static_cast<Registers::Rsp::Vector>(RAB_INSTR_RSP_GET_vd(&this->instr));
+}
+
+uint8_t InstructionRsp::GetRsp_elementhigh() const {
+    return RAB_INSTR_RSP_GET_elementhigh(&this->instr);
+}
+uint8_t InstructionRsp::GetRsp_elementlow() const {
+    return RAB_INSTR_RSP_GET_elementlow(&this->instr);
+}
+
+uint8_t InstructionRsp::GetRsp_index() const {
+    return RAB_INSTR_RSP_GET_index(&this->instr);
+}
+uint8_t InstructionRsp::GetRsp_de() const {
+    return RAB_INSTR_RSP_GET_de(&this->instr);
+}

include/analysis/RabbitizerRegistersTracker.h

@@ -14,11 +14,14 @@
 extern "C" {
 #endif
 
+#define RAB_REGISTERS_COUNT 32
+
 
 typedef struct RabbitizerRegistersTracker {
-    RabbitizerTrackedRegisterState registers[32];
+    RabbitizerTrackedRegisterState registers[RAB_REGISTERS_COUNT];
 } RabbitizerRegistersTracker;
 
+// TODO: Change functions which use parameters as a way to return values into actual structs returned by the functions
 
 NON_NULL(1)
 void RabbitizerRegistersTracker_init(RabbitizerRegistersTracker *self, const RabbitizerRegistersTracker *other);

include/common/RabbitizerVersion.h

@@ -13,8 +13,8 @@ extern "C" {
 
 // Header version
 #define RAB_VERSION_MAJOR 1
-#define RAB_VERSION_MINOR 2
-#define RAB_VERSION_PATCH 2
+#define RAB_VERSION_MINOR 3
+#define RAB_VERSION_PATCH 0
 
 #define RAB_VERSION_STR RAB_STRINGIFY(RAB_VERSION_MAJOR) "." RAB_STRINGIFY(RAB_VERSION_MINOR) "." RAB_STRINGIFY(RAB_VERSION_PATCH)
 

include/instructions/AccessType.inc

@@ -0,0 +1,15 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+RAB_DEF_ACCESSTYPE(INVALID)
+
+RAB_DEF_ACCESSTYPE(BYTE_SIGNED)
+RAB_DEF_ACCESSTYPE(BYTE_UNSIGNED)
+RAB_DEF_ACCESSTYPE(SHORT_SIGNED)
+RAB_DEF_ACCESSTYPE(SHORT_UNSIGNED)
+RAB_DEF_ACCESSTYPE(WORD_SIGNED)
+RAB_DEF_ACCESSTYPE(WORD_UNSIGNED)
+RAB_DEF_ACCESSTYPE(DOUBLEWORD_SIGNED)
+RAB_DEF_ACCESSTYPE(DOUBLEWORD_UNSIGNED)
+RAB_DEF_ACCESSTYPE(FLOAT_SIGNED)
+RAB_DEF_ACCESSTYPE(DOUBLEFLOAT_SIGNED)

include/instructions/RabbitizerAccessType.h

@@ -0,0 +1,28 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#ifndef RABBITIZER_ACCESS_TYPE_H
+#define RABBITIZER_ACCESS_TYPE_H
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define RAB_DEF_ACCESSTYPE(name) RAB_ACCESSTYPE_##name,
+
+typedef enum RabbitizerAccessType {
+    #include "instructions/AccessType.inc"
+
+    RAB_DEF_ACCESSTYPE(MAX)
+} RabbitizerAccessType;
+
+#undef RAB_DEF_ACCESSTYPE
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/instructions/RabbitizerInstrCategory.h

@@ -0,0 +1,32 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#ifndef RABBITIZER_INSTRCATEGORY_H
+#define RABBITIZER_INSTRCATEGORY_H
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define RABBITIZER_DEF_INSTR_CATEGORY(name) RABBITIZER_INSTRCAT_##name
+
+typedef enum RabbitizerInstrCategory {
+    #include "instructions/InstrCategory.inc"
+
+    RABBITIZER_DEF_INSTR_CATEGORY(MAX),
+} RabbitizerInstrCategory;
+
+#undef RABBITIZER_DEF_INSTR_CATEGORY
+
+extern const char *const RabbitizerInstrCategory_Names[];
+
+RabbitizerInstrCategory RabbitizerInstrCategory_fromStr(const char *name);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/instructions/RabbitizerInstrDescriptor.h

@@ -11,12 +11,14 @@
 #include "RabbitizerOperandType.h"
 #include "RabbitizerInstrId.h"
 #include "RabbitizerInstrSuffix.h"
+#include "RabbitizerAccessType.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 
+//! @deprecated
 typedef enum RabbitizerInstrType {
     RABBITIZER_INSTR_TYPE_UNKNOWN,
     RABBITIZER_INSTR_TYPE_J,
@@ -26,47 +28,102 @@ typedef enum RabbitizerInstrType {
     RABBITIZER_INSTR_TYPE_MAX,
 } RabbitizerInstrType;
 
-typedef enum RabbitizerArchitectureVersion {
-    RABBITIZER_ARCHVERSION_INVALID=-1,
-    RABBITIZER_ARCHVERSION_UNKNOWN,
-    RABBITIZER_ARCHVERSION_MIPS_I,
-    RABBITIZER_ARCHVERSION_MIPS_II,
-    RABBITIZER_ARCHVERSION_MIPS_III,
-    RABBITIZER_ARCHVERSION_MIPS_IV
-} RabbitizerArchitectureVersion;
-
 typedef struct RabbitizerInstrDescriptor {
     RabbitizerOperandType operands[4];
     RabbitizerInstrType instrType;
 
     RabbitizerInstrSuffix instrSuffix;
 
+    /**
+     * Local branch with "restricted" range, usually it doesn't jump outside the current function
+     */
     bool isBranch;
     bool isBranchLikely;
+    /**
+     * The instruction can jump inside or outside its current function
+     */
     bool isJump;
+    /**
+     * The target address of this jump is encoded in the instruction (MIPS: J and JAL)
+     */
+    bool isJumpWithAddress;
+    /**
+     * Triggers a trap on the processor
+     */
     bool isTrap;
 
+    /**
+     * The instruction performs float (any kind of float, including double precision) operations
+     */
     bool isFloat;
+    /**
+     * The instruction performs double precision float operations
+     */
     bool isDouble;
 
+    /**
+     * The instruction holds an immediate which is treated as an unsigned value,
+     * otherwise the immediate it may hold should be treated as a Two's complement value
+     */
     bool isUnsigned;
 
+    /**
+     * The instruction modifies the state of the MIPS `rt` register
+     */
     bool modifiesRt;
+    /**
+     * The instruction modifies the state of the MIPS `rd` register
+     */
     bool modifiesRd;
 
+    bool readsHI;
+    bool readsLO;
+    bool modifiesHI;
+    bool modifiesLO;
+
+    /**
+     * This instruction is not emited by a C compiler
+     */
     bool notEmitedByCompilers;
 
+    /**
+     * The instruction can hold the "hi" value of a %hi/%lo pair
+     */
     bool canBeHi;
+    /**
+     * The instruction can hold the "lo" value of a %hi/%lo pair
+     */
     bool canBeLo;
-    bool doesLink; // "and link" family of instructions
+    /**
+     * "and link" family of instructions
+     * The instruction stores the return address link in the MIPS $ra (GPR 31) register
+     */
+    bool doesLink;
+
+    /**
+     * This instruction performs a pointer dereference, either by loading from RAM or storing into RAM
+     */
     bool doesDereference;
-    bool doesLoad; // loads data from memory
-    bool doesStore; // stores data to memory
+    /**
+     * Dereferences a pointer and loads data from RAM
+     */
+    bool doesLoad;
+    /**
+     * Dereferences a pointer and stores data to RAM
+     */
+    bool doesStore;
+
+    /**
+     * This instruction may be the result of expanding the `move` pseudo-instruction
+     */
     bool maybeIsMove;
 
+    /**
+     * This instruction is a pseudo-instruction
+     */
     bool isPseudo;
 
-    RabbitizerArchitectureVersion architectureVersion; // TODO: consider removing
+    RabbitizerAccessType accessType;
 } RabbitizerInstrDescriptor;
 
 // TODO: less redundant name
@@ -94,6 +151,8 @@ bool RabbitizerInstrDescriptor_isBranchLikely(const RabbitizerInstrDescriptor *s
 NODISCARD NON_NULL(1) PURE
 bool RabbitizerInstrDescriptor_isJump(const RabbitizerInstrDescriptor *self);
 NODISCARD NON_NULL(1) PURE
+bool RabbitizerInstrDescriptor_isJumpWithAddress(const RabbitizerInstrDescriptor *self);
+NODISCARD NON_NULL(1) PURE
 bool RabbitizerInstrDescriptor_isTrap(const RabbitizerInstrDescriptor *self);
 
 NODISCARD NON_NULL(1) PURE
@@ -109,6 +168,15 @@ bool RabbitizerInstrDescriptor_modifiesRt(const RabbitizerInstrDescriptor *self)
 NODISCARD NON_NULL(1) PURE
 bool RabbitizerInstrDescriptor_modifiesRd(const RabbitizerInstrDescriptor *self);
 
+NODISCARD NON_NULL(1) PURE
+bool RabbitizerInstrDescriptor_readsHI(const RabbitizerInstrDescriptor *self);
+NODISCARD NON_NULL(1) PURE
+bool RabbitizerInstrDescriptor_readsLO(const RabbitizerInstrDescriptor *self);
+NODISCARD NON_NULL(1) PURE
+bool RabbitizerInstrDescriptor_modifiesHI(const RabbitizerInstrDescriptor *self);
+NODISCARD NON_NULL(1) PURE
+bool RabbitizerInstrDescriptor_modifiesLO(const RabbitizerInstrDescriptor *self);
+
 NODISCARD NON_NULL(1) PURE
 bool RabbitizerInstrDescriptor_notEmitedByCompilers(const RabbitizerInstrDescriptor *self);
 
@@ -131,7 +199,7 @@ NODISCARD NON_NULL(1) PURE
 bool RabbitizerInstrDescriptor_isPseudo(const RabbitizerInstrDescriptor *self);
 
 NODISCARD NON_NULL(1) PURE
-RabbitizerArchitectureVersion RabbitizerInstrDescriptor_getArchitectureVersion(const RabbitizerInstrDescriptor *self);
+RabbitizerAccessType RabbitizerInstrDescriptor_getAccessType(const RabbitizerInstrDescriptor *self);
 
 
 #ifdef __cplusplus

include/instructions/RabbitizerInstruction.h

@@ -13,23 +13,13 @@
 
 #include "RabbitizerInstrId.h"
 #include "RabbitizerInstrDescriptor.h"
+#include "RabbitizerInstrCategory.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 
-#define RABBITIZER_DEF_INSTR_CATEGORY(name) RABBITIZER_INSTRCAT_##name
-
-typedef enum RabbitizerInstrCategory {
-    #include "instructions/InstrCategory.inc"
-
-    RABBITIZER_DEF_INSTR_CATEGORY(MAX),
-} RabbitizerInstrCategory;
-
-#undef RABBITIZER_DEF_INSTR_CATEGORY
-
-
 typedef struct RabbitizerInstruction {
     uint32_t word;
     uint32_t _mandatorybits;
@@ -95,6 +85,8 @@ typedef struct RabbitizerInstruction {
 #define RAB_INSTR_PACK_immediate(word, value)       (BITREPACK((word), (value),  0, 16))
 
 #define RAB_INSTR_PACK_code(word, value)            (BITREPACK((word), (value),  6, 20))
+#define RAB_INSTR_PACK_code_upper(word, value)      (BITREPACK((word), (value), 16, 10))
+#define RAB_INSTR_PACK_code_lower(word, value)      (BITREPACK((word), (value),  6, 10))
 
 #define RAB_INSTR_PACK_copraw(word, value)          (BITREPACK((word), (value),  0, 25))
 
@@ -168,19 +160,21 @@ void RabbitizerInstruction_processUniqueId(RabbitizerInstruction *self);
 NODISCARD NON_NULL(1) PURE
 uint32_t RabbitizerInstruction_getRaw(const RabbitizerInstruction *self);
 
-NODISCARD NON_NULL(1) PURE
-uint32_t RabbitizerInstruction_getImmediate(const RabbitizerInstruction *self);
 NODISCARD NON_NULL(1) PURE
 int32_t RabbitizerInstruction_getProcessedImmediate(const RabbitizerInstruction *self);
 NODISCARD NON_NULL(1) PURE
-uint32_t RabbitizerInstruction_getInstrIndex(const RabbitizerInstruction *self);
-NODISCARD NON_NULL(1) PURE
 uint32_t RabbitizerInstruction_getInstrIndexAsVram(const RabbitizerInstruction *self);
 
 NODISCARD NON_NULL(1) PURE
 int32_t RabbitizerInstruction_getBranchOffset(const RabbitizerInstruction *self);
 NODISCARD NON_NULL(1) PURE
 int32_t RabbitizerInstruction_getGenericBranchOffset(const RabbitizerInstruction *self, uint32_t currentVram);
+NODISCARD NON_NULL(1) PURE
+int32_t RabbitizerInstruction_getBranchOffsetGeneric(const RabbitizerInstruction *self);
+NODISCARD NON_NULL(1) PURE
+int32_t RabbitizerInstruction_getBranchVramGeneric(const RabbitizerInstruction *self);
+NODISCARD NON_NULL(1) PURE
+int8_t RabbitizerInstruction_getDestinationGpr(const RabbitizerInstruction *self);
 
 /* General getters */
 
@@ -205,6 +199,7 @@ bool RabbitizerInstruction_isJrNotRa(const RabbitizerInstruction *self);
 NODISCARD NON_NULL(1) PURE
 bool RabbitizerInstruction_hasDelaySlot(const RabbitizerInstruction *self);
 
+//! @deprecated
 NODISCARD NON_NULL(1) PURE
 const char *RabbitizerInstruction_mapInstrToType(const RabbitizerInstruction *self);
 

include/instructions/RabbitizerOperandType.h

@@ -5,6 +5,8 @@
 #define RABBITIZER_OPERAND_TYPE_H
 #pragma once
 
+#include <stddef.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -26,6 +28,22 @@ typedef enum RabbitizerOperandType {
 #undef RAB_DEF_OPERAND
 
 
+struct RabbitizerInstruction;
+
+typedef size_t (*OperandCallback)(const struct RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength);
+
+extern const OperandCallback instrOpercandCallbacks[];
+
+
+#define RAB_DEF_OPERAND(prefix, operand) size_t RabbitizerOperandType_process_##prefix##_##operand (const struct RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength);
+
+#include "instructions/operands/RabbitizerOperandType_cpu.inc"
+#include "instructions/operands/RabbitizerOperandType_rsp.inc"
+#include "instructions/operands/RabbitizerOperandType_r5900.inc"
+
+#undef RAB_DEF_OPERAND
+
+
 #ifdef __cplusplus
 }
 #endif

include/instructions/instr_id/RabbitizerInstrId_cpu.inc

@@ -1,7 +1,10 @@
 /* SPDX-FileCopyrightText: © 2022 Decompollaborate */
 /* SPDX-License-Identifier: MIT */
 
-RABBITIZER_DEF_INSTR_ID(cpu, , INVALID, .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate})
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , INVALID,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate}
+)
 
 #include "instructions/instr_id/cpu/cpu_normal.inc"
 #include "instructions/instr_id/cpu/cpu_special.inc"
@@ -16,4 +19,88 @@ RABBITIZER_DEF_INSTR_ID(cpu, , INVALID, .operands={RAB_OPERAND_cpu_rs, RAB_OPERA
 #include "instructions/instr_id/cpu/cpu_cop1_fpu_w.inc"
 #include "instructions/instr_id/cpu/cpu_cop1_fpu_l.inc"
 
-RABBITIZER_DEF_INSTR_ID(cpu, , MAX, .operands={0})
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_00,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_01,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_02,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_03,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_04,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_05,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_06,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_07,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_08,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_09,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_10,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_11,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_12,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_13,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_14,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_15,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_16,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_17,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_18,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , USERDEF_19,
+    .operands={0}
+)
+
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , MAX,
+    .operands={0}
+)

include/instructions/instr_id/RabbitizerInstrId_r5900.inc

@@ -1,7 +1,11 @@
 /* SPDX-FileCopyrightText: © 2022 Decompollaborate */
 /* SPDX-License-Identifier: MIT */
 
-RABBITIZER_DEF_INSTR_ID(r5900, , INVALID,     .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .architectureVersion=-1)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , INVALID,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN
+)
 
 #include "instructions/instr_id/r5900/r5900_normal.inc"
 #include "instructions/instr_id/r5900/r5900_special.inc"
@@ -22,5 +26,88 @@ RABBITIZER_DEF_INSTR_ID(r5900, , INVALID,     .operands={RAB_OPERAND_cpu_rs, RAB
 #include "instructions/instr_id/r5900/r5900_cop2_special1.inc"
 #include "instructions/instr_id/r5900/r5900_cop2_special2.inc"
 
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_00,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_01,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_02,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_03,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_04,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_05,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_06,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_07,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_08,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_09,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_10,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_11,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_12,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_13,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_14,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_15,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_16,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_17,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_18,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , USERDEF_19,
+    .operands={0}
+)
 
-RABBITIZER_DEF_INSTR_ID(r5900, , MAX, .operands={0})
+RABBITIZER_DEF_INSTR_ID(
+    r5900, , MAX,
+    .operands={0}
+)

include/instructions/instr_id/RabbitizerInstrId_rsp.inc

@@ -2,7 +2,10 @@
 /* SPDX-License-Identifier: MIT */
 
 // RSP instructions
-RABBITIZER_DEF_INSTR_ID(rsp, , INVALID,               .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , INVALID,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
 
 #include "instructions/instr_id/rsp/rsp_cop2.inc"
 #include "instructions/instr_id/rsp/rsp_cop2_vu.inc"
@@ -17,4 +20,88 @@ RABBITIZER_DEF_INSTR_ID(rsp, , INVALID,               .operands={RAB_OPERAND_rsp
 #include "instructions/instr_id/rsp/rsp_regimm.inc"
 #include "instructions/instr_id/rsp/rsp_cop0.inc"
 
-RABBITIZER_DEF_INSTR_ID(rsp, , MAX, .operands={0})
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_00,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_01,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_02,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_03,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_04,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_05,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_06,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_07,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_08,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_09,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_10,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_11,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_12,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_13,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_14,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_15,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_16,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_17,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_18,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , USERDEF_19,
+    .operands={0}
+)
+
+RABBITIZER_DEF_INSTR_ID(
+    rsp, , MAX,
+    .operands={0}
+)

include/instructions/instr_id/cpu/cpu_cop0.inc

@@ -2,9 +2,38 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP rt, cop0d
-RABBITIZER_DEF_INSTR_ID(cpu, 0x00, mfc0,                          .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop0d}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .modifiesRt=true, .notEmitedByCompilers=true)      // Move word From CP0
-RABBITIZER_DEF_INSTR_ID(cpu, 0x01, dmfc0,                         .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop0d}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .modifiesRt=true)     // Doubleword Move From CP0
-RABBITIZER_DEF_INSTR_ID(cpu, 0x02, cfc0,                          .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop0d}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .modifiesRt=true)      // Move control word From CP0
-RABBITIZER_DEF_INSTR_ID(cpu, 0x04, mtc0,                          .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop0d}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .notEmitedByCompilers=true)      // Move word to CP0
-RABBITIZER_DEF_INSTR_ID(cpu, 0x05, dmtc0,                         .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop0d}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN)     // Doubleword Move To CP0
-RABBITIZER_DEF_INSTR_ID(cpu, 0x06, ctc0,                          .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop0d}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN)      // Move control word To CP0
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x00, mfc0,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop0d},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .modifiesRt=true,
+    .notEmitedByCompilers=true
+) // Move word From CP0
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x01, dmfc0,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop0d},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .modifiesRt=true
+) // Doubleword Move From CP0
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x02, cfc0,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop0d},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .modifiesRt=true
+) // Move control word From CP0
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x04, mtc0,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop0d},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .notEmitedByCompilers=true
+) // Move word to CP0
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x05, dmtc0,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop0d},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN
+) // Doubleword Move To CP0
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x06, ctc0,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop0d},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN
+) // Move control word To CP0

include/instructions/instr_id/cpu/cpu_cop0_bc0.inc

@@ -2,7 +2,29 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP IMM
-RABBITIZER_DEF_INSTR_ID(cpu, 0x00, bc0f,    .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true)      // Branch on FP False
-RABBITIZER_DEF_INSTR_ID(cpu, 0x01, bc0t,    .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true)      // Branch on FP True
-RABBITIZER_DEF_INSTR_ID(cpu, 0x02, bc0fl,   .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true, .isBranchLikely=true)     // Branch on FP False Likely
-RABBITIZER_DEF_INSTR_ID(cpu, 0x03, bc0tl,   .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true, .isBranchLikely=true)     // Branch on FP True Likely
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x00, bc0f,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isBranch=true
+) // Branch on FP False
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x01, bc0t,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isBranch=true
+) // Branch on FP True
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x02, bc0fl,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isBranch=true,
+    .isBranchLikely=true
+) // Branch on FP False Likely
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x03, bc0tl,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isBranch=true,
+    .isBranchLikely=true
+) // Branch on FP True Likely

include/instructions/instr_id/cpu/cpu_cop0_tlb.inc

@@ -2,11 +2,35 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP
-RABBITIZER_DEF_INSTR_ID(cpu, 0x01, tlbr,    .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .notEmitedByCompilers=true)      // Read Indexed TLB Entry
-RABBITIZER_DEF_INSTR_ID(cpu, 0x02, tlbwi,   .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .notEmitedByCompilers=true)     // Write Indexed TLB Entry
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x01, tlbr,
+    .operands={0},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .notEmitedByCompilers=true
+) // Read Indexed TLB Entry
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x02, tlbwi,
+    .operands={0},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .notEmitedByCompilers=true
+) // Write Indexed TLB Entry
 
-RABBITIZER_DEF_INSTR_ID(cpu, 0x06, tlbwr,   .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN)     // Write Random TLB Entry
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x06, tlbwr,
+    .operands={0},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN
+) // Write Random TLB Entry
 
-RABBITIZER_DEF_INSTR_ID(cpu, 0x08, tlbp,    .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .notEmitedByCompilers=true)      // Probe TLB for Matching Entry
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x08, tlbp,
+    .operands={0},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .notEmitedByCompilers=true
+) // Probe TLB for Matching Entry
 
-RABBITIZER_DEF_INSTR_ID(cpu, 0x18, eret,    .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .notEmitedByCompilers=true)      // Return from Exception
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x18, eret,
+    .operands={0},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .notEmitedByCompilers=true
+) // Return from Exception

include/instructions/instr_id/cpu/cpu_cop1.inc

@@ -2,11 +2,44 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP rt, fs
-RABBITIZER_DEF_INSTR_ID(cpu, 0x00, mfc1,    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesRt=true)      // Move Word From Floating-Point
-RABBITIZER_DEF_INSTR_ID(cpu, 0x01, dmfc1,   .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesRt=true)     // Doubleword Move From Floating-Point
-RABBITIZER_DEF_INSTR_ID(cpu, 0x04, mtc1,    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)      // Move Word to Floating-Point
-RABBITIZER_DEF_INSTR_ID(cpu, 0x05, dmtc1,   .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)     // Doubleword Move To Floating-Point
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x00, mfc1,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true,
+    .modifiesRt=true
+) // Move Word From Floating-Point
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x01, dmfc1,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true,
+    .modifiesRt=true
+) // Doubleword Move From Floating-Point
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x04, mtc1,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Move Word to Floating-Point
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x05, dmtc1,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Doubleword Move To Floating-Point
 
 // OP rt, cop1cs
-RABBITIZER_DEF_INSTR_ID(cpu, 0x02, cfc1,    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop1cs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesRt=true)      // Move Control Word from Floating-Point
-RABBITIZER_DEF_INSTR_ID(cpu, 0x06, ctc1,    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop1cs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)      // Move Control Word to Floating-Point
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x02, cfc1,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop1cs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true,
+    .modifiesRt=true
+) // Move Control Word from Floating-Point
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x06, ctc1,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop1cs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Move Control Word to Floating-Point

include/instructions/instr_id/cpu/cpu_cop1_bc1.inc

@@ -2,7 +2,29 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP IMM
-RABBITIZER_DEF_INSTR_ID(cpu, 0x00, bc1f,    .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true)
-RABBITIZER_DEF_INSTR_ID(cpu, 0x01, bc1t,    .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true)
-RABBITIZER_DEF_INSTR_ID(cpu, 0x02, bc1fl,   .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true, .isBranchLikely=true)
-RABBITIZER_DEF_INSTR_ID(cpu, 0x03, bc1tl,   .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true, .isBranchLikely=true)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x00, bc1f,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isBranch=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x01, bc1t,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isBranch=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x02, bc1fl,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isBranch=true,
+    .isBranchLikely=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x03, bc1tl,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isBranch=true,
+    .isBranchLikely=true
+)

include/instructions/instr_id/cpu/cpu_cop1_fpu_d.inc

@@ -2,47 +2,225 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP fd, fs, ft
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x00, add_d, add.d,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)        // Floating-Point Add
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x01, sub_d, sub.d,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)     // Floating-Point Sub
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x02, mul_d, mul.d,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)     // Floating-Point Multiply
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x03, div_d, div.d,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)     // Floating-Point Divide
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x00, add_d, add.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Add
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x01, sub_d, sub.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Sub
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x02, mul_d, mul.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Multiply
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x03, div_d, div.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Divide
 
 // OP fd, fs
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x04, sqrt_d, sqrt.d,        .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)    // Floating-Point Square Root
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x05, abs_d, abs.d,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)     // Floating-Point Absolute Value
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x06, mov_d, mov.d,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)     // Floating-Point Move
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x07, neg_d, neg.d,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)     // Floating-Point Negate
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x04, sqrt_d, sqrt.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Square Root
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x05, abs_d, abs.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Absolute Value
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x06, mov_d, mov.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Move
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x07, neg_d, neg.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Negate
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x08, round_l_d, round.l.d,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true) // Floating-Point Round to Long Fixed-Point
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x09, trunc_l_d, trunc.l.d,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true) // Floating-Point Truncate to Long Fixed-Point
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x0A, ceil_l_d, ceil.l.d,    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)  // Floating-Point Ceiling Convert to Long Fixed-Point
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x0B, floor_l_d, floor.l.d,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true) // Floating-Point Floor Convert to Long Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x08, round_l_d, round.l.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Round to Long Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x09, trunc_l_d, trunc.l.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Truncate to Long Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x0A, ceil_l_d, ceil.l.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Ceiling Convert to Long Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x0B, floor_l_d, floor.l.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Floor Convert to Long Fixed-Point
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x0C, round_w_d, round.w.d,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true) // Floating-Point Round to Word Fixed-Point
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x0D, trunc_w_d, trunc.w.d,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true) // Floating-Point Truncate to Word Fixed-Point
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x0E, ceil_w_d, ceil.w.d,    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)  // Floating-Point Ceiling Convert to Word Fixed-Point
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x0F, floor_w_d, floor.w.d,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true) // Floating-Point Floor Convert to Word Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x0C, round_w_d, round.w.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Round to Word Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x0D, trunc_w_d, trunc.w.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Truncate to Word Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x0E, ceil_w_d, ceil.w.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Ceiling Convert to Word Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x0F, floor_w_d, floor.w.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Floor Convert to Word Fixed-Point
 
 // OP fd, fs
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x20, cvt_s_d, cvt.s.d,      .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x24, cvt_w_d, cvt.w.d,      .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x25, cvt_l_d, cvt.l.d,      .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x20, cvt_s_d, cvt.s.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true,
+    .isDouble=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x24, cvt_w_d, cvt.w.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true,
+    .isDouble=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x25, cvt_l_d, cvt.l.d,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true,
+    .isDouble=true
+)
 
 // OP fs, ft
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x30, c_f_d, c.f.d,          .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x31, c_un_d, c.un.d,        .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x32, c_eq_d, c.eq.d,        .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x33, c_ueq_d, c.ueq.d,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x34, c_olt_d, c.olt.d,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x35, c_ult_d, c.ult.d,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x36, c_ole_d, c.ole.d,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x37, c_ule_d, c.ule.d,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x30, c_f_d, c.f.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x31, c_un_d, c.un.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x32, c_eq_d, c.eq.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x33, c_ueq_d, c.ueq.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x34, c_olt_d, c.olt.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x35, c_ult_d, c.ult.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x36, c_ole_d, c.ole.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x37, c_ule_d, c.ule.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x38, c_df_d, c.df.d,        .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x39, c_ngle_d, c.ngle.d,    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x3A, c_deq_d, c.deq.d,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x3B, c_ngl_d, c.ngl.d,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x3C, c_lt_d, c.lt.d,        .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x3D, c_nge_d, c.nge.d,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x3E, c_le_d, c.le.d,        .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x3F, c_ngt_d, c.ngt.d,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x38, c_df_d, c.df.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x39, c_ngle_d, c.ngle.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x3A, c_deq_d, c.deq.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x3B, c_ngl_d, c.ngl.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x3C, c_lt_d, c.lt.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x3D, c_nge_d, c.nge.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x3E, c_le_d, c.le.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x3F, c_ngt_d, c.ngt.d,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)

include/instructions/instr_id/cpu/cpu_cop1_fpu_l.inc

@@ -2,5 +2,16 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP fd, fs
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x20, cvt_s_l, cvt.s.l,    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x21, cvt_d_l, cvt.d.l,    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x20, cvt_s_l, cvt.s.l,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x21, cvt_d_l, cvt.d.l,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true,
+    .isDouble=true
+)

include/instructions/instr_id/cpu/cpu_cop1_fpu_s.inc

@@ -2,47 +2,223 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP fd, fs, ft
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x00, add_s, add.s,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)        // Floating-Point Add
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x01, sub_s, sub.s,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)     // Floating-Point Sub
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x02, mul_s, mul.s,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)     // Floating-Point Multiply
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x03, div_s, div.s,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)     // Floating-Point Divide
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x00, add_s, add.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Add
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x01, sub_s, sub.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Sub
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x02, mul_s, mul.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Multiply
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x03, div_s, div.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Divide
 
 // OP fd, fs
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x04, sqrt_s, sqrt.s,        .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)    // Floating-Point Square Root
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x05, abs_s, abs.s,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)     // Floating-Point Absolute Value
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x06, mov_s, mov.s,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)     // Floating-Point Move
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x07, neg_s, neg.s,          .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)     // Floating-Point Negate
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x04, sqrt_s, sqrt.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Square Root
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x05, abs_s, abs.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Absolute Value
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x06, mov_s, mov.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Move
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x07, neg_s, neg.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Negate
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x08, round_l_s, round.l.s,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true) // Floating-Point Round to Long Fixed-Point
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x09, trunc_l_s, trunc.l.s,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true) // Floating-Point Truncate to Long Fixed-Point
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x0A, ceil_l_s, ceil.l.s,    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)  // Floating-Point Ceiling Convert to Long Fixed-Point
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x0B, floor_l_s, floor.l.s,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true) // Floating-Point Floor Convert to Long Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x08, round_l_s, round.l.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Round to Long Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x09, trunc_l_s, trunc.l.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Truncate to Long Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x0A, ceil_l_s, ceil.l.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Ceiling Convert to Long Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x0B, floor_l_s, floor.l.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Floor Convert to Long Fixed-Point
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x0C, round_w_s, round.w.s,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true) // Floating-Point Round to Word Fixed-Point
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x0D, trunc_w_s, trunc.w.s,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true) // Floating-Point Truncate to Word Fixed-Point
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x0E, ceil_w_s, ceil.w.s,    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)  // Floating-Point Ceiling Convert to Word Fixed-Point
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x0F, floor_w_s, floor.w.s,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true) // Floating-Point Floor Convert to Word Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x0C, round_w_s, round.w.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Round to Word Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x0D, trunc_w_s, trunc.w.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Truncate to Word Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x0E, ceil_w_s, ceil.w.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Ceiling Convert to Word Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x0F, floor_w_s, floor.w.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+) // Floating-Point Floor Convert to Word Fixed-Point
 
 // OP fd, fs
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x21, cvt_d_s, cvt.d.s,      .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x24, cvt_w_s, cvt.w.s,      .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x25, cvt_l_s, cvt.l.s,      .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x21, cvt_d_s, cvt.d.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true,
+    .isDouble=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x24, cvt_w_s, cvt.w.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x25, cvt_l_s, cvt.l.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
 
 // OP fs, ft
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x30, c_f_s, c.f.s,          .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x31, c_un_s, c.un.s,        .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x32, c_eq_s, c.eq.s,        .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x33, c_ueq_s, c.ueq.s,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x34, c_olt_s, c.olt.s,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x35, c_ult_s, c.ult.s,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x36, c_ole_s, c.ole.s,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x37, c_ule_s, c.ule.s,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x30, c_f_s, c.f.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x31, c_un_s, c.un.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x32, c_eq_s, c.eq.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x33, c_ueq_s, c.ueq.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x34, c_olt_s, c.olt.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x35, c_ult_s, c.ult.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x36, c_ole_s, c.ole.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x37, c_ule_s, c.ule.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x38, c_sf_s, c.sf.s,        .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x39, c_ngle_s, c.ngle.s,    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x3A, c_seq_s, c.seq.s,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x3B, c_ngl_s, c.ngl.s,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x3C, c_lt_s, c.lt.s,        .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x3D, c_nge_s, c.nge.s,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x3E, c_le_s, c.le.s,        .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x3F, c_ngt_s, c.ngt.s,      .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x38, c_sf_s, c.sf.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x39, c_ngle_s, c.ngle.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x3A, c_seq_s, c.seq.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x3B, c_ngl_s, c.ngl.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x3C, c_lt_s, c.lt.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x3D, c_nge_s, c.nge.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x3E, c_le_s, c.le.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x3F, c_ngt_s, c.ngt.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)

include/instructions/instr_id/cpu/cpu_cop1_fpu_w.inc

@@ -2,5 +2,16 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP fd, fs
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x20, cvt_s_w, cvt.s.w,    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, 0x21, cvt_d_w, cvt.d.w,    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x20, cvt_s_w, cvt.s.w,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, 0x21, cvt_d_w, cvt.d.w,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .isFloat=true,
+    .isDouble=true
+)

include/instructions/instr_id/cpu/cpu_normal.inc

@@ -2,82 +2,481 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP LABEL
-RABBITIZER_DEF_INSTR_ID(cpu, 0x02, j,       .operands={RAB_OPERAND_cpu_label}, .instrType=RABBITIZER_INSTR_TYPE_J, .isJump=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)         // Jump
-RABBITIZER_DEF_INSTR_ID(cpu, 0x03, jal,     .operands={RAB_OPERAND_cpu_label}, .instrType=RABBITIZER_INSTR_TYPE_J, .isJump=true, .doesLink=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Jump And Link
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x02, j,
+    .operands={RAB_OPERAND_cpu_label},
+    .instrType=RABBITIZER_INSTR_TYPE_J,
+    .isJump=true,
+    .isJumpWithAddress=true
+) // Jump
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x03, jal,
+    .operands={RAB_OPERAND_cpu_label},
+    .instrType=RABBITIZER_INSTR_TYPE_J,
+    .isJump=true,
+    .isJumpWithAddress=true,
+    .doesLink=true
+) // Jump And Link
 
 // OP rs, rt, IMM
-RABBITIZER_DEF_INSTR_ID(cpu, 0x04, beq,     .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_I, .isBranch=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Branch on EQual
-RABBITIZER_DEF_INSTR_ID(cpu, 0x05, bne,     .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_I, .isBranch=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Branch on Not Equal
-RABBITIZER_DEF_INSTR_ID(cpu, 0x14, beql,    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_I, .isBranch=true, .isBranchLikely=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)      // Branch on EQual Likely
-RABBITIZER_DEF_INSTR_ID(cpu, 0x15, bnel,    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_I, .isBranch=true, .isBranchLikely=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)      // Branch on Not Equal Likely
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x04, beq,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isBranch=true
+) // Branch on EQual
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x05, bne,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isBranch=true
+) // Branch on Not Equal
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x14, beql,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isBranch=true,
+    .isBranchLikely=true
+) // Branch on EQual Likely
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x15, bnel,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isBranch=true,
+    .isBranchLikely=true
+) // Branch on Not Equal Likely
 
 // OP rs, IMM
-RABBITIZER_DEF_INSTR_ID(cpu, 0x06, blez,    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_I, .isBranch=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Branch on Less than or Equal to Zero
-RABBITIZER_DEF_INSTR_ID(cpu, 0x16, blezl,   .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_I, .isBranch=true, .isBranchLikely=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)     // Branch on Less than or Equal to Zero Likely
-RABBITIZER_DEF_INSTR_ID(cpu, 0x07, bgtz,    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_I, .isBranch=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Branch on Greater Than Zero
-RABBITIZER_DEF_INSTR_ID(cpu, 0x17, bgtzl,   .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_I, .isBranch=true, .isBranchLikely=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)     // Branch on Greater Than Zero Likely
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x06, blez,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isBranch=true
+) // Branch on Less than or Equal to Zero
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x16, blezl,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isBranch=true,
+    .isBranchLikely=true
+) // Branch on Less than or Equal to Zero Likely
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x07, bgtz,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isBranch=true
+) // Branch on Greater Than Zero
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x17, bgtzl,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isBranch=true,
+    .isBranchLikely=true
+) // Branch on Greater Than Zero Likely
 
 // OP rt, rs, IMM
-RABBITIZER_DEF_INSTR_ID(cpu, 0x08, addi,    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .notEmitedByCompilers=true, .canBeLo=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Add Immediate
-RABBITIZER_DEF_INSTR_ID(cpu, 0x09, addiu,   .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)     // Add Immediate Unsigned Word
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0A, slti,    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Set on Less Than Immediate
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0B, sltiu,   .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)     // Set on Less Than Immediate Unsigned
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0C, andi,    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .isUnsigned=true, .modifiesRt=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // And Immediate
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0D, ori,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .isUnsigned=true, .modifiesRt=true, .canBeLo=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Or Immediate
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0E, xori,    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .isUnsigned=true, .modifiesRt=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // eXclusive OR Immediate
-RABBITIZER_DEF_INSTR_ID(cpu, 0x18, daddi,   .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)     // Doubleword add Immediate
-RABBITIZER_DEF_INSTR_ID(cpu, 0x19, daddiu,  .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)    // Doubleword add Immediate Unsigned
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x08, addi,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .notEmitedByCompilers=true,
+    .canBeLo=true
+) // Add Immediate
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x09, addiu,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true
+) // Add Immediate Unsigned Word
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0A, slti,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true
+) // Set on Less Than Immediate
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0B, sltiu,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true
+) // Set on Less Than Immediate Unsigned
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0C, andi,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isUnsigned=true,
+    .modifiesRt=true
+) // And Immediate
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0D, ori,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isUnsigned=true,
+    .modifiesRt=true,
+    .canBeLo=true
+) // Or Immediate
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0E, xori,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isUnsigned=true,
+    .modifiesRt=true
+) // eXclusive OR Immediate
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x18, daddi,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true
+) // Doubleword add Immediate
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x19, daddiu,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true
+) // Doubleword add Immediate Unsigned
 
 // OP rt, IMM
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0F, lui,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .isUnsigned=true, .modifiesRt=true, .canBeHi=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Load Upper Immediate
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0F, lui,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isUnsigned=true,
+    .modifiesRt=true,
+    .canBeHi=true
+) // Load Upper Immediate
 
 // OP rt, IMM(base)
-RABBITIZER_DEF_INSTR_ID(cpu, 0x1A, ldl,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)       // Load Doubleword Left
-RABBITIZER_DEF_INSTR_ID(cpu, 0x1B, ldr,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)       // Load Doubleword Right
-RABBITIZER_DEF_INSTR_ID(cpu, 0x20, lb,      .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)        // Load Byte
-RABBITIZER_DEF_INSTR_ID(cpu, 0x21, lh,      .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)        // Load Halfword
-RABBITIZER_DEF_INSTR_ID(cpu, 0x22, lwl,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Load Word Left
-RABBITIZER_DEF_INSTR_ID(cpu, 0x23, lw,      .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)        // Load Word
-RABBITIZER_DEF_INSTR_ID(cpu, 0x24, lbu,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Load Byte Insigned
-RABBITIZER_DEF_INSTR_ID(cpu, 0x25, lhu,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Load Halfword Unsigned
-RABBITIZER_DEF_INSTR_ID(cpu, 0x26, lwr,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Load Word Right
-RABBITIZER_DEF_INSTR_ID(cpu, 0x27, lwu,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)       // Load Word Unsigned
-RABBITIZER_DEF_INSTR_ID(cpu, 0x28, sb,      .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)        // Store Byte
-RABBITIZER_DEF_INSTR_ID(cpu, 0x29, sh,      .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)        // Store Halfword
-RABBITIZER_DEF_INSTR_ID(cpu, 0x2A, swl,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Store Word Left
-RABBITIZER_DEF_INSTR_ID(cpu, 0x2B, sw,      .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)        // Store Word
-RABBITIZER_DEF_INSTR_ID(cpu, 0x2C, sdl,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)       // Store Doubleword Left
-RABBITIZER_DEF_INSTR_ID(cpu, 0x2D, sdr,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)       // Store Doubleword Right
-RABBITIZER_DEF_INSTR_ID(cpu, 0x2E, swr,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Store Word Right
-RABBITIZER_DEF_INSTR_ID(cpu, 0x30, ll,      .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)        // Load Linked word
-RABBITIZER_DEF_INSTR_ID(cpu, 0x33, pref,    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_IV)      // Prefetch
-RABBITIZER_DEF_INSTR_ID(cpu, 0x34, lld,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)       // Load Linked Doubleword
-RABBITIZER_DEF_INSTR_ID(cpu, 0x37, ld,      .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)        // Load Doubleword
-RABBITIZER_DEF_INSTR_ID(cpu, 0x38, sc,      .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)        // Store Conditional word
-RABBITIZER_DEF_INSTR_ID(cpu, 0x3C, scd,     .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)       // Store Conditional Doubleword
-RABBITIZER_DEF_INSTR_ID(cpu, 0x3F, sd,      .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)        // Store Doubleword
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x1A, ldl,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true
+) // Load Doubleword Left
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x1B, ldr,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true
+) // Load Doubleword Right
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x20, lb,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_BYTE_SIGNED
+) // Load Byte
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x21, lh,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_SHORT_SIGNED
+) // Load Halfword
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x22, lwl,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true
+) // Load Word Left
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x23, lw,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_WORD_SIGNED
+) // Load Word
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x24, lbu,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_BYTE_UNSIGNED
+) // Load Byte Insigned
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x25, lhu,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_SHORT_UNSIGNED
+) // Load Halfword Unsigned
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x26, lwr,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true
+) // Load Word Right
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x27, lwu,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_WORD_UNSIGNED
+) // Load Word Unsigned
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x28, sb,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true,
+    .accessType=RAB_ACCESSTYPE_BYTE_SIGNED
+) // Store Byte
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x29, sh,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true,
+    .accessType=RAB_ACCESSTYPE_SHORT_SIGNED
+) // Store Halfword
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x2A, swl,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true
+) // Store Word Left
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x2B, sw,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true,
+    .accessType=RAB_ACCESSTYPE_WORD_SIGNED
+) // Store Word
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x2C, sdl,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true
+) // Store Doubleword Left
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x2D, sdr,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true
+) // Store Doubleword Right
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x2E, swr,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true
+) // Store Word Right
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x30, ll,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true
+) // Load Linked word
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x33, pref,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true
+) // Prefetch
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x34, lld,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true
+) // Load Linked Doubleword
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x37, ld,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_DOUBLEWORD_SIGNED
+) // Load Doubleword
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x38, sc,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true
+) // Store Conditional word
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x3C, scd,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true
+) // Store Conditional Doubleword
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x3F, sd,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true,
+    .accessType=RAB_ACCESSTYPE_DOUBLEWORD_SIGNED
+) // Store Doubleword
 
 // OP op, IMM(base)
-RABBITIZER_DEF_INSTR_ID(cpu, 0x2F, cache,   .operands={RAB_OPERAND_cpu_op, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .notEmitedByCompilers=true)     // Cache
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x2F, cache,
+    .operands={RAB_OPERAND_cpu_op, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .notEmitedByCompilers=true
+) // Cache
 
 // OP ft, IMM(base)
-RABBITIZER_DEF_INSTR_ID(cpu, 0x31, lwc1,    .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Load Word to Coprocessor z
-RABBITIZER_DEF_INSTR_ID(cpu, 0x35, ldc1,    .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .isDouble=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)      // Load Doubleword to Coprocessor z
-RABBITIZER_DEF_INSTR_ID(cpu, 0x39, swc1,    .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Store Word from Coprocessor z
-RABBITIZER_DEF_INSTR_ID(cpu, 0x3D, sdc1,    .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .isDouble=true, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)      // Store Doubleword from Coprocessor z
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x31, lwc1,
+    .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isFloat=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_FLOAT_SIGNED
+) // Load Word to Coprocessor z
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x35, ldc1,
+    .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isFloat=true,
+    .isDouble=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_DOUBLEFLOAT_SIGNED
+) // Load Doubleword to Coprocessor z
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x39, swc1,
+    .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isFloat=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true,
+    .accessType=RAB_ACCESSTYPE_FLOAT_SIGNED
+) // Store Word from Coprocessor z
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x3D, sdc1,
+    .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isFloat=true,
+    .isDouble=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true,
+    .accessType=RAB_ACCESSTYPE_DOUBLEFLOAT_SIGNED
+) // Store Doubleword from Coprocessor z
 
 // OP cop2t, IMM(base)
-RABBITIZER_DEF_INSTR_ID(cpu, 0x32, lwc2,    .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Load Word to Coprocessor z
-RABBITIZER_DEF_INSTR_ID(cpu, 0x36, ldc2,    .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)      // Load Doubleword to Coprocessor z
-RABBITIZER_DEF_INSTR_ID(cpu, 0x3A, swc2,    .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Store Word from Coprocessor z
-RABBITIZER_DEF_INSTR_ID(cpu, 0x3E, sdc2,    .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)      // Store Doubleword from Coprocessor z
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x32, lwc2,
+    .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true
+) // Load Word to Coprocessor z
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x36, ldc2,
+    .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true
+) // Load Doubleword to Coprocessor z
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x3A, swc2,
+    .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true
+) // Store Word from Coprocessor z
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x3E, sdc2,
+    .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true
+) // Store Doubleword from Coprocessor z
 
 
 // Pseudo-Instruction Unique IDs
 
 // OP IMM
-RABBITIZER_DEF_INSTR_ID(cpu, -0x03, b,      .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_I, .isBranch=true, .isPseudo=true)         // Branch (unconditional)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, -0x03, b,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isBranch=true,
+    .isPseudo=true
+) // Branch (unconditional)
 
 // OP rs, IMM
-RABBITIZER_DEF_INSTR_ID(cpu, -0x04, beqz,   .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_I, .isBranch=true, .isPseudo=true)      // Branch on EQual Zero
-RABBITIZER_DEF_INSTR_ID(cpu, -0x05, bnez,   .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_I, .isBranch=true, .isPseudo=true)      // Branch on Not Equal Zero
+RABBITIZER_DEF_INSTR_ID(
+    cpu, -0x04, beqz,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isBranch=true,
+    .isPseudo=true
+) // Branch on EQual Zero
+RABBITIZER_DEF_INSTR_ID(
+    cpu, -0x05, bnez,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isBranch=true,
+    .isPseudo=true
+) // Branch on Not Equal Zero

include/instructions/instr_id/cpu/cpu_regimm.inc

@@ -2,24 +2,109 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP rs, IMM
-RABBITIZER_DEF_INSTR_ID(cpu, 0x00, bltz,    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Branch on Less Than Zero
-RABBITIZER_DEF_INSTR_ID(cpu, 0x01, bgez,    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Branch on Greater than or Equal to Zero
-RABBITIZER_DEF_INSTR_ID(cpu, 0x02, bltzl,   .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true, .isBranchLikely=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)     // Branch on Less Than Zero Likely
-RABBITIZER_DEF_INSTR_ID(cpu, 0x03, bgezl,   .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true, .isBranchLikely=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)     // Branch on Greater than or Equal to Zero Likely
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x00, bltz,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true
+) // Branch on Less Than Zero
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x01, bgez,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true
+) // Branch on Greater than or Equal to Zero
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x02, bltzl,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true,
+    .isBranchLikely=true
+) // Branch on Less Than Zero Likely
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x03, bgezl,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true,
+    .isBranchLikely=true
+) // Branch on Greater than or Equal to Zero Likely
 
-RABBITIZER_DEF_INSTR_ID(cpu, 0x08, tgei,    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isTrap=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)
-RABBITIZER_DEF_INSTR_ID(cpu, 0x09, tgeiu,   .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isTrap=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0A, tlti,    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isTrap=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0B, tltiu,   .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isTrap=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0C, teqi,    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isTrap=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0E, tnei,    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isTrap=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x08, tgei,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isTrap=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x09, tgeiu,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isTrap=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0A, tlti,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isTrap=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0B, tltiu,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isTrap=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0C, teqi,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isTrap=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0E, tnei,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isTrap=true
+)
 
-RABBITIZER_DEF_INSTR_ID(cpu, 0x10, bltzal,  .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true, .doesLink=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I) // Branch on Less Than Zero and Link
-RABBITIZER_DEF_INSTR_ID(cpu, 0x11, bgezal,  .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true, .doesLink=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I) // Branch on Greater Than or Equal to Zero and Link
-RABBITIZER_DEF_INSTR_ID(cpu, 0x12, bltzall, .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true, .isBranchLikely=true, .doesLink=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II) // Branch on Less Than Zero and Link Likely
-RABBITIZER_DEF_INSTR_ID(cpu, 0x13, bgezall, .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true, .isBranchLikely=true, .doesLink=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II) // Branch on Greater Than or Equal to Zero and Link Likely
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x10, bltzal,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true,
+    .doesLink=true
+) // Branch on Less Than Zero and Link
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x11, bgezal,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true,
+    .doesLink=true
+) // Branch on Greater Than or Equal to Zero and Link
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x12, bltzall,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true,
+    .isBranchLikely=true,
+    .doesLink=true
+) // Branch on Less Than Zero and Link Likely
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x13, bgezall,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true,
+    .isBranchLikely=true,
+    .doesLink=true
+) // Branch on Greater Than or Equal to Zero and Link Likely
 
 
 // Pseudo-Instruction Unique IDs
 
-RABBITIZER_DEF_INSTR_ID(cpu, -0x11, bal,    .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true, .doesLink=true, .isPseudo=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I) // Branch and Link
+RABBITIZER_DEF_INSTR_ID(
+    cpu, -0x11, bal,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true,
+    .doesLink=true,
+    .isPseudo=true
+) // Branch and Link

include/instructions/instr_id/cpu/cpu_special.inc

@@ -2,92 +2,436 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP rd, rt, sa
-RABBITIZER_DEF_INSTR_ID(cpu, 0x00, sll,                         .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Shift word Left Logical
-RABBITIZER_DEF_INSTR_ID(cpu, 0x02, srl,                         .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Shift word Right Logical
-RABBITIZER_DEF_INSTR_ID(cpu, 0x03, sra,                         .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Shift word Right Arithmetic
-RABBITIZER_DEF_INSTR_ID(cpu, 0x38, dsll,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)      // Doubleword Shift Left Logical
-RABBITIZER_DEF_INSTR_ID(cpu, 0x3A, dsrl,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)      // Doubleword Shift Right Logical
-RABBITIZER_DEF_INSTR_ID(cpu, 0x3B, dsra,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)      // Doubleword Shift Right Arithmetic
-RABBITIZER_DEF_INSTR_ID(cpu, 0x3C, dsll32,                      .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)    // Doubleword Shift Left Logical plus 32
-RABBITIZER_DEF_INSTR_ID(cpu, 0x3E, dsrl32,                      .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)    // Doubleword Shift Right Logical plus 32
-RABBITIZER_DEF_INSTR_ID(cpu, 0x3F, dsra32,                      .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)    // Doubleword Shift Right Arithmetic plus 32
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x00, sll,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Shift word Left Logical
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x02, srl,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Shift word Right Logical
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x03, sra,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Shift word Right Arithmetic
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x38, dsll,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Doubleword Shift Left Logical
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x3A, dsrl,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Doubleword Shift Right Logical
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x3B, dsra,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Doubleword Shift Right Arithmetic
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x3C, dsll32,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Doubleword Shift Left Logical plus 32
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x3E, dsrl32,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Doubleword Shift Right Logical plus 32
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x3F, dsra32,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Doubleword Shift Right Arithmetic plus 32
 
 // OP rd, rt, rs
-RABBITIZER_DEF_INSTR_ID(cpu, 0x14, dsllv,                       .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)     // Doubleword Shift Left Logical Variable
-RABBITIZER_DEF_INSTR_ID(cpu, 0x16, dsrlv,                       .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)     // Doubleword Shift Right Logical Variable
-RABBITIZER_DEF_INSTR_ID(cpu, 0x17, dsrav,                       .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)     // Doubleword Shift Right Arithmetic Variable
-RABBITIZER_DEF_INSTR_ID(cpu, 0x04, sllv,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Shift word Left Logical Variable
-RABBITIZER_DEF_INSTR_ID(cpu, 0x06, srlv,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Shift word Right Logical Variable
-RABBITIZER_DEF_INSTR_ID(cpu, 0x07, srav,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Shift word Right Arithmetic Variable
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x14, dsllv,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Doubleword Shift Left Logical Variable
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x16, dsrlv,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Doubleword Shift Right Logical Variable
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x17, dsrav,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Doubleword Shift Right Arithmetic Variable
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x04, sllv,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Shift word Left Logical Variable
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x06, srlv,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Shift word Right Logical Variable
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x07, srav,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Shift word Right Arithmetic Variable
 
 // OP rs
-RABBITIZER_DEF_INSTR_ID(cpu, 0x11, mthi,                        .operands={RAB_OPERAND_cpu_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I) // Move To HI register
-RABBITIZER_DEF_INSTR_ID(cpu, 0x13, mtlo,                        .operands={RAB_OPERAND_cpu_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Move To LO register
-RABBITIZER_DEF_INSTR_ID(cpu, 0x08, jr,                          .operands={RAB_OPERAND_cpu_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .isJump=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)                        // Jump Register
-RABBITIZER_DEF_INSTR_ID(cpu, 0x09, jalr,                        .operands={RAB_OPERAND_cpu_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .isJump=true, .modifiesRd=true, .doesLink=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Jump And Link Register
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x11, mthi,
+    .operands={RAB_OPERAND_cpu_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesHI=true
+) // Move To HI register
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x13, mtlo,
+    .operands={RAB_OPERAND_cpu_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesLO=true
+) // Move To LO register
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x08, jr,
+    .operands={RAB_OPERAND_cpu_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .isJump=true
+) // Jump Register
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x09, jalr,
+    .operands={RAB_OPERAND_cpu_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .isJump=true,
+    .modifiesRd=true,
+    .doesLink=true
+) // Jump And Link Register
 
 // OP rd, rs
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, -0x09, jalr_rd, jalr,      .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .isJump=true, .modifiesRd=true, .doesLink=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)   // Jump And Link Register // Special case for rd != 31
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, -0x09, jalr_rd, jalr,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .isJump=true,
+    .modifiesRd=true,
+    .doesLink=true
+) // Jump And Link Register // Special case for rd != 31
 
 // OP rd
-RABBITIZER_DEF_INSTR_ID(cpu, 0x10, mfhi,                        .operands={RAB_OPERAND_cpu_rd}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Move From HI register
-RABBITIZER_DEF_INSTR_ID(cpu, 0x12, mflo,                        .operands={RAB_OPERAND_cpu_rd}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Move From LO register
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x10, mfhi,
+    .operands={RAB_OPERAND_cpu_rd},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true,
+    .readsHI=true
+) // Move From HI register
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x12, mflo,
+    .operands={RAB_OPERAND_cpu_rd},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true,
+    .readsLO=true
+) // Move From LO register
 
 // OP rd, rs, rt
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0A, movz,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_IV)      // MOVe conditional on Zero
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0B, movn,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_IV)      // MOVe conditional on Not zero
-RABBITIZER_DEF_INSTR_ID(cpu, 0x1A, div,                         .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // DIVide word
-RABBITIZER_DEF_INSTR_ID(cpu, 0x1B, divu,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // DIVide Unsigned word
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0A, movz,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // MOVe conditional on Zero
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0B, movn,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // MOVe conditional on Not zero
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x1A, div,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesHI=true,
+    .modifiesLO=true
+) // DIVide word
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x1B, divu,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesHI=true,
+    .modifiesLO=true
+) // DIVide Unsigned word
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, -0x1A, sn64_div, div,      .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)  // DIVide word
-RABBITIZER_DEF_INSTR_ID_ALTNAME(cpu, -0x1B, sn64_divu, divu,    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I) // DIVide Unsigned word
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, -0x1A, sn64_div, div,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesHI=true,
+    .modifiesLO=true
+) // DIVide word
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    cpu, -0x1B, sn64_divu, divu,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesHI=true,
+    .modifiesLO=true
+) // DIVide Unsigned word
 
-RABBITIZER_DEF_INSTR_ID(cpu, 0x1E, ddiv,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)      // Doubleword DIVide
-RABBITIZER_DEF_INSTR_ID(cpu, 0x1F, ddivu,                       .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)     // Doubleword DIVide Unsigned
-// RABBITIZER_DEF_INSTR_ID(cpu, , ddiv,                          .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)
-// RABBITIZER_DEF_INSTR_ID(cpu, , ddivu,                         .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)
-RABBITIZER_DEF_INSTR_ID(cpu, 0x20, add,                         .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .notEmitedByCompilers=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // ADD word
-RABBITIZER_DEF_INSTR_ID(cpu, 0x21, addu,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .maybeIsMove=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // ADD Unsigned word
-RABBITIZER_DEF_INSTR_ID(cpu, 0x22, sub,                         .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Subtract word
-RABBITIZER_DEF_INSTR_ID(cpu, 0x23, subu,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // SUBtract Unsigned word
-RABBITIZER_DEF_INSTR_ID(cpu, 0x24, and,                         .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // AND
-RABBITIZER_DEF_INSTR_ID(cpu, 0x25, or,                          .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .maybeIsMove=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)        // OR
-RABBITIZER_DEF_INSTR_ID(cpu, 0x26, xor,                         .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // eXclusive OR
-RABBITIZER_DEF_INSTR_ID(cpu, 0x27, nor,                         .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Not OR
-RABBITIZER_DEF_INSTR_ID(cpu, 0x2A, slt,                         .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Set on Less Than
-RABBITIZER_DEF_INSTR_ID(cpu, 0x2B, sltu,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Set on Less Than Unsigned
-RABBITIZER_DEF_INSTR_ID(cpu, 0x2C, dadd,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)      // Doubleword Add
-RABBITIZER_DEF_INSTR_ID(cpu, 0x2D, daddu,                       .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .maybeIsMove=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)     // Doubleword Add Unsigned
-RABBITIZER_DEF_INSTR_ID(cpu, 0x2E, dsub,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)      // Doubleword SUBtract
-RABBITIZER_DEF_INSTR_ID(cpu, 0x2F, dsubu,                       .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)     // Doubleword SUBtract Unsigned
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x1E, ddiv,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesHI=true,
+    .modifiesLO=true
+) // Doubleword DIVide
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x1F, ddivu,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesHI=true,
+    .modifiesLO=true
+) // Doubleword DIVide Unsigned
+
+/*
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , ddiv,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesHI=true,
+    .modifiesLO=true
+)
+*/
+/*
+RABBITIZER_DEF_INSTR_ID(
+    cpu, , ddivu,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesHI=true,
+    .modifiesLO=true
+)
+*/
+
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x20, add,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true,
+    .notEmitedByCompilers=true
+) // ADD word
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x21, addu,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true,
+    .maybeIsMove=true
+) // ADD Unsigned word
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x22, sub,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Subtract word
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x23, subu,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // SUBtract Unsigned word
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x24, and,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // AND
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x25, or,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true,
+    .maybeIsMove=true
+) // OR
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x26, xor,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // eXclusive OR
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x27, nor,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Not OR
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x2A, slt,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Set on Less Than
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x2B, sltu,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Set on Less Than Unsigned
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x2C, dadd,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Doubleword Add
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x2D, daddu,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true,
+    .maybeIsMove=true
+) // Doubleword Add Unsigned
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x2E, dsub,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Doubleword SUBtract
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x2F, dsubu,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Doubleword SUBtract Unsigned
 
 // OP code
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0C, syscall,                     .operands={RAB_OPERAND_cpu_code}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)   // SYStem CALL
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0D, break,                       .operands={RAB_OPERAND_cpu_code}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)     // Break
-RABBITIZER_DEF_INSTR_ID(cpu, 0x0F, sync,                        .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)      // Sync
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0C, syscall,
+    .operands={RAB_OPERAND_cpu_code},
+    .instrType=RABBITIZER_INSTR_TYPE_R
+) // SYStem CALL
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0D, break,
+    .operands={RAB_OPERAND_cpu_code},
+    .instrType=RABBITIZER_INSTR_TYPE_R
+) // Break
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x0F, sync,
+    .operands={0},
+    .instrType=RABBITIZER_INSTR_TYPE_R
+) // Sync
 
 // OP rs, rt
-RABBITIZER_DEF_INSTR_ID(cpu, 0x18, mult,                        .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // MULTtiply word
-RABBITIZER_DEF_INSTR_ID(cpu, 0x19, multu,                       .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)     // MULTtiply Unsigned word
-RABBITIZER_DEF_INSTR_ID(cpu, 0x1C, dmult,                       .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)     // Doubleword MULTiply
-RABBITIZER_DEF_INSTR_ID(cpu, 0x1D, dmultu,                      .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_III)    // Doubleword MULTiply Unsigned
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x18, mult,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesHI=true,
+    .modifiesLO=true
+) // MULTtiply word
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x19, multu,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesHI=true,
+    .modifiesLO=true
+) // MULTtiply Unsigned word
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x1C, dmult,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesHI=true,
+    .modifiesLO=true
+) // Doubleword MULTiply
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x1D, dmultu,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesHI=true,
+    .modifiesLO=true
+) // Doubleword MULTiply Unsigned
 
-RABBITIZER_DEF_INSTR_ID(cpu, 0x30, tge,                         .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .isTrap=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)       // Trap if Greater or Equal
-RABBITIZER_DEF_INSTR_ID(cpu, 0x31, tgeu,                        .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .isTrap=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)      // Trap if Greater or Equal Unsigned
-RABBITIZER_DEF_INSTR_ID(cpu, 0x32, tlt,                         .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .isTrap=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)       // Trap if Less Than
-RABBITIZER_DEF_INSTR_ID(cpu, 0x33, tltu,                        .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .isTrap=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)      // Trap if Less Than Unsigned
-RABBITIZER_DEF_INSTR_ID(cpu, 0x34, teq,                         .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .isTrap=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)       // Trap if EQual
-RABBITIZER_DEF_INSTR_ID(cpu, 0x36, tne,                         .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .isTrap=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)       // Trap if Not Equal
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x30, tge,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_code_lower},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .isTrap=true
+) // Trap if Greater or Equal
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x31, tgeu,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_code_lower},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .isTrap=true
+) // Trap if Greater or Equal Unsigned
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x32, tlt,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_code_lower},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .isTrap=true
+) // Trap if Less Than
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x33, tltu,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_code_lower},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .isTrap=true
+) // Trap if Less Than Unsigned
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x34, teq,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_code_lower},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .isTrap=true
+) // Trap if EQual
+RABBITIZER_DEF_INSTR_ID(
+    cpu, 0x36, tne,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_code_lower},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .isTrap=true
+) // Trap if Not Equal
 
 
 // Pseudo-Instruction Unique IDs
 
 // OP
-RABBITIZER_DEF_INSTR_ID(cpu, -0x01, nop,                        .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_R, .isPseudo=true)       // No OPeration
+RABBITIZER_DEF_INSTR_ID(
+    cpu, -0x01, nop,
+    .operands={0},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .isPseudo=true
+) // No OPeration
 
 // OP rd, rs
-RABBITIZER_DEF_INSTR_ID(cpu, -0x25, move,                       .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .maybeIsMove=true, .isPseudo=true)      // Move
-RABBITIZER_DEF_INSTR_ID(cpu, -0x27, not,                        .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .isPseudo=true)       // Not
+RABBITIZER_DEF_INSTR_ID(
+    cpu, -0x25, move,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true,
+    .maybeIsMove=true,
+    .isPseudo=true
+) // Move
+RABBITIZER_DEF_INSTR_ID(
+    cpu, -0x27, not,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true,
+    .isPseudo=true
+) // Not
 
 // OP rd, rt
-RABBITIZER_DEF_INSTR_ID(cpu, -0x23, negu,                       .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .isPseudo=true)
+RABBITIZER_DEF_INSTR_ID(
+    cpu, -0x23, negu,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true,
+    .isPseudo=true
+)

include/instructions/instr_id/r5900/r5900_cop0_tlb.inc

@@ -19,5 +19,11 @@
 
 // The other instructions are implemented using the main CPU table
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x38, ei,    .operands={0})
-RABBITIZER_DEF_INSTR_ID(r5900, 0x39, di,    .operands={0})
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x38, ei,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x39, di,
+    .operands={0}
+)

include/instructions/instr_id/r5900/r5900_cop1_fpu_s.inc

@@ -19,28 +19,83 @@
 
 // The other instructions are implemented using the main CPU table
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x04, c1__sqrt_s, c1,    .operands={RAB_OPERAND_cpu_copraw})
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x04, c1__sqrt_s, c1,
+    .operands={RAB_OPERAND_cpu_copraw}
+)
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x16, rsqrt_s, rsqrt.s,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true) // floating point Reciprocal SQuare RooT
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x16, rsqrt_s, rsqrt.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .isFloat=true
+) // floating point Reciprocal SQuare RooT
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x18, adda_s, adda.s,    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true) // floating point ADD to Accumulator
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x19, suba_s, suba.s,    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true) // floating point SUBtract to Accumulator
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x1A, mula_s, mula.s,    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true) // floating point MULtiply to Accumulator
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x18, adda_s, adda.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .isFloat=true
+) // floating point ADD to Accumulator
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x19, suba_s, suba.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .isFloat=true
+) // floating point SUBtract to Accumulator
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x1A, mula_s, mula.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .isFloat=true
+) // floating point MULtiply to Accumulator
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x1C, madd_s, madd.s,    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true) // floating point Multiply-ADD
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x1D, msub_s, msub.s,    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true) // floating point Multiply abd SUBtract
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x1E, madda_s, madda.s,  .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true) // floating point Multiply-ADD Accumulator
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x1F, msuba_s, msuba.s,  .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true) // floating point Multiply SUBtract from Accumulator
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x1C, madd_s, madd.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .isFloat=true
+) // floating point Multiply-ADD
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x1D, msub_s, msub.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .isFloat=true
+) // floating point Multiply abd SUBtract
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x1E, madda_s, madda.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .isFloat=true
+) // floating point Multiply-ADD Accumulator
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x1F, msuba_s, msuba.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .isFloat=true
+) // floating point Multiply SUBtract from Accumulator
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x28, max_s, max.s,      .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true) // floating point MAXimum
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x29, min_s, min.s,      .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true) // floating point MINimum
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x28, max_s, max.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .isFloat=true
+) // floating point MAXimum
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x29, min_s, min.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .isFloat=true
+) // floating point MINimum
 
 // Due to the R5900's FPU being non properly complaint the instruction cvt.w.s always behaves as trunc.w.s because is because EE can only do round-to-zero.
 // Assemblers like GAS workaround this issue by decoding cvt.w.s as trunc.w.s, so we mimic that behaviour to allow assembling with GAS.
 // Here's some reading about the binutils rationale:
 // https://sourceware.org/legacy-ml/binutils/2012-11/msg00360.html
 // https://sourceware.org/pipermail/binutils/2013-January/079863.html
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x24, trunc_w_s, trunc.w.s,  .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .isFloat=true) // Floating-Point Truncate to Word Fixed-Point
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x24, trunc_w_s, trunc.w.s,
+    .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
+    .isFloat=true
+) // Floating-Point Truncate to Word Fixed-Point
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x34, c_lt_s, c.lt.s,        .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, 0x36, c_le_s, c.le.s,        .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x34, c_lt_s, c.lt.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, 0x36, c_le_s, c.le.s,
+    .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
+    .isFloat=true
+)

include/instructions/instr_id/r5900/r5900_cop2.inc

@@ -15,7 +15,19 @@
 */
 
 // TODO: properties
-RABBITIZER_DEF_INSTR_ID(r5900, 0x01, qmfc2, .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vfs})
-RABBITIZER_DEF_INSTR_ID(r5900, 0x02, cfc2,  .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vis})
-RABBITIZER_DEF_INSTR_ID(r5900, 0x05, qmtc2, .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vfs})
-RABBITIZER_DEF_INSTR_ID(r5900, 0x06, ctc2,  .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vis})
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x01, qmfc2,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vfs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x02, cfc2,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vis}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x05, qmtc2,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vfs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x06, ctc2,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vis}
+)

include/instructions/instr_id/r5900/r5900_cop2_bc2.inc

@@ -15,7 +15,25 @@
 
 // TODO: operands and properties
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x00, bc2f,  .operands={RAB_OPERAND_cpu_branch_target_label}, .isBranch=true)
-RABBITIZER_DEF_INSTR_ID(r5900, 0x01, bc2t,  .operands={RAB_OPERAND_cpu_branch_target_label}, .isBranch=true)
-RABBITIZER_DEF_INSTR_ID(r5900, 0x02, bc2fl, .operands={RAB_OPERAND_cpu_branch_target_label}, .isBranch=true, .isBranchLikely=true)
-RABBITIZER_DEF_INSTR_ID(r5900, 0x03, bc2tl, .operands={RAB_OPERAND_cpu_branch_target_label}, .isBranch=true, .isBranchLikely=true)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x00, bc2f,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .isBranch=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x01, bc2t,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .isBranch=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x02, bc2fl,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .isBranch=true,
+    .isBranchLikely=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x03, bc2tl,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .isBranch=true,
+    .isBranchLikely=true
+)

include/instructions/instr_id/r5900/r5900_cop2_special1.inc

@@ -20,63 +20,324 @@
 
 // TODO: properties
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x00, vaddx,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // ADD broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x01, vaddy,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // ADD broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x02, vaddz,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // ADD broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x03, vaddw,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // ADD broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x04, vsubx,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // SUBtract broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x05, vsuby,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // SUBtract broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x06, vsubz,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // SUBtract broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x07, vsubw,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // SUBtract broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x08, vmaddx,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-ADD broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x09, vmaddy,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-ADD broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0A, vmaddz,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-ADD broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0B, vmaddw,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-ADD broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0C, vmsubx,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-SUBtract broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0D, vmsuby,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-SUBtract broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0E, vmsubz,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-SUBtract broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0F, vmsubw,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-SUBtract broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x00, vaddx,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // ADD broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x01, vaddy,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // ADD broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x02, vaddz,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // ADD broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x03, vaddw,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // ADD broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x04, vsubx,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // SUBtract broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x05, vsuby,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // SUBtract broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x06, vsubz,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // SUBtract broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x07, vsubw,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // SUBtract broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x08, vmaddx,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-ADD broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x09, vmaddy,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-ADD broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0A, vmaddz,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-ADD broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0B, vmaddw,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-ADD broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0C, vmsubx,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-SUBtract broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0D, vmsuby,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-SUBtract broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0E, vmsubz,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-SUBtract broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0F, vmsubw,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-SUBtract broadcast
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x10, vmaxx,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MAXimum broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x11, vmaxy,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MAXimum broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x12, vmaxz,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MAXimum broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x13, vmaxw,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MAXimum broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x14, vminix,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MINimum broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x15, vminiy,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MINimum broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x16, vminiz,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MINimum broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x17, vminiw,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MINimum broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x18, vmulx,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MULtiply broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x19, vmuly,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MULtiply broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1A, vmulz,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MULtiply broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1B, vmulw,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MULtiply broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1C, vmulq,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MULtiply Q
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1D, vmaxi,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MAXimum I
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1E, vmuli,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MULtiply I
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1F, vminii,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MINImum I
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x10, vmaxx,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MAXimum broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x11, vmaxy,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MAXimum broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x12, vmaxz,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MAXimum broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x13, vmaxw,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MAXimum broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x14, vminix,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MINimum broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x15, vminiy,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MINimum broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x16, vminiz,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MINimum broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x17, vminiw,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MINimum broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x18, vmulx,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MULtiply broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x19, vmuly,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MULtiply broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1A, vmulz,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MULtiply broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1B, vmulw,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MULtiply broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1C, vmulq,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MULtiply Q
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1D, vmaxi,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MAXimum I
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1E, vmuli,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MULtiply I
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1F, vminii,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MINImum I
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x20, vaddq,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // ADD Q
-RABBITIZER_DEF_INSTR_ID(r5900, 0x21, vmaddq,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-ADD Q
-RABBITIZER_DEF_INSTR_ID(r5900, 0x22, vaddi,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // ADD I
-RABBITIZER_DEF_INSTR_ID(r5900, 0x23, vmaddi,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-ADD I
-RABBITIZER_DEF_INSTR_ID(r5900, 0x24, vsubq,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // SUBtract Q
-RABBITIZER_DEF_INSTR_ID(r5900, 0x25, vmsubq,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-SUBtract Q
-RABBITIZER_DEF_INSTR_ID(r5900, 0x26, vsubi,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // SUBtract I
-RABBITIZER_DEF_INSTR_ID(r5900, 0x27, vmsubi,    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-SUBtract I
-RABBITIZER_DEF_INSTR_ID(r5900, 0x28, vadd,      .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // ADD
-RABBITIZER_DEF_INSTR_ID(r5900, 0x29, vmadd,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-ADD
-RABBITIZER_DEF_INSTR_ID(r5900, 0x2A, vmul,      .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MULtiply
-RABBITIZER_DEF_INSTR_ID(r5900, 0x2B, vmax,      .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MAXimum
-RABBITIZER_DEF_INSTR_ID(r5900, 0x2C, vsub,      .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // SUBtract
-RABBITIZER_DEF_INSTR_ID(r5900, 0x2D, vmsub,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply-SUBtract
-RABBITIZER_DEF_INSTR_ID(r5900, 0x2E, vopmsub,   .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Outer product post decrement
-RABBITIZER_DEF_INSTR_ID(r5900, 0x2F, vmini,     .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // MINImum
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x20, vaddq,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // ADD Q
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x21, vmaddq,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-ADD Q
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x22, vaddi,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // ADD I
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x23, vmaddi,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-ADD I
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x24, vsubq,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // SUBtract Q
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x25, vmsubq,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-SUBtract Q
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x26, vsubi,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // SUBtract I
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x27, vmsubi,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-SUBtract I
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x28, vadd,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // ADD
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x29, vmadd,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-ADD
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x2A, vmul,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MULtiply
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x2B, vmax,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MAXimum
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x2C, vsub,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // SUBtract
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x2D, vmsub,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply-SUBtract
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x2E, vopmsub,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Outer product post decrement
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x2F, vmini,
+    .operands={RAB_OPERAND_r5900_vfdxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // MINImum
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x30, viadd,     .operands={RAB_OPERAND_r5900_vid, RAB_OPERAND_r5900_vis, RAB_OPERAND_r5900_vit}) // Integer ADD
-RABBITIZER_DEF_INSTR_ID(r5900, 0x31, visub,     .operands={RAB_OPERAND_r5900_vid, RAB_OPERAND_r5900_vis, RAB_OPERAND_r5900_vit}) // Integer SUBtract
-RABBITIZER_DEF_INSTR_ID(r5900, 0x32, viaddi,    .operands={RAB_OPERAND_r5900_vit, RAB_OPERAND_r5900_vis, RAB_OPERAND_r5900_immediate5}) // Integer ADD Immediate
-RABBITIZER_DEF_INSTR_ID(r5900, 0x34, viand,     .operands={RAB_OPERAND_r5900_vid, RAB_OPERAND_r5900_vis, RAB_OPERAND_r5900_vit}) // Integer AND
-RABBITIZER_DEF_INSTR_ID(r5900, 0x35, vior,      .operands={RAB_OPERAND_r5900_vid, RAB_OPERAND_r5900_vis, RAB_OPERAND_r5900_vit}) // Integer OR
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x30, viadd,
+    .operands={RAB_OPERAND_r5900_vid, RAB_OPERAND_r5900_vis, RAB_OPERAND_r5900_vit}
+) // Integer ADD
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x31, visub,
+    .operands={RAB_OPERAND_r5900_vid, RAB_OPERAND_r5900_vis, RAB_OPERAND_r5900_vit}
+) // Integer SUBtract
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x32, viaddi,
+    .operands={RAB_OPERAND_r5900_vit, RAB_OPERAND_r5900_vis, RAB_OPERAND_r5900_immediate5}
+) // Integer ADD Immediate
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x34, viand,
+    .operands={RAB_OPERAND_r5900_vid, RAB_OPERAND_r5900_vis, RAB_OPERAND_r5900_vit}
+) // Integer AND
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x35, vior,
+    .operands={RAB_OPERAND_r5900_vid, RAB_OPERAND_r5900_vis, RAB_OPERAND_r5900_vit}
+) // Integer OR
 
 // TODO: operands and properties
-RABBITIZER_DEF_INSTR_ID(r5900, 0x38, vcallms,   .operands={0})
-RABBITIZER_DEF_INSTR_ID(r5900, 0x39, vcallmsr,  .operands={RAB_OPERAND_r5900_vis})
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x38, vcallms,
+    .operands={0}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x39, vcallmsr,
+    .operands={RAB_OPERAND_r5900_vis}
+)

include/instructions/instr_id/r5900/r5900_cop2_special2.inc

@@ -5,7 +5,9 @@
     31---------26-25-----21-20------------------11-10------6-5-2-1--0
     |  =COP2   | Special2 |                        |  fhi  |1111|flo|
     ------6----------5-----------------------------------------------
-Note: opcode is flo | (fhi * 4).
+Note: opcode is flo | (
+    fhi * 4
+).
      |--000--|--001--|--010--|--011--|--100--|--101--|--110--|--111--| lo
 0000 |VADDAx |VADDAy |VADDAz |VADDAw |VSUBAx |VSUBAy |VSUBAz |VSUBAw |
 0001 |VMADDAx|VMADDAy|VMADDAz|VMADDAw|VMSUBAx|VMSUBAy|VMSUBAz|VMSUBAw|
@@ -28,98 +30,414 @@ Note: opcode is flo | (fhi * 4).
 
 // TODO: operands and properties
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x00, vaddax,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Add accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x01, vadday,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Add accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x02, vaddaz,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Add accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x03, vaddaw,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Add accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x04, vsubax,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and substract accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x05, vsubay,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and substract accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x06, vsubaz,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and substract accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x07, vsubaw,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and substract accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x08, vmaddax,   .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw) // Multiply and add accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x09, vmadday,   .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw) // Multiply and add accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0A, vmaddaz,   .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw) // Multiply and add accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0B, vmaddaw,   .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw) // Multiply and add accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0C, vmsubax,   .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and substract accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0D, vmsubay,   .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and substract accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0E, vmsubaz,   .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and substract accumulator broadcast
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0F, vmsubaw,   .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and substract accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x00, vaddax,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Add accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x01, vadday,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Add accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x02, vaddaz,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Add accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x03, vaddaw,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Add accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x04, vsubax,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and substract accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x05, vsubay,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and substract accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x06, vsubaz,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and substract accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x07, vsubaw,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and substract accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x08, vmaddax,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw
+) // Multiply and add accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x09, vmadday,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw
+) // Multiply and add accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0A, vmaddaz,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw
+) // Multiply and add accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0B, vmaddaw,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw
+) // Multiply and add accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0C, vmsubax,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and substract accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0D, vmsubay,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and substract accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0E, vmsubaz,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and substract accumulator broadcast
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0F, vmsubaw,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and substract accumulator broadcast
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x10, vitof0,    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Integer to floating point
-RABBITIZER_DEF_INSTR_ID(r5900, 0x11, vitof4,    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Integer to floating point
-RABBITIZER_DEF_INSTR_ID(r5900, 0x12, vitof12,   .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Integer to floating point
-RABBITIZER_DEF_INSTR_ID(r5900, 0x13, vitof15,   .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Integer to floating point
-RABBITIZER_DEF_INSTR_ID(r5900, 0x14, vftoi0,    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Floating to integer
-RABBITIZER_DEF_INSTR_ID(r5900, 0x15, vftoi4,    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Floating to integer
-RABBITIZER_DEF_INSTR_ID(r5900, 0x16, vftoi12,   .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Floating to integer
-RABBITIZER_DEF_INSTR_ID(r5900, 0x17, vftoi15,   .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Floating to integer
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x10, vitof0,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Integer to floating point
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x11, vitof4,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Integer to floating point
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x12, vitof12,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Integer to floating point
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x13, vitof15,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Integer to floating point
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x14, vftoi0,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Floating to integer
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x15, vftoi4,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Floating to integer
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x16, vftoi12,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Floating to integer
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x17, vftoi15,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Floating to integer
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x18, vmulax,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw)
-RABBITIZER_DEF_INSTR_ID(r5900, 0x19, vmulay,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw)
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1A, vmulaz,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw)
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1B, vmulaw,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x18, vmulax,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x19, vmulay,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1A, vmulaz,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1B, vmulaw,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw
+)
 // TODO
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1C, vmulaq,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1C, vmulaq,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw
+)
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1D, vabs,      .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Absolute
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1D, vabs,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Absolute
 
 // TODO
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1E, vmulai,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1E, vmulai,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw
+)
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1F, vclipw,    .operands={RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Clip
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1F, vclipw,
+    .operands={RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftn},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Clip
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x20, vaddaq,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Add accumulator Q
-RABBITIZER_DEF_INSTR_ID(r5900, 0x21, vmaddaq,   .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and add accumulator Q
-RABBITIZER_DEF_INSTR_ID(r5900, 0x22, vaddai,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Add accumulator I
-RABBITIZER_DEF_INSTR_ID(r5900, 0x23, vmaddai,   .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and add accumulator I
-RABBITIZER_DEF_INSTR_ID(r5900, 0x24, vsubaq,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Subtract accumulator Q
-RABBITIZER_DEF_INSTR_ID(r5900, 0x25, vmsubaq,   .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and Subtract accumulator Q
-RABBITIZER_DEF_INSTR_ID(r5900, 0x26, vsubai,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Subtract accumulator I
-RABBITIZER_DEF_INSTR_ID(r5900, 0x27, vmsubai,   .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and Subtract accumulator I
-RABBITIZER_DEF_INSTR_ID(r5900, 0x28, vadda,     .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Add accumulator
-RABBITIZER_DEF_INSTR_ID(r5900, 0x29, vmadda,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and add accumulator
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x20, vaddaq,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Add accumulator Q
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x21, vmaddaq,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and add accumulator Q
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x22, vaddai,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Add accumulator I
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x23, vmaddai,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and add accumulator I
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x24, vsubaq,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Subtract accumulator Q
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x25, vmsubaq,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_Q},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and Subtract accumulator Q
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x26, vsubai,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Subtract accumulator I
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x27, vmsubai,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_I},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and Subtract accumulator I
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x28, vadda,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Add accumulator
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x29, vmadda,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and add accumulator
 
 // TODO
-RABBITIZER_DEF_INSTR_ID(r5900, 0x2A, vmula,     .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x2A, vmula,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw
+)
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x2C, vsuba,     .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true)
-RABBITIZER_DEF_INSTR_ID(r5900, 0x2D, vmsuba,    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Multiply and substract accumulator
-RABBITIZER_DEF_INSTR_ID(r5900, 0x2E, vopmula,   .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Outer product pre increment
-RABBITIZER_DEF_INSTR_ID(r5900, 0x2F, vnop,      .operands={0}) // No operation
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x2C, vsuba,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x2D, vmsuba,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Multiply and substract accumulator
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x2E, vopmula,
+    .operands={RAB_OPERAND_r5900_ACCxyzw, RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vftxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Outer product pre increment
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x2F, vnop,
+    .operands={0}
+) // No operation
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x30, vmove,     .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Move floating point registers
-RABBITIZER_DEF_INSTR_ID(r5900, 0x31, vmr32,     .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Move and rotate per word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x34, vlqi,      .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vis_postincr}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Load quadraword post increment
-RABBITIZER_DEF_INSTR_ID(r5900, 0x35, vsqi,      .operands={RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vit_postincr}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Store quadraword post increment
-RABBITIZER_DEF_INSTR_ID(r5900, 0x36, vlqd,      .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vis_predecr}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Load quadraword pre decrement
-RABBITIZER_DEF_INSTR_ID(r5900, 0x37, vsqd,      .operands={RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vit_predecr}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Store quadraword pre decrement
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x30, vmove,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Move floating point registers
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x31, vmr32,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vfsxyzw},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Move and rotate per word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x34, vlqi,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vis_postincr},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Load quadraword post increment
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x35, vsqi,
+    .operands={RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vit_postincr},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Store quadraword post increment
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x36, vlqd,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vis_predecr},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Load quadraword pre decrement
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x37, vsqd,
+    .operands={RAB_OPERAND_r5900_vfsxyzw, RAB_OPERAND_r5900_vit_predecr},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Store quadraword pre decrement
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x38, vdiv,      .operands={RAB_OPERAND_r5900_Q, RAB_OPERAND_r5900_vfsl, RAB_OPERAND_r5900_vftm})
-RABBITIZER_DEF_INSTR_ID(r5900, 0x39, vsqrt,     .operands={RAB_OPERAND_r5900_Q, RAB_OPERAND_r5900_vftm})
-RABBITIZER_DEF_INSTR_ID(r5900, 0x3A, vrsqrt,    .operands={RAB_OPERAND_r5900_Q, RAB_OPERAND_r5900_vfsl,RAB_OPERAND_r5900_vftm})
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x38, vdiv,
+    .operands={RAB_OPERAND_r5900_Q, RAB_OPERAND_r5900_vfsl, RAB_OPERAND_r5900_vftm}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x39, vsqrt,
+    .operands={RAB_OPERAND_r5900_Q, RAB_OPERAND_r5900_vftm}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x3A, vrsqrt,
+    .operands={RAB_OPERAND_r5900_Q, RAB_OPERAND_r5900_vfsl,RAB_OPERAND_r5900_vftm}
+)
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x3B, vwaitq,    .operands={0}) // Wait Q operation
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x3B, vwaitq,
+    .operands={0}
+) // Wait Q operation
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x3C, vmtir,     .operands={RAB_OPERAND_r5900_vit, RAB_OPERAND_r5900_vfsl})
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x3C, vmtir,
+    .operands={RAB_OPERAND_r5900_vit, RAB_OPERAND_r5900_vfsl}
+)
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x3D, vmfir,     .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vis}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // Move from integer register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x3D, vmfir,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_vis},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // Move from integer register
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x3E, vilwr,     .operands={RAB_OPERAND_r5900_vit, RAB_OPERAND_r5900_vis}, .isFloat=true, .doesDereference=true, .doesLoad=true) // Integer load word register
-RABBITIZER_DEF_INSTR_ID(r5900, 0x3F, viswr,     .operands={RAB_OPERAND_r5900_vit, RAB_OPERAND_r5900_vis}, .isFloat=true, .doesDereference=true, .doesStore=true) // Integer store word register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x3E, vilwr,
+    .operands={RAB_OPERAND_r5900_vit, RAB_OPERAND_r5900_vis},
+    .isFloat=true,
+    .doesDereference=true,
+    .doesLoad=true
+) // Integer load word register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x3F, viswr,
+    .operands={RAB_OPERAND_r5900_vit, RAB_OPERAND_r5900_vis},
+    .isFloat=true,
+    .doesDereference=true,
+    .doesStore=true
+) // Integer store word register
 /*
-"vilwr.w",		RAB_OPERAND_r5900_vit,(RAB_OPERAND_r5900_vis)
-"vilwr.x",		RAB_OPERAND_r5900_vit,(RAB_OPERAND_r5900_vis)
-"vilwr.y",		RAB_OPERAND_r5900_vit,(RAB_OPERAND_r5900_vis)
-"vilwr.z",		RAB_OPERAND_r5900_vit,(RAB_OPERAND_r5900_vis)
-"viswr.w",		RAB_OPERAND_r5900_vit,(RAB_OPERAND_r5900_vis)
-"viswr.x",		RAB_OPERAND_r5900_vit,(RAB_OPERAND_r5900_vis)
-"viswr.y",		RAB_OPERAND_r5900_vit,(RAB_OPERAND_r5900_vis)
-"viswr.z",		RAB_OPERAND_r5900_vit,(RAB_OPERAND_r5900_vis)
+"vilwr.w",		RAB_OPERAND_r5900_vit,(
+    RAB_OPERAND_r5900_vis
+)
+"vilwr.x",		RAB_OPERAND_r5900_vit,(
+    RAB_OPERAND_r5900_vis
+)
+"vilwr.y",		RAB_OPERAND_r5900_vit,(
+    RAB_OPERAND_r5900_vis
+)
+"vilwr.z",		RAB_OPERAND_r5900_vit,(
+    RAB_OPERAND_r5900_vis
+)
+"viswr.w",		RAB_OPERAND_r5900_vit,(
+    RAB_OPERAND_r5900_vis
+)
+"viswr.x",		RAB_OPERAND_r5900_vit,(
+    RAB_OPERAND_r5900_vis
+)
+"viswr.y",		RAB_OPERAND_r5900_vit,(
+    RAB_OPERAND_r5900_vis
+)
+"viswr.z",		RAB_OPERAND_r5900_vit,(
+    RAB_OPERAND_r5900_vis
+)
 */
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x40, vrnext,    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_R}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // R next
-RABBITIZER_DEF_INSTR_ID(r5900, 0x41, vrget,     .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_R}, .instrSuffix=RABINSTRSUFFIX_R5900_xyzw, .isFloat=true) // R move
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x40, vrnext,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_R},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // R next
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x41, vrget,
+    .operands={RAB_OPERAND_r5900_vftxyzw, RAB_OPERAND_r5900_R},
+    .instrSuffix=RABINSTRSUFFIX_R5900_xyzw,
+    .isFloat=true
+) // R move
 
 // TODO
-RABBITIZER_DEF_INSTR_ID(r5900, 0x42, vrinit,    .operands={RAB_OPERAND_r5900_R, RAB_OPERAND_r5900_vfsl})
-RABBITIZER_DEF_INSTR_ID(r5900, 0x43, vrxor,     .operands={RAB_OPERAND_r5900_R, RAB_OPERAND_r5900_vfsl})
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x42, vrinit,
+    .operands={RAB_OPERAND_r5900_R, RAB_OPERAND_r5900_vfsl}
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x43, vrxor,
+    .operands={RAB_OPERAND_r5900_R, RAB_OPERAND_r5900_vfsl}
+)

include/instructions/instr_id/r5900/r5900_mmi.inc

@@ -19,31 +19,109 @@
      *3 = MMI1 list                    *4 = MMI3 list
 */
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x00, madd,      .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Multiply-ADD word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x01, maddu,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Multiply-ADD Unsigned word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x04, plzcw,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs}, .modifiesRd=true) // Parallel Leading Zero or one Count Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x00, madd,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Multiply-ADD word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x01, maddu,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Multiply-ADD Unsigned word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x04, plzcw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs},
+    .modifiesRd=true
+) // Parallel Leading Zero or one Count Word
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x10, mfhi1,     .operands={RAB_OPERAND_cpu_rd}, .modifiesRd=true) // Move From HI1 register
-RABBITIZER_DEF_INSTR_ID(r5900, 0x11, mthi1,     .operands={RAB_OPERAND_cpu_rs}) // Move To HI1 register
-RABBITIZER_DEF_INSTR_ID(r5900, 0x12, mflo1,     .operands={RAB_OPERAND_cpu_rd}) // Move From LO1 register
-RABBITIZER_DEF_INSTR_ID(r5900, 0x13, mtlo1,     .operands={RAB_OPERAND_cpu_rs}) // Move To LO1 register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x10, mfhi1,
+    .operands={RAB_OPERAND_cpu_rd},
+    .modifiesRd=true
+) // Move From HI1 register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x11, mthi1,
+    .operands={RAB_OPERAND_cpu_rs}
+) // Move To HI1 register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x12, mflo1,
+    .operands={RAB_OPERAND_cpu_rd}
+) // Move From LO1 register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x13, mtlo1,
+    .operands={RAB_OPERAND_cpu_rs}
+) // Move To LO1 register
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x18, mult1,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // MULTiply word pipeline 1
-RABBITIZER_DEF_INSTR_ID(r5900, 0x19, multu1,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // MULTiply Unsigned word pipeline 1
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1A, div1,      .operands={RAB_OPERAND_cpu_zero, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}) // DIVide word pipeline 1
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1B, divu1,     .operands={RAB_OPERAND_cpu_zero, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}) // DIVide Unsigned word pipeline 1
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x18, mult1,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // MULTiply word pipeline 1
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x19, multu1,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // MULTiply Unsigned word pipeline 1
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1A, div1,
+    .operands={RAB_OPERAND_cpu_zero, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}
+) // DIVide word pipeline 1
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1B, divu1,
+    .operands={RAB_OPERAND_cpu_zero, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}
+) // DIVide Unsigned word pipeline 1
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x20, madd1,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Multiply-ADD word pipeline 1
-RABBITIZER_DEF_INSTR_ID(r5900, 0x21, maddu1,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Multiply-ADD Unsigned word pipeline 1
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x20, madd1,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Multiply-ADD word pipeline 1
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x21, maddu1,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Multiply-ADD Unsigned word pipeline 1
 
 // TODO: check this two instruction, it is supposed to have an extra .fmt
-RABBITIZER_DEF_INSTR_ID(r5900, 0x30, pmfhl,     .operands={RAB_OPERAND_cpu_rd}, .modifiesRd=true) // Parallel Move From Hi/Lo register
-RABBITIZER_DEF_INSTR_ID(r5900, 0x31, pmthl,     .operands={RAB_OPERAND_cpu_rs}) // Parallel Move To Hi/Lo register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x30, pmfhl,
+    .operands={RAB_OPERAND_cpu_rd},
+    .modifiesRd=true
+) // Parallel Move From Hi/Lo register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x31, pmthl,
+    .operands={RAB_OPERAND_cpu_rs}
+) // Parallel Move To Hi/Lo register
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x34, psllh,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .modifiesRd=true) // Parallel Shift Left Logical Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x36, psrlh,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .modifiesRd=true) // Parallel Shift Right Logical Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x37, psrah,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .modifiesRd=true) // Parallel Shift Right Arithmetic Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x34, psllh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .modifiesRd=true
+) // Parallel Shift Left Logical Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x36, psrlh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .modifiesRd=true
+) // Parallel Shift Right Logical Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x37, psrah,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .modifiesRd=true
+) // Parallel Shift Right Arithmetic Halfword
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x3C, psllw,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .modifiesRd=true) // Parallel Shift Left Logical Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x3E, psrlw,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .modifiesRd=true) // Parallel Shift Right Logical Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x3F, psraw,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa}, .modifiesRd=true) // Parallel Shift Right Arithmetic Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x3C, psllw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .modifiesRd=true
+) // Parallel Shift Left Logical Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x3E, psrlw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .modifiesRd=true
+) // Parallel Shift Right Logical Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x3F, psraw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_sa},
+    .modifiesRd=true
+) // Parallel Shift Right Arithmetic Word

include/instructions/instr_id/r5900/r5900_mmi_0.inc

@@ -17,34 +17,134 @@
  hi |-------|-------|-------|-------|
 */
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x00, paddw,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel ADD Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x01, psubw,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel SUBtract Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x02, pcgtw,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Compare for Greater Than Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x03, pmaxw,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel MAXimum Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x00, paddw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel ADD Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x01, psubw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel SUBtract Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x02, pcgtw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Compare for Greater Than Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x03, pmaxw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel MAXimum Word
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x04, paddh,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel ADD Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x05, psubh,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel SUBtract Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x06, pcgth,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Compare for Greater Than Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x07, pmaxh,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel MAXimum Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x04, paddh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel ADD Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x05, psubh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel SUBtract Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x06, pcgth,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Compare for Greater Than Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x07, pmaxh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel MAXimum Halfword
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x08, paddb,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel ADD Byte
-RABBITIZER_DEF_INSTR_ID(r5900, 0x09, psubb,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel SUBtract Byte
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0A, pcgtb,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Compare for Greater Than Byte
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x08, paddb,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel ADD Byte
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x09, psubb,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel SUBtract Byte
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0A, pcgtb,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Compare for Greater Than Byte
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x10, paddsw,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel ADD with Signed saturation Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x11, psubsw,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel SUBtract with Signed saturation Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x12, pextlw,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel EXTend Lower from Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x13, ppacw,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel PACk to Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x10, paddsw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel ADD with Signed saturation Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x11, psubsw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel SUBtract with Signed saturation Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x12, pextlw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel EXTend Lower from Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x13, ppacw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel PACk to Word
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x14, paddsh,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel ADD with Signed saturation Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x15, psubsh,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel SUBtract with Signed saturation Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x16, pextlh,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel EXTend Lower from Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x17, ppach,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel PACk to Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x14, paddsh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel ADD with Signed saturation Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x15, psubsh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel SUBtract with Signed saturation Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x16, pextlh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel EXTend Lower from Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x17, ppach,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel PACk to Halfword
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x18, paddsb,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel ADD with Signed saturation Bytes
-RABBITIZER_DEF_INSTR_ID(r5900, 0x19, psubsb,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel SUBtract with Signed saturation Bytes
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1A, pextlb,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel EXTend Lower from Bytes
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1B, ppacb,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel PACk to Bytes
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x18, paddsb,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel ADD with Signed saturation Bytes
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x19, psubsb,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel SUBtract with Signed saturation Bytes
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1A, pextlb,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel EXTend Lower from Bytes
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1B, ppacb,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel PACk to Bytes
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1E, pext5,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel EXTend from 5-bits
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1F, ppac5,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel PACk to 5-bits
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1E, pext5,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel EXTend from 5-bits
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1F, ppac5,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel PACk to 5-bits

include/instructions/instr_id/r5900/r5900_mmi_1.inc

@@ -18,26 +18,98 @@
 */
 
 // TODO: operands and properties
-RABBITIZER_DEF_INSTR_ID(r5900, 0x01, pabsw,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel ABSolute Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x02, pceqw,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Compare for EQual Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x03, pminw,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel MINimum Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x01, pabsw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel ABSolute Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x02, pceqw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Compare for EQual Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x03, pminw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel MINimum Word
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x04, padsbh,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel ADd/SuBtract Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x05, pabsh,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel ABSolute Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x06, pceqh,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Compare for EQual Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x07, pminh,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel MINimum Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x04, padsbh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel ADd/SuBtract Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x05, pabsh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel ABSolute Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x06, pceqh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Compare for EQual Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x07, pminh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel MINimum Halfword
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0A, pceqb,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Compare for EQual Byte
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0A, pceqb,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Compare for EQual Byte
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x10, padduw,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel ADD Unsigned saturation Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x11, psubuw,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel SUBtract Unsigned saturation Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x12, pextuw,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel EXTend Upper from Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x10, padduw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel ADD Unsigned saturation Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x11, psubuw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel SUBtract Unsigned saturation Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x12, pextuw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel EXTend Upper from Word
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x14, padduh,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel ADD Unsigned saturation Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x15, psubuh,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel SUBtract Unsigned saturation Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x16, pextuh,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel EXTend Upper from Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x14, padduh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel ADD Unsigned saturation Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x15, psubuh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel SUBtract Unsigned saturation Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x16, pextuh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel EXTend Upper from Halfword
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x18, paddub,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel ADD Unsigned saturation Byte
-RABBITIZER_DEF_INSTR_ID(r5900, 0x19, psubub,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel SUBtract Unsigned saturation Byte
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1A, pextub,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel EXTend Upper from Byte
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1B, qfsrv,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Quadword Funnel Shift Right Variable
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x18, paddub,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel ADD Unsigned saturation Byte
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x19, psubub,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel SUBtract Unsigned saturation Byte
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1A, pextub,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel EXTend Upper from Byte
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1B, qfsrv,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Quadword Funnel Shift Right Variable

include/instructions/instr_id/r5900/r5900_mmi_2.inc

@@ -17,32 +17,119 @@
  hi |-------|-------|-------|-------|
 */
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x00, pmaddw,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Multiply-ADD Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x02, psllvw,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs}, .modifiesRd=true) // Parallel Shift Left Logical Variable Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x03, psrlvw,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs}, .modifiesRd=true) // Parallel Shift Right Logical Variable Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x00, pmaddw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Multiply-ADD Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x02, psllvw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs},
+    .modifiesRd=true
+) // Parallel Shift Left Logical Variable Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x03, psrlvw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs},
+    .modifiesRd=true
+) // Parallel Shift Right Logical Variable Word
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x04, pmsubw,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Multiply-SUBtract Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x04, pmsubw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Multiply-SUBtract Word
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x08, pmfhi,     .operands={RAB_OPERAND_cpu_rd}, .modifiesRd=true) // Parallel Move From HI register
-RABBITIZER_DEF_INSTR_ID(r5900, 0x09, pmflo,     .operands={RAB_OPERAND_cpu_rd}, .modifiesRd=true) // Parallel Move From LO register
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0A, pinth,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel INTerleave Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x08, pmfhi,
+    .operands={RAB_OPERAND_cpu_rd},
+    .modifiesRd=true
+) // Parallel Move From HI register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x09, pmflo,
+    .operands={RAB_OPERAND_cpu_rd},
+    .modifiesRd=true
+) // Parallel Move From LO register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0A, pinth,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel INTerleave Halfword
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0C, pmultw,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel MULTiply Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0D, pdivw,     .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}) // Parallel DIVide Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0E, pcpyld,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel CoPY Lower Doubleword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0C, pmultw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel MULTiply Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0D, pdivw,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}
+) // Parallel DIVide Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0E, pcpyld,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel CoPY Lower Doubleword
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x10, pmaddh,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Multiply-ADD Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x11, phmadh,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Horizontal Multiply-ADd Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x12, pand,      .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel AND
-RABBITIZER_DEF_INSTR_ID(r5900, 0x13, pxor,      .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel eXclusive OR
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x10, pmaddh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Multiply-ADD Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x11, phmadh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Horizontal Multiply-ADd Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x12, pand,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel AND
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x13, pxor,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel eXclusive OR
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x14, pmsubh,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Multiply-SUBtract Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x15, phmsbh,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Horizontal Multiply-Subtract Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x14, pmsubh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Multiply-SUBtract Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x15, phmsbh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Horizontal Multiply-Subtract Halfword
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1A, pexeh,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel EXchange Even Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1B, prevh,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel REVerse Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1A, pexeh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel EXchange Even Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1B, prevh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel REVerse Halfword
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1C, pmulth,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Multiply Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1D, pdivbw,    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel DIVide Broadcast Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1E, pexew,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel EXchange Even Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1F, prot3w,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel ROTate 3 Words left
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1C, pmulth,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Multiply Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1D, pdivbw,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel DIVide Broadcast Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1E, pexew,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel EXchange Even Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1F, prot3w,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel ROTate 3 Words left

include/instructions/instr_id/r5900/r5900_mmi_3.inc

@@ -17,21 +17,70 @@
  hi |-------|-------|-------|-------|
 */
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x00, pmadduw,   .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Multiply-ADD Unsigned Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x03, psravw,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs}, .modifiesRd=true) // Parallel Shift Right Arithmetic Variable Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x00, pmadduw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Multiply-ADD Unsigned Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x03, psravw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_rs},
+    .modifiesRd=true
+) // Parallel Shift Right Arithmetic Variable Word
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x08, pmthi,     .operands={RAB_OPERAND_cpu_rs}) // Parallel Move To HI register
-RABBITIZER_DEF_INSTR_ID(r5900, 0x09, pmtlo,     .operands={RAB_OPERAND_cpu_rs}) // Parallel Move To LO register
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0A, pinteh,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel INTerleave Even Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x08, pmthi,
+    .operands={RAB_OPERAND_cpu_rs}
+) // Parallel Move To HI register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x09, pmtlo,
+    .operands={RAB_OPERAND_cpu_rs}
+) // Parallel Move To LO register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0A, pinteh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel INTerleave Even Halfword
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0C, pmultuw,   .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel MULTiply Unsigned Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0D, pdivuw,    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}) // Prallel DIVide Unsigned Word
-RABBITIZER_DEF_INSTR_ID(r5900, 0x0E, pcpyud,    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel CoPY Upper Doubleword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0C, pmultuw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel MULTiply Unsigned Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0D, pdivuw,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}
+) // Prallel DIVide Unsigned Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x0E, pcpyud,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel CoPY Upper Doubleword
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x12, por,       .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel OR
-RABBITIZER_DEF_INSTR_ID(r5900, 0x13, pnor,      .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel Not OR
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x12, por,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel OR
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x13, pnor,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel Not OR
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1A, pexch,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel EXchange Center Halfword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1B, pcpyh,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel CoPY Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1A, pexch,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel EXchange Center Halfword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1B, pcpyh,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel CoPY Halfword
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1E, pexcw,     .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt}, .modifiesRd=true) // Parallel EXchange Center Word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1E, pexcw,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rt},
+    .modifiesRd=true
+) // Parallel EXchange Center Word

include/instructions/instr_id/r5900/r5900_normal.inc

@@ -23,9 +23,36 @@
 // The other instructions are implemented using the main CPU table
 
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1E, lq,    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true) // Load Quadword
-RABBITIZER_DEF_INSTR_ID(r5900, 0x1F, sq,    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true) // Store Quadword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1E, lq,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true
+) // Load Quadword
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x1F, sq,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true
+) // Store Quadword
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x36, lqc2,  .operands={RAB_OPERAND_r5900_vft, RAB_OPERAND_cpu_immediate_base}, .canBeLo=true, .doesDereference=true, .doesLoad=true)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x36, lqc2,
+    .operands={RAB_OPERAND_r5900_vft, RAB_OPERAND_cpu_immediate_base},
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true
+)
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x3E, sqc2,  .operands={RAB_OPERAND_r5900_vft, RAB_OPERAND_cpu_immediate_base}, .canBeLo=true, .doesDereference=true, .doesStore=true)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x3E, sqc2,
+    .operands={RAB_OPERAND_r5900_vft, RAB_OPERAND_cpu_immediate_base},
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true
+)

include/instructions/instr_id/r5900/r5900_regimm.inc

@@ -16,5 +16,13 @@
 // The other instructions are implemented using the main CPU table
 
 // OP rs, IMM
-RABBITIZER_DEF_INSTR_ID(r5900, 0x18, mtsab, .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM)
-RABBITIZER_DEF_INSTR_ID(r5900, 0x19, mtsah, .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x18, mtsab,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM
+)
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x19, mtsah,
+    .operands={RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM
+)

include/instructions/instr_id/r5900/r5900_special.inc

@@ -19,9 +19,25 @@
 
 // The other instructions are implemented using the main CPU table
 
-RABBITIZER_DEF_INSTR_ID_ALTNAME(r5900, -0x0F, sync_p, sync.p,   .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_R, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_II)      // Sync
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    r5900, -0x0F, sync_p, sync.p,
+    .operands={0},
+    .instrType=RABBITIZER_INSTR_TYPE_R
+) // Sync
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x18, mult,                      .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)      // MULTtiply word
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x18, mult,
+    .operands={RAB_OPERAND_cpu_rd, RAB_OPERAND_cpu_rs, RAB_OPERAND_cpu_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // MULTtiply word
 
-RABBITIZER_DEF_INSTR_ID(r5900, 0x28, mfsa,                      .operands={RAB_OPERAND_cpu_rd}, .modifiesRd=true) // Move From Shift Amount register
-RABBITIZER_DEF_INSTR_ID(r5900, 0x29, mtsa,                      .operands={RAB_OPERAND_cpu_rs}) // Move To Shift Amount register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x28, mfsa,
+    .operands={RAB_OPERAND_cpu_rd},
+    .modifiesRd=true
+) // Move From Shift Amount register
+RABBITIZER_DEF_INSTR_ID(
+    r5900, 0x29, mtsa,
+    .operands={RAB_OPERAND_cpu_rs}
+) // Move To Shift Amount register

include/instructions/instr_id/rsp/rsp_cop0.inc

@@ -2,5 +2,16 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP rt, cop0d
-RABBITIZER_DEF_INSTR_ID(rsp, 0x00, mfc0,    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_cop0d}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .modifiesRt=true, .notEmitedByCompilers=true)      // Move word From CP0
-RABBITIZER_DEF_INSTR_ID(rsp, 0x04, mtc0,    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_cop0d}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .notEmitedByCompilers=true)      // Move word to CP0
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x00, mfc0,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_cop0d},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .modifiesRt=true,
+    .notEmitedByCompilers=true
+) // Move word From CP0
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x04, mtc0,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_cop0d},
+    .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
+    .notEmitedByCompilers=true
+) // Move word to CP0

include/instructions/instr_id/rsp/rsp_cop2.inc

@@ -2,9 +2,23 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP cop2t, vd[index]
-RABBITIZER_DEF_INSTR_ID(rsp, 0x00, mfc2,    .operands={RAB_OPERAND_rsp_cop2t, RAB_OPERAND_rsp_vs_index}, .modifiesRt=true)
-RABBITIZER_DEF_INSTR_ID(rsp, 0x04, mtc2,    .operands={RAB_OPERAND_rsp_cop2t, RAB_OPERAND_rsp_vs_index})
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x00, mfc2,
+    .operands={RAB_OPERAND_rsp_cop2t, RAB_OPERAND_rsp_vs_index},
+    .modifiesRt=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x04, mtc2,
+    .operands={RAB_OPERAND_rsp_cop2t, RAB_OPERAND_rsp_vs_index}
+)
 
 // OP rt, cop2cd
-RABBITIZER_DEF_INSTR_ID(rsp, 0x02, cfc2,    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_rsp_cop2cd}, .modifiesRt=true)
-RABBITIZER_DEF_INSTR_ID(rsp, 0x06, ctc2,    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_rsp_cop2cd})
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x02, cfc2,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_rsp_cop2cd},
+    .modifiesRt=true
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x06, ctc2,
+    .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_rsp_cop2cd}
+)

include/instructions/instr_id/rsp/rsp_cop2_vu.inc

@@ -2,52 +2,184 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP vd, vs, vt[elementhigh]
-RABBITIZER_DEF_INSTR_ID(rsp, 0x00, vmulf,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x01, vmulu,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x02, vrndp,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x03, vmulq,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x04, vmudl,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x05, vmudm,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x06, vmudn,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x07, vmudh,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x08, vmacf,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x09, vmacu,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0A, vrndn,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0B, vmacq,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0C, vmadl,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0D, vmadm,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0E, vmadn,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0F, vmadh,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x10, vadd,                  .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x11, vsub,                  .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x13, vabs,                  .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x14, vaddc,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x15, vsubc,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x1D, vsar,                  .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x28, vand,                  .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x29, vnand,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x2A, vor,                   .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x2B, vnor,                  .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x2C, vxor,                  .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x2D, vnxor,                 .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x00, vmulf,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x01, vmulu,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x02, vrndp,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x03, vmulq,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x04, vmudl,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x05, vmudm,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x06, vmudn,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x07, vmudh,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x08, vmacf,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x09, vmacu,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0A, vrndn,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0B, vmacq,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0C, vmadl,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0D, vmadm,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0E, vmadn,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0F, vmadh,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x10, vadd,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x11, vsub,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x13, vabs,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x14, vaddc,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x15, vsubc,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x1D, vsar,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x28, vand,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x29, vnand,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x2A, vor,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x2B, vnor,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x2C, vxor,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x2D, vnxor,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
 
-RABBITIZER_DEF_INSTR_ID(rsp, 0x20, vlt,                   .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x21, veq,                   .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x22, vne,                   .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x23, vge,                   .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x24, vcl,                   .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x25, vch,                   .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x26, vcr,                   .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x27, vmrg,                  .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh})
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x20, vlt,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x21, veq,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x22, vne,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x23, vge,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x24, vcl,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x25, vch,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x26, vcr,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x27, vmrg,
+    .operands={RAB_OPERAND_rsp_vd, RAB_OPERAND_rsp_vs, RAB_OPERAND_rsp_vt_elementhigh}
+)
 
 // OP vd[de], vt[elementhigh]
-RABBITIZER_DEF_INSTR_ID(rsp, 0x30, vrcp,                  .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x31, vrcpl,                 .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh}) // operands may be wrong
-RABBITIZER_DEF_INSTR_ID(rsp, 0x32, vrcph,                 .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x33, vmov,                  .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x34, vrsq,                  .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x35, vrsql,                 .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x36, vrsqh,                 .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh})
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x30, vrcp,
+    .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x31, vrcpl,
+    .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh}
+) // operands may be wrong
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x32, vrcph,
+    .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x33, vmov,
+    .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x34, vrsq,
+    .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x35, vrsql,
+    .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x36, vrsqh,
+    .operands={RAB_OPERAND_rsp_vd_de, RAB_OPERAND_rsp_vt_elementhigh}
+)
 
 // OP
-RABBITIZER_DEF_INSTR_ID(rsp, 0x37, vnop,                  .operands={0})
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x37, vnop,
+    .operands={0}
+)

include/instructions/instr_id/rsp/rsp_normal.inc

@@ -2,52 +2,248 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP LABEL
-RABBITIZER_DEF_INSTR_ID(rsp, 0x02, j,       .operands={RAB_OPERAND_cpu_label}, .instrType=RABBITIZER_INSTR_TYPE_J, .isJump=true)         // Jump
-RABBITIZER_DEF_INSTR_ID(rsp, 0x03, jal,     .operands={RAB_OPERAND_cpu_label}, .instrType=RABBITIZER_INSTR_TYPE_J, .isJump=true, .doesLink=true)       // Jump And Link
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x02, j,
+    .operands={RAB_OPERAND_cpu_label},
+    .instrType=RABBITIZER_INSTR_TYPE_J,
+    .isJump=true,
+    .isJumpWithAddress=true
+) // Jump
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x03, jal,
+    .operands={RAB_OPERAND_cpu_label},
+    .instrType=RABBITIZER_INSTR_TYPE_J,
+    .isJump=true,
+    .isJumpWithAddress=true,
+    .doesLink=true
+) // Jump And Link
 
 // OP rs, rt, IMM
-RABBITIZER_DEF_INSTR_ID(rsp, 0x04, beq,     .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true)       // Branch on EQual
-RABBITIZER_DEF_INSTR_ID(rsp, 0x05, bne,     .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true)       // Branch on Not Equal
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x04, beq,
+    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true
+) // Branch on EQual
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x05, bne,
+    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true
+) // Branch on Not Equal
 
 // OP rs, IMM
-RABBITIZER_DEF_INSTR_ID(rsp, 0x06, blez,    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true)      // Branch on Less than or Equal to Zero
-RABBITIZER_DEF_INSTR_ID(rsp, 0x07, bgtz,    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true)      // Branch on Greater Than Zero
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x06, blez,
+    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true
+) // Branch on Less than or Equal to Zero
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x07, bgtz,
+    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true
+) // Branch on Greater Than Zero
 
 // OP rt, rs, IMM
-RABBITIZER_DEF_INSTR_ID(rsp, 0x08, addi,    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .notEmitedByCompilers=true, .canBeLo=true)      // Add Immediate
-RABBITIZER_DEF_INSTR_ID(rsp, 0x09, addiu,   .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true)     // Add Immediate Unsigned Word
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0A, slti,    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true)      // Set on Less Than Immediate
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0B, sltiu,   .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true)     // Set on Less Than Immediate Unsigned
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0C, andi,    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .isUnsigned=true, .modifiesRt=true)      // And Immediate
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0D, ori,     .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .isUnsigned=true, .modifiesRt=true, .canBeLo=true)       // Or Immediate
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0E, xori,    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .isUnsigned=true, .modifiesRt=true)      // eXclusive OR Immediate
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x08, addi,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .notEmitedByCompilers=true,
+    .canBeLo=true
+) // Add Immediate
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x09, addiu,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true
+) // Add Immediate Unsigned Word
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0A, slti,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true
+) // Set on Less Than Immediate
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0B, sltiu,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true
+) // Set on Less Than Immediate Unsigned
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0C, andi,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isUnsigned=true,
+    .modifiesRt=true
+) // And Immediate
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0D, ori,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isUnsigned=true,
+    .modifiesRt=true,
+    .canBeLo=true
+) // Or Immediate
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0E, xori,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isUnsigned=true,
+    .modifiesRt=true
+) // eXclusive OR Immediate
 
 // OP rt, IMM
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0F, lui,     .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_cpu_immediate}, .instrType=RABBITIZER_INSTR_TYPE_I, .isUnsigned=true, .modifiesRt=true, .canBeHi=true)       // Load Upper Immediate
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0F, lui,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_cpu_immediate},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isUnsigned=true,
+    .modifiesRt=true,
+    .canBeHi=true
+) // Load Upper Immediate
 
 // OP rt, IMM(base)
-RABBITIZER_DEF_INSTR_ID(rsp, 0x20, lb,      .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)        // Load Byte
-RABBITIZER_DEF_INSTR_ID(rsp, 0x21, lh,      .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)        // Load Halfword
-RABBITIZER_DEF_INSTR_ID(rsp, 0x23, lw,      .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)        // Load Word
-RABBITIZER_DEF_INSTR_ID(rsp, 0x24, lbu,     .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Load Byte Insigned
-RABBITIZER_DEF_INSTR_ID(rsp, 0x25, lhu,     .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)       // Load Halfword Unsigned
-RABBITIZER_DEF_INSTR_ID(rsp, 0x28, sb,      .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)        // Store Byte
-RABBITIZER_DEF_INSTR_ID(rsp, 0x29, sh,      .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)        // Store Halfword
-RABBITIZER_DEF_INSTR_ID(rsp, 0x2B, sw,      .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)        // Store Word
-RABBITIZER_DEF_INSTR_ID(rsp, 0x33, pref,    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .modifiesRt=true, .canBeLo=true, .doesDereference=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_IV)      // Prefetch
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x20, lb,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_BYTE_SIGNED
+) // Load Byte
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x21, lh,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_SHORT_SIGNED
+) // Load Halfword
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x23, lw,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_WORD_SIGNED
+) // Load Word
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x24, lbu,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_BYTE_UNSIGNED
+) // Load Byte Insigned
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x25, lhu,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_SHORT_UNSIGNED
+) // Load Halfword Unsigned
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x28, sb,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true,
+    .accessType=RAB_ACCESSTYPE_BYTE_SIGNED
+) // Store Byte
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x29, sh,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true,
+    .accessType=RAB_ACCESSTYPE_SHORT_SIGNED
+) // Store Halfword
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x2B, sw,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true,
+    .accessType=RAB_ACCESSTYPE_WORD_SIGNED
+) // Store Word
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x33, pref,
+    .operands={RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .modifiesRt=true,
+    .canBeLo=true,
+    .doesDereference=true
+) // Prefetch
 
-RABBITIZER_DEF_INSTR_ID(rsp, 0x2F, cache,   .operands={RAB_OPERAND_cpu_op, RAB_OPERAND_rsp_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .notEmitedByCompilers=true)     // Cache
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x2F, cache,
+    .operands={RAB_OPERAND_cpu_op, RAB_OPERAND_rsp_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .notEmitedByCompilers=true
+) // Cache
 
 // OP ft, IMM(base)
-RABBITIZER_DEF_INSTR_ID(rsp, 0x31, lwc1,    .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_rsp_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Load Word to Coprocessor z
-RABBITIZER_DEF_INSTR_ID(rsp, 0x39, swc1,    .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_rsp_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .canBeLo=true, .doesDereference=true, .doesStore=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I)      // Store Word from Coprocessor z
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x31, lwc1,
+    .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_rsp_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isFloat=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesLoad=true,
+    .accessType=RAB_ACCESSTYPE_FLOAT_SIGNED
+) // Load Word to Coprocessor z
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x39, swc1,
+    .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_rsp_immediate_base},
+    .instrType=RABBITIZER_INSTR_TYPE_I,
+    .isFloat=true,
+    .canBeLo=true,
+    .doesDereference=true,
+    .doesStore=true,
+    .accessType=RAB_ACCESSTYPE_FLOAT_SIGNED
+) // Store Word from Coprocessor z
 
 
 // Pseudo-Instruction Unique IDs
 
 // OP IMM
-RABBITIZER_DEF_INSTR_ID(rsp, -0x03, b,      .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true)         // Branch (unconditional)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, -0x03, b,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true
+) // Branch (unconditional)
 
 // OP rs, IMM
-RABBITIZER_DEF_INSTR_ID(rsp, -0x04, beqz,   .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true)      // Branch on EQual Zero
-RABBITIZER_DEF_INSTR_ID(rsp, -0x05, bnez,   .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true)      // Branch on Not Equal Zero
+RABBITIZER_DEF_INSTR_ID(
+    rsp, -0x04, beqz,
+    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true
+) // Branch on EQual Zero
+RABBITIZER_DEF_INSTR_ID(
+    rsp, -0x05, bnez,
+    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true
+) // Branch on Not Equal Zero

include/instructions/instr_id/rsp/rsp_normal_lwc2.inc

@@ -2,14 +2,47 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP vt[elementlow], offset(vs)
-RABBITIZER_DEF_INSTR_ID(rsp, 0x00, lbv, .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x01, lsv, .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x02, llv, .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x03, ldv, .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x04, lqv, .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x05, lrv, .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x06, lpv, .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x07, luv, .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x08, lhv, .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x09, lfv, .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0B, ltv, .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x00, lbv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x01, lsv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x02, llv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x03, ldv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x04, lqv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x05, lrv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x06, lpv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x07, luv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x08, lhv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x09, lfv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0B, ltv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)

include/instructions/instr_id/rsp/rsp_normal_swc2.inc

@@ -2,16 +2,52 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP vt[elementlow], offset(vs)
-RABBITIZER_DEF_INSTR_ID(rsp, 0x00, sbv,     .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x01, ssv,     .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x02, slv,     .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x03, sdv,     .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x04, sqv,     .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x05, srv,     .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x06, spv,     .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x07, suv,     .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x08, shv,     .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x09, sfv,     .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0B, stv,     .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x00, sbv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x01, ssv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x02, slv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x03, sdv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x04, sqv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x05, srv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x06, spv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x07, suv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x08, shv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x09, sfv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0B, stv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)
 
-RABBITIZER_DEF_INSTR_ID(rsp, -0x07, swv,    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs})
+RABBITIZER_DEF_INSTR_ID(
+    rsp, -0x07, swv,
+    .operands={RAB_OPERAND_rsp_vt_elementlow, RAB_OPERAND_rsp_offset_rs}
+)

include/instructions/instr_id/rsp/rsp_regimm.inc

@@ -2,13 +2,42 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP rs, IMM
-RABBITIZER_DEF_INSTR_ID(rsp, 0x00, bltz,    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true)      // Branch on Less Than Zero
-RABBITIZER_DEF_INSTR_ID(rsp, 0x01, bgez,    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true)      // Branch on Greater than or Equal to Zero
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x00, bltz,
+    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true
+) // Branch on Less Than Zero
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x01, bgez,
+    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true
+) // Branch on Greater than or Equal to Zero
 
-RABBITIZER_DEF_INSTR_ID(rsp, 0x10, bltzal,  .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true, .doesLink=true) // Branch on Less Than Zero and Link
-RABBITIZER_DEF_INSTR_ID(rsp, 0x11, bgezal,  .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true, .doesLink=true) // Branch on Greater Than or Equal to Zero and Link
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x10, bltzal,
+    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true,
+    .doesLink=true
+) // Branch on Less Than Zero and Link
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x11, bgezal,
+    .operands={RAB_OPERAND_rsp_rs, RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true,
+    .doesLink=true
+) // Branch on Greater Than or Equal to Zero and Link
 
 
 // Pseudo-Instruction Unique IDs
 
-RABBITIZER_DEF_INSTR_ID(rsp, -0x11, bal,    .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_REGIMM, .isBranch=true, .doesLink=true, .isPseudo=true, .architectureVersion=RABBITIZER_ARCHVERSION_MIPS_I) // Branch and Link
+RABBITIZER_DEF_INSTR_ID(
+    rsp, -0x11, bal,
+    .operands={RAB_OPERAND_cpu_branch_target_label},
+    .instrType=RABBITIZER_INSTR_TYPE_REGIMM,
+    .isBranch=true,
+    .doesLink=true,
+    .isPseudo=true
+) // Branch and Link

include/instructions/instr_id/rsp/rsp_special.inc

@@ -2,48 +2,181 @@
 /* SPDX-License-Identifier: MIT */
 
 // OP rd, rt, sa
-RABBITIZER_DEF_INSTR_ID(rsp, 0x00, sll,                    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt, RAB_OPERAND_cpu_sa}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)       // Shift word Left Logical
-RABBITIZER_DEF_INSTR_ID(rsp, 0x02, srl,                    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt, RAB_OPERAND_cpu_sa}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)       // Shift word Right Logical
-RABBITIZER_DEF_INSTR_ID(rsp, 0x03, sra,                    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt, RAB_OPERAND_cpu_sa}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)       // Shift word Right Arithmetic
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x00, sll,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt, RAB_OPERAND_cpu_sa},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Shift word Left Logical
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x02, srl,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt, RAB_OPERAND_cpu_sa},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Shift word Right Logical
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x03, sra,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt, RAB_OPERAND_cpu_sa},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Shift word Right Arithmetic
 
 // OP rd, rt, rs
-RABBITIZER_DEF_INSTR_ID(rsp, 0x04, sllv,                   .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)      // Shift word Left Logical Variable
-RABBITIZER_DEF_INSTR_ID(rsp, 0x06, srlv,                   .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)      // Shift word Right Logical Variable
-RABBITIZER_DEF_INSTR_ID(rsp, 0x07, srav,                   .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)      // Shift word Right Arithmetic Variable
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x04, sllv,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Shift word Left Logical Variable
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x06, srlv,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Shift word Right Logical Variable
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x07, srav,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt, RAB_OPERAND_rsp_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Shift word Right Arithmetic Variable
 
 // OP rs
-RABBITIZER_DEF_INSTR_ID(rsp, 0x08, jr,                     .operands={RAB_OPERAND_rsp_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .isJump=true)                        // Jump Register
-RABBITIZER_DEF_INSTR_ID(rsp, 0x09, jalr,                   .operands={RAB_OPERAND_rsp_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .isJump=true, .modifiesRd=true, .doesLink=true)      // Jump And Link Register
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x08, jr,
+    .operands={RAB_OPERAND_rsp_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .isJump=true
+) // Jump Register
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x09, jalr,
+    .operands={RAB_OPERAND_rsp_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .isJump=true,
+    .modifiesRd=true,
+    .doesLink=true
+) // Jump And Link Register
 
 // OP rd, rs
-RABBITIZER_DEF_INSTR_ID_ALTNAME(rsp, -0x09, jalr_rd, jalr,  .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .isJump=true, .modifiesRd=true, .doesLink=true)   // Jump And Link Register // Special case for rd != 31
+RABBITIZER_DEF_INSTR_ID_ALTNAME(
+    rsp, -0x09, jalr_rd, jalr,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .isJump=true,
+    .modifiesRd=true,
+    .doesLink=true
+) // Jump And Link Register // Special case for rd != 31
 
 // OP rd, rs, rt
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0A, movz,                   .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)      // MOVe conditional on Zero
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0B, movn,                   .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)      // MOVe conditional on Not zero
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0A, movz,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // MOVe conditional on Zero
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0B, movn,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // MOVe conditional on Not zero
 
-RABBITIZER_DEF_INSTR_ID(rsp, 0x20, add,                    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true, .notEmitedByCompilers=true)       // ADD word
-RABBITIZER_DEF_INSTR_ID(rsp, 0x21, addu,                   .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)      // ADD Unsigned word
-RABBITIZER_DEF_INSTR_ID(rsp, 0x22, sub,                    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)       // Subtract word
-RABBITIZER_DEF_INSTR_ID(rsp, 0x23, subu,                   .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)      // SUBtract Unsigned word
-RABBITIZER_DEF_INSTR_ID(rsp, 0x24, and,                    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)       // AND
-RABBITIZER_DEF_INSTR_ID(rsp, 0x25, or,                     .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)        // OR
-RABBITIZER_DEF_INSTR_ID(rsp, 0x26, xor,                    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)       // eXclusive OR
-RABBITIZER_DEF_INSTR_ID(rsp, 0x27, nor,                    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)       // Not OR
-RABBITIZER_DEF_INSTR_ID(rsp, 0x2A, slt,                    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)       // Set on Less Than
-RABBITIZER_DEF_INSTR_ID(rsp, 0x2B, sltu,                   .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)      // Set on Less Than Unsigned
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x20, add,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true,
+    .notEmitedByCompilers=true
+) // ADD word
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x21, addu,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // ADD Unsigned word
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x22, sub,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Subtract word
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x23, subu,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // SUBtract Unsigned word
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x24, and,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // AND
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x25, or,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // OR
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x26, xor,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // eXclusive OR
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x27, nor,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Not OR
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x2A, slt,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Set on Less Than
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x2B, sltu,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs, RAB_OPERAND_rsp_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Set on Less Than Unsigned
 
 // OP code
-RABBITIZER_DEF_INSTR_ID(rsp, 0x0D, break,                  .operands={RAB_OPERAND_cpu_code}, .instrType=RABBITIZER_INSTR_TYPE_R)     // Break
+RABBITIZER_DEF_INSTR_ID(
+    rsp, 0x0D, break,
+    .operands={RAB_OPERAND_cpu_code},
+    .instrType=RABBITIZER_INSTR_TYPE_R
+) // Break
 
 
 // Pseudo-Instruction Unique IDs
 // OP
-RABBITIZER_DEF_INSTR_ID(rsp, -0x01, nop,                    .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_R)       // No OPeration
+RABBITIZER_DEF_INSTR_ID(
+    rsp, -0x01, nop,
+    .operands={0},
+    .instrType=RABBITIZER_INSTR_TYPE_R
+) // No OPeration
 
 // OP rd, rs
-RABBITIZER_DEF_INSTR_ID(rsp, -0x25, move,                   .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)      // Move
-RABBITIZER_DEF_INSTR_ID(rsp, -0x27, not,                    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)       // Not
+RABBITIZER_DEF_INSTR_ID(
+    rsp, -0x25, move,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Move
+RABBITIZER_DEF_INSTR_ID(
+    rsp, -0x27, not,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rs},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+) // Not
 
 // OP rd, rt
-RABBITIZER_DEF_INSTR_ID(rsp, -0x23, negu,                   .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt}, .instrType=RABBITIZER_INSTR_TYPE_R, .modifiesRd=true)
+RABBITIZER_DEF_INSTR_ID(
+    rsp, -0x23, negu,
+    .operands={RAB_OPERAND_rsp_rd, RAB_OPERAND_rsp_rt},
+    .instrType=RABBITIZER_INSTR_TYPE_R,
+    .modifiesRd=true
+)

include/instructions/operands/RabbitizerOperandType_cpu.inc

@@ -15,6 +15,7 @@ RAB_DEF_OPERAND(cpu, cop1cs) // Coprocessor 1 control fs
 RAB_DEF_OPERAND(cpu, cop2t)
 RAB_DEF_OPERAND(cpu, op)
 RAB_DEF_OPERAND(cpu, code)
+RAB_DEF_OPERAND(cpu, code_lower)
 RAB_DEF_OPERAND(cpu, copraw)
 RAB_DEF_OPERAND(cpu, label)
 RAB_DEF_OPERAND(cpu, immediate)

include/rabbitizer.h

@@ -3,6 +3,7 @@
 
 #ifndef RABBITIZER_H
 #define RABBITIZER_H
+#pragma once
 
 #include "common/Utils.h"
 #include "common/RabbitizerVersion.h"

rabbitizer/AccessType.pyi

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+
+# SPDX-FileCopyrightText: © 2022 Decompollaborate
+# SPDX-License-Identifier: MIT
+
+from __future__ import annotations
+
+from .Enum import Enum
+
+
+class AccessType:
+    INVALID: Enum
+
+    BYTE_SIGNED: Enum
+    BYTE_UNSIGNED: Enum
+    SHORT_SIGNED: Enum
+    SHORT_UNSIGNED: Enum
+    WORD_SIGNED: Enum
+    WORD_UNSIGNED: Enum
+    DOUBLEWORD_SIGNED: Enum
+    DOUBLEWORD_UNSIGNED: Enum
+    FLOAT_SIGNED: Enum
+    DOUBLEFLOAT_SIGNED: Enum
+
+    MAX: Enum

rabbitizer/InstrCategory.pyi

@@ -13,3 +13,6 @@ class InstrCategory:
     RSP: Enum
     R5900: Enum
     MAX: Enum
+
+    @staticmethod
+    def fromStr(name: str | None) -> Enum|None: ...

rabbitizer/OperandType.pyi

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+
+# SPDX-FileCopyrightText: © 2022 Decompollaborate
+# SPDX-License-Identifier: MIT
+
+from __future__ import annotations
+
+from .Enum import Enum
+
+
+class OperandType:
+    ALL_INVALID: Enum
+
+    cpu_rs: Enum
+    cpu_rt: Enum
+    cpu_rd: Enum
+    cpu_sa: Enum
+    cpu_zero: Enum
+    cpu_cop0d: Enum
+    cpu_fs: Enum
+    cpu_ft: Enum
+    cpu_fd: Enum
+    cpu_cop1cs: Enum
+    cpu_cop2t: Enum
+    cpu_op: Enum
+    cpu_code: Enum
+    cpu_code_lower: Enum
+    cpu_copraw: Enum
+    cpu_label: Enum
+    cpu_immediate: Enum
+    cpu_branch_target_label: Enum
+    cpu_immediate_base: Enum
+
+    rsp_rs: Enum
+    rsp_rt: Enum
+    rsp_rd: Enum
+    rsp_cop0d: Enum
+    rsp_cop2t: Enum
+    rsp_cop2cd: Enum
+    rsp_vs: Enum
+    rsp_vt: Enum
+    rsp_vd: Enum
+    rsp_vt_elementhigh: Enum
+    rsp_vt_elementlow: Enum
+    rsp_vd_de: Enum
+    rsp_vs_index: Enum
+    rsp_offset_rs: Enum
+    rsp_immediate_base: Enum
+
+    r5900_I: Enum
+    r5900_Q: Enum
+    r5900_R: Enum
+    r5900_ACC: Enum
+    r5900_ACCxyzw: Enum
+    r5900_vfs: Enum
+    r5900_vft: Enum
+    r5900_vfd: Enum
+    r5900_vfsxyzw: Enum
+    r5900_vftxyzw: Enum
+    r5900_vfdxyzw: Enum
+    r5900_vfsn: Enum
+    r5900_vftn: Enum
+    r5900_vfdn: Enum
+    r5900_vfsl: Enum
+    r5900_vftl: Enum
+    r5900_vfdl: Enum
+    r5900_vfsm: Enum
+    r5900_vftm: Enum
+    r5900_vfdm: Enum
+    r5900_vis: Enum
+    r5900_vit: Enum
+    r5900_vid: Enum
+    r5900_vis_predecr: Enum
+    r5900_vit_predecr: Enum
+    r5900_vid_predecr: Enum
+    r5900_vis_postincr: Enum
+    r5900_vit_postincr: Enum
+    r5900_vid_postincr: Enum
+    r5900_immediate5: Enum
+
+    ALL_MAX: Enum

rabbitizer/__init__.pyi

@@ -10,6 +10,8 @@ from .Utils import *
 from .Enum import *
 from .InstrCategory import *
 from .InstrId import *
+from .OperandType import *
+from .AccessType import *
 
 from .RegGprO32 import *
 from .RegGprN32 import *

rabbitizer/enums/rabbitizer_enum_AccessType.c

@@ -0,0 +1,25 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#include "enums_utils.h"
+#include "instructions/RabbitizerAccessType.h"
+
+
+#define RAB_DEF_ACCESSTYPE(name) { "AccessType", #name , RAB_ACCESSTYPE_##name, false, NULL },
+
+RabbitizerEnumMetadata rabbitizer_enum_AccessType_enumvalues[] = {
+#include "instructions/AccessType.inc"
+
+    RAB_DEF_ACCESSTYPE(MAX)
+
+    { 0 },
+};
+
+#undef RAB_DEF_ACCESSTYPE
+
+
+static PyMethodDef rabbitizer_enum_AccessType_methods[] = {
+    { 0 },
+};
+
+DEF_ENUM(AccessType, "")

rabbitizer/enums/rabbitizer_enum_InstrCategory.c

@@ -16,7 +16,34 @@ RabbitizerEnumMetadata rabbitizer_enum_InstrCategory_enumvalues[] = {
 
 #undef RABBITIZER_DEF_INSTR_CATEGORY
 
+
+static PyObject *rabbitizer_enum_InstrCategory_fromStr(UNUSED PyObject *self, PyObject *args, PyObject *kwds) {
+    static char *kwlist[] = { "name", NULL };
+    const char *name = NULL;
+    RabbitizerInstrCategory instrCategory;
+    PyObject *ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "z", kwlist, &name)) {
+        return NULL;
+    }
+
+    instrCategory = RabbitizerInstrCategory_fromStr(name);
+    if ((int)instrCategory < 0) {
+        Py_RETURN_NONE;
+    }
+
+    ret = rabbitizer_enum_InstrCategory_enumvalues[instrCategory].instance;
+    Py_INCREF(ret);
+    return ret;
+}
+
+
+#define METHOD_NO_ARGS(name, docs)  { #name, (PyCFunction) rabbitizer_enum_InstrCategory_##name, METH_NOARGS,                  PyDoc_STR(docs) }
+#define METHOD_ARGS(name, docs)     { #name, (PyCFunction) rabbitizer_enum_InstrCategory_##name, METH_VARARGS | METH_KEYWORDS, PyDoc_STR(docs) }
+
 static PyMethodDef rabbitizer_enum_InstrCategory_methods[] = {
+    METHOD_ARGS(fromStr, ""),
+
     { 0 },
 };
 

rabbitizer/enums/rabbitizer_enum_OperandType.c

@@ -0,0 +1,28 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#include "enums_utils.h"
+#include "instructions/RabbitizerOperandType.h"
+
+
+#define RAB_DEF_OPERAND(prefix, operand) { "OperandType", #prefix "_" #operand, RAB_OPERAND_##prefix##_##operand, false, NULL },
+
+RabbitizerEnumMetadata rabbitizer_enum_OperandType_enumvalues[] = {
+    RAB_DEF_OPERAND(ALL, INVALID)
+
+#include "instructions/operands/RabbitizerOperandType_cpu.inc"
+#include "instructions/operands/RabbitizerOperandType_rsp.inc"
+#include "instructions/operands/RabbitizerOperandType_r5900.inc"
+
+    RAB_DEF_OPERAND(ALL, MAX)
+
+    { 0 },
+};
+
+#undef RAB_DEF_OPERAND
+
+static PyMethodDef rabbitizer_enum_OperandType_methods[] = {
+    { 0 },
+};
+
+DEF_ENUM(OperandType, "")

rabbitizer/rabbitizer.pyi

@@ -44,11 +44,14 @@ class Instruction:
     def __init__(self, word: int, vram: int=0, category: Enum=InstrCategory.CPU) -> None: ...
 
     def getRaw(self) -> int: ...
-    def getImmediate(self) -> int: ...
+    def getImmediate(self) -> int: ... #! deprecated
     def getProcessedImmediate(self) -> int: ...
     def getInstrIndexAsVram(self) -> int: ...
     def getBranchOffset(self) -> int: ...
-    def getGenericBranchOffset(self, currentVram: int) -> int: ...
+    def getGenericBranchOffset(self, currentVram: int) -> int: ... #! deprecated
+    def getBranchOffsetGeneric(self) -> int: ...
+    def getBranchVramGeneric(self) -> int: ...
+    def getDestinationGpr(self) -> Enum|None: ...
     def getOpcodeName(self) -> str: ...
 
     def blankOut(self) -> None: ...
@@ -60,27 +63,41 @@ class Instruction:
     def isJrRa(self) -> bool: ...
     def isJrNotRa(self) -> bool: ...
     def hasDelaySlot(self) -> bool: ...
-    def mapInstrToType(self) -> str|None: ...
+    def mapInstrToType(self) -> str|None: ... #! deprecated
 
     def sameOpcode(self, other: Instruction) -> bool: ...
     def sameOpcodeButDifferentArguments(self, other: Instruction) -> bool: ...
 
+    def hasOperand(self, operand: Enum) -> bool: ...
+    def hasOperandAlias(self, operand: Enum) -> bool: ...
+
     def isValid(self) -> bool: ...
 
+    #! deprecated
     def isUnknownType(self) -> bool: ...
+    #! deprecated
     def isJType(self) -> bool: ...
+    #! deprecated
     def isIType(self) -> bool: ...
+    #! deprecated
     def isRType(self) -> bool: ...
+    #! deprecated
     def isRegimmType(self) -> bool: ...
+
     def isBranch(self) -> bool: ...
     def isBranchLikely(self) -> bool: ...
     def isJump(self) -> bool: ...
+    def isJumpWithAddress(self) -> bool: ...
     def isTrap(self) -> bool: ...
     def isFloat(self) -> bool: ...
     def isDouble(self) -> bool: ...
     def isUnsigned(self) -> bool: ...
     def modifiesRt(self) -> bool: ...
     def modifiesRd(self) -> bool: ...
+    def readsHI(self) -> bool: ...
+    def readsLO(self) -> bool: ...
+    def modifiesHI(self) -> bool: ...
+    def modifiesLO(self) -> bool: ...
     def notEmitedByCompilers(self) -> bool: ...
     def canBeHi(self) -> bool: ...
     def canBeLo(self) -> bool: ...
@@ -90,6 +107,7 @@ class Instruction:
     def doesStore(self) -> bool: ...
     def maybeIsMove(self) -> bool: ...
     def isPseudo(self) -> bool: ...
+    def getAccessType(self) -> Enum: ...
 
     def disassemble(self, immOverride: str|None=None, extraLJust: int=0) -> str: ...
 

rabbitizer/rabbitizer_module.c

@@ -34,13 +34,19 @@ typedef struct ModuleAttribute {
 
 static ModuleAttributes rabbitizer_module_attributes[] = {
     MODULE_ATTRIBUTE_INIT(Utils),
+
     MODULE_ATTRIBUTE_GLOBAL(config),
+
     MODULE_ATTRIBUTE_TYPE(Enum),
     MODULE_ATTRIBUTE_ENUM(Abi),
     MODULE_ATTRIBUTE_ENUM(InstrCategory),
     MODULE_ATTRIBUTE_ENUM(InstrId),
+    MODULE_ATTRIBUTE_ENUM(OperandType),
+    MODULE_ATTRIBUTE_ENUM(AccessType),
+
     MODULE_ATTRIBUTE_ENUM(RegGprO32),
     MODULE_ATTRIBUTE_ENUM(RegGprN32),
+
     MODULE_ATTRIBUTE_TYPE(Instruction),
     MODULE_ATTRIBUTE_TYPE(LoPairingInfo),
     MODULE_ATTRIBUTE_TYPE(TrackedRegisterState),

rabbitizer/rabbitizer_module.h

@@ -47,6 +47,8 @@ extern PyTypeObject rabbitizer_type_RegistersTracker_TypeObject;
 DECL_ENUM(Abi)
 DECL_ENUM(InstrCategory)
 DECL_ENUM(InstrId)
+DECL_ENUM(OperandType)
+DECL_ENUM(AccessType)
 
 DECL_ENUM(RegGprO32)
 DECL_ENUM(RegGprN32)

rabbitizer/rabbitizer_type_Instruction.c

@@ -68,10 +68,34 @@ static PyMemberDef rabbitizer_type_Instruction_members[] = {
 
 
 #define DEF_MEMBER_GET_UINT(name) \
-    static PyObject *rabbitizer_type_Instruction_member_get_##name(PyRabbitizerInstruction *self, PyObject *Py_UNUSED(ignored)) { \
+    static PyObject *rabbitizer_type_Instruction_member_get_##name(PyRabbitizerInstruction *self, UNUSED PyObject *closure) { \
         return PyLong_FromUnsignedLong(RAB_INSTR_GET_##name(&self->instr)); \
     }
 
+#define RETURN_GPR(reg) \
+    do { \
+        PyObject *enumInstance = NULL; \
+        \
+        switch (RabbitizerConfig_Cfg.regNames.gprAbiNames) { \
+            case RABBITIZER_ABI_N32: \
+            case RABBITIZER_ABI_N64: \
+                enumInstance = rabbitizer_enum_RegGprN32_enumvalues[reg].instance; \
+                break; \
+        \
+            default: \
+                enumInstance = rabbitizer_enum_RegGprO32_enumvalues[reg].instance; \
+                break; \
+        } \
+        \
+        if (enumInstance == NULL) { \
+            PyErr_SetString(PyExc_RuntimeError, "Internal error: invalid RegGpr enum value"); \
+            return NULL; \
+        } \
+        \
+        Py_INCREF(enumInstance); \
+        return enumInstance; \
+    } while (0)
+
 #define DEF_MEMBER_GET_REGGPR(name) \
     static PyObject *rabbitizer_type_Instruction_member_get_##name(PyRabbitizerInstruction *self, UNUSED PyObject *closure) { \
         uint32_t reg; \
@@ -109,7 +133,7 @@ DEF_MEMBER_GET_REGGPR(rd)
 
 DEF_MEMBER_GET_UINT(sa)
 
-static PyObject *rabbitizer_type_Instruction_member_get_uniqueId(PyRabbitizerInstruction *self, PyObject *Py_UNUSED(ignored)) {
+static PyObject *rabbitizer_type_Instruction_member_get_uniqueId(PyRabbitizerInstruction *self, UNUSED PyObject *closure) {
     PyObject *enumInstance = rabbitizer_enum_InstrId_enumvalues[self->instr.uniqueId].instance;
 
     if (enumInstance == NULL) {
@@ -138,17 +162,19 @@ static PyGetSetDef rabbitizer_type_Instruction_getsetters[] = {
 
 
 #define DEF_METHOD_GET_UINT(name) \
-    static PyObject *rabbitizer_type_Instruction_##name(PyRabbitizerInstruction *self, PyObject *Py_UNUSED(ignored)) { \
+    static PyObject *rabbitizer_type_Instruction_##name(PyRabbitizerInstruction *self, UNUSED PyObject *closure) { \
         return PyLong_FromUnsignedLong(RabbitizerInstruction_##name(&self->instr)); \
     }
 
 #define DEF_METHOD_GET_INT(name) \
-    static PyObject *rabbitizer_type_Instruction_##name(PyRabbitizerInstruction *self, PyObject *Py_UNUSED(ignored)) { \
+    static PyObject *rabbitizer_type_Instruction_##name(PyRabbitizerInstruction *self, UNUSED PyObject *closure) { \
         return PyLong_FromLong(RabbitizerInstruction_##name(&self->instr)); \
     }
 
 DEF_METHOD_GET_UINT(getRaw)
-DEF_METHOD_GET_UINT(getImmediate)
+static PyObject *rabbitizer_type_Instruction_getImmediate(PyRabbitizerInstruction *self, UNUSED PyObject *closure) {
+    return PyLong_FromUnsignedLong(RAB_INSTR_GET_immediate(&self->instr));
+}
 DEF_METHOD_GET_INT(getProcessedImmediate)
 DEF_METHOD_GET_UINT(getInstrIndexAsVram)
 DEF_METHOD_GET_INT(getBranchOffset)
@@ -168,14 +194,27 @@ static PyObject *rabbitizer_type_Instruction_getGenericBranchOffset(PyRabbitizer
     return PyLong_FromLong(RabbitizerInstruction_getGenericBranchOffset(&self->instr, currentVram));
 }
 
-static PyObject *rabbitizer_type_Instruction_blankOut(PyRabbitizerInstruction *self, PyObject *Py_UNUSED(ignored)) {
+DEF_METHOD_GET_INT(getBranchOffsetGeneric)
+DEF_METHOD_GET_INT(getBranchVramGeneric)
+
+static PyObject *rabbitizer_type_Instruction_getDestinationGpr(PyRabbitizerInstruction *self, UNUSED PyObject *closure) {
+    int8_t reg = RabbitizerInstruction_getDestinationGpr(&self->instr);
+
+    if (reg < 0) {
+        Py_RETURN_NONE;
+    }
+
+    RETURN_GPR(reg);
+}
+
+static PyObject *rabbitizer_type_Instruction_blankOut(PyRabbitizerInstruction *self, UNUSED PyObject *closure) {
     RabbitizerInstruction_blankOut(&self->instr);
     Py_RETURN_NONE;
 }
 
 
 #define DEF_METHOD_BOOL(name) \
-    static PyObject *rabbitizer_type_Instruction_##name(PyRabbitizerInstruction *self, PyObject *Py_UNUSED(ignored)) { \
+    static PyObject *rabbitizer_type_Instruction_##name(PyRabbitizerInstruction *self, UNUSED PyObject *closure) { \
         if (RabbitizerInstruction_##name(&self->instr)) { \
             Py_RETURN_TRUE; \
         } \
@@ -190,7 +229,7 @@ DEF_METHOD_BOOL(isJrRa)
 DEF_METHOD_BOOL(isJrNotRa)
 DEF_METHOD_BOOL(hasDelaySlot)
 
-static PyObject *rabbitizer_type_Instruction_mapInstrToType(PyRabbitizerInstruction *self, PyObject *Py_UNUSED(ignored)) {
+static PyObject *rabbitizer_type_Instruction_mapInstrToType(PyRabbitizerInstruction *self, UNUSED PyObject *closure) {
     const char *type = RabbitizerInstruction_mapInstrToType(&self->instr);
 
     if (type != NULL) {
@@ -227,10 +266,72 @@ static PyObject *rabbitizer_type_Instruction_sameOpcodeButDifferentArguments(PyR
     Py_RETURN_FALSE;
 }
 
+static PyObject *rabbitizer_type_Instruction_hasOperand(PyRabbitizerInstruction *self, PyObject *args, PyObject *kwds) {
+    static char *kwlist[] = { "operand", NULL };
+    PyObject *pyOperand = NULL;
+    int enumCheck;
+    RabbitizerOperandType operandType = RAB_OPERAND_ALL_INVALID;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", kwlist, &rabbitizer_type_Enum_TypeObject, &pyOperand)) {
+        return NULL;
+    }
+
+    if (pyOperand == NULL) {
+        PyErr_SetString(PyExc_ValueError, "Invalid value for 'operand' parameter");
+    }
+
+    enumCheck = rabbitizer_enum_OperandType_Check(pyOperand);
+
+    if (enumCheck <= 0) {
+        if (enumCheck == 0) {
+            PyErr_SetString(PyExc_ValueError, "Invalid value for 'operand' parameter");
+        }
+        return NULL;
+    }
+
+    operandType = ((PyRabbitizerEnum*)pyOperand)->value;
+
+    if (RabbitizerInstruction_hasOperand(&self->instr, operandType)) {
+        Py_RETURN_TRUE;
+    }
+    Py_RETURN_FALSE;
+}
+
+static PyObject *rabbitizer_type_Instruction_hasOperandAlias(PyRabbitizerInstruction *self, PyObject *args, PyObject *kwds) {
+    static char *kwlist[] = { "operand", NULL };
+    PyObject *pyOperand = NULL;
+    int enumCheck;
+    RabbitizerOperandType operandType = RAB_OPERAND_ALL_INVALID;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", kwlist, &rabbitizer_type_Enum_TypeObject, &pyOperand)) {
+        return NULL;
+    }
+
+    if (pyOperand == NULL) {
+        PyErr_SetString(PyExc_ValueError, "Invalid value for 'operand' parameter");
+    }
+
+    enumCheck = rabbitizer_enum_OperandType_Check(pyOperand);
+
+    if (enumCheck <= 0) {
+        if (enumCheck == 0) {
+            PyErr_SetString(PyExc_ValueError, "Invalid value for 'operand' parameter");
+        }
+        return NULL;
+    }
+
+    operandType = ((PyRabbitizerEnum*)pyOperand)->value;
+
+    if (RabbitizerInstruction_hasOperandAlias(&self->instr, operandType)) {
+        Py_RETURN_TRUE;
+    }
+    Py_RETURN_FALSE;
+}
+
 DEF_METHOD_BOOL(isValid)
 
 #define DEF_DESCRIPTOR_METHOD_BOOL(name) \
-    static PyObject *rabbitizer_type_Instruction_##name(PyRabbitizerInstruction *self, PyObject *Py_UNUSED(ignored)) { \
+    static PyObject *rabbitizer_type_Instruction_##name(PyRabbitizerInstruction *self, UNUSED PyObject *closure) { \
         if (RabbitizerInstrDescriptor_##name(self->instr.descriptor)) { \
             Py_RETURN_TRUE; \
         } \
@@ -245,12 +346,17 @@ DEF_DESCRIPTOR_METHOD_BOOL(isRegimmType)
 DEF_DESCRIPTOR_METHOD_BOOL(isBranch)
 DEF_DESCRIPTOR_METHOD_BOOL(isBranchLikely)
 DEF_DESCRIPTOR_METHOD_BOOL(isJump)
+DEF_DESCRIPTOR_METHOD_BOOL(isJumpWithAddress)
 DEF_DESCRIPTOR_METHOD_BOOL(isTrap)
 DEF_DESCRIPTOR_METHOD_BOOL(isFloat)
 DEF_DESCRIPTOR_METHOD_BOOL(isDouble)
 DEF_DESCRIPTOR_METHOD_BOOL(isUnsigned)
 DEF_DESCRIPTOR_METHOD_BOOL(modifiesRt)
 DEF_DESCRIPTOR_METHOD_BOOL(modifiesRd)
+DEF_DESCRIPTOR_METHOD_BOOL(readsHI)
+DEF_DESCRIPTOR_METHOD_BOOL(readsLO)
+DEF_DESCRIPTOR_METHOD_BOOL(modifiesHI)
+DEF_DESCRIPTOR_METHOD_BOOL(modifiesLO)
 DEF_DESCRIPTOR_METHOD_BOOL(notEmitedByCompilers)
 DEF_DESCRIPTOR_METHOD_BOOL(canBeHi)
 DEF_DESCRIPTOR_METHOD_BOOL(canBeLo)
@@ -260,8 +366,16 @@ DEF_DESCRIPTOR_METHOD_BOOL(doesLoad)
 DEF_DESCRIPTOR_METHOD_BOOL(doesStore)
 DEF_DESCRIPTOR_METHOD_BOOL(maybeIsMove)
 DEF_DESCRIPTOR_METHOD_BOOL(isPseudo)
-// TODO: create an enum type for architectureVersion
-// architectureVersion
+
+static PyObject *rabbitizer_type_Instruction_getAccessType(PyRabbitizerInstruction *self, UNUSED PyObject *closure) {
+    RabbitizerAccessType accessType = RabbitizerInstrDescriptor_getAccessType(self->instr.descriptor);
+    PyObject *enumInstance;
+
+    enumInstance = rabbitizer_enum_AccessType_enumvalues[accessType].instance;
+
+    Py_INCREF(enumInstance);
+    return enumInstance;
+}
 
 
 static PyObject *rabbitizer_type_Instruction_disassemble(PyRabbitizerInstruction *self, PyObject *args, PyObject *kwds) {
@@ -325,6 +439,9 @@ static PyMethodDef rabbitizer_type_Instruction_methods[] = {
     METHOD_NO_ARGS(getInstrIndexAsVram, ""),
     METHOD_NO_ARGS(getBranchOffset, ""),
     METHOD_ARGS(getGenericBranchOffset, ""),
+    METHOD_NO_ARGS(getBranchOffsetGeneric, ""),
+    METHOD_NO_ARGS(getBranchVramGeneric, ""),
+    METHOD_NO_ARGS(getDestinationGpr, ""),
     METHOD_NO_ARGS(getOpcodeName, ""),
 
     METHOD_NO_ARGS(blankOut, ""),
@@ -341,6 +458,9 @@ static PyMethodDef rabbitizer_type_Instruction_methods[] = {
     METHOD_ARGS(sameOpcode, "description"),
     METHOD_ARGS(sameOpcodeButDifferentArguments, "description"),
 
+    METHOD_ARGS(hasOperand, ""),
+    METHOD_ARGS(hasOperandAlias, ""),
+
     METHOD_NO_ARGS(isValid, ""),
 
     METHOD_NO_ARGS(isUnknownType, ""),
@@ -351,12 +471,17 @@ static PyMethodDef rabbitizer_type_Instruction_methods[] = {
     METHOD_NO_ARGS(isBranch, ""),
     METHOD_NO_ARGS(isBranchLikely, ""),
     METHOD_NO_ARGS(isJump, ""),
+    METHOD_NO_ARGS(isJumpWithAddress, ""),
     METHOD_NO_ARGS(isTrap, ""),
     METHOD_NO_ARGS(isFloat, ""),
     METHOD_NO_ARGS(isDouble, ""),
     METHOD_NO_ARGS(isUnsigned, ""),
     METHOD_NO_ARGS(modifiesRt, ""),
     METHOD_NO_ARGS(modifiesRd, ""),
+    METHOD_NO_ARGS(readsHI, ""),
+    METHOD_NO_ARGS(readsLO, ""),
+    METHOD_NO_ARGS(modifiesHI, ""),
+    METHOD_NO_ARGS(modifiesLO, ""),
     METHOD_NO_ARGS(notEmitedByCompilers, ""),
     METHOD_NO_ARGS(canBeHi, ""),
     METHOD_NO_ARGS(canBeLo, ""),
@@ -366,7 +491,7 @@ static PyMethodDef rabbitizer_type_Instruction_methods[] = {
     METHOD_NO_ARGS(doesStore, ""),
     METHOD_NO_ARGS(maybeIsMove, ""),
     METHOD_NO_ARGS(isPseudo, ""),
-    // METHOD_NO_ARGS(getArchitectureVersion, ""),
+    METHOD_NO_ARGS(getAccessType, ""),
 
     METHOD_ARGS(disassemble, "description"),
 

setup.cfg

@@ -4,7 +4,7 @@
 [metadata]
 name = rabbitizer
 # Version should be synced with include/common/RabbitizerVersion.h
-version = 1.2.2
+version = 1.3.0
 author = Decompollaborate
 license = MIT
 description = MIPS instruction decoder

setup.py

@@ -9,30 +9,19 @@ setup(
         Extension(
             name="rabbitizer",
             sources=["rabbitizer/rabbitizer_module.c", "rabbitizer/rabbitizer_submodule_Utils.c", "rabbitizer/rabbitizer_type_Instruction.c", "rabbitizer/rabbitizer_global_config.c", "rabbitizer/rabbitizer_type_TrackedRegisterState.c", "rabbitizer/rabbitizer_type_RegistersTracker.c", "rabbitizer/rabbitizer_type_LoPairingInfo.c",
-            "rabbitizer/enums/rabbitizer_type_Enum.c", "rabbitizer/enums/enums_utils.c", "rabbitizer/enums/rabbitizer_enum_InstrCategory.c", "rabbitizer/enums/rabbitizer_enum_InstrId.c", "rabbitizer/enums/rabbitizer_enum_Abi.c",
+            "rabbitizer/enums/rabbitizer_type_Enum.c", "rabbitizer/enums/enums_utils.c", "rabbitizer/enums/rabbitizer_enum_InstrCategory.c", "rabbitizer/enums/rabbitizer_enum_InstrId.c", "rabbitizer/enums/rabbitizer_enum_Abi.c", "rabbitizer/enums/rabbitizer_enum_OperandType.c", "rabbitizer/enums/rabbitizer_enum_AccessType.c",
             "rabbitizer/enums/registers/rabbitizer_enum_GprO32.c", "rabbitizer/enums/registers/rabbitizer_enum_GprN32.c",
             "src/instructions/RabbitizerInstruction/RabbitizerInstruction_Disassemble.c", "src/instructions/RabbitizerInstruction/RabbitizerInstruction_ProcessUniqueId.c", "src/instructions/RabbitizerInstruction/RabbitizerInstruction.c", "src/instructions/RabbitizerInstruction/RabbitizerInstruction_Examination.c",
-            "src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp.c", "src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_ProcessUniqueId.c",
-            "src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900.c", "src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_ProcessUniqueId.c",
-            "src/instructions/RabbitizerInstrDescriptor.c", "src/instructions/RabbitizerInstrId.c", "src/instructions/RabbitizerRegister.c", "src/instructions/RabbitizerInstrSuffix.c",
+            "src/instructions/RabbitizerInstructionCpu/RabbitizerInstructionCpu_OperandType.c",
+            "src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp.c", "src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_ProcessUniqueId.c", "src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_OperandType.c",
+            "src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900.c", "src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_ProcessUniqueId.c", "src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_OperandType.c",
+            "src/instructions/RabbitizerInstrDescriptor.c", "src/instructions/RabbitizerInstrId.c", "src/instructions/RabbitizerRegister.c", "src/instructions/RabbitizerInstrSuffix.c", "src/instructions/RabbitizerInstrCategory.c",
             "src/analysis/RabbitizerTrackedRegisterState.c", "src/analysis/RabbitizerRegistersTracker.c", "src/analysis/RabbitizerLoPairingInfo.c",
             "src/common/Utils.c", "src/common/RabbitizerVersion.c", "src/common/RabbitizerConfig.c"],
             include_dirs=["include", "rabbitizer"],
             extra_compile_args = [
                 "-std=c11",
                 "-Wall",
-                #"-Wextra",
-                # "-Wpedantic", # binary constants :s
-                #"-Wno-cast-function-type",
-                #"-Werror=implicit-function-declaration",
-                #"-Werror=incompatible-pointer-types",
-                #"-Werror=vla",
-                #"-Werror=switch",
-                #"-Werror=implicit-fallthrough",
-                #"-Werror=unused-function",
-                #"-Werror=unused-parameter",
-                #"-Werror=shadow",
-                # "-Werror",
                 "-g",
             ],
         ),

src/analysis/RabbitizerRegistersTracker.c

@@ -112,22 +112,6 @@ void RabbitizerRegistersTracker_overwriteRegisters(RabbitizerRegistersTracker *s
             default:
                 break;
         }
-    } else if (RabbitizerInstrDescriptor_isRType(instr->descriptor) ||
-               (RabbitizerInstrDescriptor_isBranch(instr->descriptor) && RabbitizerInstrDescriptor_isIType(instr->descriptor))) {
-        // $at usually is a one-use reg
-        uint8_t at = 0;
-
-        if (RAB_INSTR_GET_rs(instr) == 1) {
-            at = RAB_INSTR_GET_rs(instr);
-        } else if (RAB_INSTR_GET_rt(instr) == 1) {
-            at = RAB_INSTR_GET_rt(instr);
-        }
-
-        state = &self->registers[at];
-        if (state->hasLoValue || state->hasLuiValue || state->hasGpGot) {
-            shouldRemove = true;
-            reg = at;
-        }
     }
 
     if (RabbitizerInstrDescriptor_modifiesRt(instr->descriptor)) {
@@ -275,7 +259,7 @@ void RabbitizerRegistersTracker_processLui(RabbitizerRegistersTracker *self, con
 
     state = &self->registers[RAB_INSTR_GET_rt(instr)];
     RabbitizerTrackedRegisterState_clear(state);
-    RabbitizerTrackedRegisterState_setHi(state, RabbitizerInstruction_getImmediate(instr), instrOffset);
+    RabbitizerTrackedRegisterState_setHi(state, RabbitizerInstruction_getProcessedImmediate(instr), instrOffset);
 
     if (prevInstr != NULL) {
         // If the previous instructions is a branch likely, then nulify
@@ -292,7 +276,7 @@ void RabbitizerRegistersTracker_processGpLoad(RabbitizerRegistersTracker *self,
     state = &self->registers[RAB_INSTR_GET_rt(instr)];
 
     RabbitizerTrackedRegisterState_clear(state);
-    RabbitizerTrackedRegisterState_setGpLoad(state, RabbitizerInstruction_getImmediate(instr), instrOffset);
+    RabbitizerTrackedRegisterState_setGpLoad(state, RabbitizerInstruction_getProcessedImmediate(instr), instrOffset);
 }
 
 bool RabbitizerRegistersTracker_getLuiOffsetForConstant(const RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, int *dstOffset) {

src/instructions/RabbitizerInstrCategory.c

@@ -0,0 +1,31 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#include "instructions/RabbitizerInstrCategory.h"
+
+//#include <stddef.h>
+#include <string.h>
+
+
+#define RABBITIZER_DEF_INSTR_CATEGORY(name) [RABBITIZER_INSTRCAT_##name] = #name
+
+const char *const RabbitizerInstrCategory_Names[] = {
+#include "instructions/InstrCategory.inc"
+};
+
+#undef RABBITIZER_DEF_INSTR_CATEGORY
+
+
+RabbitizerInstrCategory RabbitizerInstrCategory_fromStr(const char *name) {
+    if (name == NULL) {
+        return -2;
+    }
+
+    for (size_t i = 0; i < RABBITIZER_INSTRCAT_MAX; i++) {
+        if (strcmp(RabbitizerInstrCategory_Names[i], name) == 0) {
+            return i;
+        }
+    }
+
+    return -1;
+}

src/instructions/RabbitizerInstrDescriptor.c

@@ -47,6 +47,9 @@ bool RabbitizerInstrDescriptor_isBranchLikely(const RabbitizerInstrDescriptor *s
 bool RabbitizerInstrDescriptor_isJump(const RabbitizerInstrDescriptor *self) {
     return self->isJump;
 }
+bool RabbitizerInstrDescriptor_isJumpWithAddress(const RabbitizerInstrDescriptor *self) {
+    return self->isJumpWithAddress;
+}
 bool RabbitizerInstrDescriptor_isTrap(const RabbitizerInstrDescriptor *self) {
     return self->isTrap;
 }
@@ -69,6 +72,19 @@ bool RabbitizerInstrDescriptor_modifiesRd(const RabbitizerInstrDescriptor *self)
     return self->modifiesRd;
 }
 
+bool RabbitizerInstrDescriptor_readsHI(const RabbitizerInstrDescriptor *self) {
+    return self->readsHI;
+}
+bool RabbitizerInstrDescriptor_readsLO(const RabbitizerInstrDescriptor *self) {
+    return self->readsLO;
+}
+bool RabbitizerInstrDescriptor_modifiesHI(const RabbitizerInstrDescriptor *self) {
+    return self->modifiesHI;
+}
+bool RabbitizerInstrDescriptor_modifiesLO(const RabbitizerInstrDescriptor *self) {
+    return self->modifiesLO;
+}
+
 bool RabbitizerInstrDescriptor_notEmitedByCompilers(const RabbitizerInstrDescriptor *self) {
     return self->notEmitedByCompilers;
 }
@@ -99,6 +115,6 @@ bool RabbitizerInstrDescriptor_isPseudo(const RabbitizerInstrDescriptor *self) {
     return self->isPseudo;
 }
 
-RabbitizerArchitectureVersion RabbitizerInstrDescriptor_getArchitectureVersion(const RabbitizerInstrDescriptor *self) {
-    return self->architectureVersion;
+RabbitizerAccessType RabbitizerInstrDescriptor_getAccessType(const RabbitizerInstrDescriptor *self) {
+    return self->accessType;
 }

src/instructions/RabbitizerInstruction/RabbitizerInstruction.c

@@ -32,9 +32,6 @@ uint32_t RabbitizerInstruction_getRaw(const RabbitizerInstruction *self) {
     return self->word;
 }
 
-uint32_t RabbitizerInstruction_getImmediate(const RabbitizerInstruction *self) {
-    return RAB_INSTR_GET_immediate(self);
-}
 int32_t RabbitizerInstruction_getProcessedImmediate(const RabbitizerInstruction *self) {
     if (RabbitizerInstrDescriptor_isUnsigned(self->descriptor)) {
         return RAB_INSTR_GET_immediate(self);
@@ -42,12 +39,8 @@ int32_t RabbitizerInstruction_getProcessedImmediate(const RabbitizerInstruction
     return RabbitizerUtils_From2Complement(RAB_INSTR_GET_immediate(self), 16);
 }
 
-uint32_t RabbitizerInstruction_getInstrIndex(const RabbitizerInstruction *self) {
-    return RAB_INSTR_GET_instr_index(self);
-}
-
 uint32_t RabbitizerInstruction_getInstrIndexAsVram(const RabbitizerInstruction *self) {
-    uint32_t vram = RabbitizerInstruction_getInstrIndex(self) << 2;
+    uint32_t vram = RAB_INSTR_GET_instr_index(self) << 2;
 
     if (self->vram == 0) {
         vram |= 0x80000000;
@@ -59,7 +52,7 @@ uint32_t RabbitizerInstruction_getInstrIndexAsVram(const RabbitizerInstruction *
 }
 
 int32_t RabbitizerInstruction_getBranchOffset(const RabbitizerInstruction *self) {
-    int32_t diff = RabbitizerUtils_From2Complement(RabbitizerInstruction_getImmediate(self), 16);
+    int32_t diff = RabbitizerUtils_From2Complement(RAB_INSTR_GET_immediate(self), 16);
 
     return diff * 4 + 4;
 }
@@ -71,6 +64,34 @@ int32_t RabbitizerInstruction_getGenericBranchOffset(const RabbitizerInstruction
     return RabbitizerInstruction_getBranchOffset(self);
 }
 
+int32_t RabbitizerInstruction_getBranchOffsetGeneric(const RabbitizerInstruction *self) {
+    if (RabbitizerInstruction_hasOperandAlias(self, RAB_OPERAND_cpu_label)) {
+        return RabbitizerInstruction_getInstrIndexAsVram(self) - self->vram;
+    }
+    return RabbitizerInstruction_getBranchOffset(self);
+}
+
+int32_t RabbitizerInstruction_getBranchVramGeneric(const RabbitizerInstruction *self) {
+    if (RabbitizerInstruction_hasOperandAlias(self, RAB_OPERAND_cpu_label)) {
+        return RabbitizerInstruction_getInstrIndexAsVram(self);
+    }
+    return RabbitizerInstruction_getBranchOffset(self) + self->vram;
+}
+
+/**
+ * @brief Returns the general purpose register (GPR) which this instruction modifies,
+ * or a negative value if the instruction does not modify the state of any GPR
+ */
+int8_t RabbitizerInstruction_getDestinationGpr(const RabbitizerInstruction *self) {
+    if (RabbitizerInstrDescriptor_modifiesRd(self->descriptor)) {
+        return RAB_INSTR_GET_rd(self);
+    }
+    if (RabbitizerInstrDescriptor_modifiesRt(self->descriptor)) {
+        return RAB_INSTR_GET_rt(self);
+    }
+    return -1;
+}
+
 /* General getters */
 
 void RabbitizerInstruction_blankOut(RabbitizerInstruction *self) {
@@ -129,6 +150,10 @@ void RabbitizerInstruction_blankOut(RabbitizerInstruction *self) {
                 self->word = RAB_INSTR_PACK_code(self->word, 0);
                 break;
 
+            case RAB_OPERAND_cpu_code_lower:
+                self->word = RAB_INSTR_PACK_code_lower(self->word, 0);
+                break;
+
             case RAB_OPERAND_cpu_copraw:
                 self->word = RAB_INSTR_PACK_copraw(self->word, 0);
                 break;

src/instructions/RabbitizerInstruction/RabbitizerInstruction_Disassemble.c

@@ -2,8 +2,6 @@
 /* SPDX-License-Identifier: MIT */
 
 #include "instructions/RabbitizerInstruction.h"
-#include "instructions/RabbitizerInstructionRsp.h"
-#include "instructions/RabbitizerInstructionR5900.h"
 
 #include <assert.h>
 #include <string.h>
@@ -14,775 +12,6 @@
 #include "instructions/RabbitizerRegister.h"
 #include "instructions/RabbitizerInstrSuffix.h"
 
-typedef size_t (*OperandCallback)(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength);
-
-size_t RabbitizerOperandType_process_cpu_rs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameGpr(RAB_INSTR_GET_rs(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_rt(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameGpr(RAB_INSTR_GET_rt(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_rd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameGpr(RAB_INSTR_GET_rd(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_zero(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride,
-                                              UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameGpr(0);
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_cop0d(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameCop0(RAB_INSTR_GET_cop0d(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_fs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameCop1(RAB_INSTR_GET_fs(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_ft(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameCop1(RAB_INSTR_GET_ft(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_fd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameCop1(RAB_INSTR_GET_fd(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_cop1cs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameCop1Control(RAB_INSTR_GET_cop1cs(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_cop2t(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameCop2(RAB_INSTR_GET_cop2t(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_sa(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-// TODO: consider making this a proper configuration
-#if 0
-    if (RAB_INSTR_GET_sa(self) < 10) {
-        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "%i", RAB_INSTR_GET_sa(self));
-    } else {
-        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%x", RAB_INSTR_GET_sa(self));
-    }
-#endif
-    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "%i", RAB_INSTR_GET_sa(self));
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_op(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-// TODO: consider making this a proper configuration
-#if 0
-    if (RAB_INSTR_GET_op(self) < 10) {
-        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "%i", RAB_INSTR_GET_op(self));
-    } else {
-        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%x", RAB_INSTR_GET_op(self));
-    }
-#endif
-    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%02X", RAB_INSTR_GET_op(self));
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_code(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    int code = RAB_INSTR_GET_code_upper(self);
-    int lower = RAB_INSTR_GET_code_lower(self);
-
-    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "%i", code);
-    if (lower) {
-        RABUTILS_BUFFER_SPRINTF(dst, totalSize, ", %i", lower);
-    }
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_copraw(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%X", RAB_INSTR_GET_copraw(self));
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_label(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    if (immOverride != NULL) {
-        memcpy(dst, immOverride, immOverrideLength);
-        return immOverrideLength;
-    }
-
-    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "func_%06X", RabbitizerInstruction_getInstrIndexAsVram(self));
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_immediate(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-    int32_t number;
-
-    if (immOverride != NULL) {
-        memcpy(dst, immOverride, immOverrideLength);
-        return immOverrideLength;
-    }
-
-    number = RabbitizerInstruction_getProcessedImmediate(self);
-    if (RabbitizerConfig_Cfg.misc.omit0XOnSmallImm) {
-        if (number > -10 && number < 10) {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "%i", number);
-            return totalSize;
-        }
-    }
-    if (number < 0) {
-        if (RabbitizerConfig_Cfg.misc.upperCaseImm) {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "-0x%X", -number);
-        } else {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "-0x%x", -number);
-        }
-    } else {
-        if (RabbitizerConfig_Cfg.misc.upperCaseImm) {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%X", number);
-        } else {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%x", number);
-        }
-    }
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_branch_target_label(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    if (immOverride != NULL) {
-        memcpy(dst, immOverride, immOverrideLength);
-        return immOverrideLength;
-    }
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, ". + 4 + (");
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_immediate(self, dst, NULL, 0));
-    RABUTILS_BUFFER_CPY(dst, totalSize, " << 2)");
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_cpu_immediate_base(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-// TODO: consider making this a proper configuration
-#if 0
-    if (immOverride != NULL || RAB_INSTR_GET_immediate(self) != 0) {
-        RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_immediate(self, dst, immOverride, immOverrideLength));
-    }
-#endif
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_immediate(self, dst, immOverride, immOverrideLength));
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_rs(self, dst, immOverride, immOverrideLength));
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_rs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameRspGpr(RAB_INSTR_GET_rs(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_rt(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameRspGpr(RAB_INSTR_GET_rt(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_rd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameRspGpr(RAB_INSTR_GET_rd(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_cop0d(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameRspCop0(RAB_INSTR_GET_cop0d(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_cop2t(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameRspCop2(RAB_INSTR_RSP_GET_cop2t(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_cop2cd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameRspCop2Control(RAB_INSTR_RSP_GET_cop2cd(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_vs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameRspVector(RAB_INSTR_RSP_GET_vs(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_vt(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameRspVector(RAB_INSTR_RSP_GET_vt(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_vd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameRspVector(RAB_INSTR_RSP_GET_vd(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_vt_elementhigh(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-    uint8_t element;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_vt(self, dst, immOverride, immOverrideLength));
-
-    element = RAB_INSTR_RSP_GET_elementhigh(self);
-    if (element != 0) {
-        if ((element & 0x8) == 0x8) {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", element & 7);
-        } else if ((element & 0xC) == 0x4) {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%ih]", element & (~0xC));
-        } else if ((element & 0xE) == 0x2) {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%iq]", element & (~0xE));
-        } else {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", element);
-        }
-    }
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_vt_elementlow(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_vt(self, dst, immOverride, immOverrideLength));
-
-    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", RAB_INSTR_RSP_GET_elementlow(self));
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_vd_de(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-    uint8_t de;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_vd(self, dst, immOverride, immOverrideLength));
-
-    de = RAB_INSTR_RSP_GET_de(self);
-    if ((de & 0x8) == 0x8) {
-        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", de & (~0x8));
-    } else if ((de & 0xC) == 0x4) {
-        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%ih]", de & (~0xC));
-    } else if ((de & 0xE) == 0x2) {
-        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%iq]", de & (~0xE));
-    } else {
-        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", de);
-    }
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_vs_index(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_vs(self, dst, immOverride, immOverrideLength));
-
-    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", RAB_INSTR_RSP_GET_index(self));
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_offset_rs(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%X", RabbitizerInstructionRsp_GetOffsetVector(self));
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_rs(self, dst, immOverride, immOverrideLength));
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_rsp_immediate_base(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-// TODO: consider making this a proper configuration
-#if 0
-    if (immOverride != NULL || RAB_INSTR_GET_immediate(self) != 0) {
-        RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_immediate(self, dst, immOverride, immOverrideLength));
-    }
-#endif
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_immediate(self, dst, immOverride, immOverrideLength));
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_rs(self, dst, immOverride, immOverrideLength));
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_I(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride,
-                                             UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, "$I");
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_Q(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride,
-                                             UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, "$Q");
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_R(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride,
-                                             UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, "$R");
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_ACC(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride,
-                                               UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, "$ACC");
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_ACCxyzw(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_ACC(self, dst, immOverride, immOverrideLength));
-
-#if 0
-    if (RAB_INSTR_R5900_GET_xyzw_x(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'x');
-    }
-    if (RAB_INSTR_R5900_GET_xyzw_y(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'y');
-    }
-    if (RAB_INSTR_R5900_GET_xyzw_z(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'z');
-    }
-    if (RAB_INSTR_R5900_GET_xyzw_w(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'w');
-    }
-#endif
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vfs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameR5900VF(RAB_INSTR_R5900_GET_vfs(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vft(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameR5900VF(RAB_INSTR_R5900_GET_vft(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vfd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameR5900VF(RAB_INSTR_R5900_GET_vfd(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vfsxyzw(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfs(self, dst, immOverride, immOverrideLength));
-
-#if 0
-    if (RAB_INSTR_R5900_GET_xyzw_x(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'x');
-    }
-    if (RAB_INSTR_R5900_GET_xyzw_y(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'y');
-    }
-    if (RAB_INSTR_R5900_GET_xyzw_z(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'z');
-    }
-    if (RAB_INSTR_R5900_GET_xyzw_w(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'w');
-    }
-#endif
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vftxyzw(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vft(self, dst, immOverride, immOverrideLength));
-
-#if 0
-    if (RAB_INSTR_R5900_GET_xyzw_x(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'x');
-    }
-    if (RAB_INSTR_R5900_GET_xyzw_y(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'y');
-    }
-    if (RAB_INSTR_R5900_GET_xyzw_z(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'z');
-    }
-    if (RAB_INSTR_R5900_GET_xyzw_w(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'w');
-    }
-#endif
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vfdxyzw(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfd(self, dst, immOverride, immOverrideLength));
-
-#if 0
-    if (RAB_INSTR_R5900_GET_xyzw_x(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'x');
-    }
-    if (RAB_INSTR_R5900_GET_xyzw_y(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'y');
-    }
-    if (RAB_INSTR_R5900_GET_xyzw_z(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'z');
-    }
-    if (RAB_INSTR_R5900_GET_xyzw_w(self)) {
-        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'w');
-    }
-#endif
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vfsn(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-    uint8_t n;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfs(self, dst, immOverride, immOverrideLength));
-
-    n = RAB_INSTR_R5900_GET_n(self);
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vftn(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-    uint8_t n;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vft(self, dst, immOverride, immOverrideLength));
-
-    n = RAB_INSTR_R5900_GET_n(self);
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vfdn(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-    uint8_t n;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfd(self, dst, immOverride, immOverrideLength));
-
-    n = RAB_INSTR_R5900_GET_n(self);
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vfsl(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-    uint8_t n;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfs(self, dst, immOverride, immOverrideLength));
-
-    n = RAB_INSTR_R5900_GET_l(self);
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vftl(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-    uint8_t n;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vft(self, dst, immOverride, immOverrideLength));
-
-    n = RAB_INSTR_R5900_GET_l(self);
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vfdl(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-    uint8_t n;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfd(self, dst, immOverride, immOverrideLength));
-
-    n = RAB_INSTR_R5900_GET_l(self);
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vfsm(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-    uint8_t n;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfs(self, dst, immOverride, immOverrideLength));
-
-    n = RAB_INSTR_R5900_GET_m(self);
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vftm(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-    uint8_t n;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vft(self, dst, immOverride, immOverrideLength));
-
-    n = RAB_INSTR_R5900_GET_m(self);
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vfdm(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-    uint8_t n;
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfd(self, dst, immOverride, immOverrideLength));
-
-    n = RAB_INSTR_R5900_GET_m(self);
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vis(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameR5900VI(RAB_INSTR_R5900_GET_vis(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vit(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameR5900VI(RAB_INSTR_R5900_GET_vit(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vid(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
-    size_t totalSize = 0;
-    const char *reg = RabbitizerRegister_getNameR5900VI(RAB_INSTR_R5900_GET_vid(self));
-
-    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vis_predecr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '-');
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '-');
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vis(self, dst, immOverride, immOverrideLength));
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vit_predecr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '-');
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '-');
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vit(self, dst, immOverride, immOverrideLength));
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vid_predecr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '-');
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '-');
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vid(self, dst, immOverride, immOverrideLength));
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vis_postincr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vis(self, dst, immOverride, immOverrideLength));
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+');
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+');
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vit_postincr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vit(self, dst, immOverride, immOverrideLength));
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+');
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+');
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_vid_postincr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
-
-    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vid(self, dst, immOverride, immOverrideLength));
-
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+');
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+');
-    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
-
-    return totalSize;
-}
-
-size_t RabbitizerOperandType_process_r5900_immediate5(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
-    size_t totalSize = 0;
-    int32_t number;
-
-    if (immOverride != NULL) {
-        memcpy(dst, immOverride, immOverrideLength);
-        return immOverrideLength;
-    }
-
-    number = RAB_INSTR_R5900_GET_imm5(self);
-    if (RabbitizerConfig_Cfg.misc.omit0XOnSmallImm) {
-        if (number > -10 && number < 10) {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "%i", number);
-            return totalSize;
-        }
-    }
-    if (number < 0) {
-        if (RabbitizerConfig_Cfg.misc.upperCaseImm) {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "-0x%X", -number);
-        } else {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "-0x%x", -number);
-        }
-    } else {
-        if (RabbitizerConfig_Cfg.misc.upperCaseImm) {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%X", number);
-        } else {
-            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%x", number);
-        }
-    }
-    return totalSize;
-}
-
 #define RAB_DEF_OPERAND(prefix, operand) [RAB_OPERAND_##prefix##_##operand] = RabbitizerOperandType_process_##prefix##_##operand,
 
 const OperandCallback instrOpercandCallbacks[] = {
@@ -795,15 +24,24 @@ const OperandCallback instrOpercandCallbacks[] = {
 
 size_t RabbitizerInstruction_getSizeForBufferOperandsDisasm(const RabbitizerInstruction *self, size_t immOverrideLength) {
     size_t totalSize = 0;
+    char auxBuffer[0x100] = { 0 };
+    char immOverride[0x100] = { 0 };
 
     for (size_t i = 0; i < ARRAY_COUNT(self->descriptor->operands) && self->descriptor->operands[i] != RAB_OPERAND_ALL_INVALID; i++) {
+        RabbitizerOperandType operand;
+        OperandCallback callback;
+
         if (i != 0) {
             totalSize += 2;
         }
 
-        // A bit arbitrary, but no operand should be longer than 25 characters
-        totalSize += 25;
-        totalSize += immOverrideLength;
+        operand = self->descriptor->operands[i];
+        assert(operand > RAB_OPERAND_ALL_INVALID);
+        assert(operand < RAB_OPERAND_ALL_MAX);
+
+        callback = instrOpercandCallbacks[operand];
+        assert(callback != NULL);
+        totalSize += callback(self, auxBuffer, immOverride, immOverrideLength);
     }
 
     return totalSize;
@@ -850,7 +88,12 @@ size_t RabbitizerInstruction_getSizeForBufferInstrDisasm(const RabbitizerInstruc
         return totalSize;
     }
 
-    totalSize += extraLJust;
+    if (RabbitizerConfig_Cfg.misc.opcodeLJust > 0) {
+        totalSize += RabbitizerConfig_Cfg.misc.opcodeLJust;
+    }
+    if (extraLJust > 0) {
+        totalSize += extraLJust;
+    }
     totalSize++;
 
     totalSize += RabbitizerInstruction_getSizeForBufferOperandsDisasm(self, immOverrideLength);

src/instructions/RabbitizerInstruction/RabbitizerInstruction_Examination.c

@@ -48,32 +48,47 @@ bool RabbitizerInstruction_isNop(const RabbitizerInstruction *self) {
 }
 
 bool RabbitizerInstruction_isUnconditionalBranch(const RabbitizerInstruction *self) {
-    if (self->uniqueId == RABBITIZER_INSTR_ID_cpu_b) {
-        return true;
+    switch (self->uniqueId) {
+        case RABBITIZER_INSTR_ID_cpu_b:
+        case RABBITIZER_INSTR_ID_rsp_b:
+            return true;
+
+        case RABBITIZER_INSTR_ID_cpu_beq:
+        case RABBITIZER_INSTR_ID_rsp_beq:
+            // in case the b pseudoinstruction is disabled
+            return RAB_INSTR_GET_rt(self) == 0 && RAB_INSTR_GET_rs(self) == 0;
+
+        case RABBITIZER_INSTR_ID_cpu_j:
+        case RABBITIZER_INSTR_ID_rsp_j:
+            return RabbitizerConfig_Cfg.toolchainTweaks.treatJAsUnconditionalBranch;
+
+        default:
+            return false;
     }
-    if (self->uniqueId == RABBITIZER_INSTR_ID_cpu_beq && RAB_INSTR_GET_rt(self) == 0 && RAB_INSTR_GET_rs(self) == 0) {
-        return true;
-    }
-    if (RabbitizerConfig_Cfg.toolchainTweaks.treatJAsUnconditionalBranch && self->uniqueId == RABBITIZER_INSTR_ID_cpu_j) {
-        return true;
-    }
-    return false;
 }
 
 bool RabbitizerInstruction_isJrRa(const RabbitizerInstruction *self) {
-    if (self->uniqueId == RABBITIZER_INSTR_ID_cpu_jr) {
-        // TODO: abi stuffs
-        return RAB_INSTR_GET_rs(self) == RABBITIZER_REG_GPR_O32_ra;
+    switch (self->uniqueId) {
+        case RABBITIZER_INSTR_ID_cpu_jr:
+        case RABBITIZER_INSTR_ID_rsp_jr:
+            // TODO: abi stuffs
+            return RAB_INSTR_GET_rs(self) == RABBITIZER_REG_GPR_O32_ra;
+
+        default:
+            return false;
     }
-    return false;
 }
 
 bool RabbitizerInstruction_isJrNotRa(const RabbitizerInstruction *self) {
-    if (self->uniqueId == RABBITIZER_INSTR_ID_cpu_jr) {
-        // TODO: abi stuffs
-        return RAB_INSTR_GET_rs(self) != RABBITIZER_REG_GPR_O32_ra;
+    switch (self->uniqueId) {
+        case RABBITIZER_INSTR_ID_cpu_jr:
+        case RABBITIZER_INSTR_ID_rsp_jr:
+            // TODO: abi stuffs
+            return RAB_INSTR_GET_rs(self) != RABBITIZER_REG_GPR_O32_ra;
+
+        default:
+            return false;
     }
-    return false;
 }
 
 bool RabbitizerInstruction_hasDelaySlot(const RabbitizerInstruction *self) {
@@ -155,6 +170,9 @@ bool RabbitizerInstruction_hasOperandAlias(const RabbitizerInstruction *self, Ra
             if (RabbitizerInstruction_hasOperand(self, RAB_OPERAND_cpu_immediate_base)) {
                 return true;
             }
+            if (RabbitizerInstruction_hasOperand(self, RAB_OPERAND_cpu_branch_target_label)) {
+                return true;
+            }
             if (RabbitizerInstruction_hasOperand(self, RAB_OPERAND_rsp_immediate_base)) {
                 return true;
             }
@@ -183,6 +201,7 @@ bool RabbitizerInstruction_hasOperandAlias(const RabbitizerInstruction *self, Ra
         case RAB_OPERAND_cpu_cop2t:
         case RAB_OPERAND_cpu_op:
         case RAB_OPERAND_cpu_code:
+        case RAB_OPERAND_cpu_code_lower:
         case RAB_OPERAND_cpu_copraw:
         case RAB_OPERAND_cpu_label:
             break;
@@ -587,6 +606,10 @@ uint32_t RabbitizerInstruction_getValidBits(const RabbitizerInstruction *self) {
                 validbits = RAB_INSTR_PACK_code(validbits, ~0);
                 break;
 
+            case RAB_OPERAND_cpu_code_lower:
+                validbits = RAB_INSTR_PACK_code_lower(validbits, ~0);
+                break;
+
             case RAB_OPERAND_cpu_copraw:
                 validbits = RAB_INSTR_PACK_copraw(validbits, ~0);
                 break;

src/instructions/RabbitizerInstructionCpu/RabbitizerInstructionCpu_OperandType.c

@@ -0,0 +1,230 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#include "instructions/RabbitizerInstruction.h"
+
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "common/Utils.h"
+#include "common/RabbitizerConfig.h"
+#include "instructions/RabbitizerRegister.h"
+
+size_t RabbitizerOperandType_process_cpu_rs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameGpr(RAB_INSTR_GET_rs(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_rt(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameGpr(RAB_INSTR_GET_rt(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_rd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameGpr(RAB_INSTR_GET_rd(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_zero(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride,
+                                              UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameGpr(0);
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_cop0d(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameCop0(RAB_INSTR_GET_cop0d(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_fs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameCop1(RAB_INSTR_GET_fs(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_ft(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameCop1(RAB_INSTR_GET_ft(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_fd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameCop1(RAB_INSTR_GET_fd(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_cop1cs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameCop1Control(RAB_INSTR_GET_cop1cs(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_cop2t(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameCop2(RAB_INSTR_GET_cop2t(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_sa(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+// TODO: consider making this a proper configuration
+#if 0
+    if (RAB_INSTR_GET_sa(self) < 10) {
+        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "%i", RAB_INSTR_GET_sa(self));
+    } else {
+        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%x", RAB_INSTR_GET_sa(self));
+    }
+#endif
+    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "%i", RAB_INSTR_GET_sa(self));
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_op(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+// TODO: consider making this a proper configuration
+#if 0
+    if (RAB_INSTR_GET_op(self) < 10) {
+        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "%i", RAB_INSTR_GET_op(self));
+    } else {
+        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%x", RAB_INSTR_GET_op(self));
+    }
+#endif
+    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%02X", RAB_INSTR_GET_op(self));
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_code(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    int code = RAB_INSTR_GET_code_upper(self);
+    int lower = RAB_INSTR_GET_code_lower(self);
+
+    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "%i", code);
+    if (lower) {
+        RABUTILS_BUFFER_SPRINTF(dst, totalSize, ", %i", lower);
+    }
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_code_lower(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride,
+                                                    UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    int code_lower = RAB_INSTR_GET_code_lower(self);
+
+    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "%i", code_lower);
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_copraw(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%X", RAB_INSTR_GET_copraw(self));
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_label(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    if ((immOverride != NULL) && (immOverrideLength > 0)) {
+        memcpy(dst, immOverride, immOverrideLength);
+        return immOverrideLength;
+    }
+
+    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "func_%06X", RabbitizerInstruction_getInstrIndexAsVram(self));
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_immediate(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+    int32_t number;
+
+    if ((immOverride != NULL) && (immOverrideLength > 0)) {
+        memcpy(dst, immOverride, immOverrideLength);
+        return immOverrideLength;
+    }
+
+    number = RabbitizerInstruction_getProcessedImmediate(self);
+    if (RabbitizerConfig_Cfg.misc.omit0XOnSmallImm) {
+        if (number > -10 && number < 10) {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "%i", number);
+            return totalSize;
+        }
+    }
+    if (number < 0) {
+        if (RabbitizerConfig_Cfg.misc.upperCaseImm) {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "-0x%X", -number);
+        } else {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "-0x%x", -number);
+        }
+    } else {
+        if (RabbitizerConfig_Cfg.misc.upperCaseImm) {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%X", number);
+        } else {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%x", number);
+        }
+    }
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_branch_target_label(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    if ((immOverride != NULL) && (immOverrideLength > 0)) {
+        memcpy(dst, immOverride, immOverrideLength);
+        return immOverrideLength;
+    }
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, ". + 4 + (");
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_immediate(self, dst, NULL, 0));
+    RABUTILS_BUFFER_CPY(dst, totalSize, " << 2)");
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_cpu_immediate_base(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+// TODO: consider making this a proper configuration
+#if 0
+    if ((immOverride != NULL) && (immOverrideLength > 0) || RAB_INSTR_GET_immediate(self) != 0) {
+        RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_immediate(self, dst, immOverride, immOverrideLength));
+    }
+#endif
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_immediate(self, dst, immOverride, immOverrideLength));
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_rs(self, dst, immOverride, immOverrideLength));
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
+
+    return totalSize;
+}

src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_OperandType.c

@@ -0,0 +1,412 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#include "instructions/RabbitizerInstructionR5900.h"
+
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "common/Utils.h"
+#include "common/RabbitizerConfig.h"
+#include "instructions/RabbitizerRegister.h"
+
+size_t RabbitizerOperandType_process_r5900_I(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride,
+                                             UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, "$I");
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_Q(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride,
+                                             UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, "$Q");
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_R(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride,
+                                             UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, "$R");
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_ACC(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride,
+                                               UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, "$ACC");
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_ACCxyzw(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_ACC(self, dst, immOverride, immOverrideLength));
+
+#if 0
+    if (RAB_INSTR_R5900_GET_xyzw_x(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'x');
+    }
+    if (RAB_INSTR_R5900_GET_xyzw_y(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'y');
+    }
+    if (RAB_INSTR_R5900_GET_xyzw_z(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'z');
+    }
+    if (RAB_INSTR_R5900_GET_xyzw_w(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'w');
+    }
+#endif
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vfs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameR5900VF(RAB_INSTR_R5900_GET_vfs(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vft(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameR5900VF(RAB_INSTR_R5900_GET_vft(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vfd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameR5900VF(RAB_INSTR_R5900_GET_vfd(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vfsxyzw(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfs(self, dst, immOverride, immOverrideLength));
+
+#if 0
+    if (RAB_INSTR_R5900_GET_xyzw_x(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'x');
+    }
+    if (RAB_INSTR_R5900_GET_xyzw_y(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'y');
+    }
+    if (RAB_INSTR_R5900_GET_xyzw_z(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'z');
+    }
+    if (RAB_INSTR_R5900_GET_xyzw_w(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'w');
+    }
+#endif
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vftxyzw(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vft(self, dst, immOverride, immOverrideLength));
+
+#if 0
+    if (RAB_INSTR_R5900_GET_xyzw_x(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'x');
+    }
+    if (RAB_INSTR_R5900_GET_xyzw_y(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'y');
+    }
+    if (RAB_INSTR_R5900_GET_xyzw_z(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'z');
+    }
+    if (RAB_INSTR_R5900_GET_xyzw_w(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'w');
+    }
+#endif
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vfdxyzw(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfd(self, dst, immOverride, immOverrideLength));
+
+#if 0
+    if (RAB_INSTR_R5900_GET_xyzw_x(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'x');
+    }
+    if (RAB_INSTR_R5900_GET_xyzw_y(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'y');
+    }
+    if (RAB_INSTR_R5900_GET_xyzw_z(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'z');
+    }
+    if (RAB_INSTR_R5900_GET_xyzw_w(self)) {
+        RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, 'w');
+    }
+#endif
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vfsn(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+    uint8_t n;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfs(self, dst, immOverride, immOverrideLength));
+
+    n = RAB_INSTR_R5900_GET_n(self);
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vftn(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+    uint8_t n;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vft(self, dst, immOverride, immOverrideLength));
+
+    n = RAB_INSTR_R5900_GET_n(self);
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vfdn(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+    uint8_t n;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfd(self, dst, immOverride, immOverrideLength));
+
+    n = RAB_INSTR_R5900_GET_n(self);
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vfsl(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+    uint8_t n;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfs(self, dst, immOverride, immOverrideLength));
+
+    n = RAB_INSTR_R5900_GET_l(self);
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vftl(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+    uint8_t n;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vft(self, dst, immOverride, immOverrideLength));
+
+    n = RAB_INSTR_R5900_GET_l(self);
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vfdl(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+    uint8_t n;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfd(self, dst, immOverride, immOverrideLength));
+
+    n = RAB_INSTR_R5900_GET_l(self);
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vfsm(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+    uint8_t n;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfs(self, dst, immOverride, immOverrideLength));
+
+    n = RAB_INSTR_R5900_GET_m(self);
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vftm(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+    uint8_t n;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vft(self, dst, immOverride, immOverrideLength));
+
+    n = RAB_INSTR_R5900_GET_m(self);
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vfdm(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+    uint8_t n;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vfd(self, dst, immOverride, immOverrideLength));
+
+    n = RAB_INSTR_R5900_GET_m(self);
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, "xyzw"[n]);
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vis(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameR5900VI(RAB_INSTR_R5900_GET_vis(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vit(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameR5900VI(RAB_INSTR_R5900_GET_vit(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vid(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameR5900VI(RAB_INSTR_R5900_GET_vid(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vis_predecr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '-');
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '-');
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vis(self, dst, immOverride, immOverrideLength));
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vit_predecr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '-');
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '-');
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vit(self, dst, immOverride, immOverrideLength));
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vid_predecr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '-');
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '-');
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vid(self, dst, immOverride, immOverrideLength));
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vis_postincr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vis(self, dst, immOverride, immOverrideLength));
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+');
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+');
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vit_postincr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vit(self, dst, immOverride, immOverrideLength));
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+');
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+');
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_vid_postincr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_r5900_vid(self, dst, immOverride, immOverrideLength));
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+');
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+');
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
+
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_r5900_immediate5(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+    int32_t number;
+
+    if ((immOverride != NULL) && (immOverrideLength > 0)) {
+        memcpy(dst, immOverride, immOverrideLength);
+        return immOverrideLength;
+    }
+
+    number = RAB_INSTR_R5900_GET_imm5(self);
+    if (RabbitizerConfig_Cfg.misc.omit0XOnSmallImm) {
+        if (number > -10 && number < 10) {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "%i", number);
+            return totalSize;
+        }
+    }
+    if (number < 0) {
+        if (RabbitizerConfig_Cfg.misc.upperCaseImm) {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "-0x%X", -number);
+        } else {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "-0x%x", -number);
+        }
+    } else {
+        if (RabbitizerConfig_Cfg.misc.upperCaseImm) {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%X", number);
+        } else {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%x", number);
+        }
+    }
+    return totalSize;
+}

src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_OperandType.c

@@ -0,0 +1,171 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#include "instructions/RabbitizerInstructionRsp.h"
+
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "common/Utils.h"
+#include "common/RabbitizerConfig.h"
+#include "instructions/RabbitizerRegister.h"
+
+size_t RabbitizerOperandType_process_rsp_rs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameRspGpr(RAB_INSTR_GET_rs(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_rt(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameRspGpr(RAB_INSTR_GET_rt(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_rd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameRspGpr(RAB_INSTR_GET_rd(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_cop0d(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameRspCop0(RAB_INSTR_GET_cop0d(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_cop2t(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameRspCop2(RAB_INSTR_RSP_GET_cop2t(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_cop2cd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameRspCop2Control(RAB_INSTR_RSP_GET_cop2cd(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_vs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameRspVector(RAB_INSTR_RSP_GET_vs(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_vt(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameRspVector(RAB_INSTR_RSP_GET_vt(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_vd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) {
+    size_t totalSize = 0;
+    const char *reg = RabbitizerRegister_getNameRspVector(RAB_INSTR_RSP_GET_vd(self));
+
+    RABUTILS_BUFFER_CPY(dst, totalSize, reg);
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_vt_elementhigh(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+    uint8_t element;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_vt(self, dst, immOverride, immOverrideLength));
+
+    element = RAB_INSTR_RSP_GET_elementhigh(self);
+    if (element != 0) {
+        if ((element & 0x8) == 0x8) {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", element & 7);
+        } else if ((element & 0xC) == 0x4) {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%ih]", element & (~0xC));
+        } else if ((element & 0xE) == 0x2) {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%iq]", element & (~0xE));
+        } else {
+            RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", element);
+        }
+    }
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_vt_elementlow(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_vt(self, dst, immOverride, immOverrideLength));
+
+    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", RAB_INSTR_RSP_GET_elementlow(self));
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_vd_de(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+    uint8_t de;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_vd(self, dst, immOverride, immOverrideLength));
+
+    de = RAB_INSTR_RSP_GET_de(self);
+    if ((de & 0x8) == 0x8) {
+        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", de & (~0x8));
+    } else if ((de & 0xC) == 0x4) {
+        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%ih]", de & (~0xC));
+    } else if ((de & 0xE) == 0x2) {
+        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%iq]", de & (~0xE));
+    } else {
+        RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", de);
+    }
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_vs_index(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_vs(self, dst, immOverride, immOverrideLength));
+
+    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", RAB_INSTR_RSP_GET_index(self));
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_offset_rs(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+    RABUTILS_BUFFER_SPRINTF(dst, totalSize, "0x%X", RabbitizerInstructionRsp_GetOffsetVector(self));
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_rs(self, dst, immOverride, immOverrideLength));
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
+    return totalSize;
+}
+
+size_t RabbitizerOperandType_process_rsp_immediate_base(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) {
+    size_t totalSize = 0;
+
+// TODO: consider making this a proper configuration
+#if 0
+    if ((immOverride != NULL) && (immOverrideLength > 0) || RAB_INSTR_GET_immediate(self) != 0) {
+        RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_immediate(self, dst, immOverride, immOverrideLength));
+    }
+#endif
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_immediate(self, dst, immOverride, immOverrideLength));
+
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '(');
+    RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_rs(self, dst, immOverride, immOverrideLength));
+    RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')');
+
+    return totalSize;
+}

tests/c/test.c

@@ -14,18 +14,22 @@ int main() {
     RabbitizerInstruction instr;
     char *buffer;
     int extraLJust = 5;
+    size_t bufferSize;
+    size_t disassembledSize;
 
-    // word = 0x8D4A7E18; // lw
-    word = 0x00004010; // mfhi
+    word = 0x8D4A7E18; // lw
+    //word = 0x00004010; // mfhi
 
     RabbitizerInstruction_init(&instr, word, 0x80000000);
 
     RabbitizerInstruction_processUniqueId(&instr);
 
-    buffer = malloc(RabbitizerInstruction_getSizeForBuffer(&instr, 0, extraLJust) + 1);
+    bufferSize = RabbitizerInstruction_getSizeForBuffer(&instr, 0, extraLJust);
+    buffer = malloc(bufferSize + 1);
     assert(buffer != NULL);
 
-    RabbitizerInstruction_disassemble(&instr, buffer, NULL, 0, extraLJust);
+    disassembledSize = RabbitizerInstruction_disassemble(&instr, buffer, NULL, 0, extraLJust);
+    assert(disassembledSize <= bufferSize);
 
     printf("%08X: %s\n", word, buffer);
 

tests/cplusplus/test.cpp

@@ -0,0 +1,16 @@
+/* SPDX-FileCopyrightText: © 2022 Decompollaborate */
+/* SPDX-License-Identifier: MIT */
+
+#include "instructions/InstructionCpu.hpp"
+
+
+int main() {
+    uint32_t word = 0x8D4A7E18; // lw
+    uint32_t vram = 0x80000000;
+    int extraLJust = 5;
+    rabbitizer::InstructionCpu instr(word, vram);
+
+    printf("%08X: %s\n", word, instr.disassemble(extraLJust).c_str());
+
+    return 0;
+}