Start using rabbitizer crate

Author: AngheloAlf

Cargo.lock

@@ -32,7 +32,7 @@ notify = "5.0.0"
 object = { version = "0.30.0", features = ["read_core", "std", "elf"], default-features = false }
 png = "0.17.7"
 ppc750cl = { git = "https://github.com/encounter/ppc750cl", rev = "aa631a33de7882c679afca89350898b87cb3ba3f" }
-rabbitizer = { git = "https://github.com/encounter/rabbitizer-rs", rev = "10c279b2ef251c62885b1dcdcfe740b0db8e9956" }
+rabbitizer = "1.5.6"
 reqwest = "0.11.13"
 rfd = { version = "0.10.0" } # , default-features = false, features = ['xdg-portal']
 self_update = "0.32.0"

Cargo.toml

@@ -1,15 +1,21 @@
 use anyhow::Result;
-use rabbitizer::{config_set_register_fpr_abi_names, Abi, Instruction, SimpleOperandType};
+use rabbitizer::{config, Abi, Instruction, InstrCategory, OperandType};
 
 use crate::obj::{ObjIns, ObjInsArg, ObjReloc};
 
+fn configure_rabbitizer() {
+    unsafe {
+        config::RabbitizerConfig_Cfg.reg_names.fpr_abi_names = Abi::O32;
+    }
+}
+
 pub fn process_code(
     data: &[u8],
     start_address: u64,
     end_address: u64,
     relocs: &[ObjReloc],
 ) -> Result<(Vec<u8>, Vec<ObjIns>)> {
-    config_set_register_fpr_abi_names(Abi::RABBITIZER_ABI_O32);
+    configure_rabbitizer();
 
     let ins_count = data.len() / 4;
     let mut ops = Vec::<u8>::with_capacity(ins_count);
@@ -18,21 +24,21 @@ pub fn process_code(
     for chunk in data.chunks_exact(4) {
         let reloc = relocs.iter().find(|r| (r.address as u32 & !3) == cur_addr);
         let code = u32::from_be_bytes(chunk.try_into()?);
-        let mut instruction = Instruction::new(code, cur_addr);
+        let mut instruction = Instruction::new(code, cur_addr, InstrCategory::CPU);
 
-        let op = instruction.instr_id() as u8;
+        let op = instruction.unique_id as u8;
         ops.push(op);
 
-        let mnemonic = instruction.instr_id().get_opcode_name().unwrap_or_default().to_string();
+        let mnemonic = instruction.opcode_name().to_string();
         let is_branch = instruction.is_branch();
         let branch_offset = instruction.branch_offset();
         let branch_dest =
             if is_branch { Some((cur_addr as i32 + branch_offset) as u32) } else { None };
         let args = instruction
-            .simple_operands()
+            .get_operands_slice()
             .iter()
-            .map(|op| match op.kind {
-                SimpleOperandType::Imm | SimpleOperandType::Label => {
+            .map(|op| match op {
+                OperandType::cpu_immediate | OperandType::cpu_label => {
                     if is_branch {
                         ObjInsArg::BranchOffset(branch_offset)
                     } else if let Some(reloc) = reloc {
@@ -46,17 +52,17 @@ pub fn process_code(
                             ObjInsArg::Reloc
                         }
                     } else {
-                        ObjInsArg::MipsArg(op.disassembled.clone())
+                        ObjInsArg::MipsArg(op.disassemble(instruction, None))
                     }
                 }
-                SimpleOperandType::ImmBase => {
+                OperandType::cpu_immediate_base => {
                     if reloc.is_some() {
                         ObjInsArg::RelocWithBase
                     } else {
-                        ObjInsArg::MipsArg(op.disassembled.clone())
+                        ObjInsArg::MipsArg(op.disassemble(instruction, None))
                     }
                 }
-                _ => ObjInsArg::MipsArg(op.disassembled.clone()),
+                _ => ObjInsArg::MipsArg(op.disassemble(instruction, None)),
             })
             .collect();
         insts.push(ObjIns {