Skip to content

Ghidrust provides a hyper fast, AI native reverse engineering platform built in Rust, inspired by Ghidra. Includes experimental GPU kernels to rapidly decompile large files, a decryption suite, and network monitor for packet to binary reverse engineering.

5.2 KB
Raw Blame
use super::regs::gpr;
use super::util::{bit, fmt_imm, read_u32, sign_extend16};
use crate::error::{Error, Result};
use crate::insn::Instruction;

pub fn decode(bytes: &[u8], address: u64, big_endian: bool, ppc64: bool) -> Result<Instruction> {
    let w = read_u32(bytes, big_endian)?;
    let raw = bytes[..4].to_vec();
    let primary = bit(w, 26, 31);
    match primary {
        0b001110 => decode_addi(w, address, raw),
        0b100000 => decode_lwz(w, address, raw),
        0b100100 => decode_stw(w, address, raw),
        0b100010 => decode_lbzu(w, address, raw, "lbz"),
        0b100110 => decode_lbzu(w, address, raw, "stb"),
        0b010010 => decode_b(w, address, raw),
        0b010000 => decode_bc(w, address, raw),
        0b011111 => decode_xform(w, address, raw, ppc64),
        _ => Err(Error::Decode(format!(
            "unhandled PPC primary {primary:#04x}"
        ))),
    }
}

fn decode_addi(w: u32, address: u64, raw: Vec<u8>) -> Result<Instruction> {
    let rt = bit(w, 16, 20);
    let ra = bit(w, 21, 25);
    let imm = sign_extend16(w & 0xffff);
    let mnemonic = if ra == 0 { "li" } else { "addi" };
    let operands = if ra == 0 {
        format!("{}, {:#x}", gpr(rt), imm as u16)
    } else {
        format!("{}, {}, {:#x}", gpr(rt), gpr(ra), imm as u16)
    };
    Ok(Instruction::with_text(address, raw, mnemonic, operands, 4))
}

fn decode_lwz(w: u32, address: u64, raw: Vec<u8>) -> Result<Instruction> {
    let rt = bit(w, 16, 20);
    let ra = bit(w, 21, 25);
    let imm = sign_extend16(w & 0xffff);
    Ok(Instruction::with_text(
        address,
        raw,
        "lwz",
        format!("{}, {:#x}({})", gpr(rt), imm, gpr(ra)),
        4,
    ))
}

fn decode_stw(w: u32, address: u64, raw: Vec<u8>) -> Result<Instruction> {
    let rs = bit(w, 16, 20);
    let ra = bit(w, 21, 25);
    let imm = sign_extend16(w & 0xffff);
    Ok(Instruction::with_text(
        address,
        raw,
        "stw",
        format!("{}, {:#x}({})", gpr(rs), imm, gpr(ra)),
        4,
    ))
}

fn decode_lbzu(w: u32, address: u64, raw: Vec<u8>, mnemonic: &str) -> Result<Instruction> {
    let rt = bit(w, 16, 20);
    let ra = bit(w, 21, 25);
    let imm = sign_extend16(w & 0xffff);
    Ok(Instruction::with_text(
        address,
        raw,
        mnemonic,
        format!("{}, {:#x}({})", gpr(rt), imm, gpr(ra)),
        4,
    ))
}

fn decode_b(w: u32, address: u64, raw: Vec<u8>) -> Result<Instruction> {
    let link = bit(w, 0, 0) != 0;
    let li = bit(w, 2, 25);
    let aa = bit(w, 1, 1);
    let offset = sign_extend16(li << 2) as i64;
    let target = if aa != 0 {
        offset as u64
    } else {
        (address as i64).wrapping_add(offset) as u64
    };
    let mnemonic = if link { "bl" } else { "b" };
    Ok(Instruction::with_text(
        address,
        raw,
        mnemonic,
        fmt_imm(target as i32),
        4,
    ))
}

fn decode_bc(w: u32, address: u64, raw: Vec<u8>) -> Result<Instruction> {
    let bo = bit(w, 21, 25);
    let bi = bit(w, 16, 20);
    let bd = sign_extend16(bit(w, 2, 15) << 2) as i64;
    let target = (address as i64).wrapping_add(bd) as u64;
    let link = bit(w, 0, 0) != 0;
    let mnemonic = if link { "bcl" } else { "bc" };
    Ok(Instruction::with_text(
        address,
        raw,
        mnemonic,
        format!("{bo}, {bi}, {}", fmt_imm(target as i32)),
        4,
    ))
}

fn decode_trap(w: u32, address: u64, raw: Vec<u8>) -> Result<Instruction> {
    let to = bit(w, 21, 25);
    if to == 0 {
        Ok(Instruction::with_text(address, raw, "tw", "", 4))
    } else {
        Ok(Instruction::with_text(
            address,
            raw,
            "trap",
            format!("#{to}"),
            4,
        ))
    }
}

fn decode_xform(w: u32, address: u64, raw: Vec<u8>, ppc64: bool) -> Result<Instruction> {
    let xo = bit(w, 1, 10);
    let rs = bit(w, 11, 15);
    let ra = bit(w, 16, 20);
    let rb = bit(w, 21, 25);
    let (mnemonic, operands) = match xo {
        0b000000 => ("mcrxr", format!("cr{}", rs)),
        0b000010 => ("add", format!("{}, {}, {}", gpr(rs), gpr(ra), gpr(rb))),
        0b000100 => ("subf", format!("{}, {}, {}", gpr(rs), gpr(ra), gpr(rb))),
        0b001010 => ("addc", format!("{}, {}, {}", gpr(rs), gpr(ra), gpr(rb))),
        0b001100 => ("subfc", format!("{}, {}, {}", gpr(rs), gpr(ra), gpr(rb))),
        0b010101 => ("dcbst", format!("{}, {}", gpr(ra), gpr(rb))),
        0b011011 => ("xor", format!("{}, {}, {}", gpr(rs), gpr(ra), gpr(rb))),
        0b011111 => ("nand", format!("{}, {}, {}", gpr(rs), gpr(ra), gpr(rb))),
        0b100001 => ("mullw", format!("{}, {}, {}", gpr(rs), gpr(ra), gpr(rb))),
        0b101010 => ("divw", format!("{}, {}, {}", gpr(rs), gpr(ra), gpr(rb))),
        0b110011 => ("or", format!("{}, {}, {}", gpr(rs), gpr(ra), gpr(rb))),
        0b110101 => ("nor", format!("{}, {}, {}", gpr(rs), gpr(ra), gpr(rb))),
        0b111000 => ("and", format!("{}, {}, {}", gpr(rs), gpr(ra), gpr(rb))),
        0b000011 => ("bclr", format!("20, {}, {}", "lr", bit(w, 16, 20))),
        0b001000 => ("bctr", format!("20, {}, {}", "ctr", bit(w, 16, 20))),
        0b010011 if ppc64 => ("ld", format!("{}, 0({})", gpr(rs), gpr(ra))),
        _ => return Err(Error::Decode(format!("unhandled PPC xform {xo:#04x}"))),
    };
    Ok(Instruction::with_text(address, raw, mnemonic, operands, 4))
}