refactor(codegen): register compiled bytecode in backtrace

codegen/src/backtrace.rs

@@ -1,32 +1,36 @@
 //! Backtrace support for the code generation.
+use std::collections::BTreeMap;
 
 /// Backtrace implementation for the code generation.
 ///
-/// TODO: full implementation #21
+/// TODO: full implementation (#21)
 #[derive(Default)]
 pub struct Backtrace {
-    /// The length of each operand.
-    len: Vec<usize>,
+    /// Compiled instructions.
+    ///
+    /// TODO: Transform this into Opcodes. (#21)
+    instrs: BTreeMap<usize, Vec<u8>>,
 }
 
 impl Backtrace {
-    /// Pushes a new operand to the backtrace.
-    pub fn push(&mut self, len: usize) {
-        self.len.push(len);
+    /// Pushes a new instruction set to the backtrace.
+    pub fn push(&mut self, bytes: impl AsRef<[u8]>) {
+        self.instrs.insert(self.instrs.len(), bytes.as_ref().into());
     }
 
-    /// Pops the last operand from the backtrace.
-    pub fn pop(&mut self) -> usize {
-        self.len.pop().unwrap_or_default()
+    /// Pops the last instruction from the backtrace.
+    pub fn pop(&mut self) -> Vec<u8> {
+        self.instrs.pop_last().unwrap_or_default().1
     }
 
-    pub fn popn(&mut self, n: usize) -> usize {
-        let mut r: Vec<usize> = Default::default();
+    /// Pop the last `n` operands from the backtrace.
+    pub fn popn(&mut self, n: usize) -> Vec<Vec<u8>> {
+        let mut r: Vec<Vec<u8>> = Default::default();
 
         while r.len() < n {
             r.push(self.pop())
         }
 
-        r.into_iter().sum()
+        r
     }
 }

codegen/src/visitor/log.rs

@@ -8,7 +8,7 @@ impl CodeGen {
         let buffer: Vec<u8> = self.masm.buffer().into();
 
         // Pop offset and size from the bytecode.
-        let data_len = self.backtrace.popn(2);
+        let data_len = self.backtrace.popn(2).concat().len();
         let data = &buffer[(buffer.len() - data_len)..];
         *self.masm.buffer_mut() = buffer[..(buffer.len() - data_len)].into();
 

codegen/src/visitor/mod.rs

@@ -46,8 +46,8 @@ macro_rules! map_wasm_operators {
                 let before = self.masm.buffer().len();
                 self.masm.[< _ $evm >]()?;
 
-                let after = self.masm.buffer().len();
-                self.backtrace.push(after - before);
+                let instr = self.masm.buffer()[before..].to_vec();
+                self.backtrace.push(instr);
 
                 Ok(())
             }
@@ -100,8 +100,9 @@ macro_rules! map_wasm_operators {
 
                 let before = self.masm.buffer().len();
                 self.$($field.)*[< _ $evm >]($($arg),*)?;
-                let after = self.masm.buffer().len();
-                self.backtrace.push(after - before);
+
+                let instr = self.masm.buffer()[before..].to_vec();
+                self.backtrace.push(instr);
                 Ok(())
             }
         }