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

Merge pull request #22 from Decompollaborate/develop

Browse Source 
1.5.8
This commit is contained in:
Anghelo Carvajal 2022-12-20 13:26:30 -03:00 committed by GitHub
commit 40257d0649
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
40 changed files with 911 additions and 368 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

22
.github/workflows/isolated_python_build.yml vendored Normal file
View File

@ -0,0 +1,22 @@
name: Build Python package in isolated environment
# Build on every branch push, tag push, and pull request change:
on: [push, pull_request]
jobs:
buildstuff:
name: Build
runs-on: ubuntu-latest
steps:
- name: Checkout reposistory
uses: actions/checkout@v3
- name: Install dependencies
run: sudo apt update && sudo apt install -y python3-venv
- name: Install build module
run: pip install build -U
- name: Build
run: python3 -m build

2
Cargo.toml
View File

@ -4,7 +4,7 @@
[package]
name = "rabbitizer"
# Version should be synced with include/common/RabbitizerVersion.h
version = "1.5.7"
version = "1.5.8"
edition = "2021"
authors = ["Anghelo Carvajal <angheloalf95@gmail.com>"]
description = "MIPS instruction decoder"

1
MANIFEST.in
View File

@ -4,3 +4,4 @@
include **/*.h
include **/**/*.h
graft include
graft src

2
README.md
View File

@ -37,7 +37,7 @@ Add this crate to your `Cargo.toml` via:
```toml
[build]
rabbitizer = "1.5.5"
rabbitizer = "1.5.8"
```
See this crate at <https://crates.io/crates/rabbitizer>.

9
cplusplus/include/instructions/InstructionBase.hpp
View File

@ -228,6 +228,7 @@ namespace rabbitizer {
bool isUnsigned() const;
bool modifiesRs() const;
bool modifiesRt() const;
bool modifiesRd() const;
@ -240,6 +241,14 @@ namespace rabbitizer {
bool modifiesHI() const;
bool modifiesLO() const;
bool modifiesFs() const;
bool modifiesFt() const;
bool modifiesFd() const;
bool readsFs() const;
bool readsFt() const;
bool readsFd() const;
bool notEmitedByCompilers() const;
bool canBeHi() const;

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 {

38
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
@ -852,6 +855,9 @@ bool InstructionBase::isUnsigned() const {
return RabbitizerInstrDescriptor_isUnsigned(this->instr.descriptor);
}
bool InstructionBase::modifiesRs() const {
return RabbitizerInstrDescriptor_modifiesRs(this->instr.descriptor);
}
bool InstructionBase::modifiesRt() const {
return RabbitizerInstrDescriptor_modifiesRt(this->instr.descriptor);
}
@ -882,6 +888,26 @@ bool InstructionBase::modifiesLO() const {
return RabbitizerInstrDescriptor_modifiesLO(this->instr.descriptor);
}
bool InstructionBase::modifiesFs() const {
return RabbitizerInstrDescriptor_modifiesFs(this->instr.descriptor);
}
bool InstructionBase::modifiesFt() const {
return RabbitizerInstrDescriptor_modifiesFt(this->instr.descriptor);
}
bool InstructionBase::modifiesFd() const {
return RabbitizerInstrDescriptor_modifiesFd(this->instr.descriptor);
}
bool InstructionBase::readsFs() const {
return RabbitizerInstrDescriptor_readsFs(this->instr.descriptor);
}
bool InstructionBase::readsFt() const {
return RabbitizerInstrDescriptor_readsFt(this->instr.descriptor);
}
bool InstructionBase::readsFd() const {
return RabbitizerInstrDescriptor_readsFd(this->instr.descriptor);
}
bool InstructionBase::notEmitedByCompilers() const {
return RabbitizerInstrDescriptor_notEmitedByCompilers(this->instr.descriptor);
}
@ -993,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);
@ -1018,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);

2
include/common/RabbitizerVersion.h
View File

@ -14,7 +14,7 @@ extern "C" {
// Header version
#define RAB_VERSION_MAJOR 1
#define RAB_VERSION_MINOR 5
#define RAB_VERSION_PATCH 7
#define RAB_VERSION_PATCH 8
#define RAB_VERSION_STR RAB_STRINGIFY(RAB_VERSION_MAJOR) "." RAB_STRINGIFY(RAB_VERSION_MINOR) "." RAB_STRINGIFY(RAB_VERSION_PATCH)

27
include/instructions/RabbitizerInstrDescriptor.h
View File

@ -69,6 +69,10 @@ typedef struct RabbitizerInstrDescriptor {
*/
bool isUnsigned;
/**
* The instruction modifies the state of the MIPS `rs` register
*/
bool modifiesRs;
/**
* The instruction modifies the state of the MIPS `rt` register
*/
@ -96,6 +100,13 @@ typedef struct RabbitizerInstrDescriptor {
bool modifiesHI;
bool modifiesLO;
bool modifiesFs;
bool modifiesFt;
bool modifiesFd;
bool readsFs;
bool readsFt;
bool readsFd;
/**
* This instruction is not emited by a C compiler
*/
@ -183,6 +194,8 @@ bool RabbitizerInstrDescriptor_isDouble(const RabbitizerInstrDescriptor *self);
NODISCARD NON_NULL(1) PURE
bool RabbitizerInstrDescriptor_isUnsigned(const RabbitizerInstrDescriptor *self);
NODISCARD NON_NULL(1) PURE
bool RabbitizerInstrDescriptor_modifiesRs(const RabbitizerInstrDescriptor *self);
NODISCARD NON_NULL(1) PURE
bool RabbitizerInstrDescriptor_modifiesRt(const RabbitizerInstrDescriptor *self);
NODISCARD NON_NULL(1) PURE
@ -204,6 +217,20 @@ bool RabbitizerInstrDescriptor_modifiesHI(const RabbitizerInstrDescriptor *self)
NODISCARD NON_NULL(1) PURE
bool RabbitizerInstrDescriptor_modifiesLO(const RabbitizerInstrDescriptor *self);
NODISCARD NON_NULL(1) PURE
bool RabbitizerInstrDescriptor_modifiesFs(const RabbitizerInstrDescriptor *self);
NODISCARD NON_NULL(1) PURE
bool RabbitizerInstrDescriptor_modifiesFt(const RabbitizerInstrDescriptor *self);
NODISCARD NON_NULL(1) PURE
bool RabbitizerInstrDescriptor_modifiesFd(const RabbitizerInstrDescriptor *self);
NODISCARD NON_NULL(1) PURE
bool RabbitizerInstrDescriptor_readsFs(const RabbitizerInstrDescriptor *self);
NODISCARD NON_NULL(1) PURE
bool RabbitizerInstrDescriptor_readsFt(const RabbitizerInstrDescriptor *self);
NODISCARD NON_NULL(1) PURE
bool RabbitizerInstrDescriptor_readsFd(const RabbitizerInstrDescriptor *self);
NODISCARD NON_NULL(1) PURE
bool RabbitizerInstrDescriptor_notEmitedByCompilers(const RabbitizerInstrDescriptor *self);

12
include/instructions/instr_id/cpu/cpu_cop1.inc
View File

@ -7,28 +7,32 @@ RABBITIZER_DEF_INSTR_ID(
.operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs},
.instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
.isFloat=true,
.modifiesRt=true
.modifiesRt=true,
.readsFs=true
) // Move Word From Floating-Point
RABBITIZER_DEF_INSTR_ID(
cpu, 0x01, dmfc1,
.operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs},
.instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
.isFloat=true,
.modifiesRt=true
.modifiesRt=true,
.readsFs=true
) // Doubleword Move From Floating-Point
RABBITIZER_DEF_INSTR_ID(
cpu, 0x04, mtc1,
.operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs},
.instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
.isFloat=true,
.readsRt=true
.readsRt=true,
.modifiesFs=true
) // Move Word to Floating-Point
RABBITIZER_DEF_INSTR_ID(
cpu, 0x05, dmtc1,
.operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs},
.instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
.isFloat=true,
.readsRt=true
.readsRt=true,
.modifiesFs=true
) // Doubleword Move To Floating-Point
// OP rt, cop1cs

