Add AArch64 support for singlepass.

Cargo.toml

@@ -58,7 +58,8 @@ members = [
     "lib/wasi-tests",
     "lib/emscripten-tests",
     "lib/middleware-common-tests",
-    "examples/plugin-for-example"
+    "examples/plugin-for-example",
+    "examples/hello_world"
 ]
 
 [build-dependencies]

examples/fib.wat

@@ -0,0 +1,20 @@
+(module
+    (func $main (result i32)
+        (call $fib (i32.const 40))
+    )
+
+    (func $fib (param $n i32) (result i32)
+        (if (i32.eq (get_local $n) (i32.const 0))
+            (then (return (i32.const 1)))
+        )
+        (if (i32.eq (get_local $n) (i32.const 1))
+            (then (return (i32.const 1)))
+        )
+        (i32.add
+            (call $fib (i32.sub (get_local $n) (i32.const 1)))
+            (call $fib (i32.sub (get_local $n) (i32.const 2)))
+        )
+    )
+
+    (export "main" (func $main))
+)

examples/hello_world/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "hello_world"
+version = "0.1.0"
+authors = ["losfair <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

examples/hello_world/src/main.rs

@@ -0,0 +1,7 @@
+fn main() {
+    for i in 0..8 {
+        let s = format!("Hello, {}", i);
+        println!("{}", s);
+    }
+    panic!("OK");
+}

examples/iterative_hash/src/main.rs

@@ -20,7 +20,7 @@ fn main() {
             let diff = millis - last_millis;
             if diff >= 100 {
                 record_count += 1;
-                println!("{}", (i - round_count) as f64 / diff as f64);
+                println!("{}", ((i - round_count) as u128) * 1000000 / diff );
                 last_millis = millis;
                 round_count = i;
             }

lib/middleware-common/src/block_trace.rs

@@ -0,0 +1,153 @@
+use wasmer_runtime_core::{
+    codegen::{Event, EventSink, FunctionMiddleware, InternalEvent},
+    module::ModuleInfo,
+    wasmparser::Operator,
+};
+
+pub struct BlockTrace {
+    func_idx: usize,
+    evt_idx: usize,
+}
+
+impl BlockTrace {
+    pub fn new() -> BlockTrace {
+        BlockTrace {
+            func_idx: std::usize::MAX,
+            evt_idx: 0,
+        }
+    }
+}
+
+impl FunctionMiddleware for BlockTrace {
+    type Error = String;
+    fn feed_event<'a, 'b: 'a>(
+        &mut self,
+        op: Event<'a, 'b>,
+        _module_info: &ModuleInfo,
+        sink: &mut EventSink<'a, 'b>,
+    ) -> Result<(), Self::Error> {
+        match op {
+            Event::Internal(InternalEvent::FunctionBegin(_)) => {
+                self.func_idx = self.func_idx.wrapping_add(1);
+                self.evt_idx = 0;
+                let func_idx = self.func_idx;
+                let evt_idx = self.evt_idx;
+                sink.push(op);
+                sink.push(Event::Internal(InternalEvent::Breakpoint(Box::new(
+                    move |info| {
+                        eprintln!(
+                            "[BlockTrace] ({}, {}) -> enter_func % {:?}",
+                            func_idx,
+                            evt_idx,
+                            info.fault
+                                .and_then(|x| unsafe { x.read_stack(Some(1)) })
+                                .unwrap()
+                                .frames[0]
+                        );
+                        Ok(())
+                    },
+                ))))
+            }
+            Event::Wasm(Operator::Call { .. }) => {
+                let func_idx = self.func_idx;
+                let evt_idx = self.evt_idx;
+                sink.push(op);
+                sink.push(Event::Internal(InternalEvent::Breakpoint(Box::new(
+                    move |info| {
+                        eprintln!(
+                            "[BlockTrace] ({}, {}) -> leave_call % {:?}",
+                            func_idx,
+                            evt_idx,
+                            info.fault
+                                .and_then(|x| unsafe { x.read_stack(Some(1)) })
+                                .unwrap()
+                                .frames[0]
+                        );
+                        Ok(())
+                    },
+                ))))
+            }
+            Event::Wasm(Operator::Block { .. }) => {
+                let func_idx = self.func_idx;
+                let evt_idx = self.evt_idx;
+                sink.push(op);
+                sink.push(Event::Internal(InternalEvent::Breakpoint(Box::new(
+                    move |info| {
+                        eprintln!(
+                            "[BlockTrace] ({}, {}) -> block % {:?}",
+                            func_idx,
+                            evt_idx,
+                            info.fault
+                                .and_then(|x| unsafe { x.read_stack(Some(1)) })
+                                .unwrap()
+                                .frames[0]
+                        );
+                        Ok(())
+                    },
+                ))))
+            }
+            Event::Wasm(Operator::Loop { .. }) => {
+                let func_idx = self.func_idx;
+                let evt_idx = self.evt_idx;
+                sink.push(op);
+                sink.push(Event::Internal(InternalEvent::Breakpoint(Box::new(
+                    move |info| {
+                        eprintln!(
+                            "[BlockTrace] ({}, {}) -> loop % {:?}",
+                            func_idx,
+                            evt_idx,
+                            info.fault
+                                .and_then(|x| unsafe { x.read_stack(Some(1)) })
+                                .unwrap()
+                                .frames[0]
+                        );
+                        Ok(())
+                    },
+                ))))
+            }
+            Event::Wasm(Operator::If { .. }) => {
+                let func_idx = self.func_idx;
+                let evt_idx = self.evt_idx;
+                sink.push(op);
+                sink.push(Event::Internal(InternalEvent::Breakpoint(Box::new(
+                    move |info| {
+                        eprintln!(
+                            "[BlockTrace] ({}, {}) -> if % {:?}",
+                            func_idx,
+                            evt_idx,
+                            info.fault
+                                .and_then(|x| unsafe { x.read_stack(Some(1)) })
+                                .unwrap()
+                                .frames[0]
+                        );
+                        Ok(())
+                    },
+                ))))
+            }
+            Event::Wasm(Operator::Else { .. }) => {
+                let func_idx = self.func_idx;
+                let evt_idx = self.evt_idx;
+                sink.push(op);
+                sink.push(Event::Internal(InternalEvent::Breakpoint(Box::new(
+                    move |info| {
+                        eprintln!(
+                            "[BlockTrace] ({}, {}) -> else % {:?}",
+                            func_idx,
+                            evt_idx,
+                            info.fault
+                                .and_then(|x| unsafe { x.read_stack(Some(1)) })
+                                .unwrap()
+                                .frames[0]
+                        );
+                        Ok(())
+                    },
+                ))))
+            }
+            _ => {
+                sink.push(op);
+            }
+        }
+        self.evt_idx += 1;
+        Ok(())
+    }
+}

lib/middleware-common/src/call_trace.rs

@@ -1,9 +1,23 @@
+use std::sync::{
+    atomic::{AtomicU32, Ordering},
+    Arc,
+};
 use wasmer_runtime_core::{
     codegen::{Event, EventSink, FunctionMiddleware, InternalEvent},
     module::ModuleInfo,
 };
 
-pub struct CallTrace;
+pub struct CallTrace {
+    counter: Arc<AtomicU32>,
+}
+
+impl CallTrace {
+    pub fn new() -> CallTrace {
+        CallTrace {
+            counter: Arc::new(AtomicU32::new(0)),
+        }
+    }
+}
 
 impl FunctionMiddleware for CallTrace {
     type Error = String;
@@ -13,10 +27,13 @@ impl FunctionMiddleware for CallTrace {
         _module_info: &ModuleInfo,
         sink: &mut EventSink<'a, 'b>,
     ) -> Result<(), Self::Error> {
+        let counter = self.counter.clone();
+
         match op {
             Event::Internal(InternalEvent::FunctionBegin(id)) => sink.push(Event::Internal(
                 InternalEvent::Breakpoint(Box::new(move |_| {
-                    eprintln!("func ({})", id);
+                    let idx = counter.fetch_add(1, Ordering::SeqCst);
+                    eprintln!("[{}] func ({})", idx, id);
                     Ok(())
                 })),
             )),

lib/middleware-common/src/lib.rs

@@ -10,5 +10,6 @@
 #![doc(html_favicon_url = "https://wasmer.io/static/icons/favicon.ico")]
 #![doc(html_logo_url = "https://avatars3.githubusercontent.com/u/44205449?s=200&v=4")]
 
+pub mod block_trace;
 pub mod call_trace;
 pub mod metering;

lib/runtime-core/src/backend.rs

@@ -70,6 +70,82 @@ impl std::str::FromStr for Backend {
     }
 }
 
+#[derive(Copy, Clone, Debug)]
+pub enum Architecture {
+    X64,
+    Aarch64,
+}
+
+#[repr(u8)]
+#[derive(Copy, Clone, Debug)]
+pub enum InlineBreakpointType {
+    Trace,
+    Middleware,
+    Unknown,
+}
+
+#[derive(Clone, Debug)]
+pub struct InlineBreakpoint {
+    pub size: usize,
+    pub ty: InlineBreakpointType,
+}
+
+pub fn get_inline_breakpoint_size(arch: Architecture, backend: Backend) -> Option<usize> {
+    match (arch, backend) {
+        (Architecture::X64, Backend::Singlepass) => Some(7),
+        (Architecture::Aarch64, Backend::Singlepass) => Some(12),
+        _ => None,
+    }
+}
+
+pub fn read_inline_breakpoint(
+    arch: Architecture,
+    backend: Backend,
+    code: &[u8],
+) -> Option<InlineBreakpoint> {
+    match arch {
+        Architecture::X64 => match backend {
+            Backend::Singlepass => {
+                if code.len() < 7 {
+                    None
+                } else if &code[..6] == &[0x0f, 0x0b, 0x0f, 0xb9, 0xcd, 0xff] {
+                    // ud2 ud (int 0xff) code
+                    Some(InlineBreakpoint {
+                        size: 7,
+                        ty: match code[6] {
+                            0 => InlineBreakpointType::Trace,
+                            1 => InlineBreakpointType::Middleware,
+                            _ => InlineBreakpointType::Unknown,
+                        },
+                    })
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        },
+        Architecture::Aarch64 => match backend {
+            Backend::Singlepass => {
+                if code.len() < 12 {
+                    None
+                } else if &code[..8] == &[0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff] {
+                    Some(InlineBreakpoint {
+                        size: 12,
+                        ty: match code[8] {
+                            0 => InlineBreakpointType::Trace,
+                            1 => InlineBreakpointType::Middleware,
+                            _ => InlineBreakpointType::Unknown,
+                        },
+                    })
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        },
+    }
+}
+
 #[cfg(test)]
 mod backend_test {
     use super::*;

lib/runtime-core/src/codegen.rs

@@ -3,6 +3,7 @@ use crate::{
     backend::{Backend, CacheGen, Compiler, CompilerConfig, Features, Token},
     cache::{Artifact, Error as CacheError},
     error::{CompileError, CompileResult},
+    fault::FaultInfo,
     module::{ModuleInfo, ModuleInner},
     structures::Map,
     types::{FuncIndex, FuncSig, SigIndex},
@@ -49,7 +50,7 @@ impl fmt::Debug for InternalEvent {
 }
 
 pub struct BreakpointInfo<'a> {
-    pub fault: Option<&'a dyn Any>,
+    pub fault: Option<&'a FaultInfo>,
 }
 
 pub trait ModuleCodeGenerator<FCG: FunctionCodeGenerator<E>, RM: RunnableModule, E: Debug> {