feat: some stubs for (ternary) bit vectors (#9)

Cargo.toml

@@ -9,7 +9,7 @@ description = "Monster is a symbolic execution engine for 64-bit RISC-V code"
 goblin = "0.2"
 byteorder = "1.3.4"
 clap = "3.0.0-beta.1"
-riscv-decode = "0.2.0"
+riscv-decode = { git = "https://github.com/cksystemsgroup/riscv-decode" }
 petgraph = "0.5.1"
 
 [dev-dependencies]

src/bitvec.rs

@@ -0,0 +1,11 @@
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct BitVector {
+    pub(crate) value: u64,
+}
+
+impl BitVector {
+    #[allow(dead_code)]
+    fn new(value: u64) -> Self {
+        BitVector { value }
+    }
+}

src/engine.rs

@@ -0,0 +1,39 @@
+use crate::ternary::TernaryBitVector;
+
+struct Machine {
+    #[allow(dead_code)]
+    regs: [TernaryBitVector; 32],
+}
+
+impl Machine {
+    #[allow(dead_code)]
+    fn new() -> Self {
+        Machine {
+            regs: [TernaryBitVector::new(0, u64::max_value()); 32],
+        }
+    }
+}
+
+// fn has_inv_value_for_addi(raw: IType) -> bool {
+//     true
+// }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use riscv_decode::types::*;
+    use riscv_decode::Instruction;
+
+    #[test]
+    fn can_find_input_for_addi() {
+        let machine = Machine::new();
+
+        let raw = IType(0);
+        let _addi = Instruction::Addi(raw);
+
+        let _rd = raw.rd();
+        let _rs1_value = machine.regs[raw.rs1() as usize];
+
+        let _s = raw.imm();
+    }
+}

src/main.rs

@@ -2,11 +2,14 @@ use clap::{App, Arg};
 use std::fmt::Display;
 use std::path::Path;
 
+mod bitvec;
 mod cfg;
 mod compile;
 mod decode;
 mod disassemble;
 mod elf;
+mod engine;
+mod ternary;
 
 use compile::compile_example;
 use disassemble::disassemble_riscu;

src/ternary.rs

@@ -0,0 +1,25 @@
+use crate::bitvec::BitVector;
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct TernaryBitVector {
+    xlo: u64,
+    xhi: u64,
+}
+
+impl TernaryBitVector {
+    pub fn new(xlo: u64, xhi: u64) -> Self {
+        assert!(Self::valid(xlo, xhi), "is not a valid ternary bit vector");
+        Self { xlo, xhi }
+    }
+
+    /// verifies that these two values can form a valid ternary bit vector
+    pub fn valid(xlo: u64, xhi: u64) -> bool {
+        !xlo | xhi == u64::max_value()
+    }
+
+    /// verifies that all constant bits of a ternary bit vector match a bit vector
+    #[allow(dead_code)]
+    pub fn mcb(&self, other: &BitVector) -> bool {
+        (self.xhi & other.value == other.value) && (self.xlo | other.value == other.value)
+    }
+}