mirror/rabbitizer
1
0
Fork 0
mirror of https://github.com/Decompollaborate/rabbitizer.git synced 2025-02-25 15:39:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change column limit to 120

Browse Source
This commit is contained in:
angie 2022-12-20 00:47:17 -03:00
parent 5063702a07
commit 90eeda5f68
19 changed files with 331 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.clang-format
View File

@ -1,7 +1,7 @@
IndentWidth: 4
Language: Cpp
UseTab: Never
ColumnLimit: 160
ColumnLimit: 120
PointerAlignment: Right
BreakBeforeBraces: Attach
SpaceAfterCStyleCast: false

3
cplusplus/src/analysis/RegistersTracker.cpp
View File

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

15
cplusplus/src/instructions/InstructionBase.cpp
View File

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

59
src/analysis/RabbitizerRegistersTracker.c
View File

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

9
src/analysis/RabbitizerTrackedRegisterState.c
View File

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

3
src/instructions/RabbitizerInstrDescriptor.c
View File

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

9
src/instructions/RabbitizerInstrSuffix.c
View File

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

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

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

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

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

21
src/instructions/RabbitizerInstruction/RabbitizerInstruction_Examination.c
View File

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

23
src/instructions/RabbitizerInstruction/RabbitizerInstruction_Operand.c
View File

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

3
src/instructions/RabbitizerInstruction/RabbitizerInstruction_ProcessUniqueId.c
View File

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

74
src/instructions/RabbitizerInstructionCpu/RabbitizerInstructionCpu_OperandType.c
View File

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

151
src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_OperandType.c
View File

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

3
src/instructions/RabbitizerInstructionR5900/RabbitizerInstructionR5900_ProcessUniqueId.c
View File

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

75
src/instructions/RabbitizerInstructionRsp/RabbitizerInstructionRsp_OperandType.c
View File

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

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

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

16
src/instructions/RabbitizerRegister.c
View File

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

1
src/instructions/RabbitizerRegisterDescriptor.c
View File

@ -7,7 +7,6 @@
#include "RegisterDescriptor_Descriptors_arrays.table.h"
bool RabbitizerRegisterDescriptor_isClobberedByFuncCall(const RabbitizerRegisterDescriptor *self) {
return self->isClobberedByFuncCall;
}