144
include/instructions/instr_id/cpu/cpu_cop1_fpu_d.inc
View File

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

8
include/instructions/instr_id/cpu/cpu_cop1_fpu_l.inc
View File

@ -6,12 +6,16 @@ RABBITIZER_DEF_INSTR_ID_ALTNAME(
cpu, 0x20, cvt_s_l, cvt.s.l,
.operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
.instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
.isFloat=true
.isFloat=true,
.modifiesFd=true,
.readsFs=true
)
RABBITIZER_DEF_INSTR_ID_ALTNAME(
cpu, 0x21, cvt_d_l, cvt.d.l,
.operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
.instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
.isFloat=true,
.isDouble=true
.isDouble=true,
.modifiesFd=true,
.readsFs=true
)

144
include/instructions/instr_id/cpu/cpu_cop1_fpu_s.inc
View File

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

8
include/instructions/instr_id/cpu/cpu_cop1_fpu_w.inc
View File

@ -6,12 +6,16 @@ RABBITIZER_DEF_INSTR_ID_ALTNAME(
cpu, 0x20, cvt_s_w, cvt.s.w,
.operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
.instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
.isFloat=true
.isFloat=true,
.modifiesFd=true,
.readsFs=true
)
RABBITIZER_DEF_INSTR_ID_ALTNAME(
cpu, 0x21, cvt_d_w, cvt.d.w,
.operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
.instrType=RABBITIZER_INSTR_TYPE_UNKNOWN,
.isFloat=true,
.isDouble=true
.isDouble=true,
.modifiesFd=true,
.readsFs=true
)

