diff --git a/Cargo.lock b/Cargo.lock index 544e785..af63569 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,6 +2,17 @@ # It is not intended for manual editing. version = 3 +[[package]] +name = "atty" +version = "0.2.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" +dependencies = [ + "hermit-abi", + "libc", + "winapi", +] + [[package]] name = "autocfg" version = "1.1.0" @@ -17,12 +28,33 @@ dependencies = [ "serde", ] +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + [[package]] name = "cfg-if" version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +[[package]] +name = "clap" +version = "3.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "71c47df61d9e16dc010b55dba1952a57d8c215dbb533fd13cdd13369aac73b1c" +dependencies = [ + "atty", + "bitflags", + "indexmap", + "os_str_bytes", + "strsim", + "termcolor", + "textwrap", +] + [[package]] name = "dol" version = "0.1.0" @@ -38,6 +70,12 @@ version = "1.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457" +[[package]] +name = "fixedbitset" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "279fb028e20b3c4c320317955b77c5e0c9701f05a1d309905d6fc702cdc5053e" + [[package]] name = "getrandom" version = "0.2.6" @@ -95,6 +133,12 @@ version = "0.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7fb9b38af92608140b86b693604b9ffcc5824240a484d1ecd4795bacb2fe88f3" +[[package]] +name = "memchr" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a" + [[package]] name = "num-traits" version = "0.2.14" @@ -114,6 +158,34 @@ dependencies = [ "libc", ] +[[package]] +name = "os_str_bytes" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64" +dependencies = [ + "memchr", +] + +[[package]] +name = "parse_int" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2d695b79916a2c08bcff7be7647ab60d1402885265005a6658ffe6d763553c5a" +dependencies = [ + "num-traits", +] + +[[package]] +name = "petgraph" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a13a2fa9d0b63e5f22328828741e523766fff0ee9e779316902290dff3f824f" +dependencies = [ + "fixedbitset", + "indexmap", +] + [[package]] name = "ppc750cl" version = "0.1.1" @@ -122,6 +194,18 @@ dependencies = [ "serde", ] +[[package]] +name = "ppc750cl-flow-graph" +version = "0.1.1" +dependencies = [ + "clap", + "dol", + "itertools", + "parse_int", + "petgraph", + "ppc750cl", +] + [[package]] name = "ppc750cl-fuzz" version = "0.1.1" @@ -253,6 +337,12 @@ dependencies = [ "rand_core", ] +[[package]] +name = "strsim" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" + [[package]] name = "syn" version = "1.0.91" @@ -264,6 +354,21 @@ dependencies = [ "unicode-xid", ] +[[package]] +name = "termcolor" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "textwrap" +version = "0.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb" + [[package]] name = "thiserror" version = "1.0.30" @@ -296,6 +401,37 @@ version = "0.10.2+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6" +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" +dependencies = [ + "winapi", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + [[package]] name = "yaml-rust" version = "0.4.5" diff --git a/Cargo.toml b/Cargo.toml index 8525731..fb5f89a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,5 +4,6 @@ members = [ "dol", "fuzz", "genisa", + "flow-graph", "rand", ] diff --git a/disasm/src/formatter.rs b/disasm/src/formatter.rs index d68c986..3e2ca3c 100644 --- a/disasm/src/formatter.rs +++ b/disasm/src/formatter.rs @@ -7,7 +7,7 @@ pub struct FormattedIns(pub Ins); impl Display for FormattedIns { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { let simple = self.0.clone().simplified(); - write!(f, "{}{}", simple.mnemonic, simple.modifiers)?; + write!(f, "{}{}", simple.mnemonic, simple.ins.suffix())?; let mut writing_offset = false; for (i, arg) in simple.args.iter().enumerate() { if i == 0 { diff --git a/disasm/src/generated.rs b/disasm/src/generated.rs index 837abd2..f4e7393 100644 --- a/disasm/src/generated.rs +++ b/disasm/src/generated.rs @@ -235,14 +235,14 @@ impl Opcode { Opcode::Adde => "adde", Opcode::Addi => "addi", Opcode::Addic => "addic", - Opcode::Addic_ => "addic", + Opcode::Addic_ => "addic.", Opcode::Addis => "addis", Opcode::Addme => "addme", Opcode::Addze => "addze", Opcode::And => "and", Opcode::Andc => "andc", - Opcode::Andi_ => "andi", - Opcode::Andis_ => "andis", + Opcode::Andi_ => "andi.", + Opcode::Andis_ => "andis.", Opcode::B => "b", Opcode::Bc => "bc", Opcode::Bcctr => "bcctr", @@ -434,7 +434,7 @@ impl Opcode { Opcode::Stswx => "stswx", Opcode::Stw => "stw", Opcode::Stwbrx => "stwbrx", - Opcode::Stwcx_ => "stwcx", + Opcode::Stwcx_ => "stwcx.", Opcode::Stwu => "stwu", Opcode::Stwux => "stwux", Opcode::Stwx => "stwx", @@ -4010,639 +4010,849 @@ impl Ins { } } } - pub(crate) fn _modifiers(&self) -> Modifiers { + pub(crate) fn _suffix(&self) -> String { match self.op { - Opcode::Illegal => Modifiers::default(), + Opcode::Illegal => String::new(), Opcode::Add => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Addc => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Adde => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::Addi => Modifiers::default(), - Opcode::Addic => Modifiers::default(), - Opcode::Addic_ => { - let mut m = Modifiers::default(); - m.rc = true; - m - } - Opcode::Addis => Modifiers::default(), + Opcode::Addi => String::new(), + Opcode::Addic => String::new(), + Opcode::Addic_ => String::new(), + Opcode::Addis => String::new(), Opcode::Addme => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Addze => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::And => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Andc => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m - } - Opcode::Andi_ => { - let mut m = Modifiers::default(); - m.rc = true; - m - } - Opcode::Andis_ => { - let mut m = Modifiers::default(); - m.rc = true; - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } + Opcode::Andi_ => String::new(), + Opcode::Andis_ => String::new(), Opcode::B => { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(30usize) { + s.push('a'); + } + if self.bit(31usize) { + s.push('l'); + } + s } Opcode::Bc => { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(30usize) { + s.push('a'); + } + if self.bit(31usize) { + s.push('l'); + } + s } Opcode::Bcctr => { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('l'); + } + s } Opcode::Bclr => { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('l'); + } + s } - Opcode::Cmp => Modifiers::default(), - Opcode::Cmpi => Modifiers::default(), - Opcode::Cmpl => Modifiers::default(), - Opcode::Cmpli => Modifiers::default(), + Opcode::Cmp => String::new(), + Opcode::Cmpi => String::new(), + Opcode::Cmpl => String::new(), + Opcode::Cmpli => String::new(), Opcode::Cntlzw => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::Crand => Modifiers::default(), - Opcode::Crandc => Modifiers::default(), - Opcode::Creqv => Modifiers::default(), - Opcode::Crnand => Modifiers::default(), - Opcode::Crnor => Modifiers::default(), - Opcode::Cror => Modifiers::default(), - Opcode::Crorc => Modifiers::default(), - Opcode::Crxor => Modifiers::default(), - Opcode::Dcbf => Modifiers::default(), - Opcode::Dcbi => Modifiers::default(), - Opcode::Dcbst => Modifiers::default(), - Opcode::Dcbt => Modifiers::default(), - Opcode::Dcbtst => Modifiers::default(), - Opcode::Dcbz => Modifiers::default(), - Opcode::DcbzL => Modifiers::default(), + Opcode::Crand => String::new(), + Opcode::Crandc => String::new(), + Opcode::Creqv => String::new(), + Opcode::Crnand => String::new(), + Opcode::Crnor => String::new(), + Opcode::Cror => String::new(), + Opcode::Crorc => String::new(), + Opcode::Crxor => String::new(), + Opcode::Dcbf => String::new(), + Opcode::Dcbi => String::new(), + Opcode::Dcbst => String::new(), + Opcode::Dcbt => String::new(), + Opcode::Dcbtst => String::new(), + Opcode::Dcbz => String::new(), + Opcode::DcbzL => String::new(), Opcode::Divw => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Divwu => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::Eciwx => Modifiers::default(), - Opcode::Ecowx => Modifiers::default(), - Opcode::Eieio => Modifiers::default(), + Opcode::Eciwx => String::new(), + Opcode::Ecowx => String::new(), + Opcode::Eieio => String::new(), Opcode::Eqv => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Extsb => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Extsh => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fabs => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fadd => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fadds => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::Fcmpo => Modifiers::default(), - Opcode::Fcmpu => Modifiers::default(), + Opcode::Fcmpo => String::new(), + Opcode::Fcmpu => String::new(), Opcode::Fctiw => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fctiwz => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fdiv => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fdivs => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fmadd => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fmadds => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fmr => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fmsub => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fmsubs => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fmul => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fmuls => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fnabs => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fneg => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fnmadd => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fnmadds => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fnmsub => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fnmsubs => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fres => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Frsp => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Frsqrte => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fsel => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fsub => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Fsubs => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Icbi => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::Isync => Modifiers::default(), - Opcode::Lbz => Modifiers::default(), - Opcode::Lbzu => Modifiers::default(), - Opcode::Lbzux => Modifiers::default(), - Opcode::Lbzx => Modifiers::default(), - Opcode::Lfd => Modifiers::default(), - Opcode::Lfdu => Modifiers::default(), - Opcode::Lfdux => Modifiers::default(), - Opcode::Lfdx => Modifiers::default(), - Opcode::Lfs => Modifiers::default(), - Opcode::Lfsu => Modifiers::default(), - Opcode::Lfsux => Modifiers::default(), - Opcode::Lfsx => Modifiers::default(), - Opcode::Lha => Modifiers::default(), - Opcode::Lhau => Modifiers::default(), - Opcode::Lhaux => Modifiers::default(), - Opcode::Lhax => Modifiers::default(), - Opcode::Lhbrx => Modifiers::default(), - Opcode::Lhz => Modifiers::default(), - Opcode::Lhzu => Modifiers::default(), - Opcode::Lhzux => Modifiers::default(), - Opcode::Lhzx => Modifiers::default(), - Opcode::Lmw => Modifiers::default(), - Opcode::Lswi => Modifiers::default(), - Opcode::Lswx => Modifiers::default(), - Opcode::Lwarx => Modifiers::default(), - Opcode::Lwbrx => Modifiers::default(), - Opcode::Lwz => Modifiers::default(), - Opcode::Lwzu => Modifiers::default(), - Opcode::Lwzux => Modifiers::default(), - Opcode::Lwzx => Modifiers::default(), - Opcode::Mcrf => Modifiers::default(), - Opcode::Mcrfs => Modifiers::default(), - Opcode::Mcrxr => Modifiers::default(), - Opcode::Mfcr => Modifiers::default(), + Opcode::Isync => String::new(), + Opcode::Lbz => String::new(), + Opcode::Lbzu => String::new(), + Opcode::Lbzux => String::new(), + Opcode::Lbzx => String::new(), + Opcode::Lfd => String::new(), + Opcode::Lfdu => String::new(), + Opcode::Lfdux => String::new(), + Opcode::Lfdx => String::new(), + Opcode::Lfs => String::new(), + Opcode::Lfsu => String::new(), + Opcode::Lfsux => String::new(), + Opcode::Lfsx => String::new(), + Opcode::Lha => String::new(), + Opcode::Lhau => String::new(), + Opcode::Lhaux => String::new(), + Opcode::Lhax => String::new(), + Opcode::Lhbrx => String::new(), + Opcode::Lhz => String::new(), + Opcode::Lhzu => String::new(), + Opcode::Lhzux => String::new(), + Opcode::Lhzx => String::new(), + Opcode::Lmw => String::new(), + Opcode::Lswi => String::new(), + Opcode::Lswx => String::new(), + Opcode::Lwarx => String::new(), + Opcode::Lwbrx => String::new(), + Opcode::Lwz => String::new(), + Opcode::Lwzu => String::new(), + Opcode::Lwzux => String::new(), + Opcode::Lwzx => String::new(), + Opcode::Mcrf => String::new(), + Opcode::Mcrfs => String::new(), + Opcode::Mcrxr => String::new(), + Opcode::Mfcr => String::new(), Opcode::Mffs => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::Mfmsr => Modifiers::default(), - Opcode::Mfspr => Modifiers::default(), - Opcode::Mfsr => Modifiers::default(), - Opcode::Mfsrin => Modifiers::default(), - Opcode::Mftb => Modifiers::default(), - Opcode::Mtcrf => Modifiers::default(), + Opcode::Mfmsr => String::new(), + Opcode::Mfspr => String::new(), + Opcode::Mfsr => String::new(), + Opcode::Mfsrin => String::new(), + Opcode::Mftb => String::new(), + Opcode::Mtcrf => String::new(), Opcode::Mtfsb0 => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Mtfsb1 => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Mtfsf => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Mtfsfi => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::Mtmsr => Modifiers::default(), - Opcode::Mtspr => Modifiers::default(), - Opcode::Mtsr => Modifiers::default(), - Opcode::Mtsrin => Modifiers::default(), + Opcode::Mtmsr => String::new(), + Opcode::Mtspr => String::new(), + Opcode::Mtsr => String::new(), + Opcode::Mtsrin => String::new(), Opcode::Mulhw => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Mulhwu => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Mulli => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Mullw => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Nand => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Neg => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Nor => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Or => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Orc => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::Ori => Modifiers::default(), - Opcode::Oris => Modifiers::default(), - Opcode::PsqL => Modifiers::default(), - Opcode::PsqLu => Modifiers::default(), - Opcode::PsqLux => Modifiers::default(), - Opcode::PsqLx => Modifiers::default(), - Opcode::PsqSt => Modifiers::default(), - Opcode::PsqStu => Modifiers::default(), - Opcode::PsqStux => Modifiers::default(), - Opcode::PsqStx => Modifiers::default(), + Opcode::Ori => String::new(), + Opcode::Oris => String::new(), + Opcode::PsqL => String::new(), + Opcode::PsqLu => String::new(), + Opcode::PsqLux => String::new(), + Opcode::PsqLx => String::new(), + Opcode::PsqSt => String::new(), + Opcode::PsqStu => String::new(), + Opcode::PsqStux => String::new(), + Opcode::PsqStx => String::new(), Opcode::PsAbs => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsAdd => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::PsCmpo0 => Modifiers::default(), - Opcode::PsCmpo1 => Modifiers::default(), - Opcode::PsCmpu0 => Modifiers::default(), - Opcode::PsCmpu1 => Modifiers::default(), + Opcode::PsCmpo0 => String::new(), + Opcode::PsCmpo1 => String::new(), + Opcode::PsCmpu0 => String::new(), + Opcode::PsCmpu1 => String::new(), Opcode::PsDiv => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsMadd => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsMadds0 => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsMadds1 => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsMerge00 => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsMerge01 => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsMerge10 => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsMerge11 => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsMr => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsMsub => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsMul => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsMuls0 => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsMuls1 => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsNabs => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsNeg => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsNmadd => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsNmsub => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsRes => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsRsqrte => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsSel => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsSub => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsSum0 => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::PsSum1 => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::Rfi => Modifiers::default(), + Opcode::Rfi => String::new(), Opcode::Rlwimi => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Rlwinm => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Rlwnm => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::Sc => Modifiers::default(), + Opcode::Sc => String::new(), Opcode::Slw => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Sraw => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Srawi => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Srw => { - let mut m = Modifiers::default(); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::Stb => Modifiers::default(), - Opcode::Stbu => Modifiers::default(), - Opcode::Stbux => Modifiers::default(), - Opcode::Stbx => Modifiers::default(), - Opcode::Stfd => Modifiers::default(), - Opcode::Stfdu => Modifiers::default(), - Opcode::Stfdux => Modifiers::default(), - Opcode::Stfdx => Modifiers::default(), - Opcode::Stfiwx => Modifiers::default(), - Opcode::Stfs => Modifiers::default(), - Opcode::Stfsu => Modifiers::default(), - Opcode::Stfsux => Modifiers::default(), - Opcode::Stfsx => Modifiers::default(), - Opcode::Sth => Modifiers::default(), - Opcode::Sthbrx => Modifiers::default(), - Opcode::Sthu => Modifiers::default(), - Opcode::Sthux => Modifiers::default(), - Opcode::Sthx => Modifiers::default(), - Opcode::Stmw => Modifiers::default(), - Opcode::Stswi => Modifiers::default(), - Opcode::Stswx => Modifiers::default(), - Opcode::Stw => Modifiers::default(), - Opcode::Stwbrx => Modifiers::default(), - Opcode::Stwcx_ => Modifiers::default(), - Opcode::Stwu => Modifiers::default(), - Opcode::Stwux => Modifiers::default(), - Opcode::Stwx => Modifiers::default(), + Opcode::Stb => String::new(), + Opcode::Stbu => String::new(), + Opcode::Stbux => String::new(), + Opcode::Stbx => String::new(), + Opcode::Stfd => String::new(), + Opcode::Stfdu => String::new(), + Opcode::Stfdux => String::new(), + Opcode::Stfdx => String::new(), + Opcode::Stfiwx => String::new(), + Opcode::Stfs => String::new(), + Opcode::Stfsu => String::new(), + Opcode::Stfsux => String::new(), + Opcode::Stfsx => String::new(), + Opcode::Sth => String::new(), + Opcode::Sthbrx => String::new(), + Opcode::Sthu => String::new(), + Opcode::Sthux => String::new(), + Opcode::Sthx => String::new(), + Opcode::Stmw => String::new(), + Opcode::Stswi => String::new(), + Opcode::Stswx => String::new(), + Opcode::Stw => String::new(), + Opcode::Stwbrx => String::new(), + Opcode::Stwcx_ => String::new(), + Opcode::Stwu => String::new(), + Opcode::Stwux => String::new(), + Opcode::Stwx => String::new(), Opcode::Subf => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Subfc => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Subfe => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::Subfic => Modifiers::default(), + Opcode::Subfic => String::new(), Opcode::Subfme => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } Opcode::Subfze => { - let mut m = Modifiers::default(); - m.oe = self.bit(21); - m.rc = self.bit(31); - m + let mut s = String::with_capacity(4); + if self.bit(21usize) { + s.push('o'); + } + if self.bit(31usize) { + s.push('.'); + } + s } - Opcode::Sync => Modifiers::default(), - Opcode::Tlbie => Modifiers::default(), - Opcode::Tlbsync => Modifiers::default(), - Opcode::Tw => Modifiers::default(), - Opcode::Twi => Modifiers::default(), - Opcode::Xor => Modifiers::default(), - Opcode::Xori => Modifiers::default(), - Opcode::Xoris => Modifiers::default(), + Opcode::Sync => String::new(), + Opcode::Tlbie => String::new(), + Opcode::Tlbsync => String::new(), + Opcode::Tw => String::new(), + Opcode::Twi => String::new(), + Opcode::Xor => String::new(), + Opcode::Xori => String::new(), + Opcode::Xoris => String::new(), } } pub(crate) fn _simplified(self) -> SimplifiedIns { @@ -4651,7 +4861,6 @@ impl Ins { if ((self.code >> 16u8) & 0x1f) == 0 { return SimplifiedIns { mnemonic: "li", - modifiers: Modifiers::default(), args: vec![ Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _)), Argument::Simm(Simm( @@ -4666,7 +4875,6 @@ impl Ins { if ((self.code >> 16u8) & 0x1f) == 0 { return SimplifiedIns { mnemonic: "lis", - modifiers: Modifiers::default(), args: vec![ Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _)), Argument::Uimm(Uimm((self.code & 0xffff) as _)), @@ -4682,12 +4890,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "blt", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![Argument::BranchDest(BranchDest( (((((self.code >> 2u8) & 0x3fff) ^ 0x2000).wrapping_sub(0x2000)) << 2u8) as _, @@ -4699,12 +4901,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "blt", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![ Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _)), Argument::BranchDest(BranchDest( @@ -4721,12 +4917,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "ble", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![Argument::BranchDest(BranchDest( (((((self.code >> 2u8) & 0x3fff) ^ 0x2000).wrapping_sub(0x2000)) << 2u8) as _, @@ -4738,12 +4928,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "ble", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![ Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _)), Argument::BranchDest(BranchDest( @@ -4760,12 +4944,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "beq", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![Argument::BranchDest(BranchDest( (((((self.code >> 2u8) & 0x3fff) ^ 0x2000).wrapping_sub(0x2000)) << 2u8) as _, @@ -4777,12 +4955,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "beq", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![ Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _)), Argument::BranchDest(BranchDest( @@ -4799,12 +4971,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bge", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![Argument::BranchDest(BranchDest( (((((self.code >> 2u8) & 0x3fff) ^ 0x2000).wrapping_sub(0x2000)) << 2u8) as _, @@ -4816,12 +4982,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bge", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![ Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _)), Argument::BranchDest(BranchDest( @@ -4838,12 +4998,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bgt", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![Argument::BranchDest(BranchDest( (((((self.code >> 2u8) & 0x3fff) ^ 0x2000).wrapping_sub(0x2000)) << 2u8) as _, @@ -4855,12 +5009,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bgt", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![ Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _)), Argument::BranchDest(BranchDest( @@ -4877,12 +5025,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bne", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![Argument::BranchDest(BranchDest( (((((self.code >> 2u8) & 0x3fff) ^ 0x2000).wrapping_sub(0x2000)) << 2u8) as _, @@ -4894,12 +5036,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bne", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![ Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _)), Argument::BranchDest(BranchDest( @@ -4916,12 +5052,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bso", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![Argument::BranchDest(BranchDest( (((((self.code >> 2u8) & 0x3fff) ^ 0x2000).wrapping_sub(0x2000)) << 2u8) as _, @@ -4933,12 +5063,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bso", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![ Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _)), Argument::BranchDest(BranchDest( @@ -4955,12 +5079,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bns", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![Argument::BranchDest(BranchDest( (((((self.code >> 2u8) & 0x3fff) ^ 0x2000).wrapping_sub(0x2000)) << 2u8) as _, @@ -4972,12 +5090,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bns", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![ Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _)), Argument::BranchDest(BranchDest( @@ -4991,12 +5103,6 @@ impl Ins { if ((self.code >> 21u8) & 0x1f) == 16 && ((self.code >> 16u8) & 0x1f) == 0 { return SimplifiedIns { mnemonic: "bdnz", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![Argument::BranchDest(BranchDest( (((((self.code >> 2u8) & 0x3fff) ^ 0x2000).wrapping_sub(0x2000)) << 2u8) as _, @@ -5007,12 +5113,6 @@ impl Ins { if ((self.code >> 21u8) & 0x1f) == 18 && ((self.code >> 16u8) & 0x1f) == 0 { return SimplifiedIns { mnemonic: "bdz", - modifiers: { - let mut m = Modifiers::default(); - m.aa = self.bit(30); - m.lk = self.bit(31); - m - }, args: vec![Argument::BranchDest(BranchDest( (((((self.code >> 2u8) & 0x3fff) ^ 0x2000).wrapping_sub(0x2000)) << 2u8) as _, @@ -5025,11 +5125,6 @@ impl Ins { if ((self.code >> 21u8) & 0x1f) == 20 && ((self.code >> 16u8) & 0x1f) == 0 { return SimplifiedIns { mnemonic: "bctr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5040,11 +5135,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bltctr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5053,11 +5143,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bltctr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5068,11 +5153,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "blectr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5081,11 +5161,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "blectr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5096,11 +5171,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "beqctr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5109,11 +5179,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "beqctr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5124,11 +5189,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bgectr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5137,11 +5197,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bgectr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5152,11 +5207,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bgtctr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5165,11 +5215,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bgtctr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5180,11 +5225,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bnectr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5193,11 +5233,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bnectr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5208,11 +5243,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bsoctr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5221,11 +5251,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bsoctr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5236,11 +5261,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bnsctr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5249,11 +5269,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bnsctr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5263,11 +5278,6 @@ impl Ins { if ((self.code >> 21u8) & 0x1f) == 20 && ((self.code >> 16u8) & 0x1f) == 0 { return SimplifiedIns { mnemonic: "blr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5278,11 +5288,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bltlr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5291,11 +5296,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bltlr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5306,11 +5306,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "blelr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5319,11 +5314,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "blelr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5334,11 +5324,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "beqlr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5347,11 +5332,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "beqlr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5362,11 +5342,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bgelr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5375,11 +5350,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bgelr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5390,11 +5360,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bgtlr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5403,11 +5368,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bgtlr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5418,11 +5378,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bnelr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5431,11 +5386,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bnelr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5446,11 +5396,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bsolr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5459,11 +5404,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bsolr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5474,11 +5414,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bnslr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![], ins: self, }; @@ -5487,11 +5422,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "bnslr", - modifiers: { - let mut m = Modifiers::default(); - m.lk = self.bit(31); - m - }, args: vec![Argument::CRBit(CRBit(((self.code >> 18u8) & 0x7) as _))], ins: self, }; @@ -5501,7 +5431,6 @@ impl Ins { if ((self.code >> 23u8) & 0x7) == 0 { return SimplifiedIns { mnemonic: "cmpw", - modifiers: Modifiers::default(), args: vec![ Argument::GPR(GPR(((self.code >> 16u8) & 0x1f) as _)), Argument::GPR(GPR(((self.code >> 11u8) & 0x1f) as _)), @@ -5514,7 +5443,6 @@ impl Ins { if ((self.code >> 23u8) & 0x7) == 0 { return SimplifiedIns { mnemonic: "cmpwi", - modifiers: Modifiers::default(), args: vec![ Argument::GPR(GPR(((self.code >> 16u8) & 0x1f) as _)), Argument::Simm(Simm( @@ -5527,7 +5455,6 @@ impl Ins { if ((self.code >> 23u8) & 0x7) == 0 { return SimplifiedIns { mnemonic: "cmpwi", - modifiers: Modifiers::default(), args: vec![ Argument::CRBit(CRBit(((self.code >> 23u8) & 0x7) as _)), Argument::GPR(GPR(((self.code >> 16u8) & 0x1f) as _)), @@ -5543,7 +5470,6 @@ impl Ins { if ((self.code >> 23u8) & 0x7) == 0 { return SimplifiedIns { mnemonic: "cmplw", - modifiers: Modifiers::default(), args: vec![ Argument::GPR(GPR(((self.code >> 16u8) & 0x1f) as _)), Argument::GPR(GPR(((self.code >> 11u8) & 0x1f) as _)), @@ -5556,7 +5482,6 @@ impl Ins { if ((self.code >> 23u8) & 0x7) == 0 { return SimplifiedIns { mnemonic: "cmplwi", - modifiers: Modifiers::default(), args: vec![ Argument::GPR(GPR(((self.code >> 16u8) & 0x1f) as _)), Argument::Uimm(Uimm((self.code & 0xffff) as _)), @@ -5567,7 +5492,6 @@ impl Ins { if ((self.code >> 23u8) & 0x7) == 0 { return SimplifiedIns { mnemonic: "cmplwi", - modifiers: Modifiers::default(), args: vec![ Argument::CRBit(CRBit(((self.code >> 23u8) & 0x7) as _)), Argument::GPR(GPR(((self.code >> 16u8) & 0x1f) as _)), @@ -5581,7 +5505,6 @@ impl Ins { if ((self.code >> 11u8) & 0x3ff) == 1 { return SimplifiedIns { mnemonic: "mfxer", - modifiers: Modifiers::default(), args: vec![Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _))], ins: self, }; @@ -5589,7 +5512,6 @@ impl Ins { if ((self.code >> 11u8) & 0x3ff) == 8 { return SimplifiedIns { mnemonic: "mflr", - modifiers: Modifiers::default(), args: vec![Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _))], ins: self, }; @@ -5597,7 +5519,6 @@ impl Ins { if ((self.code >> 11u8) & 0x3ff) == 9 { return SimplifiedIns { mnemonic: "mfctr", - modifiers: Modifiers::default(), args: vec![Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _))], ins: self, }; @@ -5605,7 +5526,6 @@ impl Ins { if ((self.code >> 11u8) & 0x3ff) == 18 { return SimplifiedIns { mnemonic: "mfdsisr", - modifiers: Modifiers::default(), args: vec![Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _))], ins: self, }; @@ -5613,7 +5533,6 @@ impl Ins { if ((self.code >> 11u8) & 0x3ff) == 397 { return SimplifiedIns { mnemonic: "mfdbatu", - modifiers: Modifiers::default(), args: vec![Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _))], ins: self, }; @@ -5621,7 +5540,6 @@ impl Ins { if ((self.code >> 11u8) & 0x3ff) == 571 { return SimplifiedIns { mnemonic: "mftdu", - modifiers: Modifiers::default(), args: vec![Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _))], ins: self, }; @@ -5631,7 +5549,6 @@ impl Ins { if ((self.code >> 11u8) & 0x3ff) == 1 { return SimplifiedIns { mnemonic: "mtxer", - modifiers: Modifiers::default(), args: vec![Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _))], ins: self, }; @@ -5639,7 +5556,6 @@ impl Ins { if ((self.code >> 11u8) & 0x3ff) == 8 { return SimplifiedIns { mnemonic: "mtlr", - modifiers: Modifiers::default(), args: vec![Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _))], ins: self, }; @@ -5647,7 +5563,6 @@ impl Ins { if ((self.code >> 11u8) & 0x3ff) == 9 { return SimplifiedIns { mnemonic: "mtctr", - modifiers: Modifiers::default(), args: vec![Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _))], ins: self, }; @@ -5655,7 +5570,6 @@ impl Ins { if ((self.code >> 11u8) & 0x3ff) == 18 { return SimplifiedIns { mnemonic: "mtdsisr", - modifiers: Modifiers::default(), args: vec![Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _))], ins: self, }; @@ -5663,7 +5577,6 @@ impl Ins { if ((self.code >> 11u8) & 0x3ff) == 397 { return SimplifiedIns { mnemonic: "mtdbatu", - modifiers: Modifiers::default(), args: vec![Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _))], ins: self, }; @@ -5671,7 +5584,6 @@ impl Ins { if ((self.code >> 11u8) & 0x3ff) == 571 { return SimplifiedIns { mnemonic: "mttdu", - modifiers: Modifiers::default(), args: vec![Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _))], ins: self, }; @@ -5681,7 +5593,6 @@ impl Ins { if ((self.code >> 21u8) & 0x1f) == ((self.code >> 11u8) & 0x1f) { return SimplifiedIns { mnemonic: "mr", - modifiers: Modifiers::default(), args: vec![ Argument::GPR(GPR(((self.code >> 16u8) & 0x1f) as _)), Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _)), @@ -5697,7 +5608,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "nop", - modifiers: Modifiers::default(), args: vec![], ins: self, }; @@ -5707,7 +5617,6 @@ impl Ins { if ((self.code >> 11u8) & 0x1f) == 0 && ((self.code >> 1u8) & 0x1f) == 31 { return SimplifiedIns { mnemonic: "clrlwi", - modifiers: Modifiers::default(), args: vec![ Argument::GPR(GPR(((self.code >> 16u8) & 0x1f) as _)), Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _)), @@ -5719,7 +5628,6 @@ impl Ins { if ((self.code >> 6u8) & 0x1f) == 0 && ((self.code >> 1u8) & 0x1f) == 31 { return SimplifiedIns { mnemonic: "rotlwi", - modifiers: Modifiers::default(), args: vec![ Argument::GPR(GPR(((self.code >> 16u8) & 0x1f) as _)), Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _)), @@ -5733,7 +5641,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "slwi", - modifiers: Modifiers::default(), args: vec![ Argument::GPR(GPR(((self.code >> 16u8) & 0x1f) as _)), Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _)), @@ -5747,7 +5654,6 @@ impl Ins { { return SimplifiedIns { mnemonic: "srwi", - modifiers: Modifiers::default(), args: vec![ Argument::GPR(GPR(((self.code >> 16u8) & 0x1f) as _)), Argument::GPR(GPR(((self.code >> 21u8) & 0x1f) as _)), @@ -5761,7 +5667,6 @@ impl Ins { if ((self.code >> 21u8) & 0x1f) == 8 { return SimplifiedIns { mnemonic: "twgti", - modifiers: Modifiers::default(), args: vec![ Argument::GPR(GPR(((self.code >> 16u8) & 0x1f) as _)), Argument::Simm(Simm( @@ -5774,7 +5679,6 @@ impl Ins { if ((self.code >> 21u8) & 0x1f) == 6 { return SimplifiedIns { mnemonic: "twllei", - modifiers: Modifiers::default(), args: vec![ Argument::GPR(GPR(((self.code >> 16u8) & 0x1f) as _)), Argument::Simm(Simm( @@ -5792,109 +5696,160 @@ impl Ins { } #[allow(clippy::all, non_snake_case)] impl Ins { + #[inline(always)] pub fn field_simm(&self) -> isize { (((self.code & 0xffff) ^ 0x8000).wrapping_sub(0x8000)) as _ } + #[inline(always)] pub fn field_uimm(&self) -> usize { (self.code & 0xffff) as _ } + #[inline(always)] pub fn field_offset(&self) -> isize { (((self.code & 0xffff) ^ 0x8000).wrapping_sub(0x8000)) as _ } + #[inline(always)] pub fn field_BO(&self) -> usize { ((self.code >> 21u8) & 0x1f) as _ } + #[inline(always)] pub fn field_BI(&self) -> usize { ((self.code >> 16u8) & 0x1f) as _ } + #[inline(always)] pub fn field_BD(&self) -> isize { (((((self.code >> 2u8) & 0x3fff) ^ 0x2000).wrapping_sub(0x2000)) << 2u8) as _ } + #[inline(always)] pub fn field_LI(&self) -> isize { (((((self.code >> 2u8) & 0xffffff) ^ 0x800000).wrapping_sub(0x800000)) << 2u8) as _ } + #[inline(always)] pub fn field_SH(&self) -> usize { ((self.code >> 11u8) & 0x1f) as _ } + #[inline(always)] pub fn field_MB(&self) -> usize { ((self.code >> 6u8) & 0x1f) as _ } + #[inline(always)] pub fn field_ME(&self) -> usize { ((self.code >> 1u8) & 0x1f) as _ } + #[inline(always)] pub fn field_rS(&self) -> usize { ((self.code >> 21u8) & 0x1f) as _ } + #[inline(always)] pub fn field_rD(&self) -> usize { ((self.code >> 21u8) & 0x1f) as _ } + #[inline(always)] pub fn field_rA(&self) -> usize { ((self.code >> 16u8) & 0x1f) as _ } + #[inline(always)] pub fn field_rB(&self) -> usize { ((self.code >> 11u8) & 0x1f) as _ } + #[inline(always)] pub fn field_rC(&self) -> usize { ((self.code >> 6u8) & 0x1f) as _ } + #[inline(always)] pub fn field_sr(&self) -> usize { ((self.code >> 16u8) & 0xf) as _ } + #[inline(always)] pub fn field_spr(&self) -> usize { ((self.code >> 11u8) & 0x3ff) as _ } + #[inline(always)] pub fn field_frS(&self) -> usize { ((self.code >> 21u8) & 0x1f) as _ } + #[inline(always)] pub fn field_frD(&self) -> usize { ((self.code >> 21u8) & 0x1f) as _ } + #[inline(always)] pub fn field_frA(&self) -> usize { ((self.code >> 16u8) & 0x1f) as _ } + #[inline(always)] pub fn field_frB(&self) -> usize { ((self.code >> 11u8) & 0x1f) as _ } + #[inline(always)] pub fn field_frC(&self) -> usize { ((self.code >> 6u8) & 0x1f) as _ } + #[inline(always)] pub fn field_crbD(&self) -> usize { ((self.code >> 21u8) & 0x1f) as _ } + #[inline(always)] pub fn field_crbA(&self) -> usize { ((self.code >> 16u8) & 0x1f) as _ } + #[inline(always)] pub fn field_crbB(&self) -> usize { ((self.code >> 11u8) & 0x1f) as _ } + #[inline(always)] pub fn field_crfD(&self) -> usize { ((self.code >> 23u8) & 0x7) as _ } + #[inline(always)] pub fn field_crfS(&self) -> usize { ((self.code >> 18u8) & 0x7) as _ } + #[inline(always)] pub fn field_crm(&self) -> usize { ((self.code >> 12u8) & 0xff) as _ } + #[inline(always)] pub fn field_ps_l(&self) -> usize { ((self.code >> 12u8) & 0x7) as _ } + #[inline(always)] pub fn field_ps_W(&self) -> usize { ((self.code >> 16u8) & 0x0) as _ } + #[inline(always)] pub fn field_NB(&self) -> usize { ((self.code >> 11u8) & 0x1f) as _ } + #[inline(always)] pub fn field_tbr(&self) -> usize { ((self.code >> 11u8) & 0x3ff) as _ } + #[inline(always)] pub fn field_mtfsf_FM(&self) -> usize { ((self.code >> 17u8) & 0xff) as _ } + #[inline(always)] pub fn field_mtfsf_IMM(&self) -> usize { ((self.code >> 12u8) & 0xf) as _ } + #[inline(always)] pub fn field_TO(&self) -> usize { ((self.code >> 21u8) & 0x1f) as _ } + #[inline(always)] + pub fn field_OE(&self) -> bool { + self.bit(21usize) + } + #[inline(always)] + pub fn field_Rc(&self) -> bool { + self.bit(31usize) + } + #[inline(always)] + pub fn field_LK(&self) -> bool { + self.bit(31usize) + } + #[inline(always)] + pub fn field_AA(&self) -> bool { + self.bit(30usize) + } } diff --git a/disasm/src/lib.rs b/disasm/src/lib.rs index a09d433..7f14e1e 100644 --- a/disasm/src/lib.rs +++ b/disasm/src/lib.rs @@ -15,7 +15,6 @@ pub mod prelude { pub use crate::Argument; pub use crate::Field::*; pub use crate::Ins; - pub use crate::Modifiers; pub use crate::Opcode::*; pub use crate::SimplifiedIns; pub use crate::{ @@ -210,32 +209,6 @@ impl Field { } } -#[derive(Debug, Default)] -pub struct Modifiers { - pub oe: bool, - pub rc: bool, - pub lk: bool, - pub aa: bool, -} - -impl std::fmt::Display for Modifiers { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - if self.aa { - write!(f, "a")?; - } - if self.lk { - write!(f, "l")?; - } - if self.oe { - write!(f, "o")?; - } - if self.rc { - write!(f, ".")?; - } - Ok(()) - } -} - impl Opcode { /// Detects the opcode of a machine code instruction. pub fn detect(code: u32) -> Self { @@ -289,9 +262,9 @@ impl Ins { self._fields() // auto-generated } - /// Gets the modifiers of an instruction. - pub fn modifiers(&self) -> Modifiers { - self._modifiers() // auto-generated + /// Gets the suffix of an instruction mnemonic. + pub fn suffix(&self) -> String { + self._suffix() // auto-generated } /// Gets the defs of an instruction. @@ -314,10 +287,9 @@ impl Ins { bits(self.code, range) } - /* pub fn branch_offset(&self) -> Option { match self.op { - Opcode::B => Some(self.li()), + Opcode::B => Some(self.field_LI() as i32), Opcode::Bc | Opcode::Bcctr | Opcode::Bclr => Some(self.field_BD() as i32), _ => None, } @@ -332,20 +304,18 @@ impl Ins { } }) } - */ } /// A simplified PowerPC 750CL instruction. pub struct SimplifiedIns { pub ins: Ins, pub mnemonic: &'static str, - pub modifiers: Modifiers, pub args: Vec, } impl Display for SimplifiedIns { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}{} ", self.mnemonic, self.modifiers)?; + write!(f, "{}{} ", self.mnemonic, self.ins.suffix())?; let mut writing_offset = false; for (i, argument) in self.args.iter().enumerate() { write!(f, "{}", argument)?; @@ -370,7 +340,6 @@ impl SimplifiedIns { pub(crate) fn basic_form(ins: Ins) -> Self { Self { mnemonic: ins.op.mnemonic(), - modifiers: ins.modifiers(), args: ins .fields() .iter() diff --git a/flow-graph/src/flow.rs b/flow-graph/src/flow.rs index 4eb7d15..8ded08f 100644 --- a/flow-graph/src/flow.rs +++ b/flow-graph/src/flow.rs @@ -8,6 +8,7 @@ use petgraph::algo::dominators::Dominators; use petgraph::graph::{DefaultIx, NodeIndex}; use petgraph::Graph; +use ppc750cl::formatter::FormattedIns; use ppc750cl::{Ins, Opcode}; use crate::slices::{BasicSlices, CodeIdx}; @@ -53,21 +54,21 @@ impl<'a> BasicBlock<'a> { for ins in code { match ins.op { Opcode::Addis => { - if ins.a() == 0 { + if ins.field_rA() == 0 { // lis - defs.insert(ins.d(), ins.field_uimm() as u16); + defs.insert(ins.field_rD() as u8, ins.field_uimm() as u16); } else { - defs.remove(&ins.d()); + defs.remove(&(ins.field_rD() as u8)); } } Opcode::Addi => { - if let Some(hi) = defs.get(&ins.a()) { + if let Some(hi) = defs.get(&(ins.field_rA() as u8)) { data_refs.insert( ins.addr / 4, ((*hi as u32) << 16) + (ins.field_uimm() as u32), ); } - defs.remove(&ins.d()); + defs.remove(&(ins.field_rD() as u8)); } _ => (), } @@ -91,7 +92,7 @@ impl<'a> Debug for BasicBlock<'a> { self.range.end * 4 )?; for ins in self.code { - writeln!(f, "{}", ins.to_string())?; + writeln!(f, "{}", FormattedIns(ins.clone()))?; if let Some(addr) = self.data_refs.get(&(ins.addr / 4)) { writeln!(f, " ref: {:0>#8x}", addr)?; } @@ -154,8 +155,8 @@ impl<'a> FlowGraph<'a> { // Get last instruction of left block. // Unless it's an unconditional branch, we can connect the blocks. let last_ins = &src_block.code.last().unwrap(); - if last_ins.code == Opcode::BLR - || (last_ins.op == Opcode::B && last_ins.bo() == 0b10100) + if last_ins.code == 0x4E800020 + || (last_ins.op == Opcode::B && last_ins.field_BO() == 0b10100) { continue; } diff --git a/flow-graph/src/slices.rs b/flow-graph/src/slices.rs index 2529ec9..6b62759 100644 --- a/flow-graph/src/slices.rs +++ b/flow-graph/src/slices.rs @@ -24,7 +24,7 @@ impl BasicSlices { let is_control_flow_ins = match ins.op { // Direct branches are control flow instructions if they don't save the link register. // If they do, we encountered a function call. - Opcode::B | Opcode::Bc => ins.lk() == 0, + Opcode::B | Opcode::Bc => !ins.field_LK(), // Switch table Opcode::Bcctr => panic!("jump tables not supported yet"), _ => false, diff --git a/genisa/src/main.rs b/genisa/src/main.rs index 7fc4e04..8aad187 100644 --- a/genisa/src/main.rs +++ b/genisa/src/main.rs @@ -9,7 +9,7 @@ use itertools::Itertools; use proc_macro2::{Ident, Literal, Span, TokenStream, TokenTree}; use quote::quote; use serde::{Deserialize, Deserializer}; -use syn::{LitInt, LitStr}; +use syn::{LitChar, LitInt, LitStr}; macro_rules! token_stream { ($stream:ident) => { @@ -194,6 +194,7 @@ impl Field { quote!(usize) }; quote! { + #[inline(always)] pub fn #field_variant(&self) -> #ret_type { #value as _ } @@ -236,12 +237,32 @@ pub(crate) struct Mnemonic { pub(crate) struct Modifier { name: String, suffix: char, + bit: u8, +} + +impl Modifier { + fn express_value_self(&self) -> TokenStream { + let modifier_bit = self.bit as usize; + quote!(self.bit(#modifier_bit)) + } + + fn construct_accessor(&self) -> TokenStream { + let field_variant = to_rust_ident("field_", &self.name); + let value = self.express_value_self(); + quote! { + #[inline(always)] + pub fn #field_variant(&self) -> bool { + #value + } + } + } } #[derive(Deserialize, Default)] #[serde(default)] pub(crate) struct Isa { fields: Vec, + modifiers: Vec, opcodes: Vec, mnemonics: Vec, } @@ -294,8 +315,7 @@ impl Isa { .iter() .map(|opcode| { let variant = opcode.variant_identifier()?; - let literal = - Literal::string(opcode.name.strip_suffix('.').unwrap_or(&opcode.name)); + let literal = Literal::string(&opcode.name); Ok(quote! { Opcode::#variant => #literal, }) @@ -370,6 +390,10 @@ impl Isa { for field in &self.fields { field_by_name.insert(field.name.clone(), field); } + let mut modifier_by_name = HashMap::::new(); + for modifier in &self.modifiers { + modifier_by_name.insert(modifier.name.clone(), modifier); + } // Map mnemonics by opcode. let mut mnemonics_by_opcode = HashMap::<&String, Vec<&Mnemonic>>::new(); for simple in &self.mnemonics { @@ -382,7 +406,7 @@ impl Isa { let mut field_match_arms = Vec::new(); let mut def_match_arms = Vec::new(); let mut use_match_arms = Vec::new(); - let mut modifier_match_arms = Vec::new(); + let mut suffix_match_arms = Vec::new(); let mut simplified_ins_match_arms = Vec::new(); for opcode in &self.opcodes { // Generate fields of opcode. @@ -402,13 +426,9 @@ impl Isa { }); // Generate modifiers. - let modifiers = ModifiersExpr { - modifiers: opcode.modifiers.clone(), - side_effects: opcode.side_effects.clone(), - } - .build()?; - modifier_match_arms.push(quote! { - Opcode::#ident => #modifiers, + let suffix = express_suffix(&modifier_by_name, opcode)?; + suffix_match_arms.push(quote! { + Opcode::#ident => #suffix, }); // Generate defs. @@ -480,12 +500,6 @@ impl Isa { )?); // Emit branch. let mnemonic_lit = LitStr::new(&mnemonic.name, Span::call_site()); - // Extract modifier bits. - let modifiers = ModifiersExpr { - modifiers: mnemonic.modifiers.clone(), - side_effects: vec![], - } - .build()?; // Extract arguments. let mut args = Vec::new(); for arg in &mnemonic.args { @@ -501,7 +515,6 @@ impl Isa { { return SimplifiedIns { mnemonic: #mnemonic_lit, - modifiers: #modifiers, args: vec![#args], ins: self, }; @@ -519,7 +532,7 @@ impl Isa { let field_match_arms = token_stream!(field_match_arms); let def_match_arms = token_stream!(def_match_arms); let use_match_arms = token_stream!(use_match_arms); - let modifier_match_arms = token_stream!(modifier_match_arms); + let suffix_match_arms = token_stream!(suffix_match_arms); let simplified_ins_match_arms = token_stream!(simplified_ins_match_arms); let field_accessors = self .fields @@ -527,6 +540,12 @@ impl Isa { .map(|field| field.construct_accessor()) .collect::>(); let field_accessors = token_stream!(field_accessors); + let modifier_accessors = self + .modifiers + .iter() + .map(|modifier| modifier.construct_accessor()) + .collect::>(); + let modifier_accessors = token_stream!(modifier_accessors); // Generate final fields function. let ins_impl = quote! { #[allow(clippy::all, unused_mut)] @@ -552,10 +571,10 @@ impl Isa { } } - pub(crate) fn _modifiers(&self) -> Modifiers { + pub(crate) fn _suffix(&self) -> String { match self.op { - Opcode::Illegal => Modifiers::default(), - #modifier_match_arms + Opcode::Illegal => String::new(), + #suffix_match_arms } } @@ -570,6 +589,7 @@ impl Isa { #[allow(clippy::all, non_snake_case)] impl Ins { #field_accessors + #modifier_accessors } }; Ok(ins_impl) @@ -624,56 +644,6 @@ fn to_rust_variant_str(key: &str) -> Result { } } -#[derive(Default)] -pub(crate) struct ModifiersExpr { - pub(crate) modifiers: Vec, - pub(crate) side_effects: Vec, -} - -impl ModifiersExpr { - fn build(&self) -> Result { - if self.modifiers.is_empty() && self.side_effects.is_empty() { - return Ok(Self::build_empty()); - } - let mut statements: Vec = Vec::new(); - for modifier in &self.modifiers { - statements.extend(match modifier.as_str() { - "OE" => quote! { m.oe = self.bit(21); }, - "Rc" => quote! { m.rc = self.bit(31); }, - "AA" => quote! { m.aa = self.bit(30); }, - "LK" => quote! { m.lk = self.bit(31); }, - _ => { - return Err(format!("unsupported modifier {}", modifier).into()); - } - }) - } - for modifier in &self.side_effects { - statements.extend(match modifier.as_str() { - // TODO dedup modifiers - "OE" => quote! { m.oe = true; }, - "Rc" => quote! { m.rc = true; }, - "AA" => quote! { m.aa = true; }, - "LK" => quote! { m.lk = true; }, - _ => { - return Err(format!("unsupported modifier {}", modifier).into()); - } - }) - } - let statements = token_stream!(statements); - Ok(quote! { - { - let mut m = Modifiers::default(); - #statements - m - } - }) - } - - fn build_empty() -> TokenStream { - quote!(Modifiers::default()) - } -} - /// Compiles conditions such as `S == B` into valid Rust expressions on a PowerPC instruction. fn compile_mnemonic_condition( field_by_name: &HashMap, @@ -690,3 +660,34 @@ fn compile_mnemonic_condition( }); Ok(TokenStream::from_iter(token_iter)) } + +fn express_suffix( + modifier_by_name: &HashMap, + opcode: &Opcode, +) -> Result { + Ok(if opcode.modifiers.is_empty() { + quote!(String::new()) + } else { + let mut chars = Vec::new(); + for mod_name in &opcode.modifiers { + let modifier: &Modifier = modifier_by_name + .get(mod_name) + .ok_or_else(|| Error::from(format!("undefined modifier {}", mod_name)))?; + let lit_char = LitChar::new(modifier.suffix, Span::call_site()); + let modifier_bit = modifier.express_value_self(); + chars.push(quote! { + if #modifier_bit { + s.push(#lit_char); + } + }); + } + let chars = token_stream!(chars); + quote!({ + { + let mut s = String::with_capacity(4); + #chars + s + } + }) + }) +} diff --git a/isa.yaml b/isa.yaml index 2392c73..9f196ba 100644 --- a/isa.yaml +++ b/isa.yaml @@ -141,12 +141,16 @@ fields: modifiers: - name: OE suffix: o + bit: 21 - name: Rc suffix: . + bit: 31 - name: LK suffix: l + bit: 31 - name: AA suffix: a + bit: 30 opcodes: - name: add