mirror/rabbitizer
1
0
Fork 0
mirror of https://github.com/Decompollaborate/rabbitizer.git synced 2025-02-19 06:40:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove specific registers from instruction struct

Browse Source 
do bitwise operations to access them instead
This commit is contained in:
Angie 2022-07-03 08:34:26 -04:00
parent d0b39c6f8c
commit 0c678ab6df
8 changed files with 149 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
include/common/Utils.h
View File

@ -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);

62
include/instructions/RabbitizerInstruction.h
View File

@ -9,6 +9,8 @@
#include <stddef.h>
#include <stdint.h>
#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);

25
include/instructions/RabbitizerInstructionRsp.h
View File

@ -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);

2
rabbitizer/rabbitizer_type_Instruction.c
View File

@ -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)

68
src/analysis/RabbitizerRegistersTracker.c
View File

@ -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;
}

74
src/instructions/RabbitizerInstruction/RabbitizerInstruction.c
View File

@ -5,18 +5,13 @@
#include <assert.h>
#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:

4
src/instructions/RabbitizerInstruction/RabbitizerInstruction_Disassemble.c
View File

@ -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;
}

4
src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_ProcessUniqueId.c
View File

@ -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;