[WIP] replace 'ir with owning pointers

isla-lib/Cargo.toml

@@ -23,9 +23,14 @@ lalrpop-util = "0.19.0"
 crossbeam = "0.7.3"
 lazy_static = "1.4.0"
 toml = "0.5.5"
-z3-sys = "0.5.0"
+z3-sys = { path = "C:\\Users\\Benni\\repositories\\z3.rs\\z3-sys" }
 libc = "0.2.5"
 serde = "1.0.104"
 bincode = "1.2.1"
 sha2 = "0.8.1"
 petgraph = "0.5.0"
+elfloader = { path = "C:\\Users\\Benni\\repositories\\rust-elfloader" }
+
+[[bin]]
+name = "test"
+path = "src/test.rs"

isla-lib/src/elf_loader.rs

@@ -0,0 +1,63 @@
+use std::collections::HashMap;
+use std::fs;
+
+use crate::memory::Memory;
+use crate::concrete::BV;
+
+use elfloader::*;
+
+/// A simple ExampleLoader, that implements ElfLoader
+/// but does nothing but logging
+struct ExampleLoader<'ir, B: BV> {
+    memory: &'ir mut Memory<B>
+}
+
+impl<'ir, B: BV> ElfLoader for ExampleLoader<'ir, B> {
+    fn allocate(&mut self, load_headers: LoadableHeaders) -> Result<(), &'static str> {
+        for header in load_headers {
+            let base = header.virtual_addr();
+            let end = base + header.mem_size();
+            self.memory.add_concrete_region(base..end, HashMap::new());
+            println!(
+                "allocate base = {:#x} size = {:#x} flags = {}",
+                header.virtual_addr(),
+                header.mem_size(),
+                header.flags()
+            );
+        }
+        Ok(())
+    }
+
+    fn relocate(&mut self, _entry: &Rela<P64>) -> Result<(), &'static str> {
+        unimplemented!()
+    }
+
+    fn load(&mut self, _flags: Flags, base: VAddr, region: &[u8]) -> Result<(), &'static str> {
+        let start = base;
+        let end = base + region.len() as u64;
+        let mut i = 0;
+        for b in region {
+            self.memory.write_byte(start + i, *b);
+            i += 1;
+        }
+        println!("load region into = {:#x} -- {:#x}", start, end);
+        Ok(())
+    }
+
+    fn tls(
+        &mut self,
+        _tdata_start: VAddr,
+        _tdata_length: u64,
+        _total_size: u64,
+        _align: u64
+    ) -> Result<(), &'static str> {
+        unimplemented!()
+    }
+}
+
+pub fn load_elf<'ir, B: BV>(path: &str, memory: &'ir mut Memory<B>) {
+    let binary_blob = fs::read(path).expect("Can't read binary");
+    let binary = ElfBinary::new("test", binary_blob.as_slice()).expect("Got proper ELF file");
+    let mut loader = ExampleLoader { memory: memory };
+    binary.load(&mut loader).expect("Can't load the binary?");
+}

isla-lib/src/error.rs

@@ -29,6 +29,8 @@
 
 use std::error::Error;
 use std::fmt;
+use crate::executor::Backtrace;
+use crate::ir::SharedState;
 
 #[derive(Debug)]
 pub enum ExecError {
@@ -75,3 +77,13 @@ impl Error for ExecError {
         None
     }
 }
+
+impl ExecError {
+    pub fn to_string<'ir, B>(&self, bt: &Backtrace, shared_state: &SharedState<B>) -> String {
+        let mut stacktrace = format!("{}:\n", &self);
+        for (name, num) in bt {
+            stacktrace.push_str(&format!("    {} ({})\n", &shared_state.symtab.to_str(*name), num));
+        }
+        stacktrace
+    }
+}