From 5063702a0724dbb783cae278877c4e8f8db6d2db Mon Sep 17 00:00:00 2001 From: angie Date: Tue, 20 Dec 2022 00:42:27 -0300 Subject: [PATCH 1/6] modifiesF* and readsF --- .../include/instructions/InstructionBase.hpp | 9 + .../src/instructions/InstructionBase.cpp | 23 +++ .../instructions/RabbitizerInstrDescriptor.h | 27 +++ .../instructions/instr_id/cpu/cpu_cop1.inc | 12 +- .../instr_id/cpu/cpu_cop1_fpu_d.inc | 144 +++++++++---- .../instr_id/cpu/cpu_cop1_fpu_l.inc | 8 +- .../instr_id/cpu/cpu_cop1_fpu_s.inc | 144 +++++++++---- .../instr_id/cpu/cpu_cop1_fpu_w.inc | 8 +- .../instructions/instr_id/cpu/cpu_normal.inc | 4 + .../instr_id/r5900/r5900_cop1_fpu_s.inc | 57 ++++-- rabbitizer/rabbitizer.pyi | 7 + rabbitizer/rabbitizer_type_Instruction.c | 14 ++ rust/src/instr_descriptor.rs | 9 + rust/src/instruction.rs | 44 ++++ .../InstrDescriptor_Descriptors_array.table.h | 190 +++++++++--------- src/instructions/RabbitizerInstrDescriptor.c | 23 +++ tests/c/logic_checks/descriptor_logic_check.c | 18 +- 17 files changed, 553 insertions(+), 188 deletions(-) diff --git a/cplusplus/include/instructions/InstructionBase.hpp b/cplusplus/include/instructions/InstructionBase.hpp index e09949c..6b131a8 100644 --- a/cplusplus/include/instructions/InstructionBase.hpp +++ b/cplusplus/include/instructions/InstructionBase.hpp @@ -228,6 +228,7 @@ namespace rabbitizer { bool isUnsigned() const; + bool modifiesRs() const; bool modifiesRt() const; bool modifiesRd() const; @@ -240,6 +241,14 @@ namespace rabbitizer { bool modifiesHI() const; bool modifiesLO() const; + bool modifiesFs() const; + bool modifiesFt() const; + bool modifiesFd() const; + + bool readsFs() const; + bool readsFt() const; + bool readsFd() const; + bool notEmitedByCompilers() const; bool canBeHi() const; diff --git a/cplusplus/src/instructions/InstructionBase.cpp b/cplusplus/src/instructions/InstructionBase.cpp index 2076b8e..ba6e06d 100644 --- a/cplusplus/src/instructions/InstructionBase.cpp +++ b/cplusplus/src/instructions/InstructionBase.cpp @@ -852,6 +852,9 @@ bool InstructionBase::isUnsigned() const { return RabbitizerInstrDescriptor_isUnsigned(this->instr.descriptor); } +bool InstructionBase::modifiesRs() const { + return RabbitizerInstrDescriptor_modifiesRs(this->instr.descriptor); +} bool InstructionBase::modifiesRt() const { return RabbitizerInstrDescriptor_modifiesRt(this->instr.descriptor); } @@ -882,6 +885,26 @@ bool InstructionBase::modifiesLO() const { return RabbitizerInstrDescriptor_modifiesLO(this->instr.descriptor); } +bool InstructionBase::modifiesFs() const { + return RabbitizerInstrDescriptor_modifiesFs(this->instr.descriptor); +} +bool InstructionBase::modifiesFt() const { + return RabbitizerInstrDescriptor_modifiesFt(this->instr.descriptor); +} +bool InstructionBase::modifiesFd() const { + return RabbitizerInstrDescriptor_modifiesFd(this->instr.descriptor); +} + +bool InstructionBase::readsFs() const { + return RabbitizerInstrDescriptor_readsFs(this->instr.descriptor); +} +bool InstructionBase::readsFt() const { + return RabbitizerInstrDescriptor_readsFt(this->instr.descriptor); +} +bool InstructionBase::readsFd() const { + return RabbitizerInstrDescriptor_readsFd(this->instr.descriptor); +} + bool InstructionBase::notEmitedByCompilers() const { return RabbitizerInstrDescriptor_notEmitedByCompilers(this->instr.descriptor); } diff --git a/include/instructions/RabbitizerInstrDescriptor.h b/include/instructions/RabbitizerInstrDescriptor.h index c3222e2..d114624 100644 --- a/include/instructions/RabbitizerInstrDescriptor.h +++ b/include/instructions/RabbitizerInstrDescriptor.h @@ -69,6 +69,10 @@ typedef struct RabbitizerInstrDescriptor { */ bool isUnsigned; + /** + * The instruction modifies the state of the MIPS `rs` register + */ + bool modifiesRs; /** * The instruction modifies the state of the MIPS `rt` register */ @@ -96,6 +100,13 @@ typedef struct RabbitizerInstrDescriptor { bool modifiesHI; bool modifiesLO; + bool modifiesFs; + bool modifiesFt; + bool modifiesFd; + bool readsFs; + bool readsFt; + bool readsFd; + /** * This instruction is not emited by a C compiler */ @@ -183,6 +194,8 @@ bool RabbitizerInstrDescriptor_isDouble(const RabbitizerInstrDescriptor *self); NODISCARD NON_NULL(1) PURE bool RabbitizerInstrDescriptor_isUnsigned(const RabbitizerInstrDescriptor *self); +NODISCARD NON_NULL(1) PURE +bool RabbitizerInstrDescriptor_modifiesRs(const RabbitizerInstrDescriptor *self); NODISCARD NON_NULL(1) PURE bool RabbitizerInstrDescriptor_modifiesRt(const RabbitizerInstrDescriptor *self); NODISCARD NON_NULL(1) PURE @@ -204,6 +217,20 @@ bool RabbitizerInstrDescriptor_modifiesHI(const RabbitizerInstrDescriptor *self) NODISCARD NON_NULL(1) PURE bool RabbitizerInstrDescriptor_modifiesLO(const RabbitizerInstrDescriptor *self); +NODISCARD NON_NULL(1) PURE +bool RabbitizerInstrDescriptor_modifiesFs(const RabbitizerInstrDescriptor *self); +NODISCARD NON_NULL(1) PURE +bool RabbitizerInstrDescriptor_modifiesFt(const RabbitizerInstrDescriptor *self); +NODISCARD NON_NULL(1) PURE +bool RabbitizerInstrDescriptor_modifiesFd(const RabbitizerInstrDescriptor *self); + +NODISCARD NON_NULL(1) PURE +bool RabbitizerInstrDescriptor_readsFs(const RabbitizerInstrDescriptor *self); +NODISCARD NON_NULL(1) PURE +bool RabbitizerInstrDescriptor_readsFt(const RabbitizerInstrDescriptor *self); +NODISCARD NON_NULL(1) PURE +bool RabbitizerInstrDescriptor_readsFd(const RabbitizerInstrDescriptor *self); + NODISCARD NON_NULL(1) PURE bool RabbitizerInstrDescriptor_notEmitedByCompilers(const RabbitizerInstrDescriptor *self); diff --git a/include/instructions/instr_id/cpu/cpu_cop1.inc b/include/instructions/instr_id/cpu/cpu_cop1.inc index 5b635e4..8dd4337 100644 --- a/include/instructions/instr_id/cpu/cpu_cop1.inc +++ b/include/instructions/instr_id/cpu/cpu_cop1.inc @@ -7,28 +7,32 @@ RABBITIZER_DEF_INSTR_ID( .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, - .modifiesRt=true + .modifiesRt=true, + .readsFs=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 + .modifiesRt=true, + .readsFs=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, - .readsRt=true + .readsRt=true, + .modifiesFs=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, - .readsRt=true + .readsRt=true, + .modifiesFs=true ) // Doubleword Move To Floating-Point // OP rt, cop1cs diff --git a/include/instructions/instr_id/cpu/cpu_cop1_fpu_d.inc b/include/instructions/instr_id/cpu/cpu_cop1_fpu_d.inc index bf1bdb4..a845f26 100644 --- a/include/instructions/instr_id/cpu/cpu_cop1_fpu_d.inc +++ b/include/instructions/instr_id/cpu/cpu_cop1_fpu_d.inc @@ -6,25 +6,37 @@ 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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true, + .readsFt=true ) // Floating-Point Divide // OP fd, fs @@ -32,75 +44,99 @@ 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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true ) // Floating-Point Floor Convert to Word Fixed-Point // OP fd, fs @@ -109,21 +145,27 @@ RABBITIZER_DEF_INSTR_ID_ALTNAME( .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, - .isDouble=true + .isDouble=true, + .modifiesFd=true, + .readsFs=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 + .isDouble=true, + .modifiesFd=true, + .readsFs=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 + .isDouble=true, + .modifiesFd=true, + .readsFs=true ) // OP fs, ft @@ -131,96 +173,128 @@ 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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=true ) diff --git a/include/instructions/instr_id/cpu/cpu_cop1_fpu_l.inc b/include/instructions/instr_id/cpu/cpu_cop1_fpu_l.inc index f5ca07e..f8fb5d4 100644 --- a/include/instructions/instr_id/cpu/cpu_cop1_fpu_l.inc +++ b/include/instructions/instr_id/cpu/cpu_cop1_fpu_l.inc @@ -6,12 +6,16 @@ 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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isDouble=true, + .modifiesFd=true, + .readsFs=true ) diff --git a/include/instructions/instr_id/cpu/cpu_cop1_fpu_s.inc b/include/instructions/instr_id/cpu/cpu_cop1_fpu_s.inc index 58d7ae1..28fb614 100644 --- a/include/instructions/instr_id/cpu/cpu_cop1_fpu_s.inc +++ b/include/instructions/instr_id/cpu/cpu_cop1_fpu_s.inc @@ -6,25 +6,37 @@ 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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true, + .readsFt=true ) // Floating-Point Divide // OP fd, fs @@ -32,75 +44,99 @@ 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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true ) // Floating-Point Floor Convert to Word Fixed-Point // OP fd, fs @@ -109,19 +145,25 @@ RABBITIZER_DEF_INSTR_ID_ALTNAME( .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, - .isDouble=true + .isDouble=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true ) // OP fs, ft @@ -129,96 +171,128 @@ 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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=true ) diff --git a/include/instructions/instr_id/cpu/cpu_cop1_fpu_w.inc b/include/instructions/instr_id/cpu/cpu_cop1_fpu_w.inc index 03c9b32..5d52e70 100644 --- a/include/instructions/instr_id/cpu/cpu_cop1_fpu_w.inc +++ b/include/instructions/instr_id/cpu/cpu_cop1_fpu_w.inc @@ -6,12 +6,16 @@ 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 + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isDouble=true, + .modifiesFd=true, + .readsFs=true ) diff --git a/include/instructions/instr_id/cpu/cpu_normal.inc b/include/instructions/instr_id/cpu/cpu_normal.inc index 4e32c02..50b1de4 100644 --- a/include/instructions/instr_id/cpu/cpu_normal.inc +++ b/include/instructions/instr_id/cpu/cpu_normal.inc @@ -439,6 +439,7 @@ RABBITIZER_DEF_INSTR_ID( .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .readsRs=true, + .modifiesFt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, @@ -451,6 +452,7 @@ RABBITIZER_DEF_INSTR_ID( .isFloat=true, .isDouble=true, .readsRs=true, + .modifiesFt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, @@ -462,6 +464,7 @@ RABBITIZER_DEF_INSTR_ID( .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .readsRs=true, + .readsFt=true, .canBeLo=true, .doesDereference=true, .doesStore=true, @@ -474,6 +477,7 @@ RABBITIZER_DEF_INSTR_ID( .isFloat=true, .isDouble=true, .readsRs=true, + .readsFt=true, .canBeLo=true, .doesDereference=true, .doesStore=true, diff --git a/include/instructions/instr_id/r5900/r5900_cop1_fpu_s.inc b/include/instructions/instr_id/r5900/r5900_cop1_fpu_s.inc index 5748161..2e65ae6 100644 --- a/include/instructions/instr_id/r5900/r5900_cop1_fpu_s.inc +++ b/include/instructions/instr_id/r5900/r5900_cop1_fpu_s.inc @@ -27,55 +27,80 @@ RABBITIZER_DEF_INSTR_ID_ALTNAME( 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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .modifiesFs=true, + .readsFt=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 + .isFloat=true, + .modifiesFs=true, + .readsFt=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 + .isFloat=true, + .modifiesFs=true, + .readsFt=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .modifiesFd=true, + .readsFs=true, + .readsFt=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. @@ -86,16 +111,22 @@ RABBITIZER_DEF_INSTR_ID_ALTNAME( RABBITIZER_DEF_INSTR_ID_ALTNAME( r5900, 0x24, trunc_w_s, trunc.w.s, .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, - .isFloat=true + .isFloat=true, + .modifiesFd=true, + .readsFs=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 + .isFloat=true, + .readsFs=true, + .readsFt=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 + .isFloat=true, + .readsFs=true, + .readsFt=true ) diff --git a/rabbitizer/rabbitizer.pyi b/rabbitizer/rabbitizer.pyi index 298b20f..254c3f8 100644 --- a/rabbitizer/rabbitizer.pyi +++ b/rabbitizer/rabbitizer.pyi @@ -98,6 +98,7 @@ class Instruction: def isFloat(self) -> bool: ... def isDouble(self) -> bool: ... def isUnsigned(self) -> bool: ... + def modifiesRs(self) -> bool: ... def modifiesRt(self) -> bool: ... def modifiesRd(self) -> bool: ... def readsRs(self) -> bool: ... @@ -107,6 +108,12 @@ class Instruction: def readsLO(self) -> bool: ... def modifiesHI(self) -> bool: ... def modifiesLO(self) -> bool: ... + def modifiesFs(self) -> bool: ... + def modifiesFt(self) -> bool: ... + def modifiesFd(self) -> bool: ... + def readsFs(self) -> bool: ... + def readsFt(self) -> bool: ... + def readsFd(self) -> bool: ... def notEmitedByCompilers(self) -> bool: ... def canBeHi(self) -> bool: ... def canBeLo(self) -> bool: ... diff --git a/rabbitizer/rabbitizer_type_Instruction.c b/rabbitizer/rabbitizer_type_Instruction.c index 0cce2a0..a948841 100644 --- a/rabbitizer/rabbitizer_type_Instruction.c +++ b/rabbitizer/rabbitizer_type_Instruction.c @@ -357,6 +357,7 @@ DEF_DESCRIPTOR_METHOD_BOOL(isTrap) DEF_DESCRIPTOR_METHOD_BOOL(isFloat) DEF_DESCRIPTOR_METHOD_BOOL(isDouble) DEF_DESCRIPTOR_METHOD_BOOL(isUnsigned) +DEF_DESCRIPTOR_METHOD_BOOL(modifiesRs) DEF_DESCRIPTOR_METHOD_BOOL(modifiesRt) DEF_DESCRIPTOR_METHOD_BOOL(modifiesRd) DEF_DESCRIPTOR_METHOD_BOOL(readsRs) @@ -366,6 +367,12 @@ DEF_DESCRIPTOR_METHOD_BOOL(readsHI) DEF_DESCRIPTOR_METHOD_BOOL(readsLO) DEF_DESCRIPTOR_METHOD_BOOL(modifiesHI) DEF_DESCRIPTOR_METHOD_BOOL(modifiesLO) +DEF_DESCRIPTOR_METHOD_BOOL(modifiesFs) +DEF_DESCRIPTOR_METHOD_BOOL(modifiesFt) +DEF_DESCRIPTOR_METHOD_BOOL(modifiesFd) +DEF_DESCRIPTOR_METHOD_BOOL(readsFs) +DEF_DESCRIPTOR_METHOD_BOOL(readsFt) +DEF_DESCRIPTOR_METHOD_BOOL(readsFd) DEF_DESCRIPTOR_METHOD_BOOL(notEmitedByCompilers) DEF_DESCRIPTOR_METHOD_BOOL(canBeHi) DEF_DESCRIPTOR_METHOD_BOOL(canBeLo) @@ -493,6 +500,7 @@ static PyMethodDef rabbitizer_type_Instruction_methods[] = { METHOD_NO_ARGS(isFloat, ""), METHOD_NO_ARGS(isDouble, ""), METHOD_NO_ARGS(isUnsigned, ""), + METHOD_NO_ARGS(modifiesRs, ""), METHOD_NO_ARGS(modifiesRt, ""), METHOD_NO_ARGS(modifiesRd, ""), METHOD_NO_ARGS(readsRs, ""), @@ -502,6 +510,12 @@ static PyMethodDef rabbitizer_type_Instruction_methods[] = { METHOD_NO_ARGS(readsLO, ""), METHOD_NO_ARGS(modifiesHI, ""), METHOD_NO_ARGS(modifiesLO, ""), + METHOD_NO_ARGS(modifiesFs, ""), + METHOD_NO_ARGS(modifiesFt, ""), + METHOD_NO_ARGS(modifiesFd, ""), + METHOD_NO_ARGS(readsFs, ""), + METHOD_NO_ARGS(readsFt, ""), + METHOD_NO_ARGS(readsFd, ""), METHOD_NO_ARGS(notEmitedByCompilers, ""), METHOD_NO_ARGS(canBeHi, ""), METHOD_NO_ARGS(canBeLo, ""), diff --git a/rust/src/instr_descriptor.rs b/rust/src/instr_descriptor.rs index b795699..39ffdea 100644 --- a/rust/src/instr_descriptor.rs +++ b/rust/src/instr_descriptor.rs @@ -23,6 +23,7 @@ pub struct InstrDescriptor { is_unsigned: bool, + modifies_rs: bool, modifies_rt: bool, modifies_rd: bool, @@ -35,6 +36,14 @@ pub struct InstrDescriptor { modifies_hi: bool, modifies_lo: bool, + modifies_fs: bool, + modifies_ft: bool, + modifies_fd: bool, + + reads_fs: bool, + reads_ft: bool, + reads_fd: bool, + not_emited_by_compilers: bool, can_be_hi: bool, diff --git a/rust/src/instruction.rs b/rust/src/instruction.rs index 85f1d51..ce320f5 100644 --- a/rust/src/instruction.rs +++ b/rust/src/instruction.rs @@ -115,6 +115,7 @@ extern "C" { fn RabbitizerInstrDescriptor_isDouble(self_: *const instr_descriptor::InstrDescriptor) -> bool; fn RabbitizerInstrDescriptor_isUnsigned(self_: *const instr_descriptor::InstrDescriptor) -> bool; + fn RabbitizerInstrDescriptor_modifiesRs(self_: *const instr_descriptor::InstrDescriptor) -> bool; fn RabbitizerInstrDescriptor_modifiesRt(self_: *const instr_descriptor::InstrDescriptor) -> bool; fn RabbitizerInstrDescriptor_modifiesRd(self_: *const instr_descriptor::InstrDescriptor) -> bool; fn RabbitizerInstrDescriptor_readsRs(self_: *const instr_descriptor::InstrDescriptor) -> bool; @@ -125,6 +126,14 @@ extern "C" { fn RabbitizerInstrDescriptor_readsLO(self_: *const instr_descriptor::InstrDescriptor) -> bool; fn RabbitizerInstrDescriptor_modifiesHI(self_: *const instr_descriptor::InstrDescriptor) -> bool; fn RabbitizerInstrDescriptor_modifiesLO(self_: *const instr_descriptor::InstrDescriptor) -> bool; + + fn RabbitizerInstrDescriptor_modifiesFs(self_: *const instr_descriptor::InstrDescriptor) -> bool; + fn RabbitizerInstrDescriptor_modifiesFt(self_: *const instr_descriptor::InstrDescriptor) -> bool; + fn RabbitizerInstrDescriptor_modifiesFd(self_: *const instr_descriptor::InstrDescriptor) -> bool; + fn RabbitizerInstrDescriptor_readsFs(self_: *const instr_descriptor::InstrDescriptor) -> bool; + fn RabbitizerInstrDescriptor_readsFt(self_: *const instr_descriptor::InstrDescriptor) -> bool; + fn RabbitizerInstrDescriptor_readsFd(self_: *const instr_descriptor::InstrDescriptor) -> bool; + fn RabbitizerInstrDescriptor_notEmitedByCompilers( self_: *const instr_descriptor::InstrDescriptor, ) -> bool; @@ -584,6 +593,11 @@ impl Instruction { RabbitizerInstrDescriptor_isUnsigned(self.descriptor) } } + pub fn modifies_rs(&self) -> bool { + unsafe { + RabbitizerInstrDescriptor_modifiesRs(self.descriptor) + } + } pub fn modifies_rt(&self) -> bool { unsafe { RabbitizerInstrDescriptor_modifiesRt(self.descriptor) @@ -629,6 +643,36 @@ impl Instruction { RabbitizerInstrDescriptor_modifiesLO(self.descriptor) } } + pub fn modifies_fs(&self) -> bool { + unsafe { + RabbitizerInstrDescriptor_modifiesFs(self.descriptor) + } + } + pub fn modifies_ft(&self) -> bool { + unsafe { + RabbitizerInstrDescriptor_modifiesFt(self.descriptor) + } + } + pub fn modifies_fd(&self) -> bool { + unsafe { + RabbitizerInstrDescriptor_modifiesFd(self.descriptor) + } + } + pub fn reads_fs(&self) -> bool { + unsafe { + RabbitizerInstrDescriptor_readsFs(self.descriptor) + } + } + pub fn reads_ft(&self) -> bool { + unsafe { + RabbitizerInstrDescriptor_readsFt(self.descriptor) + } + } + pub fn reads_fd(&self) -> bool { + unsafe { + RabbitizerInstrDescriptor_readsFd(self.descriptor) + } + } pub fn not_emited_by_compilers(&self) -> bool { unsafe { RabbitizerInstrDescriptor_notEmitedByCompilers(self.descriptor) diff --git a/src/instructions/InstrDescriptor_Descriptors_array.table.h b/src/instructions/InstrDescriptor_Descriptors_array.table.h index 9aaa170..927d2d2 100644 --- a/src/instructions/InstrDescriptor_Descriptors_array.table.h +++ b/src/instructions/InstrDescriptor_Descriptors_array.table.h @@ -53,10 +53,10 @@ const RabbitizerInstrDescriptor RabbitizerInstrDescriptor_Descriptors[] = { [RABBITIZER_INSTR_ID_cpu_scd] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .readsRs=true, .readsRt=true, .canBeLo=true, .doesDereference=true, .doesStore=true }, [RABBITIZER_INSTR_ID_cpu_sd] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .readsRs=true, .readsRt=true, .canBeLo=true, .doesDereference=true, .doesStore=true, .accessType=RAB_ACCESSTYPE_DOUBLEWORD }, [RABBITIZER_INSTR_ID_cpu_cache] = { .operands={RAB_OPERAND_cpu_op, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .readsRs=true, .notEmitedByCompilers=true }, -[RABBITIZER_INSTR_ID_cpu_lwc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .accessType=RAB_ACCESSTYPE_FLOAT }, -[RABBITIZER_INSTR_ID_cpu_ldc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .isDouble=true, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .accessType=RAB_ACCESSTYPE_DOUBLEFLOAT }, -[RABBITIZER_INSTR_ID_cpu_swc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesStore=true, .accessType=RAB_ACCESSTYPE_FLOAT }, -[RABBITIZER_INSTR_ID_cpu_sdc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .isDouble=true, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesStore=true, .accessType=RAB_ACCESSTYPE_DOUBLEFLOAT }, +[RABBITIZER_INSTR_ID_cpu_lwc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .readsRs=true, .modifiesFt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .accessType=RAB_ACCESSTYPE_FLOAT }, +[RABBITIZER_INSTR_ID_cpu_ldc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .isDouble=true, .readsRs=true, .modifiesFt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .accessType=RAB_ACCESSTYPE_DOUBLEFLOAT }, +[RABBITIZER_INSTR_ID_cpu_swc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .readsRs=true, .readsFt=true, .canBeLo=true, .doesDereference=true, .doesStore=true, .accessType=RAB_ACCESSTYPE_FLOAT }, +[RABBITIZER_INSTR_ID_cpu_sdc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .isDouble=true, .readsRs=true, .readsFt=true, .canBeLo=true, .doesDereference=true, .doesStore=true, .accessType=RAB_ACCESSTYPE_DOUBLEFLOAT }, [RABBITIZER_INSTR_ID_cpu_lwc2] = { .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesLoad=true }, [RABBITIZER_INSTR_ID_cpu_ldc2] = { .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesLoad=true }, [RABBITIZER_INSTR_ID_cpu_swc2] = { .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesStore=true }, @@ -154,90 +154,90 @@ const RabbitizerInstrDescriptor RabbitizerInstrDescriptor_Descriptors[] = { [RABBITIZER_INSTR_ID_cpu_tlbwr] = { .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN }, [RABBITIZER_INSTR_ID_cpu_tlbp] = { .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .notEmitedByCompilers=true }, [RABBITIZER_INSTR_ID_cpu_eret] = { .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .notEmitedByCompilers=true }, -[RABBITIZER_INSTR_ID_cpu_mfc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesRt=true }, -[RABBITIZER_INSTR_ID_cpu_dmfc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesRt=true }, -[RABBITIZER_INSTR_ID_cpu_mtc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsRt=true }, -[RABBITIZER_INSTR_ID_cpu_dmtc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsRt=true }, +[RABBITIZER_INSTR_ID_cpu_mfc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesRt=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_dmfc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesRt=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_mtc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsRt=true, .modifiesFs=true }, +[RABBITIZER_INSTR_ID_cpu_dmtc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsRt=true, .modifiesFs=true }, [RABBITIZER_INSTR_ID_cpu_cfc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop1cs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesRt=true }, [RABBITIZER_INSTR_ID_cpu_ctc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop1cs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsRt=true }, [RABBITIZER_INSTR_ID_cpu_bc1f] = { .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true }, [RABBITIZER_INSTR_ID_cpu_bc1t] = { .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true }, [RABBITIZER_INSTR_ID_cpu_bc1fl] = { .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true, .isBranchLikely=true }, [RABBITIZER_INSTR_ID_cpu_bc1tl] = { .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true, .isBranchLikely=true }, -[RABBITIZER_INSTR_ID_cpu_add_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_sub_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_mul_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_div_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_sqrt_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_abs_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_mov_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_neg_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_round_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_trunc_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_ceil_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_floor_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_round_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_trunc_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_ceil_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_floor_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_cvt_d_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true }, -[RABBITIZER_INSTR_ID_cpu_cvt_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_cvt_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_f_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_un_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_eq_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ueq_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_olt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ult_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ole_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ule_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_sf_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ngle_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_seq_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ngl_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_lt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_nge_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_le_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ngt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_add_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_sub_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_mul_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_div_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_sqrt_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_abs_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_mov_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_neg_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_round_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_trunc_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_ceil_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_floor_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_round_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_trunc_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_ceil_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_floor_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_cvt_s_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true }, -[RABBITIZER_INSTR_ID_cpu_cvt_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true }, -[RABBITIZER_INSTR_ID_cpu_cvt_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true }, -[RABBITIZER_INSTR_ID_cpu_c_f_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_un_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_eq_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ueq_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_olt_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ult_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ole_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ule_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_df_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ngle_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_deq_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ngl_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_lt_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_nge_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_le_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_c_ngt_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_cvt_s_w] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_cvt_d_w] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true }, -[RABBITIZER_INSTR_ID_cpu_cvt_s_l] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true }, -[RABBITIZER_INSTR_ID_cpu_cvt_d_l] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true }, +[RABBITIZER_INSTR_ID_cpu_add_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_sub_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_mul_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_div_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_sqrt_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_abs_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_mov_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_neg_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_round_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_trunc_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_ceil_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_floor_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_round_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_trunc_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_ceil_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_floor_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_cvt_d_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_cvt_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_cvt_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_c_f_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_un_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_eq_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ueq_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_olt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ult_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ole_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ule_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_sf_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ngle_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_seq_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ngl_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_lt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_nge_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_le_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ngt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_add_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_sub_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_mul_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_div_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_sqrt_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_abs_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_mov_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_neg_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_round_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_trunc_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_ceil_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_floor_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_round_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_trunc_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_ceil_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_floor_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_cvt_s_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_cvt_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_cvt_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_c_f_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_un_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_eq_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ueq_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_olt_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ult_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ole_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ule_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_df_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ngle_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_deq_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ngl_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_lt_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_nge_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_le_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_c_ngt_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_cpu_cvt_s_w] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_cvt_d_w] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_cvt_s_l] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_cpu_cvt_d_l] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true, .modifiesFd=true, .readsFs=true }, [RABBITIZER_INSTR_ID_cpu_USERDEF_00] = { .operands={0} }, [RABBITIZER_INSTR_ID_cpu_USERDEF_01] = { .operands={0} }, [RABBITIZER_INSTR_ID_cpu_USERDEF_02] = { .operands={0} }, @@ -523,19 +523,19 @@ const RabbitizerInstrDescriptor RabbitizerInstrDescriptor_Descriptors[] = { [RABBITIZER_INSTR_ID_r5900_ei] = { .operands={0} }, [RABBITIZER_INSTR_ID_r5900_di] = { .operands={0} }, [RABBITIZER_INSTR_ID_r5900_c1__sqrt_s] = { .operands={RAB_OPERAND_cpu_copraw} }, -[RABBITIZER_INSTR_ID_r5900_rsqrt_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true }, -[RABBITIZER_INSTR_ID_r5900_adda_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true }, -[RABBITIZER_INSTR_ID_r5900_suba_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true }, -[RABBITIZER_INSTR_ID_r5900_mula_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true }, -[RABBITIZER_INSTR_ID_r5900_madd_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true }, -[RABBITIZER_INSTR_ID_r5900_msub_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true }, -[RABBITIZER_INSTR_ID_r5900_madda_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true }, -[RABBITIZER_INSTR_ID_r5900_msuba_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true }, -[RABBITIZER_INSTR_ID_r5900_max_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true }, -[RABBITIZER_INSTR_ID_r5900_min_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true }, -[RABBITIZER_INSTR_ID_r5900_trunc_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .isFloat=true }, -[RABBITIZER_INSTR_ID_r5900_c_lt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true }, -[RABBITIZER_INSTR_ID_r5900_c_le_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true }, +[RABBITIZER_INSTR_ID_r5900_rsqrt_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_r5900_adda_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_r5900_suba_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_r5900_mula_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_r5900_madd_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_r5900_msub_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_r5900_madda_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_r5900_msuba_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_r5900_max_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_r5900_min_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_r5900_trunc_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .isFloat=true, .modifiesFd=true, .readsFs=true }, +[RABBITIZER_INSTR_ID_r5900_c_lt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .readsFs=true, .readsFt=true }, +[RABBITIZER_INSTR_ID_r5900_c_le_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .readsFs=true, .readsFt=true }, [RABBITIZER_INSTR_ID_r5900_qmfc2] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vfs}, .modifiesRt=true }, [RABBITIZER_INSTR_ID_r5900_cfc2] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vis}, .modifiesRt=true }, [RABBITIZER_INSTR_ID_r5900_qmtc2] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vfs}, .readsRt=true }, diff --git a/src/instructions/RabbitizerInstrDescriptor.c b/src/instructions/RabbitizerInstrDescriptor.c index 2a69bb8..5c9b957 100644 --- a/src/instructions/RabbitizerInstrDescriptor.c +++ b/src/instructions/RabbitizerInstrDescriptor.c @@ -525,6 +525,9 @@ bool RabbitizerInstrDescriptor_isUnsigned(const RabbitizerInstrDescriptor *self) return self->isUnsigned; } +bool RabbitizerInstrDescriptor_modifiesRs(const RabbitizerInstrDescriptor *self) { + return self->modifiesRs; +} bool RabbitizerInstrDescriptor_modifiesRt(const RabbitizerInstrDescriptor *self) { return self->modifiesRt; } @@ -555,6 +558,26 @@ bool RabbitizerInstrDescriptor_modifiesLO(const RabbitizerInstrDescriptor *self) return self->modifiesLO; } +bool RabbitizerInstrDescriptor_modifiesFs(const RabbitizerInstrDescriptor *self) { + return self->modifiesFs; +} +bool RabbitizerInstrDescriptor_modifiesFt(const RabbitizerInstrDescriptor *self) { + return self->modifiesFt; +} +bool RabbitizerInstrDescriptor_modifiesFd(const RabbitizerInstrDescriptor *self) { + return self->modifiesFd; +} + +bool RabbitizerInstrDescriptor_readsFs(const RabbitizerInstrDescriptor *self) { + return self->readsFs; +} +bool RabbitizerInstrDescriptor_readsFt(const RabbitizerInstrDescriptor *self) { + return self->readsFt; +} +bool RabbitizerInstrDescriptor_readsFd(const RabbitizerInstrDescriptor *self) { + return self->readsFd; +} + bool RabbitizerInstrDescriptor_notEmitedByCompilers(const RabbitizerInstrDescriptor *self) { return self->notEmitedByCompilers; } diff --git a/tests/c/logic_checks/descriptor_logic_check.c b/tests/c/logic_checks/descriptor_logic_check.c index 5245486..4f84bf4 100644 --- a/tests/c/logic_checks/descriptor_logic_check.c +++ b/tests/c/logic_checks/descriptor_logic_check.c @@ -47,16 +47,30 @@ int main() { LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, descriptor->isDouble, descriptor->isFloat); // modifiesR* and readsR* + LOGIC_ERROR(uniqueId, errorCount, !(descriptor->modifiesRs && descriptor->readsRs)); LOGIC_ERROR(uniqueId, errorCount, !(descriptor->modifiesRt && descriptor->readsRt)); LOGIC_ERROR(uniqueId, errorCount, !(descriptor->modifiesRd && descriptor->readsRd)); - LOGIC_ERROR(uniqueId, errorCount, !(descriptor->readsRs && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rs))); + LOGIC_ERROR(uniqueId, errorCount, !((descriptor->modifiesRs || descriptor->readsRs) && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rs))); LOGIC_ERROR(uniqueId, errorCount, !((descriptor->modifiesRt || descriptor->readsRt) && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rt))); LOGIC_ERROR(uniqueId, errorCount, !((descriptor->modifiesRd || descriptor->readsRd) && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rd))); - LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rs), descriptor->readsRs); + LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rs), (descriptor->readsRs || descriptor->modifiesRs)); LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rt), (descriptor->readsRt || descriptor->modifiesRt)); LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rd), (descriptor->readsRd || descriptor->modifiesRd)); + // float modifiesR* and readsR* + LOGIC_ERROR(uniqueId, errorCount, !(descriptor->modifiesFs && descriptor->readsFs)); + LOGIC_ERROR(uniqueId, errorCount, !(descriptor->modifiesFt && descriptor->readsFt)); + LOGIC_ERROR(uniqueId, errorCount, !(descriptor->modifiesFd && descriptor->readsFd)); + LOGIC_ERROR(uniqueId, errorCount, !((descriptor->modifiesFs || descriptor->readsFs) && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_fs))); + LOGIC_ERROR(uniqueId, errorCount, !((descriptor->modifiesFt || descriptor->readsFt) && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_ft))); + LOGIC_ERROR(uniqueId, errorCount, !((descriptor->modifiesFd || descriptor->readsFd) && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_fd))); + + LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_fs), (descriptor->readsFs || descriptor->modifiesFs)); + LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_ft), (descriptor->readsFt || descriptor->modifiesFt)); + LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_fd), (descriptor->readsFd || descriptor->modifiesFd)); + + // An instruction should have at most canBeHi or canBeLo, not both LOGIC_ERROR(uniqueId, errorCount, !(descriptor->canBeHi && descriptor->canBeLo)); From 90eeda5f68da2a7f6e9fab0c62c96f1fe9532d02 Mon Sep 17 00:00:00 2001 From: angie Date: Tue, 20 Dec 2022 00:47:17 -0300 Subject: [PATCH 2/6] Change column limit to 120 --- .clang-format | 2 +- cplusplus/src/analysis/RegistersTracker.cpp | 3 +- .../src/instructions/InstructionBase.cpp | 15 +- src/analysis/RabbitizerRegistersTracker.c | 59 ++++--- src/analysis/RabbitizerTrackedRegisterState.c | 9 +- src/instructions/RabbitizerInstrDescriptor.c | 3 +- src/instructions/RabbitizerInstrSuffix.c | 9 +- .../RabbitizerInstruction.c | 6 +- .../RabbitizerInstruction_Disassemble.c | 31 ++-- .../RabbitizerInstruction_Examination.c | 21 ++- .../RabbitizerInstruction_Operand.c | 23 ++- .../RabbitizerInstruction_ProcessUniqueId.c | 3 +- .../RabbitizerInstructionCpu_OperandType.c | 74 ++++++--- .../RabbitizerInstructionR5900_OperandType.c | 151 ++++++++++++------ ...bbitizerInstructionR5900_ProcessUniqueId.c | 3 +- .../RabbitizerInstructionRsp_OperandType.c | 75 ++++++--- ...RabbitizerInstructionRsp_ProcessUniqueId.c | 3 +- src/instructions/RabbitizerRegister.c | 16 +- .../RabbitizerRegisterDescriptor.c | 1 - 19 files changed, 331 insertions(+), 176 deletions(-) diff --git a/.clang-format b/.clang-format index 414e3cf..91d6207 100644 --- a/.clang-format +++ b/.clang-format @@ -1,7 +1,7 @@ IndentWidth: 4 Language: Cpp UseTab: Never -ColumnLimit: 160 +ColumnLimit: 120 PointerAlignment: Right BreakBeforeBraces: Attach SpaceAfterCStyleCast: false diff --git a/cplusplus/src/analysis/RegistersTracker.cpp b/cplusplus/src/analysis/RegistersTracker.cpp index 5294d58..989eff1 100644 --- a/cplusplus/src/analysis/RegistersTracker.cpp +++ b/cplusplus/src/analysis/RegistersTracker.cpp @@ -31,7 +31,8 @@ void RegistersTracker::overwriteRegisters(const InstructionBase &instr, int inst 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 { +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 { diff --git a/cplusplus/src/instructions/InstructionBase.cpp b/cplusplus/src/instructions/InstructionBase.cpp index ba6e06d..691667c 100644 --- a/cplusplus/src/instructions/InstructionBase.cpp +++ b/cplusplus/src/instructions/InstructionBase.cpp @@ -697,7 +697,8 @@ int32_t InstructionBase::getGenericBranchOffset(uint32_t currentVram) const { #ifdef RAB_SANITY_CHECKS if (!hasOperandAlias(OperandType::cpu_branch_target_label) && !hasOperandAlias(OperandType::cpu_label)) { // TODO: make a rabbitizer exception class - throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have either 'branch_target_label' or 'label' operands."); + throw std::runtime_error("Instruction '" + getOpcodeName() + + "' does not have either 'branch_target_label' or 'label' operands."); } #endif @@ -707,7 +708,8 @@ int32_t InstructionBase::getBranchOffsetGeneric() const { #ifdef RAB_SANITY_CHECKS if (!hasOperandAlias(OperandType::cpu_branch_target_label) && !hasOperandAlias(OperandType::cpu_label)) { // TODO: make a rabbitizer exception class - throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have either 'branch_target_label' or 'label' operands."); + throw std::runtime_error("Instruction '" + getOpcodeName() + + "' does not have either 'branch_target_label' or 'label' operands."); } #endif @@ -717,7 +719,8 @@ int32_t InstructionBase::getBranchVramGeneric() const { #ifdef RAB_SANITY_CHECKS if (!hasOperandAlias(OperandType::cpu_branch_target_label) && !hasOperandAlias(OperandType::cpu_label)) { // TODO: make a rabbitizer exception class - throw std::runtime_error("Instruction '" + getOpcodeName() + "' does not have either 'branch_target_label' or 'label' operands."); + throw std::runtime_error("Instruction '" + getOpcodeName() + + "' does not have either 'branch_target_label' or 'label' operands."); } #endif @@ -1016,7 +1019,8 @@ std::string InstructionBase::disassembleInstruction(int extraLJust) const { throw std::runtime_error("buffer == NULL"); } - disassmbledSize = RabbitizerInstruction_disassembleInstruction(&instr, buffer, immOverridePtr, immOverrideLength, extraLJust); + disassmbledSize = + RabbitizerInstruction_disassembleInstruction(&instr, buffer, immOverridePtr, immOverrideLength, extraLJust); std::string output(buffer); free(buffer); @@ -1041,7 +1045,8 @@ std::string InstructionBase::disassembleInstruction(int extraLJust, std::string_ throw std::runtime_error("buffer == NULL"); } - disassmbledSize = RabbitizerInstruction_disassembleInstruction(&instr, buffer, immOverridePtr, immOverrideLength, extraLJust); + disassmbledSize = + RabbitizerInstruction_disassembleInstruction(&instr, buffer, immOverridePtr, immOverrideLength, extraLJust); std::string output(buffer); free(buffer); diff --git a/src/analysis/RabbitizerRegistersTracker.c b/src/analysis/RabbitizerRegistersTracker.c index d70f431..a0eca20 100644 --- a/src/analysis/RabbitizerRegistersTracker.c +++ b/src/analysis/RabbitizerRegistersTracker.c @@ -49,9 +49,11 @@ bool RabbitizerRegistersTracker_moveRegisters(RabbitizerRegistersTracker *self, } else if (rs == 0) { reg = rt; } else { - if (RabbitizerTrackedRegisterState_hasAnyValue(&self->registers[rs]) && !RabbitizerTrackedRegisterState_hasAnyValue(&self->registers[rt])) { + if (RabbitizerTrackedRegisterState_hasAnyValue(&self->registers[rs]) && + !RabbitizerTrackedRegisterState_hasAnyValue(&self->registers[rt])) { reg = rs; - } else if (RabbitizerTrackedRegisterState_hasAnyValue(&self->registers[rt]) && !RabbitizerTrackedRegisterState_hasAnyValue(&self->registers[rs])) { + } else if (RabbitizerTrackedRegisterState_hasAnyValue(&self->registers[rt]) && + !RabbitizerTrackedRegisterState_hasAnyValue(&self->registers[rs])) { reg = rt; } else if (rd == rs) { // Check stuff like `addu $3, $3, $2` reg = rt; @@ -86,7 +88,8 @@ bool RabbitizerRegistersTracker_moveRegisters(RabbitizerRegistersTracker *self, return false; } -void RabbitizerRegistersTracker_overwriteRegisters(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, int instrOffset) { +void RabbitizerRegistersTracker_overwriteRegisters(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, + int instrOffset) { bool shouldRemove = false; uint8_t reg = 0; RabbitizerTrackedRegisterState *state = NULL; @@ -141,7 +144,8 @@ void RabbitizerRegistersTracker_overwriteRegisters(RabbitizerRegistersTracker *s } } -void RabbitizerRegistersTracker_unsetRegistersAfterFuncCall(RabbitizerRegistersTracker *self, UNUSED const RabbitizerInstruction *instr, +void RabbitizerRegistersTracker_unsetRegistersAfterFuncCall(RabbitizerRegistersTracker *self, + UNUSED const RabbitizerInstruction *instr, const RabbitizerInstruction *prevInstr) { if (!RabbitizerInstrDescriptor_doesLink(prevInstr->descriptor)) { return; @@ -158,7 +162,8 @@ void RabbitizerRegistersTracker_unsetRegistersAfterFuncCall(RabbitizerRegistersT } } -bool RabbitizerRegistersTracker_getAddressIfCanSetType(const RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, int instrOffset, +bool RabbitizerRegistersTracker_getAddressIfCanSetType(const RabbitizerRegistersTracker *self, + const RabbitizerInstruction *instr, int instrOffset, uint32_t *dstAddress) { const RabbitizerTrackedRegisterState *state = &self->registers[RAB_INSTR_GET_rs(instr)]; @@ -174,7 +179,8 @@ bool RabbitizerRegistersTracker_getAddressIfCanSetType(const RabbitizerRegisters return false; } -bool RabbitizerRegistersTracker_getJrInfo(const RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, int *dstOffset, uint32_t *dstAddress) { +bool RabbitizerRegistersTracker_getJrInfo(const RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, + int *dstOffset, uint32_t *dstAddress) { const RabbitizerTrackedRegisterState *state = &self->registers[RAB_INSTR_GET_rs(instr)]; if (!state->hasLoValue || !state->dereferenced) { @@ -187,8 +193,8 @@ bool RabbitizerRegistersTracker_getJrInfo(const RabbitizerRegistersTracker *self } // prevInstr can be NULL -void RabbitizerRegistersTracker_processLui(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, int instrOffset, - const RabbitizerInstruction *prevInstr) { +void RabbitizerRegistersTracker_processLui(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, + int instrOffset, const RabbitizerInstruction *prevInstr) { RabbitizerTrackedRegisterState *state = NULL; assert(RabbitizerInstrDescriptor_canBeHi(instr->descriptor)); @@ -200,11 +206,13 @@ void RabbitizerRegistersTracker_processLui(RabbitizerRegistersTracker *self, con if (prevInstr != NULL) { // If the previous instructions is a branch likely, then nulify // the effects of this instruction for future analysis - state->luiSetOnBranchLikely = RabbitizerInstrDescriptor_isBranchLikely(prevInstr->descriptor) || RabbitizerInstruction_isUnconditionalBranch(prevInstr); + state->luiSetOnBranchLikely = RabbitizerInstrDescriptor_isBranchLikely(prevInstr->descriptor) || + RabbitizerInstruction_isUnconditionalBranch(prevInstr); } } -void RabbitizerRegistersTracker_processGpLoad(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, int instrOffset) { +void RabbitizerRegistersTracker_processGpLoad(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, + int instrOffset) { RabbitizerTrackedRegisterState *state = NULL; assert(RabbitizerInstrDescriptor_canBeLo(instr->descriptor)); @@ -215,7 +223,8 @@ void RabbitizerRegistersTracker_processGpLoad(RabbitizerRegistersTracker *self, RabbitizerTrackedRegisterState_setGpLoad(state, RabbitizerInstruction_getProcessedImmediate(instr), instrOffset); } -bool RabbitizerRegistersTracker_getLuiOffsetForConstant(const RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, int *dstOffset) { +bool RabbitizerRegistersTracker_getLuiOffsetForConstant(const RabbitizerRegistersTracker *self, + const RabbitizerInstruction *instr, int *dstOffset) { const RabbitizerTrackedRegisterState *state = &self->registers[RAB_INSTR_GET_rs(instr)]; if (!state->hasLuiValue) { @@ -226,15 +235,16 @@ bool RabbitizerRegistersTracker_getLuiOffsetForConstant(const RabbitizerRegister return true; } -void RabbitizerRegistersTracker_processConstant(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, uint32_t value, int offset) { +void RabbitizerRegistersTracker_processConstant(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, + uint32_t value, int offset) { RabbitizerTrackedRegisterState *stateDst = &self->registers[RAB_INSTR_GET_rt(instr)]; RabbitizerTrackedRegisterState_setLo(stateDst, value, offset); } // TODO: this function should not be changing the state of the tracker -bool RabbitizerRegistersTracker_getLuiOffsetForLo(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, int instrOffset, int *dstOffset, - bool *dstIsGp) { +bool RabbitizerRegistersTracker_getLuiOffsetForLo(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, + int instrOffset, int *dstOffset, bool *dstIsGp) { const RabbitizerTrackedRegisterState *state = &self->registers[RAB_INSTR_GET_rs(instr)]; const RabbitizerRegisterDescriptor *regDescriptor; @@ -251,17 +261,20 @@ bool RabbitizerRegistersTracker_getLuiOffsetForLo(RabbitizerRegistersTracker *se return true; } - if (RabbitizerInstrDescriptor_modifiesRt(instr->descriptor) && RabbitizerInstrDescriptor_doesDereference(instr->descriptor)) { + if (RabbitizerInstrDescriptor_modifiesRt(instr->descriptor) && + RabbitizerInstrDescriptor_doesDereference(instr->descriptor)) { if (state->hasLoValue && !state->dereferenced) { // Simulate a dereference - RabbitizerTrackedRegisterState_dereferenceState(&self->registers[RAB_INSTR_GET_rt(instr)], state, instrOffset); + RabbitizerTrackedRegisterState_dereferenceState(&self->registers[RAB_INSTR_GET_rt(instr)], state, + instrOffset); } } return false; } -RabbitizerLoPairingInfo RabbitizerRegistersTracker_preprocessLoAndGetInfo(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, +RabbitizerLoPairingInfo RabbitizerRegistersTracker_preprocessLoAndGetInfo(RabbitizerRegistersTracker *self, + const RabbitizerInstruction *instr, int instrOffset) { const RabbitizerTrackedRegisterState *state = &self->registers[RAB_INSTR_GET_rs(instr)]; RabbitizerLoPairingInfo pairingInfo; @@ -292,17 +305,20 @@ RabbitizerLoPairingInfo RabbitizerRegistersTracker_preprocessLoAndGetInfo(Rabbit return pairingInfo; } - if (RabbitizerInstrDescriptor_modifiesRt(instr->descriptor) && RabbitizerInstrDescriptor_doesDereference(instr->descriptor)) { + if (RabbitizerInstrDescriptor_modifiesRt(instr->descriptor) && + RabbitizerInstrDescriptor_doesDereference(instr->descriptor)) { if (state->hasLoValue && !state->dereferenced) { // Simulate a dereference - RabbitizerTrackedRegisterState_dereferenceState(&self->registers[RAB_INSTR_GET_rt(instr)], state, instrOffset); + RabbitizerTrackedRegisterState_dereferenceState(&self->registers[RAB_INSTR_GET_rt(instr)], state, + instrOffset); } } return pairingInfo; } -void RabbitizerRegistersTracker_processLo(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, uint32_t value, int offset) { +void RabbitizerRegistersTracker_processLo(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, + uint32_t value, int offset) { RabbitizerTrackedRegisterState *stateDst; if (!RabbitizerInstrDescriptor_modifiesRt(instr->descriptor)) { @@ -320,7 +336,8 @@ void RabbitizerRegistersTracker_processLo(RabbitizerRegistersTracker *self, cons } } -bool RabbitizerRegistersTracker_hasLoButNoHi(const RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr) { +bool RabbitizerRegistersTracker_hasLoButNoHi(const RabbitizerRegistersTracker *self, + const RabbitizerInstruction *instr) { const RabbitizerTrackedRegisterState *state; assert(instr != NULL); diff --git a/src/analysis/RabbitizerTrackedRegisterState.c b/src/analysis/RabbitizerTrackedRegisterState.c index 9129894..de4f575 100644 --- a/src/analysis/RabbitizerTrackedRegisterState.c +++ b/src/analysis/RabbitizerTrackedRegisterState.c @@ -62,7 +62,8 @@ void RabbitizerTrackedRegisterState_clearLo(RabbitizerTrackedRegisterState *self self->dereferenceOffset = 0; } -void RabbitizerTrackedRegisterState_copyState(RabbitizerTrackedRegisterState *self, const RabbitizerTrackedRegisterState *other) { +void RabbitizerTrackedRegisterState_copyState(RabbitizerTrackedRegisterState *self, + const RabbitizerTrackedRegisterState *other) { self->hasLuiValue = other->hasLuiValue; self->luiOffset = other->luiOffset; self->luiSetOnBranchLikely = other->luiSetOnBranchLikely; @@ -107,7 +108,8 @@ void RabbitizerTrackedRegisterState_deref(RabbitizerTrackedRegisterState *self, self->dereferenceOffset = offset; } -void RabbitizerTrackedRegisterState_dereferenceState(RabbitizerTrackedRegisterState *self, const RabbitizerTrackedRegisterState *other, int offset) { +void RabbitizerTrackedRegisterState_dereferenceState(RabbitizerTrackedRegisterState *self, + const RabbitizerTrackedRegisterState *other, int offset) { assert(other->hasLoValue); assert(!other->dereferenced); @@ -124,7 +126,8 @@ bool RabbitizerTrackedRegisterState_wasSetInCurrentOffset(const RabbitizerTracke } void RabbitizerTrackedRegisterState_fprint(const RabbitizerTrackedRegisterState *self, FILE *outFile) { - fprintf(outFile, "TrackedRegisterState(%i / %s)\n", self->registerNum, RabbitizerRegister_getNameGpr(self->registerNum)); + fprintf(outFile, "TrackedRegisterState(%i / %s)\n", self->registerNum, + RabbitizerRegister_getNameGpr(self->registerNum)); fprintf(outFile, " hasLuiValue: %s\n", self->hasLuiValue ? "true" : "false"); fprintf(outFile, " luiOffset: 0x%X\n", self->luiOffset); diff --git a/src/instructions/RabbitizerInstrDescriptor.c b/src/instructions/RabbitizerInstrDescriptor.c index 5c9b957..04b63bf 100644 --- a/src/instructions/RabbitizerInstrDescriptor.c +++ b/src/instructions/RabbitizerInstrDescriptor.c @@ -9,7 +9,8 @@ #include "InstrDescriptor_Descriptors_array.table.h" -bool RabbitizerInstrDescriptor_hasSpecificOperand(const RabbitizerInstrDescriptor *self, RabbitizerOperandType operand) { +bool RabbitizerInstrDescriptor_hasSpecificOperand(const RabbitizerInstrDescriptor *self, + RabbitizerOperandType operand) { size_t i; for (i = 0; i < ARRAY_COUNT(self->operands) && self->operands[i] != RAB_OPERAND_ALL_INVALID; i++) { diff --git a/src/instructions/RabbitizerInstrSuffix.c b/src/instructions/RabbitizerInstrSuffix.c index e067b3f..3f0946d 100644 --- a/src/instructions/RabbitizerInstrSuffix.c +++ b/src/instructions/RabbitizerInstrSuffix.c @@ -19,7 +19,8 @@ size_t RabbitizerInstrSuffix_None(UNUSED const RabbitizerInstruction *self, UNUS size_t RabbitizerInstrSuffixR5900_xyzw(const RabbitizerInstruction *self, char *dst) { size_t totalSize = 0; - if (RAB_INSTR_R5900_GET_xyzw_x(self) || RAB_INSTR_R5900_GET_xyzw_y(self) || RAB_INSTR_R5900_GET_xyzw_z(self) || RAB_INSTR_R5900_GET_xyzw_w(self)) { + if (RAB_INSTR_R5900_GET_xyzw_x(self) || RAB_INSTR_R5900_GET_xyzw_y(self) || RAB_INSTR_R5900_GET_xyzw_z(self) || + RAB_INSTR_R5900_GET_xyzw_w(self)) { RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '.'); } @@ -44,12 +45,14 @@ const InstrSuffixCallback instrSuffixCallbacks[] = { [RABINSTRSUFFIX_R5900_xyzw] = RabbitizerInstrSuffixR5900_xyzw, }; -size_t RabbitizerInstrSuffix_getSizeForBuffer(UNUSED const RabbitizerInstruction *self, UNUSED RabbitizerInstrSuffix instrSuffix) { +size_t RabbitizerInstrSuffix_getSizeForBuffer(UNUSED const RabbitizerInstruction *self, + UNUSED RabbitizerInstrSuffix instrSuffix) { // Just hardcode the size of the bigger possible suffix, faster than actually computing it. return 5; } -size_t RabbitizerInstrSuffix_processSuffix(const RabbitizerInstruction *self, char *dst, RabbitizerInstrSuffix instrSuffix) { +size_t RabbitizerInstrSuffix_processSuffix(const RabbitizerInstruction *self, char *dst, + RabbitizerInstrSuffix instrSuffix) { InstrSuffixCallback callback; assert(instrSuffix >= RABINSTRSUFFIX_ALL_NONE); diff --git a/src/instructions/RabbitizerInstruction/RabbitizerInstruction.c b/src/instructions/RabbitizerInstruction/RabbitizerInstruction.c index c6f1aee..a595265 100644 --- a/src/instructions/RabbitizerInstruction/RabbitizerInstruction.c +++ b/src/instructions/RabbitizerInstruction/RabbitizerInstruction.c @@ -105,7 +105,8 @@ bool RabbitizerInstruction_outputsToGprZero(const RabbitizerInstruction *self) { void RabbitizerInstruction_blankOut(RabbitizerInstruction *self) { size_t i; - for (i = 0; i < ARRAY_COUNT(self->descriptor->operands) && self->descriptor->operands[i] != RAB_OPERAND_ALL_INVALID; i++) { + for (i = 0; i < ARRAY_COUNT(self->descriptor->operands) && self->descriptor->operands[i] != RAB_OPERAND_ALL_INVALID; + i++) { switch (self->descriptor->operands[i]) { case RAB_OPERAND_cpu_rs: self->word = RAB_INSTR_PACK_rs(self->word, 0); @@ -400,7 +401,8 @@ void RabbitizerInstruction_blankOut(RabbitizerInstruction *self) { case RAB_OPERAND_ALL_INVALID: case RAB_OPERAND_ALL_MAX: - assert(self->descriptor->operands[i] != RAB_OPERAND_ALL_INVALID && self->descriptor->operands[i] != RAB_OPERAND_ALL_MAX); + assert(self->descriptor->operands[i] != RAB_OPERAND_ALL_INVALID && + self->descriptor->operands[i] != RAB_OPERAND_ALL_MAX); break; } } diff --git a/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Disassemble.c b/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Disassemble.c index 8424436..fb21cfb 100644 --- a/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Disassemble.c +++ b/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Disassemble.c @@ -9,7 +9,8 @@ #include "common/RabbitizerConfig.h" -size_t RabbitizerInstruction_getSizeForBufferInstrDisasm(const RabbitizerInstruction *self, size_t immOverrideLength, int extraLJust) { +size_t RabbitizerInstruction_getSizeForBufferInstrDisasm(const RabbitizerInstruction *self, size_t immOverrideLength, + int extraLJust) { size_t totalSize = 0; size_t opcodeNameLength; @@ -37,14 +38,15 @@ size_t RabbitizerInstruction_getSizeForBufferInstrDisasm(const RabbitizerInstruc return totalSize; } -size_t RabbitizerInstruction_disassembleInstruction(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength, - int extraLJust) { +size_t RabbitizerInstruction_disassembleInstruction(const RabbitizerInstruction *self, char *dst, + const char *immOverride, size_t immOverrideLength, int extraLJust) { size_t totalSize = 0; const char *opcodeName = RabbitizerInstrId_getOpcodeName(self->uniqueId); RABUTILS_BUFFER_CPY(dst, totalSize, opcodeName); - RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerInstrSuffix_processSuffix(self, dst, self->descriptor->instrSuffix)); + RABUTILS_BUFFER_ADVANCE(dst, totalSize, + RabbitizerInstrSuffix_processSuffix(self, dst, self->descriptor->instrSuffix)); if (self->descriptor->operands[0] == RAB_OPERAND_ALL_INVALID) { // There are no operands @@ -52,10 +54,13 @@ size_t RabbitizerInstruction_disassembleInstruction(const RabbitizerInstruction return totalSize; } - RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerUtils_CharFill(dst, RabbitizerConfig_Cfg.misc.opcodeLJust + extraLJust - totalSize, ' ')); + RABUTILS_BUFFER_ADVANCE( + dst, totalSize, + RabbitizerUtils_CharFill(dst, RabbitizerConfig_Cfg.misc.opcodeLJust + extraLJust - totalSize, ' ')); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ' '); - RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerInstruction_disassembleOperands(self, dst, immOverride, immOverrideLength)); + RABUTILS_BUFFER_ADVANCE(dst, totalSize, + RabbitizerInstruction_disassembleOperands(self, dst, immOverride, immOverrideLength)); *dst = '\0'; return totalSize; @@ -75,7 +80,9 @@ size_t RabbitizerInstruction_disassembleAsData(const RabbitizerInstruction *self RABUTILS_BUFFER_CPY(dst, totalSize, ".word"); - RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerUtils_CharFill(dst, RabbitizerConfig_Cfg.misc.opcodeLJust + extraLJust - totalSize, ' ')); + RABUTILS_BUFFER_ADVANCE( + dst, totalSize, + RabbitizerUtils_CharFill(dst, RabbitizerConfig_Cfg.misc.opcodeLJust + extraLJust - totalSize, ' ')); RABUTILS_BUFFER_SPRINTF(dst, totalSize, " 0x%08X", RabbitizerInstruction_getRaw(self)); return totalSize; @@ -94,7 +101,8 @@ bool RabbitizerInstruction_mustDisasmAsData(const RabbitizerInstruction *self) { return false; } -size_t RabbitizerInstruction_getSizeForBuffer(const RabbitizerInstruction *self, size_t immOverrideLength, int extraLJust) { +size_t RabbitizerInstruction_getSizeForBuffer(const RabbitizerInstruction *self, size_t immOverrideLength, + int extraLJust) { if (!RabbitizerInstruction_isImplemented(self) || RabbitizerInstruction_mustDisasmAsData(self)) { size_t totalSize = RabbitizerInstruction_getSizeForBufferDataDisasm(self, extraLJust); @@ -110,7 +118,8 @@ size_t RabbitizerInstruction_getSizeForBuffer(const RabbitizerInstruction *self, return RabbitizerInstruction_getSizeForBufferInstrDisasm(self, immOverrideLength, extraLJust); } -size_t RabbitizerInstruction_disassemble(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength, int extraLJust) { +size_t RabbitizerInstruction_disassemble(const RabbitizerInstruction *self, char *dst, const char *immOverride, + size_t immOverrideLength, int extraLJust) { assert(dst != NULL); if (!RabbitizerInstruction_isImplemented(self) || RabbitizerInstruction_mustDisasmAsData(self)) { @@ -127,7 +136,9 @@ size_t RabbitizerInstruction_disassemble(const RabbitizerInstruction *self, char RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '#'); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ' '); - RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerInstruction_disassembleInstruction(self, dst, immOverride, immOverrideLength, extraLJust)); + RABUTILS_BUFFER_ADVANCE( + dst, totalSize, + RabbitizerInstruction_disassembleInstruction(self, dst, immOverride, immOverrideLength, extraLJust)); validBits = RabbitizerInstruction_getValidBits(self); diff --git a/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Examination.c b/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Examination.c index fcd64d7..53b38d4 100644 --- a/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Examination.c +++ b/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Examination.c @@ -21,10 +21,12 @@ bool RabbitizerInstruction_isLikelyHandwritten(const RabbitizerInstruction *self } if (RabbitizerInstrDescriptor_isIType(self->descriptor) && !RabbitizerInstrDescriptor_isFloat(self->descriptor)) { - if (RAB_INSTR_GET_rs(self) == RABBITIZER_REG_GPR_O32_k0 || RAB_INSTR_GET_rs(self) == RABBITIZER_REG_GPR_O32_k1) { + if (RAB_INSTR_GET_rs(self) == RABBITIZER_REG_GPR_O32_k0 || + RAB_INSTR_GET_rs(self) == RABBITIZER_REG_GPR_O32_k1) { return true; } - if (RAB_INSTR_GET_rt(self) == RABBITIZER_REG_GPR_O32_k0 || RAB_INSTR_GET_rt(self) == RABBITIZER_REG_GPR_O32_k1) { + if (RAB_INSTR_GET_rt(self) == RABBITIZER_REG_GPR_O32_k0 || + RAB_INSTR_GET_rt(self) == RABBITIZER_REG_GPR_O32_k1) { return true; } } @@ -64,7 +66,8 @@ bool RabbitizerInstruction_isReturn(const RabbitizerInstruction *self) { switch (self->uniqueId) { case RABBITIZER_INSTR_ID_cpu_jr: case RABBITIZER_INSTR_ID_rsp_jr: { - const RabbitizerRegisterDescriptor *regDescriptor = RabbitizerRegister_getDescriptor_Gpr(RAB_INSTR_GET_rs(self)); + const RabbitizerRegisterDescriptor *regDescriptor = + RabbitizerRegister_getDescriptor_Gpr(RAB_INSTR_GET_rs(self)); return RabbitizerRegisterDescriptor_isRa(regDescriptor); } @@ -78,7 +81,8 @@ bool RabbitizerInstruction_isJumptableJump(const RabbitizerInstruction *self) { switch (self->uniqueId) { case RABBITIZER_INSTR_ID_cpu_jr: case RABBITIZER_INSTR_ID_rsp_jr: { - const RabbitizerRegisterDescriptor *regDescriptor = RabbitizerRegister_getDescriptor_Gpr(RAB_INSTR_GET_rs(self)); + const RabbitizerRegisterDescriptor *regDescriptor = + RabbitizerRegister_getDescriptor_Gpr(RAB_INSTR_GET_rs(self)); return !RabbitizerRegisterDescriptor_isRa(regDescriptor); } @@ -127,7 +131,8 @@ bool RabbitizerInstruction_sameOpcode(const RabbitizerInstruction *self, const R return self->uniqueId == other->uniqueId; } -bool RabbitizerInstruction_sameOpcodeButDifferentArguments(const RabbitizerInstruction *self, const RabbitizerInstruction *other) { +bool RabbitizerInstruction_sameOpcodeButDifferentArguments(const RabbitizerInstruction *self, + const RabbitizerInstruction *other) { if (!RabbitizerInstruction_sameOpcode(self, other)) { return false; } @@ -149,7 +154,8 @@ uint32_t RabbitizerInstruction_getValidBits(const RabbitizerInstruction *self) { validbits = self->_mandatorybits; - for (i = 0; i < ARRAY_COUNT(self->descriptor->operands) && self->descriptor->operands[i] != RAB_OPERAND_ALL_INVALID; i++) { + for (i = 0; i < ARRAY_COUNT(self->descriptor->operands) && self->descriptor->operands[i] != RAB_OPERAND_ALL_INVALID; + i++) { switch (self->descriptor->operands[i]) { case RAB_OPERAND_cpu_rs: @@ -445,7 +451,8 @@ uint32_t RabbitizerInstruction_getValidBits(const RabbitizerInstruction *self) { case RAB_OPERAND_ALL_INVALID: case RAB_OPERAND_ALL_MAX: - assert(self->descriptor->operands[i] != RAB_OPERAND_ALL_INVALID && self->descriptor->operands[i] != RAB_OPERAND_ALL_MAX); + assert(self->descriptor->operands[i] != RAB_OPERAND_ALL_INVALID && + self->descriptor->operands[i] != RAB_OPERAND_ALL_MAX); break; } } diff --git a/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Operand.c b/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Operand.c index 93d7685..3c64495 100644 --- a/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Operand.c +++ b/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Operand.c @@ -7,7 +7,8 @@ #include "instrOpercandCallbacks_array.table.h" -size_t RabbitizerOperandType_getBufferSize(RabbitizerOperandType operand, const RabbitizerInstruction *instr, size_t immOverrideLength) { +size_t RabbitizerOperandType_getBufferSize(RabbitizerOperandType operand, const RabbitizerInstruction *instr, + size_t immOverrideLength) { char auxBuffer[0x100] = { 0 }; char immOverride[0x100] = { 0 }; OperandCallback callback; @@ -21,10 +22,12 @@ size_t RabbitizerOperandType_getBufferSize(RabbitizerOperandType operand, const return callback(instr, auxBuffer, immOverride, immOverrideLength); } -size_t RabbitizerInstruction_getSizeForBufferOperandsDisasm(const RabbitizerInstruction *self, size_t immOverrideLength) { +size_t RabbitizerInstruction_getSizeForBufferOperandsDisasm(const RabbitizerInstruction *self, + size_t immOverrideLength) { size_t totalSize = 0; - for (size_t i = 0; i < ARRAY_COUNT(self->descriptor->operands) && self->descriptor->operands[i] != RAB_OPERAND_ALL_INVALID; i++) { + for (size_t i = 0; + i < ARRAY_COUNT(self->descriptor->operands) && self->descriptor->operands[i] != RAB_OPERAND_ALL_INVALID; i++) { if (i != 0) { totalSize += 2; } @@ -35,8 +38,8 @@ size_t RabbitizerInstruction_getSizeForBufferOperandsDisasm(const RabbitizerInst return totalSize; } -size_t RabbitizerOperandType_disassemble(RabbitizerOperandType operand, const RabbitizerInstruction *instr, char *dst, const char *immOverride, - size_t immOverrideLength) { +size_t RabbitizerOperandType_disassemble(RabbitizerOperandType operand, const RabbitizerInstruction *instr, char *dst, + const char *immOverride, size_t immOverrideLength) { OperandCallback callback; assert(operand > RAB_OPERAND_ALL_INVALID); @@ -47,16 +50,20 @@ size_t RabbitizerOperandType_disassemble(RabbitizerOperandType operand, const Ra return callback(instr, dst, immOverride, immOverrideLength); } -size_t RabbitizerInstruction_disassembleOperands(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +size_t RabbitizerInstruction_disassembleOperands(const RabbitizerInstruction *self, char *dst, const char *immOverride, + size_t immOverrideLength) { size_t totalSize = 0; - for (size_t i = 0; i < ARRAY_COUNT(self->descriptor->operands) && self->descriptor->operands[i] != RAB_OPERAND_ALL_INVALID; i++) { + for (size_t i = 0; + i < ARRAY_COUNT(self->descriptor->operands) && self->descriptor->operands[i] != RAB_OPERAND_ALL_INVALID; i++) { if (i != 0) { RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ','); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ' '); } - RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_disassemble(self->descriptor->operands[i], self, dst, immOverride, immOverrideLength)); + RABUTILS_BUFFER_ADVANCE(dst, totalSize, + RabbitizerOperandType_disassemble(self->descriptor->operands[i], self, dst, immOverride, + immOverrideLength)); } *dst = '\0'; diff --git a/src/instructions/RabbitizerInstruction/RabbitizerInstruction_ProcessUniqueId.c b/src/instructions/RabbitizerInstruction/RabbitizerInstruction_ProcessUniqueId.c index b269a10..85a2fe1 100644 --- a/src/instructions/RabbitizerInstruction/RabbitizerInstruction_ProcessUniqueId.c +++ b/src/instructions/RabbitizerInstruction/RabbitizerInstruction_ProcessUniqueId.c @@ -10,7 +10,8 @@ case (caseBits): \ self->uniqueId = RABBITIZER_INSTR_ID_##prefix##_##name; \ break; -#define RABBITIZER_DEF_INSTR_ID_ALTNAME(prefix, caseBits, name, altname, ...) RABBITIZER_DEF_INSTR_ID(prefix, caseBits, name, __VA_ARGS__) +#define RABBITIZER_DEF_INSTR_ID_ALTNAME(prefix, caseBits, name, altname, ...) \ + RABBITIZER_DEF_INSTR_ID(prefix, caseBits, name, __VA_ARGS__) void RabbitizerInstruction_processUniqueId_Normal(RabbitizerInstruction *self) { uint32_t opcode = RAB_INSTR_GET_opcode(self); diff --git a/src/instructions/RabbitizerInstructionCpu/RabbitizerInstructionCpu_OperandType.c b/src/instructions/RabbitizerInstructionCpu/RabbitizerInstructionCpu_OperandType.c index 64e38f4..5f08f81 100644 --- a/src/instructions/RabbitizerInstructionCpu/RabbitizerInstructionCpu_OperandType.c +++ b/src/instructions/RabbitizerInstructionCpu/RabbitizerInstructionCpu_OperandType.c @@ -11,7 +11,8 @@ #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 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)); @@ -19,7 +20,8 @@ size_t RabbitizerOperandType_process_cpu_rs(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_cpu_rt(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -27,7 +29,8 @@ size_t RabbitizerOperandType_process_cpu_rt(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_cpu_rd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -35,8 +38,8 @@ size_t RabbitizerOperandType_process_cpu_rd(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_cpu_zero(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, - UNUSED size_t immOverrideLength) { +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); @@ -44,7 +47,8 @@ size_t RabbitizerOperandType_process_cpu_zero(UNUSED const RabbitizerInstruction return totalSize; } -size_t RabbitizerOperandType_process_cpu_cop0d(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -52,7 +56,8 @@ size_t RabbitizerOperandType_process_cpu_cop0d(const RabbitizerInstruction *self return totalSize; } -size_t RabbitizerOperandType_process_cpu_fs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -60,7 +65,8 @@ size_t RabbitizerOperandType_process_cpu_fs(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_cpu_ft(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -68,7 +74,8 @@ size_t RabbitizerOperandType_process_cpu_ft(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_cpu_fd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -76,7 +83,8 @@ size_t RabbitizerOperandType_process_cpu_fd(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_cpu_cop1cs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -84,7 +92,8 @@ size_t RabbitizerOperandType_process_cpu_cop1cs(const RabbitizerInstruction *sel return totalSize; } -size_t RabbitizerOperandType_process_cpu_cop2t(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -92,7 +101,8 @@ size_t RabbitizerOperandType_process_cpu_cop2t(const RabbitizerInstruction *self return totalSize; } -size_t RabbitizerOperandType_process_cpu_sa(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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 @@ -107,7 +117,8 @@ size_t RabbitizerOperandType_process_cpu_sa(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_cpu_op(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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 @@ -122,7 +133,8 @@ size_t RabbitizerOperandType_process_cpu_op(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_cpu_code(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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); @@ -135,8 +147,8 @@ size_t RabbitizerOperandType_process_cpu_code(const RabbitizerInstruction *self, return totalSize; } -size_t RabbitizerOperandType_process_cpu_code_lower(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, - UNUSED size_t immOverrideLength) { +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); @@ -145,7 +157,8 @@ size_t RabbitizerOperandType_process_cpu_code_lower(const RabbitizerInstruction return totalSize; } -size_t RabbitizerOperandType_process_cpu_copraw(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -153,7 +166,8 @@ size_t RabbitizerOperandType_process_cpu_copraw(const RabbitizerInstruction *sel return totalSize; } -size_t RabbitizerOperandType_process_cpu_label(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)) { @@ -165,7 +179,8 @@ size_t RabbitizerOperandType_process_cpu_label(const RabbitizerInstruction *self return totalSize; } -size_t RabbitizerOperandType_process_cpu_immediate(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +size_t RabbitizerOperandType_process_cpu_immediate(const RabbitizerInstruction *self, char *dst, + const char *immOverride, size_t immOverrideLength) { size_t totalSize = 0; int32_t number; @@ -197,7 +212,8 @@ size_t RabbitizerOperandType_process_cpu_immediate(const RabbitizerInstruction * return totalSize; } -size_t RabbitizerOperandType_process_cpu_branch_target_label(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)) { @@ -211,7 +227,8 @@ size_t RabbitizerOperandType_process_cpu_branch_target_label(const RabbitizerIns return totalSize; } -size_t RabbitizerOperandType_process_cpu_immediate_base(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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 @@ -220,28 +237,33 @@ size_t RabbitizerOperandType_process_cpu_immediate_base(const RabbitizerInstruct 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_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_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_cpu_rs(self, dst, immOverride, immOverrideLength)); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')'); return totalSize; } -size_t RabbitizerOperandType_process_cpu_maybe_rd_rs(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +size_t RabbitizerOperandType_process_cpu_maybe_rd_rs(const RabbitizerInstruction *self, char *dst, + const char *immOverride, size_t immOverrideLength) { size_t totalSize = 0; uint8_t rd = RAB_INSTR_GET_rd(self); const RabbitizerRegisterDescriptor *regDescriptor = RabbitizerRegister_getDescriptor_Gpr(rd); if (!RabbitizerRegisterDescriptor_isRa(regDescriptor)) { - RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_rd(self, dst, immOverride, immOverrideLength)); + RABUTILS_BUFFER_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_cpu_rd(self, dst, immOverride, immOverrideLength)); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ','); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ' '); } - RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_cpu_rs(self, dst, immOverride, immOverrideLength)); + RABUTILS_BUFFER_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_cpu_rs(self, dst, immOverride, immOverrideLength)); return totalSize; } diff --git a/src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_OperandType.c b/src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_OperandType.c index 6ebbacf..d420e1c 100644 --- a/src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_OperandType.c +++ b/src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_OperandType.c @@ -11,8 +11,8 @@ #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 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"); @@ -20,8 +20,8 @@ size_t RabbitizerOperandType_process_r5900_I(UNUSED const RabbitizerInstruction return totalSize; } -size_t RabbitizerOperandType_process_r5900_Q(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, - UNUSED size_t immOverrideLength) { +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"); @@ -29,8 +29,8 @@ size_t RabbitizerOperandType_process_r5900_Q(UNUSED const RabbitizerInstruction return totalSize; } -size_t RabbitizerOperandType_process_r5900_R(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, - UNUSED size_t immOverrideLength) { +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"); @@ -38,8 +38,8 @@ size_t RabbitizerOperandType_process_r5900_R(UNUSED const RabbitizerInstruction return totalSize; } -size_t RabbitizerOperandType_process_r5900_ACC(UNUSED const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, - UNUSED size_t immOverrideLength) { +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"); @@ -47,10 +47,12 @@ size_t RabbitizerOperandType_process_r5900_ACC(UNUSED const RabbitizerInstructio return totalSize; } -size_t RabbitizerOperandType_process_r5900_ACCxyzw(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + RABUTILS_BUFFER_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_r5900_ACC(self, dst, immOverride, immOverrideLength)); #if 0 if (RAB_INSTR_R5900_GET_xyzw_x(self)) { @@ -70,7 +72,8 @@ size_t RabbitizerOperandType_process_r5900_ACCxyzw(const RabbitizerInstruction * return totalSize; } -size_t RabbitizerOperandType_process_r5900_vfs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -78,7 +81,8 @@ size_t RabbitizerOperandType_process_r5900_vfs(const RabbitizerInstruction *self return totalSize; } -size_t RabbitizerOperandType_process_r5900_vft(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -86,7 +90,8 @@ size_t RabbitizerOperandType_process_r5900_vft(const RabbitizerInstruction *self return totalSize; } -size_t RabbitizerOperandType_process_r5900_vfd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -94,10 +99,12 @@ size_t RabbitizerOperandType_process_r5900_vfd(const RabbitizerInstruction *self return totalSize; } -size_t RabbitizerOperandType_process_r5900_vfsxyzw(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + RABUTILS_BUFFER_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_r5900_vfs(self, dst, immOverride, immOverrideLength)); #if 0 if (RAB_INSTR_R5900_GET_xyzw_x(self)) { @@ -117,10 +124,12 @@ size_t RabbitizerOperandType_process_r5900_vfsxyzw(const RabbitizerInstruction * return totalSize; } -size_t RabbitizerOperandType_process_r5900_vftxyzw(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + RABUTILS_BUFFER_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_r5900_vft(self, dst, immOverride, immOverrideLength)); #if 0 if (RAB_INSTR_R5900_GET_xyzw_x(self)) { @@ -140,10 +149,12 @@ size_t RabbitizerOperandType_process_r5900_vftxyzw(const RabbitizerInstruction * return totalSize; } -size_t RabbitizerOperandType_process_r5900_vfdxyzw(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + RABUTILS_BUFFER_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_r5900_vfd(self, dst, immOverride, immOverrideLength)); #if 0 if (RAB_INSTR_R5900_GET_xyzw_x(self)) { @@ -163,11 +174,13 @@ size_t RabbitizerOperandType_process_r5900_vfdxyzw(const RabbitizerInstruction * return totalSize; } -size_t RabbitizerOperandType_process_r5900_vfsn(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + 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]); @@ -175,11 +188,13 @@ size_t RabbitizerOperandType_process_r5900_vfsn(const RabbitizerInstruction *sel return totalSize; } -size_t RabbitizerOperandType_process_r5900_vftn(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + 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]); @@ -187,11 +202,13 @@ size_t RabbitizerOperandType_process_r5900_vftn(const RabbitizerInstruction *sel return totalSize; } -size_t RabbitizerOperandType_process_r5900_vfdn(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + 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]); @@ -199,11 +216,13 @@ size_t RabbitizerOperandType_process_r5900_vfdn(const RabbitizerInstruction *sel return totalSize; } -size_t RabbitizerOperandType_process_r5900_vfsl(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + 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]); @@ -211,11 +230,13 @@ size_t RabbitizerOperandType_process_r5900_vfsl(const RabbitizerInstruction *sel return totalSize; } -size_t RabbitizerOperandType_process_r5900_vftl(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + 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]); @@ -223,11 +244,13 @@ size_t RabbitizerOperandType_process_r5900_vftl(const RabbitizerInstruction *sel return totalSize; } -size_t RabbitizerOperandType_process_r5900_vfdl(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + 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]); @@ -235,11 +258,13 @@ size_t RabbitizerOperandType_process_r5900_vfdl(const RabbitizerInstruction *sel return totalSize; } -size_t RabbitizerOperandType_process_r5900_vfsm(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + 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]); @@ -247,11 +272,13 @@ size_t RabbitizerOperandType_process_r5900_vfsm(const RabbitizerInstruction *sel return totalSize; } -size_t RabbitizerOperandType_process_r5900_vftm(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + 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]); @@ -259,11 +286,13 @@ size_t RabbitizerOperandType_process_r5900_vftm(const RabbitizerInstruction *sel return totalSize; } -size_t RabbitizerOperandType_process_r5900_vfdm(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + 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]); @@ -271,7 +300,8 @@ size_t RabbitizerOperandType_process_r5900_vfdm(const RabbitizerInstruction *sel return totalSize; } -size_t RabbitizerOperandType_process_r5900_vis(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -279,7 +309,8 @@ size_t RabbitizerOperandType_process_r5900_vis(const RabbitizerInstruction *self return totalSize; } -size_t RabbitizerOperandType_process_r5900_vit(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -287,7 +318,8 @@ size_t RabbitizerOperandType_process_r5900_vit(const RabbitizerInstruction *self return totalSize; } -size_t RabbitizerOperandType_process_r5900_vid(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -295,54 +327,62 @@ size_t RabbitizerOperandType_process_r5900_vid(const RabbitizerInstruction *self return totalSize; } -size_t RabbitizerOperandType_process_r5900_vis_predecr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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_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 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_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 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_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 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_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_r5900_vis(self, dst, immOverride, immOverrideLength)); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+'); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+'); @@ -351,12 +391,14 @@ size_t RabbitizerOperandType_process_r5900_vis_postincr(const RabbitizerInstruct return totalSize; } -size_t RabbitizerOperandType_process_r5900_vit_postincr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_r5900_vit(self, dst, immOverride, immOverrideLength)); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+'); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+'); @@ -365,12 +407,14 @@ size_t RabbitizerOperandType_process_r5900_vit_postincr(const RabbitizerInstruct return totalSize; } -size_t RabbitizerOperandType_process_r5900_vid_postincr(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_r5900_vid(self, dst, immOverride, immOverrideLength)); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+'); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, '+'); @@ -379,7 +423,8 @@ size_t RabbitizerOperandType_process_r5900_vid_postincr(const RabbitizerInstruct return totalSize; } -size_t RabbitizerOperandType_process_r5900_immediate5(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +size_t RabbitizerOperandType_process_r5900_immediate5(const RabbitizerInstruction *self, char *dst, + const char *immOverride, size_t immOverrideLength) { size_t totalSize = 0; int32_t number; diff --git a/src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_ProcessUniqueId.c b/src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_ProcessUniqueId.c index 1972f3f..4f91780 100644 --- a/src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_ProcessUniqueId.c +++ b/src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_ProcessUniqueId.c @@ -7,7 +7,8 @@ case (caseBits): \ self->uniqueId = RABBITIZER_INSTR_ID_##prefix##_##name; \ break; -#define RABBITIZER_DEF_INSTR_ID_ALTNAME(prefix, caseBits, name, altname, ...) RABBITIZER_DEF_INSTR_ID(prefix, caseBits, name, __VA_ARGS__) +#define RABBITIZER_DEF_INSTR_ID_ALTNAME(prefix, caseBits, name, altname, ...) \ + RABBITIZER_DEF_INSTR_ID(prefix, caseBits, name, __VA_ARGS__) void RabbitizerInstructionR5900_processUniqueId_Normal(RabbitizerInstruction *self) { uint32_t opcode = RAB_INSTR_GET_opcode(self); diff --git a/src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_OperandType.c b/src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_OperandType.c index df1f840..92ad44c 100644 --- a/src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_OperandType.c +++ b/src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_OperandType.c @@ -11,7 +11,8 @@ #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 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)); @@ -19,7 +20,8 @@ size_t RabbitizerOperandType_process_rsp_rs(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_rsp_rt(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -27,7 +29,8 @@ size_t RabbitizerOperandType_process_rsp_rt(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_rsp_rd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -35,7 +38,8 @@ size_t RabbitizerOperandType_process_rsp_rd(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_rsp_cop0d(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -43,7 +47,8 @@ size_t RabbitizerOperandType_process_rsp_cop0d(const RabbitizerInstruction *self return totalSize; } -size_t RabbitizerOperandType_process_rsp_cop2t(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -51,7 +56,8 @@ size_t RabbitizerOperandType_process_rsp_cop2t(const RabbitizerInstruction *self return totalSize; } -size_t RabbitizerOperandType_process_rsp_cop2cd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -59,7 +65,8 @@ size_t RabbitizerOperandType_process_rsp_cop2cd(const RabbitizerInstruction *sel return totalSize; } -size_t RabbitizerOperandType_process_rsp_vs(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -67,7 +74,8 @@ size_t RabbitizerOperandType_process_rsp_vs(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_rsp_vt(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -75,7 +83,8 @@ size_t RabbitizerOperandType_process_rsp_vt(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_rsp_vd(const RabbitizerInstruction *self, char *dst, UNUSED const char *immOverride, UNUSED size_t immOverrideLength) { +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)); @@ -83,11 +92,13 @@ size_t RabbitizerOperandType_process_rsp_vd(const RabbitizerInstruction *self, c return totalSize; } -size_t RabbitizerOperandType_process_rsp_vt_elementhigh(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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)); + RABUTILS_BUFFER_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_rsp_vt(self, dst, immOverride, immOverrideLength)); element = RAB_INSTR_RSP_GET_elementhigh(self); if (element != 0) { @@ -104,20 +115,24 @@ size_t RabbitizerOperandType_process_rsp_vt_elementhigh(const RabbitizerInstruct return totalSize; } -size_t RabbitizerOperandType_process_rsp_vt_elementlow(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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_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 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)); + RABUTILS_BUFFER_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_rsp_vd(self, dst, immOverride, immOverrideLength)); de = RAB_INSTR_RSP_GET_de(self); if ((de & 0x8) == 0x8) { @@ -132,27 +147,32 @@ size_t RabbitizerOperandType_process_rsp_vd_de(const RabbitizerInstruction *self return totalSize; } -size_t RabbitizerOperandType_process_rsp_vs_index(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +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_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 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_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 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 @@ -161,28 +181,33 @@ size_t RabbitizerOperandType_process_rsp_immediate_base(const RabbitizerInstruct 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_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_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_rsp_rs(self, dst, immOverride, immOverrideLength)); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ')'); return totalSize; } -size_t RabbitizerOperandType_process_rsp_maybe_rd_rs(const RabbitizerInstruction *self, char *dst, const char *immOverride, size_t immOverrideLength) { +size_t RabbitizerOperandType_process_rsp_maybe_rd_rs(const RabbitizerInstruction *self, char *dst, + const char *immOverride, size_t immOverrideLength) { size_t totalSize = 0; uint8_t rd = RAB_INSTR_GET_rd(self); const RabbitizerRegisterDescriptor *regDescriptor = RabbitizerRegister_getDescriptor_Gpr(rd); if (!RabbitizerRegisterDescriptor_isRa(regDescriptor)) { - RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_rd(self, dst, immOverride, immOverrideLength)); + RABUTILS_BUFFER_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_rsp_rd(self, dst, immOverride, immOverrideLength)); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ','); RABUTILS_BUFFER_WRITE_CHAR(dst, totalSize, ' '); } - RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandType_process_rsp_rs(self, dst, immOverride, immOverrideLength)); + RABUTILS_BUFFER_ADVANCE(dst, totalSize, + RabbitizerOperandType_process_rsp_rs(self, dst, immOverride, immOverrideLength)); return totalSize; } diff --git a/src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_ProcessUniqueId.c b/src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_ProcessUniqueId.c index 551eca4..2e2147c 100644 --- a/src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_ProcessUniqueId.c +++ b/src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_ProcessUniqueId.c @@ -10,7 +10,8 @@ case (caseBits): \ self->uniqueId = RABBITIZER_INSTR_ID_##prefix##_##name; \ break; -#define RABBITIZER_DEF_INSTR_ID_ALTNAME(prefix, caseBits, name, altname, ...) RABBITIZER_DEF_INSTR_ID(prefix, caseBits, name, __VA_ARGS__) +#define RABBITIZER_DEF_INSTR_ID_ALTNAME(prefix, caseBits, name, altname, ...) \ + RABBITIZER_DEF_INSTR_ID(prefix, caseBits, name, __VA_ARGS__) void RabbitizerInstructionRsp_processUniqueId_Normal_Lwc2(RabbitizerInstruction *self) { uint32_t rd = RAB_INSTR_GET_rd(self); diff --git a/src/instructions/RabbitizerRegister.c b/src/instructions/RabbitizerRegister.c index f53bd5e..29278b7 100644 --- a/src/instructions/RabbitizerRegister.c +++ b/src/instructions/RabbitizerRegister.c @@ -30,8 +30,10 @@ const char *RabbitizerRegister_getNameGpr(uint8_t regValue) { const char *RabbitizerRegister_getNameCop0(uint8_t regValue) { assert(regValue < ARRAY_COUNT(RabbitizerRegister_Cop0_Names)); - return RabbitizerRegister_Cop0_Names[regValue] - [RabbitizerConfig_Cfg.regNames.namedRegisters && RabbitizerConfig_Cfg.regNames.vr4300Cop0NamedRegisters ? 1 : 0]; + return RabbitizerRegister_Cop0_Names[regValue][RabbitizerConfig_Cfg.regNames.namedRegisters && + RabbitizerConfig_Cfg.regNames.vr4300Cop0NamedRegisters + ? 1 + : 0]; } const char *RabbitizerRegister_getNameCop1(uint8_t regValue) { @@ -56,7 +58,8 @@ const char *RabbitizerRegister_getNameCop1(uint8_t regValue) { const char *RabbitizerRegister_getNameCop1Control(uint8_t regValue) { assert(regValue < ARRAY_COUNT(RabbitizerRegister_Cop1Control_Names)); - return RabbitizerRegister_Cop1Control_Names[regValue][RabbitizerConfig_Cfg.regNames.namedRegisters && RabbitizerConfig_Cfg.regNames.userFpcCsr ? 1 : 0]; + return RabbitizerRegister_Cop1Control_Names + [regValue][RabbitizerConfig_Cfg.regNames.namedRegisters && RabbitizerConfig_Cfg.regNames.userFpcCsr ? 1 : 0]; } const char *RabbitizerRegister_getNameCop2(uint8_t regValue) { @@ -74,8 +77,10 @@ const char *RabbitizerRegister_getNameRspGpr(uint8_t regValue) { const char *RabbitizerRegister_getNameRspCop0(uint8_t regValue) { assert(regValue < ARRAY_COUNT(RabbitizerRegister_RspCop0_Names)); - return RabbitizerRegister_RspCop0_Names[regValue] - [RabbitizerConfig_Cfg.regNames.namedRegisters && RabbitizerConfig_Cfg.regNames.vr4300RspCop0NamedRegisters ? 1 : 0]; + return RabbitizerRegister_RspCop0_Names[regValue][RabbitizerConfig_Cfg.regNames.namedRegisters && + RabbitizerConfig_Cfg.regNames.vr4300RspCop0NamedRegisters + ? 1 + : 0]; } const char *RabbitizerRegister_getNameRspCop2(uint8_t regValue) { @@ -108,7 +113,6 @@ const char *RabbitizerRegister_getNameR5900VI(uint8_t regValue) { return RabbitizerRegister_R5900VI_Names[regValue][RabbitizerConfig_Cfg.regNames.namedRegisters ? 1 : 0]; } - const RabbitizerRegisterDescriptor *RabbitizerRegister_getDescriptor_Gpr(uint8_t regValue) { assert(regValue < ARRAY_COUNT(RabbitizerRegister_GprO32_Names)); diff --git a/src/instructions/RabbitizerRegisterDescriptor.c b/src/instructions/RabbitizerRegisterDescriptor.c index bfd4734..28c206c 100644 --- a/src/instructions/RabbitizerRegisterDescriptor.c +++ b/src/instructions/RabbitizerRegisterDescriptor.c @@ -7,7 +7,6 @@ #include "RegisterDescriptor_Descriptors_arrays.table.h" - bool RabbitizerRegisterDescriptor_isClobberedByFuncCall(const RabbitizerRegisterDescriptor *self) { return self->isClobberedByFuncCall; } From 14070be9627babd7dbc5200f826cdb93679c9cf4 Mon Sep 17 00:00:00 2001 From: angie Date: Tue, 20 Dec 2022 12:58:50 -0300 Subject: [PATCH 3/6] isolated python build --- .github/workflows/isolated_python_build.yml | 22 +++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 .github/workflows/isolated_python_build.yml diff --git a/.github/workflows/isolated_python_build.yml b/.github/workflows/isolated_python_build.yml new file mode 100644 index 0000000..198e553 --- /dev/null +++ b/.github/workflows/isolated_python_build.yml @@ -0,0 +1,22 @@ +name: Build and upload to PyPI + +# Build on every branch push, tag push, and pull request change: +on: [push, pull_request] + +jobs: + buildstuff: + name: Build + runs-on: ubuntu-latest + + steps: + - name: Checkout reposistory + uses: actions/checkout@v3 + + - name: Install dependencies + run: sudo apt update && sudo apt install -y python3-venv + + - name: Install build module + run: pip install build -U + + - name: Build + run: python3 -m build From de05c7211c1905fa322c6b31be755bd243ec12b0 Mon Sep 17 00:00:00 2001 From: angie Date: Tue, 20 Dec 2022 12:59:54 -0300 Subject: [PATCH 4/6] Include .h files in src folder --- MANIFEST.in | 1 + 1 file changed, 1 insertion(+) diff --git a/MANIFEST.in b/MANIFEST.in index 1e60716..70f664e 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -4,3 +4,4 @@ include **/*.h include **/**/*.h graft include +graft src From 1d59c857df0edae17421eec1613846a578bad278 Mon Sep 17 00:00:00 2001 From: angie Date: Tue, 20 Dec 2022 13:01:08 -0300 Subject: [PATCH 5/6] rename ci --- .github/workflows/isolated_python_build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/isolated_python_build.yml b/.github/workflows/isolated_python_build.yml index 198e553..c30dc8a 100644 --- a/.github/workflows/isolated_python_build.yml +++ b/.github/workflows/isolated_python_build.yml @@ -1,4 +1,4 @@ -name: Build and upload to PyPI +name: Build Python package in isolated environment # Build on every branch push, tag push, and pull request change: on: [push, pull_request] From b4a8771df122fdc9a38286198ecc06df0e560f7f Mon Sep 17 00:00:00 2001 From: angie Date: Tue, 20 Dec 2022 13:03:11 -0300 Subject: [PATCH 6/6] version bump --- Cargo.toml | 2 +- README.md | 2 +- include/common/RabbitizerVersion.h | 2 +- pyproject.toml | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index d951b70..784dcf8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,7 +4,7 @@ [package] name = "rabbitizer" # Version should be synced with include/common/RabbitizerVersion.h -version = "1.5.7" +version = "1.5.8" edition = "2021" authors = ["Anghelo Carvajal "] description = "MIPS instruction decoder" diff --git a/README.md b/README.md index 25d975f..cf80255 100644 --- a/README.md +++ b/README.md @@ -37,7 +37,7 @@ Add this crate to your `Cargo.toml` via: ```toml [build] -rabbitizer = "1.5.5" +rabbitizer = "1.5.8" ``` See this crate at . diff --git a/include/common/RabbitizerVersion.h b/include/common/RabbitizerVersion.h index cb00404..de2cd7d 100644 --- a/include/common/RabbitizerVersion.h +++ b/include/common/RabbitizerVersion.h @@ -14,7 +14,7 @@ extern "C" { // Header version #define RAB_VERSION_MAJOR 1 #define RAB_VERSION_MINOR 5 -#define RAB_VERSION_PATCH 7 +#define RAB_VERSION_PATCH 8 #define RAB_VERSION_STR RAB_STRINGIFY(RAB_VERSION_MAJOR) "." RAB_STRINGIFY(RAB_VERSION_MINOR) "." RAB_STRINGIFY(RAB_VERSION_PATCH) diff --git a/pyproject.toml b/pyproject.toml index fadcb45..cbf54a9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ [project] name = "rabbitizer" # Version should be synced with include/common/RabbitizerVersion.h -version = "1.5.7" +version = "1.5.8" description = "MIPS instruction decoder" # license = "MIT" readme = "README.md"