4
include/instructions/instr_id/cpu/cpu_normal.inc
View File

@ -439,6 +439,7 @@ RABBITIZER_DEF_INSTR_ID(
.instrType=RABBITIZER_INSTR_TYPE_I,
.isFloat=true,
.readsRs=true,
.modifiesFt=true,
.canBeLo=true,
.doesDereference=true,
.doesLoad=true,
@ -451,6 +452,7 @@ RABBITIZER_DEF_INSTR_ID(
.isFloat=true,
.isDouble=true,
.readsRs=true,
.modifiesFt=true,
.canBeLo=true,
.doesDereference=true,
.doesLoad=true,
@ -462,6 +464,7 @@ RABBITIZER_DEF_INSTR_ID(
.instrType=RABBITIZER_INSTR_TYPE_I,
.isFloat=true,
.readsRs=true,
.readsFt=true,
.canBeLo=true,
.doesDereference=true,
.doesStore=true,
@ -474,6 +477,7 @@ RABBITIZER_DEF_INSTR_ID(
.isFloat=true,
.isDouble=true,
.readsRs=true,
.readsFt=true,
.canBeLo=true,
.doesDereference=true,
.doesStore=true,

57
include/instructions/instr_id/r5900/r5900_cop1_fpu_s.inc
View File

@ -27,55 +27,80 @@ RABBITIZER_DEF_INSTR_ID_ALTNAME(
RABBITIZER_DEF_INSTR_ID_ALTNAME(
r5900, 0x16, rsqrt_s, rsqrt.s,
.operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
.isFloat=true
.isFloat=true,
.modifiesFd=true,
.readsFs=true,
.readsFt=true
) // floating point Reciprocal SQuare RooT
RABBITIZER_DEF_INSTR_ID_ALTNAME(
r5900, 0x18, adda_s, adda.s,
.operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
.isFloat=true
.isFloat=true,
.modifiesFs=true,
.readsFt=true
) // floating point ADD to Accumulator
RABBITIZER_DEF_INSTR_ID_ALTNAME(
r5900, 0x19, suba_s, suba.s,
.operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
.isFloat=true
.isFloat=true,
.modifiesFs=true,
.readsFt=true
) // floating point SUBtract to Accumulator
RABBITIZER_DEF_INSTR_ID_ALTNAME(
r5900, 0x1A, mula_s, mula.s,
.operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
.isFloat=true
.isFloat=true,
.modifiesFs=true,
.readsFt=true
) // floating point MULtiply to Accumulator
RABBITIZER_DEF_INSTR_ID_ALTNAME(
r5900, 0x1C, madd_s, madd.s,
.operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
.isFloat=true
.isFloat=true,
.modifiesFd=true,
.readsFs=true,
.readsFt=true
) // floating point Multiply-ADD
RABBITIZER_DEF_INSTR_ID_ALTNAME(
r5900, 0x1D, msub_s, msub.s,
.operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
.isFloat=true
.isFloat=true,
.modifiesFd=true,
.readsFs=true,
.readsFt=true
) // floating point Multiply abd SUBtract
RABBITIZER_DEF_INSTR_ID_ALTNAME(
r5900, 0x1E, madda_s, madda.s,
.operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
.isFloat=true
.isFloat=true,
.readsFs=true,
.readsFt=true
) // floating point Multiply-ADD Accumulator
RABBITIZER_DEF_INSTR_ID_ALTNAME(
r5900, 0x1F, msuba_s, msuba.s,
.operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
.isFloat=true
.isFloat=true,
.readsFs=true,
.readsFt=true
) // floating point Multiply SUBtract from Accumulator
RABBITIZER_DEF_INSTR_ID_ALTNAME(
r5900, 0x28, max_s, max.s,
.operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
.isFloat=true
.isFloat=true,
.modifiesFd=true,
.readsFs=true,
.readsFt=true
) // floating point MAXimum
RABBITIZER_DEF_INSTR_ID_ALTNAME(
r5900, 0x29, min_s, min.s,
.operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
.isFloat=true
.isFloat=true,
.modifiesFd=true,
.readsFs=true,
.readsFt=true
) // floating point MINimum
// Due to the R5900's FPU being non properly complaint the instruction cvt.w.s always behaves as trunc.w.s because is because EE can only do round-to-zero.
@ -86,16 +111,22 @@ RABBITIZER_DEF_INSTR_ID_ALTNAME(
RABBITIZER_DEF_INSTR_ID_ALTNAME(
r5900, 0x24, trunc_w_s, trunc.w.s,
.operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs},
.isFloat=true
.isFloat=true,
.modifiesFd=true,
.readsFs=true
) // Floating-Point Truncate to Word Fixed-Point
RABBITIZER_DEF_INSTR_ID_ALTNAME(
r5900, 0x34, c_lt_s, c.lt.s,
.operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
.isFloat=true
.isFloat=true,
.readsFs=true,
.readsFt=true
)
RABBITIZER_DEF_INSTR_ID_ALTNAME(
r5900, 0x36, c_le_s, c.le.s,
.operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft},
.isFloat=true
.isFloat=true,
.readsFs=true,
.readsFt=true
)

2
pyproject.toml
View File

@ -4,7 +4,7 @@
[project]
name = "rabbitizer"
# Version should be synced with include/common/RabbitizerVersion.h
version = "1.5.7"
version = "1.5.8"
description = "MIPS instruction decoder"
# license = "MIT"
readme = "README.md"

7
rabbitizer/rabbitizer.pyi
View File

@ -98,6 +98,7 @@ class Instruction:
def isFloat(self) -> bool: ...
def isDouble(self) -> bool: ...
def isUnsigned(self) -> bool: ...
def modifiesRs(self) -> bool: ...
def modifiesRt(self) -> bool: ...
def modifiesRd(self) -> bool: ...
def readsRs(self) -> bool: ...
@ -107,6 +108,12 @@ class Instruction:
def readsLO(self) -> bool: ...
def modifiesHI(self) -> bool: ...
def modifiesLO(self) -> bool: ...
def modifiesFs(self) -> bool: ...
def modifiesFt(self) -> bool: ...
def modifiesFd(self) -> bool: ...
def readsFs(self) -> bool: ...
def readsFt(self) -> bool: ...
def readsFd(self) -> bool: ...
def notEmitedByCompilers(self) -> bool: ...
def canBeHi(self) -> bool: ...
def canBeLo(self) -> bool: ...

14
rabbitizer/rabbitizer_type_Instruction.c
View File

@ -357,6 +357,7 @@ DEF_DESCRIPTOR_METHOD_BOOL(isTrap)
DEF_DESCRIPTOR_METHOD_BOOL(isFloat)
DEF_DESCRIPTOR_METHOD_BOOL(isDouble)
DEF_DESCRIPTOR_METHOD_BOOL(isUnsigned)
DEF_DESCRIPTOR_METHOD_BOOL(modifiesRs)
DEF_DESCRIPTOR_METHOD_BOOL(modifiesRt)
DEF_DESCRIPTOR_METHOD_BOOL(modifiesRd)
DEF_DESCRIPTOR_METHOD_BOOL(readsRs)
@ -366,6 +367,12 @@ DEF_DESCRIPTOR_METHOD_BOOL(readsHI)
DEF_DESCRIPTOR_METHOD_BOOL(readsLO)
DEF_DESCRIPTOR_METHOD_BOOL(modifiesHI)
DEF_DESCRIPTOR_METHOD_BOOL(modifiesLO)
DEF_DESCRIPTOR_METHOD_BOOL(modifiesFs)
DEF_DESCRIPTOR_METHOD_BOOL(modifiesFt)
DEF_DESCRIPTOR_METHOD_BOOL(modifiesFd)
DEF_DESCRIPTOR_METHOD_BOOL(readsFs)
DEF_DESCRIPTOR_METHOD_BOOL(readsFt)
DEF_DESCRIPTOR_METHOD_BOOL(readsFd)
DEF_DESCRIPTOR_METHOD_BOOL(notEmitedByCompilers)
DEF_DESCRIPTOR_METHOD_BOOL(canBeHi)
DEF_DESCRIPTOR_METHOD_BOOL(canBeLo)
@ -493,6 +500,7 @@ static PyMethodDef rabbitizer_type_Instruction_methods[] = {
METHOD_NO_ARGS(isFloat, ""),
METHOD_NO_ARGS(isDouble, ""),
METHOD_NO_ARGS(isUnsigned, ""),
METHOD_NO_ARGS(modifiesRs, ""),
METHOD_NO_ARGS(modifiesRt, ""),
METHOD_NO_ARGS(modifiesRd, ""),
METHOD_NO_ARGS(readsRs, ""),
@ -502,6 +510,12 @@ static PyMethodDef rabbitizer_type_Instruction_methods[] = {
METHOD_NO_ARGS(readsLO, ""),
METHOD_NO_ARGS(modifiesHI, ""),
METHOD_NO_ARGS(modifiesLO, ""),
METHOD_NO_ARGS(modifiesFs, ""),
METHOD_NO_ARGS(modifiesFt, ""),
METHOD_NO_ARGS(modifiesFd, ""),
METHOD_NO_ARGS(readsFs, ""),
METHOD_NO_ARGS(readsFt, ""),
METHOD_NO_ARGS(readsFd, ""),
METHOD_NO_ARGS(notEmitedByCompilers, ""),
METHOD_NO_ARGS(canBeHi, ""),
METHOD_NO_ARGS(canBeLo, ""),

9
rust/src/instr_descriptor.rs
View File

@ -23,6 +23,7 @@ pub struct InstrDescriptor {
is_unsigned: bool,
modifies_rs: bool,
modifies_rt: bool,
modifies_rd: bool,
@ -35,6 +36,14 @@ pub struct InstrDescriptor {
modifies_hi: bool,
modifies_lo: bool,
modifies_fs: bool,
modifies_ft: bool,
modifies_fd: bool,
reads_fs: bool,
reads_ft: bool,
reads_fd: bool,
not_emited_by_compilers: bool,
can_be_hi: bool,

44
rust/src/instruction.rs
View File

@ -115,6 +115,7 @@ extern "C" {
fn RabbitizerInstrDescriptor_isDouble(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_isUnsigned(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_modifiesRs(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_modifiesRt(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_modifiesRd(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_readsRs(self_: *const instr_descriptor::InstrDescriptor) -> bool;
@ -125,6 +126,14 @@ extern "C" {
fn RabbitizerInstrDescriptor_readsLO(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_modifiesHI(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_modifiesLO(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_modifiesFs(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_modifiesFt(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_modifiesFd(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_readsFs(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_readsFt(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_readsFd(self_: *const instr_descriptor::InstrDescriptor) -> bool;
fn RabbitizerInstrDescriptor_notEmitedByCompilers(
self_: *const instr_descriptor::InstrDescriptor,
) -> bool;
@ -584,6 +593,11 @@ impl Instruction {
RabbitizerInstrDescriptor_isUnsigned(self.descriptor)
}
}
pub fn modifies_rs(&self) -> bool {
unsafe {
RabbitizerInstrDescriptor_modifiesRs(self.descriptor)
}
}
pub fn modifies_rt(&self) -> bool {
unsafe {
RabbitizerInstrDescriptor_modifiesRt(self.descriptor)
@ -629,6 +643,36 @@ impl Instruction {
RabbitizerInstrDescriptor_modifiesLO(self.descriptor)
}
}
pub fn modifies_fs(&self) -> bool {
unsafe {
RabbitizerInstrDescriptor_modifiesFs(self.descriptor)
}
}
pub fn modifies_ft(&self) -> bool {
unsafe {
RabbitizerInstrDescriptor_modifiesFt(self.descriptor)
}
}
pub fn modifies_fd(&self) -> bool {
unsafe {
RabbitizerInstrDescriptor_modifiesFd(self.descriptor)
}
}
pub fn reads_fs(&self) -> bool {
unsafe {
RabbitizerInstrDescriptor_readsFs(self.descriptor)
}
}
pub fn reads_ft(&self) -> bool {
unsafe {
RabbitizerInstrDescriptor_readsFt(self.descriptor)
}
}
pub fn reads_fd(&self) -> bool {
unsafe {
RabbitizerInstrDescriptor_readsFd(self.descriptor)
}
}
pub fn not_emited_by_compilers(&self) -> bool {
unsafe {
RabbitizerInstrDescriptor_notEmitedByCompilers(self.descriptor)

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

190
src/instructions/InstrDescriptor_Descriptors_array.table.h
View File

@ -53,10 +53,10 @@ const RabbitizerInstrDescriptor RabbitizerInstrDescriptor_Descriptors[] = {
[RABBITIZER_INSTR_ID_cpu_scd] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .readsRs=true, .readsRt=true, .canBeLo=true, .doesDereference=true, .doesStore=true },
[RABBITIZER_INSTR_ID_cpu_sd] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .readsRs=true, .readsRt=true, .canBeLo=true, .doesDereference=true, .doesStore=true, .accessType=RAB_ACCESSTYPE_DOUBLEWORD },
[RABBITIZER_INSTR_ID_cpu_cache] = { .operands={RAB_OPERAND_cpu_op, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .readsRs=true, .notEmitedByCompilers=true },
[RABBITIZER_INSTR_ID_cpu_lwc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .accessType=RAB_ACCESSTYPE_FLOAT },
[RABBITIZER_INSTR_ID_cpu_ldc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .isDouble=true, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .accessType=RAB_ACCESSTYPE_DOUBLEFLOAT },
[RABBITIZER_INSTR_ID_cpu_swc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesStore=true, .accessType=RAB_ACCESSTYPE_FLOAT },
[RABBITIZER_INSTR_ID_cpu_sdc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .isDouble=true, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesStore=true, .accessType=RAB_ACCESSTYPE_DOUBLEFLOAT },
[RABBITIZER_INSTR_ID_cpu_lwc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .readsRs=true, .modifiesFt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .accessType=RAB_ACCESSTYPE_FLOAT },
[RABBITIZER_INSTR_ID_cpu_ldc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .isDouble=true, .readsRs=true, .modifiesFt=true, .canBeLo=true, .doesDereference=true, .doesLoad=true, .accessType=RAB_ACCESSTYPE_DOUBLEFLOAT },
[RABBITIZER_INSTR_ID_cpu_swc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .readsRs=true, .readsFt=true, .canBeLo=true, .doesDereference=true, .doesStore=true, .accessType=RAB_ACCESSTYPE_FLOAT },
[RABBITIZER_INSTR_ID_cpu_sdc1] = { .operands={RAB_OPERAND_cpu_ft, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .isFloat=true, .isDouble=true, .readsRs=true, .readsFt=true, .canBeLo=true, .doesDereference=true, .doesStore=true, .accessType=RAB_ACCESSTYPE_DOUBLEFLOAT },
[RABBITIZER_INSTR_ID_cpu_lwc2] = { .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesLoad=true },
[RABBITIZER_INSTR_ID_cpu_ldc2] = { .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesLoad=true },
[RABBITIZER_INSTR_ID_cpu_swc2] = { .operands={RAB_OPERAND_cpu_cop2t, RAB_OPERAND_cpu_immediate_base}, .instrType=RABBITIZER_INSTR_TYPE_I, .readsRs=true, .canBeLo=true, .doesDereference=true, .doesStore=true },
@ -154,90 +154,90 @@ const RabbitizerInstrDescriptor RabbitizerInstrDescriptor_Descriptors[] = {
[RABBITIZER_INSTR_ID_cpu_tlbwr] = { .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN },
[RABBITIZER_INSTR_ID_cpu_tlbp] = { .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .notEmitedByCompilers=true },
[RABBITIZER_INSTR_ID_cpu_eret] = { .operands={0}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .notEmitedByCompilers=true },
[RABBITIZER_INSTR_ID_cpu_mfc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesRt=true },
[RABBITIZER_INSTR_ID_cpu_dmfc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesRt=true },
[RABBITIZER_INSTR_ID_cpu_mtc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsRt=true },
[RABBITIZER_INSTR_ID_cpu_dmtc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsRt=true },
[RABBITIZER_INSTR_ID_cpu_mfc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesRt=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_dmfc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesRt=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_mtc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsRt=true, .modifiesFs=true },
[RABBITIZER_INSTR_ID_cpu_dmtc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsRt=true, .modifiesFs=true },
[RABBITIZER_INSTR_ID_cpu_cfc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop1cs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesRt=true },
[RABBITIZER_INSTR_ID_cpu_ctc1] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_cpu_cop1cs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsRt=true },
[RABBITIZER_INSTR_ID_cpu_bc1f] = { .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true },
[RABBITIZER_INSTR_ID_cpu_bc1t] = { .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true },
[RABBITIZER_INSTR_ID_cpu_bc1fl] = { .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true, .isBranchLikely=true },
[RABBITIZER_INSTR_ID_cpu_bc1tl] = { .operands={RAB_OPERAND_cpu_branch_target_label}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isBranch=true, .isBranchLikely=true },
[RABBITIZER_INSTR_ID_cpu_add_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_sub_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_mul_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_div_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_sqrt_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_abs_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_mov_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_neg_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_round_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_trunc_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_ceil_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_floor_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_round_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_trunc_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_ceil_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_floor_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_cvt_d_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true },
[RABBITIZER_INSTR_ID_cpu_cvt_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_cvt_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_f_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_un_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_eq_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ueq_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_olt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ult_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ole_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ule_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_sf_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ngle_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_seq_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ngl_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_lt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_nge_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_le_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ngt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_add_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_sub_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_mul_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_div_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_sqrt_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_abs_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_mov_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_neg_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_round_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_trunc_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_ceil_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_floor_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_round_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_trunc_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_ceil_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_floor_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_cvt_s_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true },
[RABBITIZER_INSTR_ID_cpu_cvt_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true },
[RABBITIZER_INSTR_ID_cpu_cvt_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true },
[RABBITIZER_INSTR_ID_cpu_c_f_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_un_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_eq_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ueq_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_olt_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ult_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ole_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ule_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_df_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ngle_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_deq_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ngl_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_lt_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_nge_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_le_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_c_ngt_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_cvt_s_w] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_cvt_d_w] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true },
[RABBITIZER_INSTR_ID_cpu_cvt_s_l] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true },
[RABBITIZER_INSTR_ID_cpu_cvt_d_l] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true },
[RABBITIZER_INSTR_ID_cpu_add_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_sub_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_mul_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_div_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_sqrt_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_abs_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_mov_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_neg_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_round_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_trunc_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_ceil_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_floor_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_round_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_trunc_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_ceil_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_floor_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_cvt_d_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_cvt_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_cvt_l_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_c_f_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_un_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_eq_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ueq_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_olt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ult_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ole_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ule_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_sf_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ngle_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_seq_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ngl_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_lt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_nge_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_le_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ngt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_add_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_sub_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_mul_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_div_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_sqrt_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_abs_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_mov_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_neg_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_round_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_trunc_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_ceil_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_floor_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_round_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_trunc_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_ceil_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_floor_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_cvt_s_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_cvt_w_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_cvt_l_d] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_c_f_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_un_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_eq_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ueq_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_olt_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ult_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ole_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ule_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_df_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ngle_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_deq_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ngl_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_lt_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_nge_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_le_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_c_ngt_d] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_cpu_cvt_s_w] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_cvt_d_w] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_cvt_s_l] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_cvt_d_l] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .instrType=RABBITIZER_INSTR_TYPE_UNKNOWN, .isFloat=true, .isDouble=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_cpu_USERDEF_00] = { .operands={0} },
[RABBITIZER_INSTR_ID_cpu_USERDEF_01] = { .operands={0} },
[RABBITIZER_INSTR_ID_cpu_USERDEF_02] = { .operands={0} },
@ -523,19 +523,19 @@ const RabbitizerInstrDescriptor RabbitizerInstrDescriptor_Descriptors[] = {
[RABBITIZER_INSTR_ID_r5900_ei] = { .operands={0} },
[RABBITIZER_INSTR_ID_r5900_di] = { .operands={0} },
[RABBITIZER_INSTR_ID_r5900_c1__sqrt_s] = { .operands={RAB_OPERAND_cpu_copraw} },
[RABBITIZER_INSTR_ID_r5900_rsqrt_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true },
[RABBITIZER_INSTR_ID_r5900_adda_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true },
[RABBITIZER_INSTR_ID_r5900_suba_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true },
[RABBITIZER_INSTR_ID_r5900_mula_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true },
[RABBITIZER_INSTR_ID_r5900_madd_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true },
[RABBITIZER_INSTR_ID_r5900_msub_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true },
[RABBITIZER_INSTR_ID_r5900_madda_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true },
[RABBITIZER_INSTR_ID_r5900_msuba_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true },
[RABBITIZER_INSTR_ID_r5900_max_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true },
[RABBITIZER_INSTR_ID_r5900_min_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true },
[RABBITIZER_INSTR_ID_r5900_trunc_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .isFloat=true },
[RABBITIZER_INSTR_ID_r5900_c_lt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true },
[RABBITIZER_INSTR_ID_r5900_c_le_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true },
[RABBITIZER_INSTR_ID_r5900_rsqrt_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_r5900_adda_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_r5900_suba_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_r5900_mula_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_r5900_madd_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_r5900_msub_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_r5900_madda_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_r5900_msuba_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_r5900_max_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_r5900_min_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .modifiesFd=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_r5900_trunc_w_s] = { .operands={RAB_OPERAND_cpu_fd, RAB_OPERAND_cpu_fs}, .isFloat=true, .modifiesFd=true, .readsFs=true },
[RABBITIZER_INSTR_ID_r5900_c_lt_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_r5900_c_le_s] = { .operands={RAB_OPERAND_cpu_fs, RAB_OPERAND_cpu_ft}, .isFloat=true, .readsFs=true, .readsFt=true },
[RABBITIZER_INSTR_ID_r5900_qmfc2] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vfs}, .modifiesRt=true },
[RABBITIZER_INSTR_ID_r5900_cfc2] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vis}, .modifiesRt=true },
[RABBITIZER_INSTR_ID_r5900_qmtc2] = { .operands={RAB_OPERAND_cpu_rt, RAB_OPERAND_r5900_vfs}, .readsRt=true },

26
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++) {
@ -525,6 +526,9 @@ bool RabbitizerInstrDescriptor_isUnsigned(const RabbitizerInstrDescriptor *self)
return self->isUnsigned;
}
bool RabbitizerInstrDescriptor_modifiesRs(const RabbitizerInstrDescriptor *self) {
return self->modifiesRs;
}
bool RabbitizerInstrDescriptor_modifiesRt(const RabbitizerInstrDescriptor *self) {
return self->modifiesRt;
}
@ -555,6 +559,26 @@ bool RabbitizerInstrDescriptor_modifiesLO(const RabbitizerInstrDescriptor *self)
return self->modifiesLO;
}
bool RabbitizerInstrDescriptor_modifiesFs(const RabbitizerInstrDescriptor *self) {
return self->modifiesFs;
}
bool RabbitizerInstrDescriptor_modifiesFt(const RabbitizerInstrDescriptor *self) {
return self->modifiesFt;
}
bool RabbitizerInstrDescriptor_modifiesFd(const RabbitizerInstrDescriptor *self) {
return self->modifiesFd;
}
bool RabbitizerInstrDescriptor_readsFs(const RabbitizerInstrDescriptor *self) {
return self->readsFs;
}
bool RabbitizerInstrDescriptor_readsFt(const RabbitizerInstrDescriptor *self) {
return self->readsFt;
}
bool RabbitizerInstrDescriptor_readsFd(const RabbitizerInstrDescriptor *self) {
return self->readsFd;
}
bool RabbitizerInstrDescriptor_notEmitedByCompilers(const RabbitizerInstrDescriptor *self) {
return self->notEmitedByCompilers;
}

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

18
tests/c/logic_checks/descriptor_logic_check.c
View File

@ -47,16 +47,30 @@ int main() {
LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, descriptor->isDouble, descriptor->isFloat);
// modifiesR* and readsR*
LOGIC_ERROR(uniqueId, errorCount, !(descriptor->modifiesRs && descriptor->readsRs));
LOGIC_ERROR(uniqueId, errorCount, !(descriptor->modifiesRt && descriptor->readsRt));
LOGIC_ERROR(uniqueId, errorCount, !(descriptor->modifiesRd && descriptor->readsRd));
LOGIC_ERROR(uniqueId, errorCount, !(descriptor->readsRs && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rs)));
LOGIC_ERROR(uniqueId, errorCount, !((descriptor->modifiesRs || descriptor->readsRs) && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rs)));
LOGIC_ERROR(uniqueId, errorCount, !((descriptor->modifiesRt || descriptor->readsRt) && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rt)));
LOGIC_ERROR(uniqueId, errorCount, !((descriptor->modifiesRd || descriptor->readsRd) && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rd)));
LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rs), descriptor->readsRs);
LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rs), (descriptor->readsRs || descriptor->modifiesRs));
LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rt), (descriptor->readsRt || descriptor->modifiesRt));
LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_rd), (descriptor->readsRd || descriptor->modifiesRd));
// float modifiesR* and readsR*
LOGIC_ERROR(uniqueId, errorCount, !(descriptor->modifiesFs && descriptor->readsFs));
LOGIC_ERROR(uniqueId, errorCount, !(descriptor->modifiesFt && descriptor->readsFt));
LOGIC_ERROR(uniqueId, errorCount, !(descriptor->modifiesFd && descriptor->readsFd));
LOGIC_ERROR(uniqueId, errorCount, !((descriptor->modifiesFs || descriptor->readsFs) && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_fs)));
LOGIC_ERROR(uniqueId, errorCount, !((descriptor->modifiesFt || descriptor->readsFt) && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_ft)));
LOGIC_ERROR(uniqueId, errorCount, !((descriptor->modifiesFd || descriptor->readsFd) && !RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_fd)));
LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_fs), (descriptor->readsFs || descriptor->modifiesFs));
LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_ft), (descriptor->readsFt || descriptor->modifiesFt));
LOGIC_ERROR_A_IMPLIES_B(uniqueId, errorCount, RabbitizerInstrDescriptor_hasOperandAlias(descriptor, RAB_OPERAND_cpu_fd), (descriptor->readsFd || descriptor->modifiesFd));
// An instruction should have at most canBeHi or canBeLo, not both
LOGIC_ERROR(uniqueId, errorCount, !(descriptor->canBeHi && descriptor->canBeLo));