/*
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 std::mem::transmute;
#[derive(Clone, Copy)]
#[repr(u8)]
pub enum Predicate {
Eq = 0b0000,
Ne = 0b0001,
Cs = 0b0010, // Hs
Cc = 0b0011, // Lo
Mi = 0b0100,
Pl = 0b0101,
Vs = 0b0110,
Vc = 0b0111,
Hi = 0b1000,
Ls = 0b1001,
Ge = 0b1010,
Lt = 0b1011,
Gt = 0b1100,
Le = 0b1101,
Al = 0b1110,
Nv = 0b1111,
}
impl Predicate {
pub fn from_raw(mut raw: u8) -> Self {
raw &= 0b00001111;
return unsafe { transmute(raw) };
}
pub fn test(self, cpsr: u32) -> bool {
let v = cpsr & 0b00010000000000000000000000000000 != 0x0;
let c = cpsr & 0b00100000000000000000000000000000 != 0x0;
let z = cpsr & 0b01000000000000000000000000000000 != 0x0;
let n = cpsr & 0b10000000000000000000000000000000 != 0x0;
use Predicate::*;
return match self {
Eq => z,
Ne => !z,
Cs => c,
Cc => !c,
Mi => n,
Pl => !n,
Vs => v,
Vc => !v,
Hi => c && !z,
Ls => !c && z,
Ge => n == v,
Lt => n != v,
Gt => !z && n == v,
Le => z && n != v,
Al => true,
Nv => false, // Unpredictable in ARMv4.
};
}
pub fn code(self) -> &'static str {
use Predicate::*;
return match self {
Eq => "eq",
Ne => "ne",
Cs => "cs",
Cc => "cc",
Mi => "mi",
Pl => "pl",
Vs => "vs",
Vc => "vc",
Hi => "hi",
Ls => "ls",
Ge => "ge",
Lt => "lt",
Gt => "gt",
Le => "le",
Al => "al",
Nv => "nv",
};
}
}
