1 files changed, 80 insertions, 0 deletions
diff --git a/rust/src/llil/mod.rs b/rust/src/llil/mod.rs
new file mode 100644
index 00000000..c3b1b350
--- /dev/null
+++ b/rust/src/llil/mod.rs
@@ -0,0 +1,80 @@
+use std::fmt;
+
+// TODO provide some way to forbid emitting register reads for certain registers
+// also writing for certain registers (e.g. zero register must prohibit il.set_reg and il.reg
+// (replace with nop or const(0) respectively)
+// requirements on load/store memory address sizes?
+// can reg/set_reg be used with sizes that differ from what is in BNRegisterInfo?
+
+use crate::architecture::Register as ArchReg;
+use crate::architecture::Architecture;
+use crate::function::Location;
+
+mod function;
+mod instruction;
+mod expression;
+mod lifting;
+mod block;
+pub mod operation;
+
+pub use self::function::*;
+pub use self::instruction::*;
+pub use self::expression::*;
+pub use self::lifting::{Liftable, LiftableWithSize, Label, ExpressionBuilder, FlagWriteOp, RegisterOrConstant};
+pub use self::lifting::get_default_flag_write_llil;
+pub use self::lifting::get_default_flag_cond_llil;
+
+pub use self::block::Block as LowLevelBlock;
+pub use self::block::BlockIter as LowLevelBlockIter;
+
+pub type Lifter<Arch> = Function<Arch, Mutable, NonSSA<LiftedNonSSA>>;
+pub type LiftedFunction<Arch> = Function<Arch, Finalized, NonSSA<LiftedNonSSA>>;
+pub type LiftedExpr<'a, Arch> = Expression<'a, Arch, Mutable, NonSSA<LiftedNonSSA>, ValueExpr>;
+pub type RegularFunction<Arch> = Function<Arch, Finalized, NonSSA<RegularNonSSA>>;
+pub type SSAFunction<Arch> = Function<Arch, Finalized, SSA>;
+
+#[derive(Copy, Clone)]
+pub enum Register<R: ArchReg> {
+    ArchReg(R),
+    Temp(u32),
+}
+
+impl<R: ArchReg> Register<R> {
+    fn id(&self) -> u32 {
+        match *self {
+            Register::ArchReg(ref r) => r.id(),
+            Register::Temp(id) => 0x8000_0000 | id,
+        }
+    }
+}
+
+impl<R: ArchReg> fmt::Debug for Register<R> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Register::ArchReg(ref r) => write!(f, "{}", r.name().as_ref()),
+            Register::Temp(id) => write!(f, "temp{}", id),
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum SSARegister<R: ArchReg> {
+    Full(Register<R>, u32), // no such thing as partial access to a temp register, I think
+    Partial(R, u32, R), // partial accesses only possible for arch registers, I think
+}
+
+impl<R: ArchReg> SSARegister<R> {
+    pub fn version(&self) -> u32 {
+        match *self {
+            SSARegister::Full(_, ver) |
+            SSARegister::Partial(_, ver, _) => ver
+        }
+    }
+}
+
+pub enum VisitorAction {
+    Descend,
+    Sibling,
+    Halt,
+}
+