From 0c678ab6dfd89ba44ae72435a2ba28df1ba89fb4 Mon Sep 17 00:00:00 2001 From: Angie Date: Sun, 3 Jul 2022 08:34:26 -0400 Subject: [PATCH] remove specific registers from instruction struct do bitwise operations to access them instead --- include/common/Utils.h | 18 +++++ include/instructions/RabbitizerInstruction.h | 62 ++++++++++------ .../instructions/RabbitizerInstructionRsp.h | 25 +++++-- rabbitizer/rabbitizer_type_Instruction.c | 2 +- src/analysis/RabbitizerRegistersTracker.c | 68 ++++++++--------- .../RabbitizerInstruction.c | 74 +++++++++---------- .../RabbitizerInstruction_Disassemble.c | 4 +- ...RabbitizerInstructionRsp_ProcessUniqueId.c | 4 +- 8 files changed, 149 insertions(+), 108 deletions(-) diff --git a/include/common/Utils.h b/include/common/Utils.h index 2480654..625b2d0 100644 --- a/include/common/Utils.h +++ b/include/common/Utils.h @@ -38,6 +38,24 @@ #define ARRAY_COUNT(arr) (sizeof(arr) / sizeof(arr[0])) +/* + * the SHIFT macros take a value, a shift amount, and a width. + * + * For the left shift, the lower bits of the value are masked, + * then shifted left. + * + * For the right shift, the value is shifted right, then the lower bits + * are masked. + * + * (NOTE: SHIFTL(v, 0, 32) won't work, just use an assignment) + * + */ +#define SHIFTL(v, s, w) (((v) & ((1 << (w)) - 1)) << (s)) +#define SHIFTR(v, s, w) (((v) >> (s)) & ((1 << (w)) - 1)) + +#define BITREPACK(fullword, v, s, w) (SHIFTL((self)->word, (s)+(w), 32-((s)+(w))) | SHIFTL((v), (s), (w)) | SHIFTL((self)->word, 0, (s))) + + int32_t RabbitizerUtils_From2Complement(uint32_t number, int bits); size_t RabbitizerUtils_CharFill(char *dst, int count, char fillchar); diff --git a/include/instructions/RabbitizerInstruction.h b/include/instructions/RabbitizerInstruction.h index 118a532..0e3b45b 100644 --- a/include/instructions/RabbitizerInstruction.h +++ b/include/instructions/RabbitizerInstruction.h @@ -9,6 +9,8 @@ #include #include +#include "common/Utils.h" + #include "RabbitizerInstrId.h" #include "RabbitizerInstrDescriptor.h" @@ -25,12 +27,7 @@ typedef enum RabbitizerInstrCategory { typedef struct RabbitizerInstruction { - uint8_t opcode; - uint8_t rs; - uint8_t rt; - uint8_t rd; - uint8_t sa; - uint8_t function; + uint32_t word; RabbitizerInstrId uniqueId; const RabbitizerInstrDescriptor *descriptor; @@ -41,28 +38,47 @@ typedef struct RabbitizerInstruction { RabbitizerInstrCategory category; } RabbitizerInstruction; -#define RAB_INSTR_GET_opcode(self) ((self)->opcode) -#define RAB_INSTR_GET_rs(self) ((self)->rs) -#define RAB_INSTR_GET_rt(self) ((self)->rt) -#define RAB_INSTR_GET_rd(self) ((self)->rd) -#define RAB_INSTR_GET_sa(self) ((self)->sa) -#define RAB_INSTR_GET_function(self) ((self)->function) -#define RAB_INSTR_GET_instr_index(self) (((self)->rs << 21) | ((self)->rt << 16) | ((self)->rd << 11) | ((self)->sa << 6) | ((self)->function)) -#define RAB_INSTR_GET_immediate(self) (((self)->rd << 11) | ((self)->sa << 6) | ((self)->function)) +#define RAB_INSTR_GET_opcode(self) (SHIFTR((self)->word, 26, 6)) +#define RAB_INSTR_GET_rs(self) (SHIFTR((self)->word, 21, 5)) +#define RAB_INSTR_GET_rt(self) (SHIFTR((self)->word, 16, 5)) +#define RAB_INSTR_GET_rd(self) (SHIFTR((self)->word, 11, 5)) +#define RAB_INSTR_GET_sa(self) (SHIFTR((self)->word, 6, 5)) +#define RAB_INSTR_GET_function(self) (SHIFTR((self)->word, 0, 6)) -#define RAB_INSTR_GET_fs(self) ((self)->rd) -#define RAB_INSTR_GET_ft(self) ((self)->rt) -#define RAB_INSTR_GET_fd(self) ((self)->sa) +#define RAB_INSTR_GET_instr_index(self) (SHIFTR((self)->word, 0, 26)) +#define RAB_INSTR_GET_immediate(self) (SHIFTR((self)->word, 0, 16)) -#define RAB_INSTR_GET_op(self) ((self)->rt) -#define RAB_INSTR_GET_fmt(self) ((self)->rs) -#define RAB_INSTR_GET_fc(self) (((self)->function >> 4) & 0x3) -#define RAB_INSTR_GET_cond(self) ((self)->function & 0xF) +#define RAB_INSTR_GET_fs(self) (SHIFTR((self)->word, 11, 5)) +#define RAB_INSTR_GET_ft(self) (SHIFTR((self)->word, 16, 5)) +#define RAB_INSTR_GET_fd(self) (SHIFTR((self)->word, 6, 5)) -#define RAB_INSTR_GET_cop0d(self) ((self)->rd) +#define RAB_INSTR_GET_op(self) (SHIFTR((self)->word, 16, 5)) +#define RAB_INSTR_GET_fmt(self) (SHIFTR((self)->word, 21, 5)) +#define RAB_INSTR_GET_fc(self) (SHIFTR((self)->word, 4, 2)) +#define RAB_INSTR_GET_cond(self) (SHIFTR((self)->word, 0, 4)) + +#define RAB_INSTR_GET_cop0d(self) (SHIFTR((self)->word, 11, 5)) + +#define RAB_INSTR_GET_cop2t(self) (SHIFTR((self)->word, 16, 5)) + + +#define RAB_INSTR_SET_opcode(self, value) ((self)->word = BITREPACK((self)->word, value, 26, 6)) +#define RAB_INSTR_SET_rs(self, value) ((self)->word = BITREPACK((self)->word, value, 21, 5)) +#define RAB_INSTR_SET_rt(self, value) ((self)->word = BITREPACK((self)->word, value, 16, 5)) +#define RAB_INSTR_SET_rd(self, value) ((self)->word = BITREPACK((self)->word, value, 11, 5)) +#define RAB_INSTR_SET_sa(self, value) ((self)->word = BITREPACK((self)->word, value, 6, 5)) +#define RAB_INSTR_SET_function(self, value) ((self)->word = BITREPACK((self)->word, value, 0, 6)) + +#define RAB_INSTR_SET_instr_index(self, value) ((self)->word = BITREPACK((self)->word, value, 0, 26)) +#define RAB_INSTR_SET_immediate(self, value) ((self)->word = BITREPACK((self)->word, value, 0, 16)) + +#define RAB_INSTR_SET_code(self, value) ((self)->word = BITREPACK((self)->word, value, 6, 20)) + +#define RAB_INSTR_SET_fs(self, value) ((self)->word = BITREPACK((self)->word, value, 11, 5)) +#define RAB_INSTR_SET_ft(self, value) ((self)->word = BITREPACK((self)->word, value, 16, 5)) +#define RAB_INSTR_SET_fd(self, value) ((self)->word = BITREPACK((self)->word, value, 6, 5)) -#define RAB_INSTR_GET_cop2t(self) ((self)->rt) void RabbitizerInstruction_init(RabbitizerInstruction *self, uint32_t word); void RabbitizerInstruction_destroy(RabbitizerInstruction* self); diff --git a/include/instructions/RabbitizerInstructionRsp.h b/include/instructions/RabbitizerInstructionRsp.h index 75790d3..c546ccc 100644 --- a/include/instructions/RabbitizerInstructionRsp.h +++ b/include/instructions/RabbitizerInstructionRsp.h @@ -8,15 +8,26 @@ #include "RabbitizerInstruction.h" -#define RAB_INSTR_RSP_GET_VS(self) ((self)->rd) -#define RAB_INSTR_RSP_GET_VT(self) ((self)->rt) -#define RAB_INSTR_RSP_GET_VD(self) ((self)->sa) +#define RAB_INSTR_RSP_GET_VS(self) (SHIFTR((self)->word, 11, 5)) +#define RAB_INSTR_RSP_GET_VT(self) (SHIFTR((self)->word, 16, 5)) +#define RAB_INSTR_RSP_GET_VD(self) (SHIFTR((self)->word, 6, 5)) -#define RAB_INSTR_RSP_GET_ELEMENT_HIGH(self) ((((self)->rs)) & 0xF) -#define RAB_INSTR_RSP_GET_ELEMENT_LOW(self) ((((self)->sa) >> 1) & 0xF) -#define RAB_INSTR_RSP_GET_OFFSET_VECTOR_RAW(self) (RAB_INSTR_GET_immediate(self) & 0x7F) +#define RAB_INSTR_RSP_GET_elementhigh(self) (SHIFTR((self)->word, 21, 4)) +#define RAB_INSTR_RSP_GET_elementlow(self) (SHIFTR((self)->word, 7, 4)) +#define RAB_INSTR_RSP_GET_OFFSET_VECTOR_RAW(self) (SHIFTR((self)->word, 0, 7)) -#define RAB_INSTR_RSP_GET_index(self) ((self)->sa >> 1) +#define RAB_INSTR_RSP_GET_index(self) (SHIFTR((self)->word, 7, 4)) + + +#define RAB_INSTR_RSP_SET_vs(self, value) ((self)->word = BITREPACK((self)->word, value, 11, 5)) +#define RAB_INSTR_RSP_SET_vt(self, value) ((self)->word = BITREPACK((self)->word, value, 16, 5)) +#define RAB_INSTR_RSP_SET_vd(self, value) ((self)->word = BITREPACK((self)->word, value, 6, 5)) + +#define RAB_INSTR_RSP_SET_elementhigh(self, value) ((self)->word = BITREPACK((self)->word, value, 16, 4)) +#define RAB_INSTR_RSP_SET_elementlow(self, value) ((self)->word = BITREPACK((self)->word, value, 7, 4)) + +#define RAB_INSTR_RSP_SET_index(self, value) ((self)->word = BITREPACK((self)->word, value, 7, 4)) +#define RAB_INSTR_RSP_SET_offset(self, value) ((self)->word = BITREPACK((self)->word, value, 0, 7)) void RabbitizerInstructionRsp_init(RabbitizerInstruction *self, uint32_t word); diff --git a/rabbitizer/rabbitizer_type_Instruction.c b/rabbitizer/rabbitizer_type_Instruction.c index 80c018a..baad87f 100644 --- a/rabbitizer/rabbitizer_type_Instruction.c +++ b/rabbitizer/rabbitizer_type_Instruction.c @@ -61,7 +61,7 @@ static PyMemberDef rabbitizer_type_Instruction_members[] = { #define DEF_MEMBER_GET_UINT(name) \ static PyObject *rabbitizer_type_Instruction_member_get_##name(PyRabbitizerInstruction *self, PyObject *Py_UNUSED(ignored)) { \ - return PyLong_FromUnsignedLong(self->instr.name); \ + return PyLong_FromUnsignedLong(RAB_INSTR_GET_##name(&self->instr)); \ } DEF_MEMBER_GET_UINT(rs) diff --git a/src/analysis/RabbitizerRegistersTracker.c b/src/analysis/RabbitizerRegistersTracker.c index 936fa50..3ccfc0f 100644 --- a/src/analysis/RabbitizerRegistersTracker.c +++ b/src/analysis/RabbitizerRegistersTracker.c @@ -36,27 +36,27 @@ bool RabbitizerRegistersTracker_moveRegisters(RabbitizerRegistersTracker *self, if (!RabbitizerInstrDescriptor_maybeIsMove(instr->descriptor)) { return false; } - if (instr->rt == 0 && instr->rs == 0) { + if (RAB_INSTR_GET_rt(instr) == 0 && RAB_INSTR_GET_rs(instr) == 0) { // ? // RabbitizerTrackedRegisterState_clear(dstState); return false; } - if (instr->rt == 0) { - reg = instr->rs; - } else if (instr->rs == 0) { - reg = instr->rt; + if (RAB_INSTR_GET_rt(instr) == 0) { + reg = RAB_INSTR_GET_rs(instr); + } else if (RAB_INSTR_GET_rs(instr) == 0) { + reg = RAB_INSTR_GET_rt(instr); } else { // Check stuff like `addu $3, $3, $2` - if (instr->rd == instr->rs) { - reg = instr->rt; - if (self->registers[instr->rs].hasLuiValue) { - reg = instr->rs; + if (RAB_INSTR_GET_rd(instr) == RAB_INSTR_GET_rs(instr)) { + reg = RAB_INSTR_GET_rt(instr); + if (self->registers[RAB_INSTR_GET_rs(instr)].hasLuiValue) { + reg = RAB_INSTR_GET_rs(instr); } - } else if (instr->rd == instr->rt) { - reg = instr->rs; - if (self->registers[instr->rt].hasLuiValue) { - reg = instr->rt; + } else if (RAB_INSTR_GET_rd(instr) == RAB_INSTR_GET_rt(instr)) { + reg = RAB_INSTR_GET_rs(instr); + if (self->registers[RAB_INSTR_GET_rt(instr)].hasLuiValue) { + reg = RAB_INSTR_GET_rt(instr); } } else { // ? @@ -65,12 +65,12 @@ bool RabbitizerRegistersTracker_moveRegisters(RabbitizerRegistersTracker *self, } srcState = &self->registers[reg]; - RabbitizerTrackedRegisterState_copyState(&self->registers[instr->rd], srcState); + RabbitizerTrackedRegisterState_copyState(&self->registers[RAB_INSTR_GET_rd(instr)], srcState); return true; } srcState = &self->registers[reg]; - dstState = &self->registers[instr->rd]; + dstState = &self->registers[RAB_INSTR_GET_rd(instr)]; if (srcState->hasLoValue || srcState->hasLuiValue) { RabbitizerTrackedRegisterState_copyState(dstState, srcState); @@ -99,7 +99,7 @@ void RabbitizerRegistersTracker_overwriteRegisters(RabbitizerRegistersTracker *s // into the float coprocessor, after that IDO never re-uses the value // in that reg for anything else shouldRemove = true; - reg = instr->rt; + reg = RAB_INSTR_GET_rt(instr); break; default: @@ -109,10 +109,10 @@ void RabbitizerRegistersTracker_overwriteRegisters(RabbitizerRegistersTracker *s // $at usually is a one-use reg uint8_t at = 0; - if (instr->rs == 1) { - at = instr->rs; - } else if (instr->rt == 1) { - at = instr->rt; + if (RAB_INSTR_GET_rs(instr) == 1) { + at = RAB_INSTR_GET_rs(instr); + } else if (RAB_INSTR_GET_rt(instr) == 1) { + at = RAB_INSTR_GET_rt(instr); } state = &self->registers[at]; @@ -124,15 +124,15 @@ void RabbitizerRegistersTracker_overwriteRegisters(RabbitizerRegistersTracker *s if (RabbitizerInstrDescriptor_modifiesRt(instr->descriptor)) { shouldRemove = true; - reg = instr->rt; + reg = RAB_INSTR_GET_rt(instr); if (RabbitizerInstrDescriptor_isHiPair(instr->descriptor)) { - RabbitizerTrackedRegisterState_clearLo(&self->registers[instr->rt]); + RabbitizerTrackedRegisterState_clearLo(&self->registers[RAB_INSTR_GET_rt(instr)]); shouldRemove = false; } } if (RabbitizerInstrDescriptor_modifiesRd(instr->descriptor)) { shouldRemove = true; - reg = instr->rd; + reg = RAB_INSTR_GET_rd(instr); } if (shouldRemove) { @@ -229,7 +229,7 @@ void RabbitizerRegistersTracker_unsetRegistersAfterFuncCall(RabbitizerRegistersT } bool RabbitizerRegistersTracker_getAddressIfCanSetType(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, int instrOffset, uint32_t *dstAddress) { - RabbitizerTrackedRegisterState *state = &self->registers[instr->rs]; + RabbitizerTrackedRegisterState *state = &self->registers[RAB_INSTR_GET_rs(instr)]; if (!state->hasLoValue) { return false; @@ -244,7 +244,7 @@ bool RabbitizerRegistersTracker_getAddressIfCanSetType(RabbitizerRegistersTracke } bool RabbitizerRegistersTracker_getJrInfo(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, int *dstOffset, uint32_t *dstAddress) { - RabbitizerTrackedRegisterState *state = &self->registers[instr->rs]; + RabbitizerTrackedRegisterState *state = &self->registers[RAB_INSTR_GET_rs(instr)]; if (!state->hasLoValue || !state->dereferenced) { return false; @@ -262,7 +262,7 @@ void RabbitizerRegistersTracker_processLui(RabbitizerRegistersTracker *self, con assert(RabbitizerInstrDescriptor_isHiPair(instr->descriptor)); - state = &self->registers[instr->rt]; + state = &self->registers[RAB_INSTR_GET_rt(instr)]; RabbitizerTrackedRegisterState_clear(state); RabbitizerTrackedRegisterState_setHi(state, RabbitizerInstruction_getImmediate(instr), instrOffset); @@ -274,7 +274,7 @@ void RabbitizerRegistersTracker_processLui(RabbitizerRegistersTracker *self, con } bool RabbitizerRegistersTracker_getLuiOffsetForConstant(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, int *dstOffset) { - RabbitizerTrackedRegisterState *state = &self->registers[instr->rs]; + RabbitizerTrackedRegisterState *state = &self->registers[RAB_INSTR_GET_rs(instr)]; if (!state->hasLuiValue) { return false; @@ -285,13 +285,13 @@ bool RabbitizerRegistersTracker_getLuiOffsetForConstant(RabbitizerRegistersTrack } void RabbitizerRegistersTracker_processConstant(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, uint32_t value, int offset) { - RabbitizerTrackedRegisterState *stateDst = &self->registers[instr->rt]; + RabbitizerTrackedRegisterState *stateDst = &self->registers[RAB_INSTR_GET_rt(instr)]; RabbitizerTrackedRegisterState_setLo(stateDst, value, offset); } bool RabbitizerRegistersTracker_getLuiOffsetForLo(RabbitizerRegistersTracker *self, const RabbitizerInstruction *instr, int instrOffset, int *dstOffset, bool *dstIsGp) { - RabbitizerTrackedRegisterState *state = &self->registers[instr->rs]; + RabbitizerTrackedRegisterState *state = &self->registers[RAB_INSTR_GET_rs(instr)]; if (state->hasLuiValue && !state->luiSetOnBranchLikely) { *dstOffset = state->luiOffset; @@ -300,7 +300,7 @@ bool RabbitizerRegistersTracker_getLuiOffsetForLo(RabbitizerRegistersTracker *se } // TODO: abi - if (instr->rs == 28) { // $gp + if (RAB_INSTR_GET_rs(instr) == 28) { // $gp *dstOffset = 0; *dstIsGp = true; return true; @@ -309,7 +309,7 @@ bool RabbitizerRegistersTracker_getLuiOffsetForLo(RabbitizerRegistersTracker *se if (RabbitizerInstrDescriptor_modifiesRt(instr->descriptor) && RabbitizerInstrDescriptor_doesDereference(instr->descriptor)) { if (state->hasLoValue && !state->dereferenced) { // Simulate a dereference - RabbitizerTrackedRegisterState_dereferenceState(&self->registers[instr->rt], state, instrOffset); + RabbitizerTrackedRegisterState_dereferenceState(&self->registers[RAB_INSTR_GET_rt(instr)], state, instrOffset); } } @@ -323,12 +323,12 @@ void RabbitizerRegistersTracker_processLo(RabbitizerRegistersTracker *self, cons return; } - stateDst = &self->registers[instr->rt]; + stateDst = &self->registers[RAB_INSTR_GET_rt(instr)]; RabbitizerTrackedRegisterState_setLo(stateDst, value, offset); if (RabbitizerInstrDescriptor_doesDereference(instr->descriptor)) { RabbitizerTrackedRegisterState_deref(stateDst, offset); } - if (instr->rt == instr->rs) { + if (RAB_INSTR_GET_rt(instr) == RAB_INSTR_GET_rs(instr)) { RabbitizerTrackedRegisterState_clearHi(stateDst); } } @@ -338,7 +338,7 @@ bool RabbitizerRegistersTracker_hasLoButNoHi(RabbitizerRegistersTracker *self, c assert(instr != NULL); - state = &self->registers[instr->rs]; + state = &self->registers[RAB_INSTR_GET_rs(instr)]; return state->hasLoValue && !state->hasLuiValue; } diff --git a/src/instructions/RabbitizerInstruction/RabbitizerInstruction.c b/src/instructions/RabbitizerInstruction/RabbitizerInstruction.c index 28f5054..1cea603 100644 --- a/src/instructions/RabbitizerInstruction/RabbitizerInstruction.c +++ b/src/instructions/RabbitizerInstruction/RabbitizerInstruction.c @@ -5,18 +5,13 @@ #include -#include "common/Utils.h" #include "common/RabbitizerConfig.h" #include "instructions/RabbitizerRegister.h" +#include "instructions/RabbitizerInstructionRsp.h" void RabbitizerInstruction_init(RabbitizerInstruction *self, uint32_t word) { - self->opcode = (word >> 26) & 0x3F; - self->rs = (word >> 21) & 0x1F; - self->rt = (word >> 16) & 0x1F; - self->rd = (word >> 11) & 0x1F; - self->sa = (word >> 6) & 0x1F; - self->function = (word >> 0) & 0x3F; + self->word = word; self->uniqueId = RABBITIZER_INSTR_ID_cpu_INVALID; self->descriptor = &RabbitizerInstrDescriptor_Descriptors[self->uniqueId]; @@ -72,7 +67,7 @@ uint8_t RabbitizerInstruction_getCond(const RabbitizerInstruction *self) { /* General getters */ uint32_t RabbitizerInstruction_getRaw(const RabbitizerInstruction *self) { - return (self->opcode << 26) | (self->rs << 21) | (self->rt << 16) | (self->rd << 11) | (self->sa << 6) | (self->function); + return self->word; } uint32_t RabbitizerInstruction_getImmediate(const RabbitizerInstruction *self) { @@ -117,80 +112,81 @@ void RabbitizerInstruction_blankOut(RabbitizerInstruction *self) { case RABBITIZER_OPERAND_TYPE_rs: case RABBITIZER_OPERAND_TYPE_RSP_rs: case RABBITIZER_OPERAND_TYPE_RSP_vs: - self->rs = 0; + RAB_INSTR_SET_rs(self, 0); break; case RABBITIZER_OPERAND_TYPE_rt: - case RABBITIZER_OPERAND_TYPE_ft: case RABBITIZER_OPERAND_TYPE_cop2t: case RABBITIZER_OPERAND_TYPE_op: case RABBITIZER_OPERAND_TYPE_RSP_rt: case RABBITIZER_OPERAND_TYPE_RSP_vt: - self->rt = 0; + RAB_INSTR_SET_rt(self, 0); break; case RABBITIZER_OPERAND_TYPE_rd: case RABBITIZER_OPERAND_TYPE_cop0d: - case RABBITIZER_OPERAND_TYPE_fs: case RABBITIZER_OPERAND_TYPE_cop1cs: case RABBITIZER_OPERAND_TYPE_RSP_rd: case RABBITIZER_OPERAND_TYPE_RSP_vd: case RABBITIZER_OPERAND_TYPE_RSP_cop0d: - self->rd = 0; + RAB_INSTR_SET_rd(self, 0); break; case RABBITIZER_OPERAND_TYPE_sa: + RAB_INSTR_SET_sa(self, 0); + break; + + case RABBITIZER_OPERAND_TYPE_fs: + RAB_INSTR_SET_fs(self, 0); + break; + + case RABBITIZER_OPERAND_TYPE_ft: + RAB_INSTR_SET_ft(self, 0); + break; + case RABBITIZER_OPERAND_TYPE_fd: - self->sa = 0; + RAB_INSTR_SET_fd(self, 0); break; case RABBITIZER_OPERAND_TYPE_LABEL: - // rs rt rd sa function - self->function = 0; - FALLTHROUGH; + RAB_INSTR_SET_instr_index(self, 0); + break; + case RABBITIZER_OPERAND_TYPE_code: - // rs rt rd sa - self->rs = 0; - self->rt = 0; - self->rd = 0; - self->sa = 0; + RAB_INSTR_SET_code(self, 0); break; case RABBITIZER_OPERAND_TYPE_IMM_base: - // rs rd sa function - self->rs = 0; + // rs imm + RAB_INSTR_SET_rs(self, 0); FALLTHROUGH; case RABBITIZER_OPERAND_TYPE_IMM: - // rd sa function - self->rd = 0; - self->sa = 0; - self->function = 0; + RAB_INSTR_SET_immediate(self, 0); break; case RABBITIZER_OPERAND_TYPE_RSP_vt_elementhigh: - self->rt = 0; - self->rs &= ~0xF; + RAB_INSTR_RSP_SET_vt(self, 0); + RAB_INSTR_RSP_SET_elementhigh(self, 0); break; case RABBITIZER_OPERAND_TYPE_RSP_vt_elementlow: - self->rt = 0; - self->sa &= ~0x1E; + RAB_INSTR_RSP_SET_vt(self, 0); + RAB_INSTR_RSP_SET_elementlow(self, 0); break; case RABBITIZER_OPERAND_TYPE_RSP_vd_vs: - self->rd = 0; - self->rs = 0; + RAB_INSTR_RSP_SET_vd(self, 0); + RAB_INSTR_RSP_SET_vs(self, 0); break; case RABBITIZER_OPERAND_TYPE_RSP_vd_index: - self->rd = 0; - self->sa &= ~0x1; + RAB_INSTR_RSP_SET_vd(self, 0); + RAB_INSTR_RSP_SET_index(self, 0); break; case RABBITIZER_OPERAND_TYPE_RSP_offset_rs: - self->function = 0; - self->sa &= ~0x1; - self->rs = 0; + RAB_INSTR_RSP_SET_offset(self, 0); + RAB_INSTR_SET_rs(self, 0); break; case RABBITIZER_OPERAND_TYPE_INVALID: diff --git a/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Disassemble.c b/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Disassemble.c index a56404f..1f1023f 100644 --- a/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Disassemble.c +++ b/src/instructions/RabbitizerInstruction/RabbitizerInstruction_Disassemble.c @@ -253,7 +253,7 @@ size_t RabbitizerOperandTypeRsp_processVtElementhigh(const RabbitizerInstruction RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandTypeRsp_processVt(self, dst, immOverride, immOverrideLength)); - element = RabbitizerInstructionRsp_processVectorElement(self, RAB_INSTR_RSP_GET_ELEMENT_HIGH(self)); + element = RabbitizerInstructionRsp_processVectorElement(self, RAB_INSTR_RSP_GET_elementhigh(self)); if (element != 0) { RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", element); } @@ -266,7 +266,7 @@ size_t RabbitizerOperandTypeRsp_processVtElementlow(const RabbitizerInstruction RABUTILS_BUFFER_ADVANCE(dst, totalSize, RabbitizerOperandTypeRsp_processVt(self, dst, immOverride, immOverrideLength)); - element = RabbitizerInstructionRsp_processVectorElement(self, RAB_INSTR_RSP_GET_ELEMENT_LOW(self)); + element = RabbitizerInstructionRsp_processVectorElement(self, RAB_INSTR_RSP_GET_elementlow(self)); RABUTILS_BUFFER_SPRINTF(dst, totalSize, "[%i]", element); return totalSize; } diff --git a/src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_ProcessUniqueId.c b/src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_ProcessUniqueId.c index 772086f..c1cb34d 100644 --- a/src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_ProcessUniqueId.c +++ b/src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_ProcessUniqueId.c @@ -121,7 +121,7 @@ void RabbitizerInstructionRsp_processUniqueId_Normal(RabbitizerInstruction *self self->uniqueId = RABBITIZER_INSTR_ID_rsp_spv; break; case 0b00111: - if (RAB_INSTR_RSP_GET_ELEMENT_LOW(self) == 0) { + if (RAB_INSTR_RSP_GET_elementlow(self) == 0) { self->uniqueId = RABBITIZER_INSTR_ID_rsp_suv; } else { self->uniqueId = RABBITIZER_INSTR_ID_rsp_swv; @@ -364,7 +364,7 @@ void RabbitizerInstructionRsp_processUniqueId_Coprocessor0(RabbitizerInstruction void RabbitizerInstructionRsp_processUniqueId_Coprocessor2(RabbitizerInstruction *self) { if (((RAB_INSTR_GET_rs(self) >> 4) & 0x1) == 0) { - switch (RAB_INSTR_RSP_GET_ELEMENT_HIGH(self)) { + switch (RAB_INSTR_RSP_GET_elementhigh(self)) { case 0b00000: self->uniqueId = RABBITIZER_INSTR_ID_rsp_mfc2; break;