diff options
Diffstat (limited to 'src/instruction/decode_arm.rs')
| -rw-r--r-- | src/instruction/decode_arm.rs | 201 |
1 files changed, 201 insertions, 0 deletions
diff --git a/src/instruction/decode_arm.rs b/src/instruction/decode_arm.rs new file mode 100644 index 0000000..9efe859 --- /dev/null +++ b/src/instruction/decode_arm.rs @@ -0,0 +1,201 @@ +/* + Copyright 2021-2023 Gabriel Jensen. + + This file is part of Luma. + + Luma is free software: you can redistribute it + and/or modify it under the terms of the GNU + Affero General Public License as published by + the Free Software Foundation, either version 3 + of the License, or (at your option) any later + version. + + Luma is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Affero General Public License for more details. + + You should have received a copy of the GNU + Affero General Public License along with Luma. + If not, see <https://www.gnu.org/licenses/>. +*/ + +use crate::instruction::Instruction; +use crate::predicate::Predicate; +use crate::shifter::Shifter; + +use std::hint::unreachable_unchecked; + +impl Instruction { + #[must_use] + pub fn decode_arm(opcode: u32) -> (Self, Predicate) { + use Instruction::*; + use Predicate::*; + + let predicate = (opcode & 0b11110000000000000000000000000000).wrapping_shr(0x1C) as u8; + let predicate = Predicate::from_raw(predicate); + + return match (opcode & 0b00001110000000000000000000000000).wrapping_shr(0x19) { + 0b000 => { + match (opcode & 0b00000000000000000000000000010000).wrapping_shr(0x4) { + 0b0 => { + let rd = (opcode & 0b00000000000000001111000000000000).wrapping_shr(0xC) as u8; + let rn = (opcode & 0b00000000000011110000000000000000).wrapping_shr(0x10) as u8; + let s = opcode & 0b00000000000100000000000000000000 != 0x0; + + let shifter = Shifter::extract(opcode); + + match (opcode & 0b00000001111000000000000000000000).wrapping_shr(0x15) { + 0b0000 => (And(rd, rn, shifter, s), predicate), + 0b0001 => (Eor(rd, rn, shifter, s), predicate), + 0b0010 => (Sub(rd, rn, shifter,s), predicate), + 0b0011 => (Rsb(rd, rn, shifter, s), predicate), + 0b0100 => (Add(rd, rn, shifter, s), predicate), + 0b0101 => (Adc(rd, rn, shifter, s), predicate), + 0b0110 => (Sbc(rd, rn, shifter, s), predicate), + 0b0111 => (Rsc(rd, rn, shifter, s), predicate), + 0b1000 => (Tst(rd, shifter), predicate), + 0b1001 => (Teq(rd, shifter), predicate), + 0b1010 => (Cmp(rd, shifter), predicate), + 0b1011 => (Cmn(rd, shifter), predicate), + 0b1100 => (Orr(rd, rn, shifter, s), predicate), + 0b1101 => (Mov(rd, shifter, s), predicate), + 0b1110 => (Bic(rd, rn, shifter, s), predicate), + 0b1111 => (Mvn(rd, shifter, s), predicate), + + _ => unsafe { unreachable_unchecked() }, + } + }, + + 0b1 => { + match (opcode & 0b00000000000000000000000010000000).wrapping_shr(0x7) { + 0b0 => { + match opcode & 0b00000001100100000000000000000000 { + 0b00000001000000000000000000000000 => { + let rm = (opcode & 0b00000000000000000000000000001111) as u8; + + match (opcode & 0b00000000011000000000000000000000).wrapping_shr(0x13) | (opcode & 0b00000000000000000000000001100000).wrapping_shr(0x5) { + 0b0000 => (Undefined, Al), + 0b0001 => (Undefined, Al), + 0b0010 => (Undefined, Al), + 0b0011 => (Undefined, Al), + 0b0100 => (Bx(rm), predicate), + 0b0101 => (Undefined, Al), + 0b0110 => (Undefined, Al), + 0b0111 => (Undefined, Al), + 0b1000 => (Undefined, Al), + 0b1001 => (Undefined, Al), + 0b1010 => (Undefined, Al), + 0b1011 => (Undefined, Al), + 0b1100 => (Undefined, Al), + 0b1101 => (Undefined, Al), + 0b1110 => (Undefined, Al), + 0b1111 => (Undefined, Al), + + _ => unsafe { unreachable_unchecked() }, + } + }, + + _ => (Undefined, Al), + } + }, + + 0b1 => (Undefined, Al), + + _ => unsafe { unreachable_unchecked() }, + } + }, + + _ => unsafe { unreachable_unchecked() }, + } + }, + + 0b001 => { + let rd = (opcode & 0b00000000000000001111000000000000).wrapping_shr(0xC) as u8; + let rn = (opcode & 0b00000000000011110000000000000000).wrapping_shr(0x10) as u8; + let s = opcode & 0b00000000000100000000000000000000 != 0x0; + + let shifter = Shifter::extract(opcode); + + match (opcode & 0b00000001111000000000000000000000).wrapping_shr(0x15) { + 0b0000 => (And(rd, rn, shifter, s), predicate), + 0b0001 => (Eor(rd, rn, shifter, s), predicate), + 0b0010 => (Sub(rd, rn, shifter, s), predicate), + 0b0011 => (Rsb(rd, rn, shifter, s), predicate), + 0b0100 => (Add(rd, rn, shifter, s), predicate), + 0b0101 => (Adc(rd, rn, shifter, s), predicate), + 0b0110 => (Sbc(rd, rn, shifter, s), predicate), + 0b0111 => (Rsc(rd, rn, shifter, s), predicate), + 0b1000 => (Tst(rn, shifter), predicate), + 0b1001 => (Teq(rn, shifter), predicate), + 0b1010 => (Cmp(rn, shifter), predicate), + 0b1011 => (Cmn(rn, shifter), predicate), + 0b1100 => (Orr(rd, rn, shifter, s), predicate), + 0b1101 => (Mov(rd, shifter, s), predicate), + 0b1110 => (Bic(rd, rn, shifter, s), predicate), + 0b1111 => (Mvn(rd, shifter, s), predicate), + + _ => unsafe { unreachable_unchecked() }, + } + }, + + 0b010 => { + let imm = (opcode & 0b00000000000000000000111111111111) as u16; + + let register = (opcode & 0b00000000000000001111000000000000).wrapping_shr(0xC) as u8; + + let base = (opcode & 0b00000000000011110000000000000000).wrapping_shr(0x10) as u8; + + let l = opcode & 0b00000000000100000000000000000000 != 0x0; + let _w = opcode & 0b00000000001000000000000000000000 != 0x0; + let _b = opcode & 0b00000000010000000000000000000000 != 0x0; + let u = opcode & 0b00000000100000000000000000000000 != 0x0; + let _p = opcode & 0b00000001000000000000000000000000 != 0x0; + + let imm = match u { + false => 0x0 - imm as i16, + true => imm as i16, + }; + + match l { + false => (StoreImmediateOffset(register, base, imm), predicate), + true => (LoadImmediateOffset( register, base, imm), predicate), + } + }, + + 0b011 => (Undefined, Al), + + 0b100 => (Undefined, Al), + + 0b101 => { + let offset = opcode & 0b00000000111111111111111111111111; + let offset = (offset << 0x8) as i32 >> 0x6; + + let l = opcode & 0b00000001000000000000000000000000 != 0x0; + + match l { + false => (B(offset), predicate), + true => (Bl(offset), predicate), + } + }, + + 0b110 => (Undefined, Al), + + 0b111 => { + match (opcode & 0b00000001000000000000000000000000).wrapping_shr(0x18) { + 0b0 => (Undefined, Al), + + 0b1 => { + let imm = opcode & 0b00000000111111111111111111111111; + (Swi(imm), predicate) + }, + + _ => unsafe { unreachable_unchecked() }, + } + }, + + _ => unsafe { unreachable_unchecked() }, + }; + } +} |