From 3538f51086336db556776a1bfb141c59244195d6 Mon Sep 17 00:00:00 2001 From: Angie Date: Sun, 18 Dec 2022 20:29:22 -0300 Subject: [PATCH] yeet extra InstructionBase indirection --- Cargo.toml | 1 - rust/src/instruction.rs | 266 +++++++++++++++++----------------- rust/src/opereand_type.rs | 8 +- rust/src/registers_methods.rs | 2 + 4 files changed, 136 insertions(+), 141 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index b296cf2..2f42d96 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,7 +23,6 @@ path = "rust/src/lib.rs" [dependencies] cty = "0.2.2" -libc = "0.2.138" num_enum = "0.5.7" [build-dependencies] diff --git a/rust/src/instruction.rs b/rust/src/instruction.rs index 3d5d9c2..550f19e 100644 --- a/rust/src/instruction.rs +++ b/rust/src/instruction.rs @@ -4,9 +4,9 @@ use crate::{instr_id_enum, instr_category_enum, instr_descriptor, operand_type_enum, instr_suffix_enum, access_type_enum, registers_enum, utils}; #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Clone)] #[allow(non_camel_case_types)] -pub struct InstructionBase { +pub struct Instruction { word: u32, _mandatorybits: u32, pub unique_id: instr_id_enum::InstrId, @@ -17,83 +17,79 @@ pub struct InstructionBase { pub category: instr_category_enum::InstrCategory, } -pub struct Instruction { - pub instr: InstructionBase, -} - #[link(name = "rabbitizer", kind = "static")] extern "C" { fn RabbitizerInstrId_getOpcodeName(unique_id: instr_id_enum::InstrId) -> *const cty::c_char; } extern "C" { - fn RabbitizerInstruction_init(self_: *mut InstructionBase, word: u32, vram: u32); - fn RabbitizerInstruction_destroy(self_: *mut InstructionBase); + fn RabbitizerInstruction_init(self_: *mut Instruction, word: u32, vram: u32); + fn RabbitizerInstruction_destroy(self_: *mut Instruction); - fn RabbitizerInstruction_processUniqueId(self_: *mut InstructionBase); + fn RabbitizerInstruction_processUniqueId(self_: *mut Instruction); } extern "C" { - fn RabbitizerInstructionRsp_init(self_: *mut InstructionBase, word: u32, vram: u32); - fn RabbitizerInstructionRsp_destroy(self_: *mut InstructionBase); + fn RabbitizerInstructionRsp_init(self_: *mut Instruction, word: u32, vram: u32); + fn RabbitizerInstructionRsp_destroy(self_: *mut Instruction); - fn RabbitizerInstructionRsp_processUniqueId(self_: *mut InstructionBase); + fn RabbitizerInstructionRsp_processUniqueId(self_: *mut Instruction); } extern "C" { - fn RabbitizerInstructionR5900_init(self_: *mut InstructionBase, word: u32, vram: u32); - fn RabbitizerInstructionR5900_destroy(self_: *mut InstructionBase); + fn RabbitizerInstructionR5900_init(self_: *mut Instruction, word: u32, vram: u32); + fn RabbitizerInstructionR5900_destroy(self_: *mut Instruction); - fn RabbitizerInstructionR5900_processUniqueId(self_: *mut InstructionBase); + fn RabbitizerInstructionR5900_processUniqueId(self_: *mut Instruction); } extern "C" { - fn RabbitizerInstruction_getRaw(self_: *const InstructionBase) -> u32; - fn RabbitizerInstruction_getProcessedImmediate(self_: *const InstructionBase) -> i32; - fn RabbitizerInstruction_getInstrIndexAsVram(self_: *const InstructionBase) -> u32; - fn RabbitizerInstruction_getBranchOffset(self_: *const InstructionBase) -> i32; + fn RabbitizerInstruction_getRaw(self_: *const Instruction) -> u32; + fn RabbitizerInstruction_getProcessedImmediate(self_: *const Instruction) -> i32; + fn RabbitizerInstruction_getInstrIndexAsVram(self_: *const Instruction) -> u32; + fn RabbitizerInstruction_getBranchOffset(self_: *const Instruction) -> i32; - fn RabbitizerInstruction_getBranchOffsetGeneric(self_: *const InstructionBase) + fn RabbitizerInstruction_getBranchOffsetGeneric(self_: *const Instruction) -> i32; - fn RabbitizerInstruction_getBranchVramGeneric(self_: *const InstructionBase) -> i32; - fn RabbitizerInstruction_getDestinationGpr(self_: *const InstructionBase) -> i8; - fn RabbitizerInstruction_blankOut(self_: *mut InstructionBase); - fn RabbitizerInstruction_isImplemented(self_: *const InstructionBase) -> bool; - fn RabbitizerInstruction_isLikelyHandwritten(self_: *const InstructionBase) -> bool; - fn RabbitizerInstruction_isNop(self_: *const InstructionBase) -> bool; - fn RabbitizerInstruction_isUnconditionalBranch(self_: *const InstructionBase) + fn RabbitizerInstruction_getBranchVramGeneric(self_: *const Instruction) -> i32; + fn RabbitizerInstruction_getDestinationGpr(self_: *const Instruction) -> i8; + fn RabbitizerInstruction_blankOut(self_: *mut Instruction); + fn RabbitizerInstruction_isImplemented(self_: *const Instruction) -> bool; + fn RabbitizerInstruction_isLikelyHandwritten(self_: *const Instruction) -> bool; + fn RabbitizerInstruction_isNop(self_: *const Instruction) -> bool; + fn RabbitizerInstruction_isUnconditionalBranch(self_: *const Instruction) -> bool; - fn RabbitizerInstruction_isReturn(self_: *const InstructionBase) -> bool; - fn RabbitizerInstruction_isJumptableJump(self_: *const InstructionBase) -> bool; + fn RabbitizerInstruction_isReturn(self_: *const Instruction) -> bool; + fn RabbitizerInstruction_isJumptableJump(self_: *const Instruction) -> bool; - fn RabbitizerInstruction_hasDelaySlot(self_: *const InstructionBase) -> bool; + fn RabbitizerInstruction_hasDelaySlot(self_: *const Instruction) -> bool; fn RabbitizerInstruction_sameOpcode( - self_: *const InstructionBase, - other: *const InstructionBase, + self_: *const Instruction, + other: *const Instruction, ) -> bool; fn RabbitizerInstruction_sameOpcodeButDifferentArguments( - self_: *const InstructionBase, - other: *const InstructionBase, + self_: *const Instruction, + other: *const Instruction, ) -> bool; fn RabbitizerInstruction_hasOperand( - self_: *const InstructionBase, + self_: *const Instruction, operand: operand_type_enum::OperandType, ) -> bool; fn RabbitizerInstruction_hasOperandAlias( - self_: *const InstructionBase, + self_: *const Instruction, operand: operand_type_enum::OperandType, ) -> bool; - fn RabbitizerInstruction_isValid(self_: *const InstructionBase) -> bool; + fn RabbitizerInstruction_isValid(self_: *const Instruction) -> bool; fn RabbitizerInstruction_getSizeForBuffer( - self_: *const InstructionBase, + self_: *const Instruction, immOverrideLength: utils::SizeT, extraLJust: cty::c_int, ) -> utils::SizeT; fn RabbitizerInstruction_disassemble( - self_: *const InstructionBase, + self_: *const Instruction, dst: *mut cty::c_char, immOverride: *const cty::c_char, immOverrideLength: utils::SizeT, @@ -152,15 +148,15 @@ extern "C" { impl Drop for Instruction { fn drop(&mut self) { unsafe { - match self.instr.category { + match self.category { instr_category_enum::InstrCategory::CPU => { - RabbitizerInstruction_destroy(&mut self.instr); + RabbitizerInstruction_destroy(self); } instr_category_enum::InstrCategory::RSP => { - RabbitizerInstructionRsp_destroy(&mut self.instr); + RabbitizerInstructionRsp_destroy(self); } instr_category_enum::InstrCategory::R5900 => { - RabbitizerInstructionR5900_destroy(&mut self.instr); + RabbitizerInstructionR5900_destroy(self); } instr_category_enum::InstrCategory::MAX => { core::panic!(); @@ -172,34 +168,32 @@ impl Drop for Instruction { impl Instruction { pub fn new(word: u32, vram: u32, instr_cat: instr_category_enum::InstrCategory) -> Self { - Self { - instr: unsafe { - let mut instr: std::mem::MaybeUninit = std::mem::MaybeUninit::uninit(); - match instr_cat { - instr_category_enum::InstrCategory::CPU => { - RabbitizerInstruction_init(instr.as_mut_ptr(), word, vram); - RabbitizerInstruction_processUniqueId(instr.as_mut_ptr()); - } - instr_category_enum::InstrCategory::RSP => { - RabbitizerInstructionRsp_init(instr.as_mut_ptr(), word, vram); - RabbitizerInstructionRsp_processUniqueId(instr.as_mut_ptr()); - } - instr_category_enum::InstrCategory::R5900 => { - RabbitizerInstructionR5900_init(instr.as_mut_ptr(), word, vram); - RabbitizerInstructionR5900_processUniqueId(instr.as_mut_ptr()); - } - instr_category_enum::InstrCategory::MAX => { - core::panic!(); - } - // _ => not used because in purpose + unsafe { + let mut instr: std::mem::MaybeUninit = std::mem::MaybeUninit::uninit(); + match instr_cat { + instr_category_enum::InstrCategory::CPU => { + RabbitizerInstruction_init(instr.as_mut_ptr(), word, vram); + RabbitizerInstruction_processUniqueId(instr.as_mut_ptr()); } - instr.assume_init() + instr_category_enum::InstrCategory::RSP => { + RabbitizerInstructionRsp_init(instr.as_mut_ptr(), word, vram); + RabbitizerInstructionRsp_processUniqueId(instr.as_mut_ptr()); + } + instr_category_enum::InstrCategory::R5900 => { + RabbitizerInstructionR5900_init(instr.as_mut_ptr(), word, vram); + RabbitizerInstructionR5900_processUniqueId(instr.as_mut_ptr()); + } + instr_category_enum::InstrCategory::MAX => { + core::panic!(); + } + // _ => not used in purpose } + instr.assume_init() } } pub fn get_opcode(&self) -> u32 { - utils::shiftr(self.instr.word, 26, 6) + utils::shiftr(self.word, 26, 6) } pub fn get_rs(&self) -> u32 { @@ -207,7 +201,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 21, 5) + utils::shiftr(self.word, 21, 5) } pub fn get_rs_o32(&self) -> registers_enum::registers::GprO32 { @@ -223,7 +217,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 16, 5) + utils::shiftr(self.word, 16, 5) } pub fn get_rt_o32(&self) -> registers_enum::registers::GprO32 { @@ -239,7 +233,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 11, 5) + utils::shiftr(self.word, 11, 5) } pub fn get_rd_o32(&self) -> registers_enum::registers::GprO32 { @@ -255,7 +249,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 6, 5) + utils::shiftr(self.word, 6, 5) } pub fn get_function(&self) -> u32 { @@ -263,7 +257,7 @@ impl Instruction { // core::panic!(); //} - utils::shiftr(self.instr.word, 0, 6) + utils::shiftr(self.word, 0, 6) } pub fn get_cop0d(&self) -> u32 { @@ -271,7 +265,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 11, 5) + utils::shiftr(self.word, 11, 5) } pub fn get_cop0d_cop0(&self) -> registers_enum::registers::Cop0 { @@ -279,7 +273,7 @@ impl Instruction { } pub fn get_instr_index(&self) -> u32 { - utils::shiftr(self.instr.word, 0, 26) + utils::shiftr(self.word, 0, 26) } pub fn get_immediate(&self) -> u16 { @@ -287,7 +281,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 0, 16).try_into().unwrap() + utils::shiftr(self.word, 0, 16).try_into().unwrap() } pub fn get_code(&self) -> u32 { @@ -295,7 +289,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 6, 20) + utils::shiftr(self.word, 6, 20) } pub fn get_code_upper(&self) -> u32 { @@ -303,7 +297,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 16, 10) + utils::shiftr(self.word, 16, 10) } pub fn get_code_lower(&self) -> u32 { @@ -311,7 +305,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 6, 10) + utils::shiftr(self.word, 6, 10) } pub fn get_copraw(&self) -> u32 { @@ -319,7 +313,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 0, 25) + utils::shiftr(self.word, 0, 25) } @@ -328,7 +322,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 11, 5) + utils::shiftr(self.word, 11, 5) } pub fn get_fs_o32(&self) -> registers_enum::registers::Cop1O32 { @@ -348,7 +342,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 16, 5) + utils::shiftr(self.word, 16, 5) } pub fn get_ft_o32(&self) -> registers_enum::registers::Cop1O32 { @@ -368,7 +362,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 6, 5) + utils::shiftr(self.word, 6, 5) } pub fn get_fd_o32(&self) -> registers_enum::registers::Cop1O32 { @@ -388,7 +382,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 11, 5) + utils::shiftr(self.word, 11, 5) } pub fn get_cop1cs_cop1control(&self) -> registers_enum::registers::Cop1Control { @@ -400,7 +394,7 @@ impl Instruction { core::panic!(); } - utils::shiftr(self.instr.word, 16, 5) + utils::shiftr(self.word, 16, 5) } pub fn get_cop2t_cop2(&self) -> registers_enum::registers::Cop2 { @@ -409,274 +403,274 @@ impl Instruction { pub fn raw(&self) -> u32 { unsafe { - RabbitizerInstruction_getRaw(&self.instr) + RabbitizerInstruction_getRaw(self) } } pub fn processed_immediate(&self) -> i32 { unsafe { - RabbitizerInstruction_getProcessedImmediate(&self.instr) + RabbitizerInstruction_getProcessedImmediate(self) } } pub fn instr_index_as_vram(&self) -> u32 { unsafe { - RabbitizerInstruction_getInstrIndexAsVram(&self.instr) + RabbitizerInstruction_getInstrIndexAsVram(self) } } pub fn branch_offset(&self) -> i32 { unsafe { - RabbitizerInstruction_getBranchOffset(&self.instr) + RabbitizerInstruction_getBranchOffset(self) } } pub fn branch_offset_generic(&self) -> i32 { unsafe { - RabbitizerInstruction_getBranchOffsetGeneric(&self.instr) + RabbitizerInstruction_getBranchOffsetGeneric(self) } } pub fn branch_vram_generic(&self) -> i32 { unsafe { - RabbitizerInstruction_getBranchVramGeneric(&self.instr) + RabbitizerInstruction_getBranchVramGeneric(self) } } pub fn destination_gpr(&self) -> i8 { unsafe { - RabbitizerInstruction_getDestinationGpr(&self.instr) + RabbitizerInstruction_getDestinationGpr(self) } } pub fn opcode_name(&self) -> &'static str { unsafe { - std::ffi::CStr::from_ptr(RabbitizerInstrId_getOpcodeName(self.instr.unique_id)).to_str().unwrap() + std::ffi::CStr::from_ptr(RabbitizerInstrId_getOpcodeName(self.unique_id)).to_str().unwrap() } } pub fn blank_out(mut self) { unsafe { - RabbitizerInstruction_blankOut(&mut self.instr) + RabbitizerInstruction_blankOut(&mut self) } } pub fn is_implemented(&self) -> bool { unsafe { - RabbitizerInstruction_isImplemented(&self.instr) + RabbitizerInstruction_isImplemented(self) } } pub fn is_likely_handwritten(&self) -> bool { unsafe { - RabbitizerInstruction_isLikelyHandwritten(&self.instr) + RabbitizerInstruction_isLikelyHandwritten(self) } } pub fn is_nop(&self) -> bool { unsafe { - RabbitizerInstruction_isNop(&self.instr) + RabbitizerInstruction_isNop(self) } } pub fn is_unconditional_branch(&self) -> bool { unsafe { - RabbitizerInstruction_isUnconditionalBranch(&self.instr) + RabbitizerInstruction_isUnconditionalBranch(self) } } pub fn is_return(&self) -> bool { unsafe { - RabbitizerInstruction_isReturn(&self.instr) + RabbitizerInstruction_isReturn(self) } } pub fn is_jumptable_jump(&self) -> bool { unsafe { - RabbitizerInstruction_isJumptableJump(&self.instr) + RabbitizerInstruction_isJumptableJump(self) } } pub fn has_delay_slot(&self) -> bool { unsafe { - RabbitizerInstruction_hasDelaySlot(&self.instr) + RabbitizerInstruction_hasDelaySlot(self) } } pub fn same_opcode(&self, other: &Instruction) -> bool { unsafe { - RabbitizerInstruction_sameOpcode(&self.instr, &other.instr) + RabbitizerInstruction_sameOpcode(self, other) } } pub fn same_opcode_but_different_arguments(&self, other: &Instruction) -> bool { unsafe { - RabbitizerInstruction_sameOpcodeButDifferentArguments(&self.instr, &other.instr) + RabbitizerInstruction_sameOpcodeButDifferentArguments(self, other) } } pub fn has_operand(&self, operand: operand_type_enum::OperandType) -> bool { unsafe { - RabbitizerInstruction_hasOperand(&self.instr, operand) + RabbitizerInstruction_hasOperand(self, operand) } } pub fn has_operand_alias(&self, operand: operand_type_enum::OperandType) -> bool { unsafe { - RabbitizerInstruction_hasOperandAlias(&self.instr, operand) + RabbitizerInstruction_hasOperandAlias(self, operand) } } pub fn is_valid(&self) -> bool { unsafe { - RabbitizerInstruction_isValid(&self.instr) + RabbitizerInstruction_isValid(self) } } pub fn get_operand_type(&self, index: usize) -> operand_type_enum::OperandType { unsafe { - self.instr.descriptor.as_ref().unwrap().get_operand_type(index) + self.descriptor.as_ref().unwrap().get_operand_type(index) } } pub fn get_operands_slice(&self) -> &[operand_type_enum::OperandType] { unsafe { - self.instr.descriptor.as_ref().unwrap().operands_slice() + self.descriptor.as_ref().unwrap().operands_slice() } } pub fn instr_suffix(&self) -> instr_suffix_enum::InstrSuffix { unsafe { - RabbitizerInstrDescriptor_instrSuffix(self.instr.descriptor) + RabbitizerInstrDescriptor_instrSuffix(self.descriptor) } } pub fn is_branch(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_isBranch(self.instr.descriptor) + RabbitizerInstrDescriptor_isBranch(self.descriptor) } } pub fn is_branch_likely(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_isBranchLikely(self.instr.descriptor) + RabbitizerInstrDescriptor_isBranchLikely(self.descriptor) } } pub fn is_jump(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_isJump(self.instr.descriptor) + RabbitizerInstrDescriptor_isJump(self.descriptor) } } pub fn is_jump_with_address(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_isJumpWithAddress(self.instr.descriptor) + RabbitizerInstrDescriptor_isJumpWithAddress(self.descriptor) } } pub fn is_trap(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_isTrap(self.instr.descriptor) + RabbitizerInstrDescriptor_isTrap(self.descriptor) } } pub fn is_float(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_isFloat(self.instr.descriptor) + RabbitizerInstrDescriptor_isFloat(self.descriptor) } } pub fn is_double(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_isDouble(self.instr.descriptor) + RabbitizerInstrDescriptor_isDouble(self.descriptor) } } pub fn is_unsigned(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_isUnsigned(self.instr.descriptor) + RabbitizerInstrDescriptor_isUnsigned(self.descriptor) } } pub fn modifies_rt(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_modifiesRt(self.instr.descriptor) + RabbitizerInstrDescriptor_modifiesRt(self.descriptor) } } pub fn modifies_rd(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_modifiesRd(self.instr.descriptor) + RabbitizerInstrDescriptor_modifiesRd(self.descriptor) } } pub fn reads_rs(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_readsRs(self.instr.descriptor) + RabbitizerInstrDescriptor_readsRs(self.descriptor) } } pub fn reads_rt(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_readsRt(self.instr.descriptor) + RabbitizerInstrDescriptor_readsRt(self.descriptor) } } pub fn reads_rd(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_readsRd(self.instr.descriptor) + RabbitizerInstrDescriptor_readsRd(self.descriptor) } } pub fn reads_hi(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_readsHI(self.instr.descriptor) + RabbitizerInstrDescriptor_readsHI(self.descriptor) } } pub fn reads_lo(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_readsLO(self.instr.descriptor) + RabbitizerInstrDescriptor_readsLO(self.descriptor) } } pub fn modifies_hi(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_modifiesHI(self.instr.descriptor) + RabbitizerInstrDescriptor_modifiesHI(self.descriptor) } } pub fn modifies_lo(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_modifiesLO(self.instr.descriptor) + RabbitizerInstrDescriptor_modifiesLO(self.descriptor) } } pub fn not_emited_by_compilers(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_notEmitedByCompilers(self.instr.descriptor) + RabbitizerInstrDescriptor_notEmitedByCompilers(self.descriptor) } } pub fn can_be_hi(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_canBeHi(self.instr.descriptor) + RabbitizerInstrDescriptor_canBeHi(self.descriptor) } } pub fn can_be_lo(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_canBeLo(self.instr.descriptor) + RabbitizerInstrDescriptor_canBeLo(self.descriptor) } } pub fn does_link(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_doesLink(self.instr.descriptor) + RabbitizerInstrDescriptor_doesLink(self.descriptor) } } pub fn does_dereference(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_doesDereference(self.instr.descriptor) + RabbitizerInstrDescriptor_doesDereference(self.descriptor) } } pub fn does_load(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_doesLoad(self.instr.descriptor) + RabbitizerInstrDescriptor_doesLoad(self.descriptor) } } pub fn does_store(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_doesStore(self.instr.descriptor) + RabbitizerInstrDescriptor_doesStore(self.descriptor) } } pub fn maybe_is_move(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_maybeIsMove(self.instr.descriptor) + RabbitizerInstrDescriptor_maybeIsMove(self.descriptor) } } pub fn is_pseudo(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_isPseudo(self.instr.descriptor) + RabbitizerInstrDescriptor_isPseudo(self.descriptor) } } pub fn access_type(&self) -> access_type_enum::AccessType { unsafe { - RabbitizerInstrDescriptor_getAccessType(self.instr.descriptor) + RabbitizerInstrDescriptor_getAccessType(self.descriptor) } } pub fn does_unsigned_memory_access(&self) -> bool { unsafe { - RabbitizerInstrDescriptor_doesUnsignedMemoryAccess(self.instr.descriptor) + RabbitizerInstrDescriptor_doesUnsignedMemoryAccess(self.descriptor) } } @@ -684,11 +678,11 @@ impl Instruction { let (imm_override_ptr, imm_override_len) = utils::c_string_from_str(imm_override); unsafe { - let buffer_size = RabbitizerInstruction_getSizeForBuffer(& self.instr, imm_override_len, extra_l_just.try_into().unwrap()); + let buffer_size = RabbitizerInstruction_getSizeForBuffer(self, imm_override_len, extra_l_just.try_into().unwrap()); let mut buffer: Vec = vec![0; buffer_size.try_into().unwrap()]; let disassembled_size = RabbitizerInstruction_disassemble( - &self.instr, + self, buffer.as_mut_ptr() as *mut cty::c_char, imm_override_ptr, imm_override_len, diff --git a/rust/src/opereand_type.rs b/rust/src/opereand_type.rs index 8e1b045..c570f12 100644 --- a/rust/src/opereand_type.rs +++ b/rust/src/opereand_type.rs @@ -6,13 +6,13 @@ use crate::{operand_type_enum, instruction, utils}; extern "C" { fn RabbitizerOperandType_getBufferSize( operand: operand_type_enum::OperandType, - instr: *const instruction::InstructionBase, + instr: *const instruction::Instruction, immOverrideLength: utils::SizeT, ) -> utils::SizeT; fn RabbitizerOperandType_disassemble( operand: operand_type_enum::OperandType, - instr: *const instruction::InstructionBase, + instr: *const instruction::Instruction, dst: *mut cty::c_char, immOverride: *const cty::c_char, immOverrideLength: utils::SizeT, @@ -24,12 +24,12 @@ impl operand_type_enum::OperandType { let (imm_override_ptr, imm_override_len) = utils::c_string_from_str(imm_override); unsafe { - let buffer_size = RabbitizerOperandType_getBufferSize(*self, &instr.instr, imm_override_len); + let buffer_size = RabbitizerOperandType_getBufferSize(*self, &instr, imm_override_len); let mut buffer: Vec = vec![0; buffer_size.try_into().unwrap()]; let disassembled_size = RabbitizerOperandType_disassemble( *self, - &instr.instr, + &instr, buffer.as_mut_ptr() as *mut cty::c_char, imm_override_ptr, imm_override_len, diff --git a/rust/src/registers_methods.rs b/rust/src/registers_methods.rs index 5910ec1..78a845c 100644 --- a/rust/src/registers_methods.rs +++ b/rust/src/registers_methods.rs @@ -20,6 +20,7 @@ extern "C" { pub static mut RabbitizerRegister_R5900VF_Names: [[*const cty::c_char; 2usize]; 0usize]; pub static mut RabbitizerRegister_R5900VI_Names: [[*const cty::c_char; 2usize]; 0usize]; + /* pub fn RabbitizerRegister_getNameGpr(reg_value: u8) -> *const cty::c_char; pub fn RabbitizerRegister_getNameCop0(reg_value: u8) -> *const cty::c_char; pub fn RabbitizerRegister_getNameCop1(reg_value: u8) -> *const cty::c_char; @@ -34,6 +35,7 @@ extern "C" { pub fn RabbitizerRegister_getNameR5900VF(reg_value: u8) -> *const cty::c_char; pub fn RabbitizerRegister_getNameR5900VI(reg_value: u8) -> *const cty::c_char; + */ } impl registers_enum::registers::GprO32 {