Propagate generic type T in udbserver to support custom Unicorn user data

bet4it · bet4it · commit 613e832e7a6f · 2026-01-08T08:46:08.000+08:00
diff --git a/examples/server.rs b/examples/server.rs
@@ -1,6 +1,10 @@
 use unicorn_engine::unicorn_const::{Arch, Mode, Prot};
 use unicorn_engine::{RegisterARM, Unicorn};
 
+struct CustomData {
+    pub _val: u32,
+}
+
 fn main() {
     let arm_code32: Vec<u8> = vec![
         0x0f, 0x00, 0xa0, 0xe1, 0x14, 0x00, 0x80, 0xe2, 0x00, 0x10, 0x90, 0xe5, 0x14, 0x10, 0x81, 0xe2, 0x00, 0x10, 0x80, 0xe5, 0xfb, 0xff, 0xff, 0xea,
diff --git a/src/emu.rs b/src/emu.rs
@@ -33,29 +33,29 @@ fn copy_range_to_buf(data: &[u8], offset: u64, length: usize, buf: &mut [u8]) ->
     copy_to_buf(data, buf)
 }
 
-fn step_cb(uc: &mut Unicorn<()>, _addr: u64, _size: u32) {
+fn step_cb<T: 'static>(uc: &mut Unicorn<T>, _addr: u64, _size: u32) {
     if *STEP_STATE.get() {
         STEP_STATE.replace(false);
         return;
     }
     if let Some(step_hook) = STEP_HOOK.take() {
         uc.remove_hook(step_hook).expect("Failed to remove step hook");
     }
-    crate::udbserver_resume(WATCH_ADDR.take()).expect("Failed to resume udbserver");
+    crate::udbserver_resume::<T>(WATCH_ADDR.take()).expect("Failed to resume udbserver");
 }
 
-fn watch_cb(uc: &mut Unicorn<()>, _mem_type: MemType, addr: u64, _size: usize, _value: i64) -> bool {
+fn watch_cb<T: 'static>(uc: &mut Unicorn<T>, _mem_type: MemType, addr: u64, _size: usize, _value: i64) -> bool {
     if WATCH_ADDR.is_none() {
         WATCH_ADDR.replace(addr);
         if STEP_HOOK.is_none() {
-            STEP_HOOK.replace(uc.add_code_hook(1, 0, step_cb).expect("Failed to add code hook"));
+            STEP_HOOK.replace(uc.add_code_hook(1, 0, step_cb::<T>).expect("Failed to add code hook"));
         }
     }
     true
 }
 
-pub struct Emu {
-    uc: &'static mut Unicorn<'static, ()>,
+pub struct Emu<T: 'static> {
+    uc: &'static mut Unicorn<'static, T>,
     reg: Register,
     code_hook: UcHookId,
     mem_hook: UcHookId,
@@ -66,8 +66,8 @@ pub struct Emu {
     wp_rw_hooks: HashMap<u64, HashMap<u64, UcHookId>>,
 }
 
-impl Emu {
-    pub fn new(uc: &'static mut Unicorn<'static, ()>, code_hook: UcHookId, mem_hook: UcHookId) -> DynResult<Emu> {
+impl<T: 'static> Emu<T> {
+    pub fn new(uc: &'static mut Unicorn<'static, T>, code_hook: UcHookId, mem_hook: UcHookId) -> DynResult<Emu<T>> {
         let arch = uc.get_arch();
         let query_mode = uc.query(Query::MODE).expect("Failed to query mode");
         let mode = Mode::try_from(query_mode as i32).unwrap();
@@ -86,14 +86,14 @@ impl Emu {
     }
 }
 
-impl Drop for Emu {
+impl<T: 'static> Drop for Emu<T> {
     fn drop(&mut self) {
         self.uc.remove_hook(self.code_hook).expect("Failed to remove empty code hook");
         self.uc.remove_hook(self.mem_hook).expect("Failed to remove empty mem hook");
     }
 }
 
-impl target::Target for Emu {
+impl<T: 'static> target::Target for Emu<T> {
     type Arch = arch::GenericArch;
     type Error = &'static str;
 
@@ -113,7 +113,7 @@ impl target::Target for Emu {
     }
 }
 
-impl target::ext::base::singlethread::SingleThreadBase for Emu {
+impl<T: 'static> target::ext::base::singlethread::SingleThreadBase for Emu<T> {
     fn read_registers(&mut self, regs: &mut arch::GenericRegs) -> TargetResult<(), Self> {
         regs.buf = Vec::new();
         for reg in self.reg.list() {
@@ -166,7 +166,7 @@ impl target::ext::base::singlethread::SingleThreadBase for Emu {
     }
 }
 
-impl target::ext::base::singlethread::SingleThreadResume for Emu {
+impl<T: 'static> target::ext::base::singlethread::SingleThreadResume for Emu<T> {
     fn resume(&mut self, _signal: Option<Signal>) -> Result<(), Self::Error> {
         Ok(())
     }
@@ -177,20 +177,20 @@ impl target::ext::base::singlethread::SingleThreadResume for Emu {
     }
 }
 
-impl target::ext::base::singlethread::SingleThreadSingleStep for Emu {
+impl<T: 'static> target::ext::base::singlethread::SingleThreadSingleStep for Emu<T> {
     fn step(&mut self, signal: Option<Signal>) -> Result<(), Self::Error> {
         if signal.is_some() {
             return Err("no support for stepping with signal");
         }
 
         STEP_STATE.replace(true);
-        STEP_HOOK.replace(self.uc.add_code_hook(1, 0, step_cb).map_err(|_| "Failed to add code hook")?);
+        STEP_HOOK.replace(self.uc.add_code_hook(1, 0, step_cb::<T>).map_err(|_| "Failed to add code hook")?);
 
         Ok(())
     }
 }
 
-impl target::ext::breakpoints::Breakpoints for Emu {
+impl<T: 'static> target::ext::breakpoints::Breakpoints for Emu<T> {
     #[inline(always)]
     fn support_sw_breakpoint(&mut self) -> Option<target::ext::breakpoints::SwBreakpointOps<'_, Self>> {
         Some(self)
@@ -209,15 +209,18 @@ impl target::ext::breakpoints::Breakpoints for Emu {
 
 macro_rules! add_breakpoint {
     ( $self:ident, $addr:ident, $hook_map:ident ) => {{
-        let hook = match $self.uc.add_code_hook($addr.into(), $addr.into(), step_cb) {
+        let hook = match $self.uc.add_code_hook($addr.into(), $addr.into(), step_cb::<T>) {
             Ok(h) => h,
             Err(_) => return Ok(false),
         };
         $self.$hook_map.insert($addr.into(), hook);
         Ok(true)
     }};
     ( $self:ident, $mem_type:ident, $addr:ident, $len:ident, $hook_map:ident ) => {{
-        let hook = match $self.uc.add_mem_hook(HookType::$mem_type, $addr.into(), ($addr + $len - 1).into(), watch_cb) {
+        let hook = match $self
+            .uc
+            .add_mem_hook(HookType::$mem_type, $addr.into(), ($addr + $len - 1).into(), watch_cb::<T>)
+        {
             Ok(h) => h,
             Err(_) => return Ok(false),
         };
@@ -253,7 +256,7 @@ macro_rules! remove_breakpoint {
     }};
 }
 
-impl target::ext::breakpoints::SwBreakpoint for Emu {
+impl<T: 'static> target::ext::breakpoints::SwBreakpoint for Emu<T> {
     fn add_sw_breakpoint(&mut self, addr: u64, _kind: usize) -> TargetResult<bool, Self> {
         add_breakpoint!(self, addr, bp_sw_hooks)
     }
@@ -263,7 +266,7 @@ impl target::ext::breakpoints::SwBreakpoint for Emu {
     }
 }
 
-impl target::ext::breakpoints::HwBreakpoint for Emu {
+impl<T: 'static> target::ext::breakpoints::HwBreakpoint for Emu<T> {
     fn add_hw_breakpoint(&mut self, addr: u64, _kind: usize) -> TargetResult<bool, Self> {
         add_breakpoint!(self, addr, bp_hw_hooks)
     }
@@ -273,7 +276,7 @@ impl target::ext::breakpoints::HwBreakpoint for Emu {
     }
 }
 
-impl target::ext::breakpoints::HwWatchpoint for Emu {
+impl<T: 'static> target::ext::breakpoints::HwWatchpoint for Emu<T> {
     fn add_hw_watchpoint(&mut self, addr: u64, len: u64, kind: WatchKind) -> TargetResult<bool, Self> {
         match kind {
             WatchKind::Read => add_breakpoint!(self, MEM_READ, addr, len, wp_r_hooks),
@@ -291,7 +294,7 @@ impl target::ext::breakpoints::HwWatchpoint for Emu {
     }
 }
 
-impl target::ext::base::single_register_access::SingleRegisterAccess<()> for Emu {
+impl<T: 'static> target::ext::base::single_register_access::SingleRegisterAccess<()> for Emu<T> {
     fn read_register(&mut self, _tid: (), reg_id: arch::GenericRegId, buf: &mut [u8]) -> TargetResult<usize, Self> {
         let reg = self.reg.get(reg_id.0)?;
         if reg.1 <= 8 {
@@ -323,7 +326,7 @@ impl target::ext::base::single_register_access::SingleRegisterAccess<()> for Emu
     }
 }
 
-impl target::ext::target_description_xml_override::TargetDescriptionXmlOverride for Emu {
+impl<T: 'static> target::ext::target_description_xml_override::TargetDescriptionXmlOverride for Emu<T> {
     fn target_description_xml(&self, _annex: &[u8], offset: u64, length: usize, buf: &mut [u8]) -> TargetResult<usize, Self> {
         let xml = self.reg.description_xml().as_bytes();
         Ok(copy_range_to_buf(xml, offset, length, buf))
diff --git a/src/lib.rs b/src/lib.rs
@@ -10,15 +10,16 @@ use gdbstub::stub::state_machine::GdbStubStateMachine;
 use gdbstub::stub::{DisconnectReason, GdbStubBuilder, SingleThreadStopReason};
 use gdbstub::target::ext::breakpoints::WatchKind;
 use singlyton::SingletonOption;
+use std::any::Any;
 use std::borrow::BorrowMut;
 use std::net::{TcpListener, TcpStream};
 use unicorn_engine::unicorn_const::HookType;
 use unicorn_engine::Unicorn;
 
 type DynResult<T> = Result<T, Box<dyn std::error::Error>>;
 
-static GDBSTUB: SingletonOption<GdbStubStateMachine<emu::Emu, TcpStream>> = SingletonOption::new();
-static EMU: SingletonOption<emu::Emu> = SingletonOption::new();
+static GDBSTUB: SingletonOption<Box<dyn Any>> = SingletonOption::new();
+static EMU: SingletonOption<Box<dyn Any>> = SingletonOption::new();
 
 fn wait_for_tcp(port: u16) -> DynResult<TcpStream> {
     let sockaddr = format!("0.0.0.0:{}", port);
@@ -31,38 +32,45 @@ fn wait_for_tcp(port: u16) -> DynResult<TcpStream> {
     Ok(stream)
 }
 
-pub fn udbserver<T>(uc: &mut Unicorn<T>, port: u16, start_addr: u64) -> DynResult<()> {
+pub fn udbserver<T: 'static>(uc: &mut Unicorn<T>, port: u16, start_addr: u64) -> DynResult<()> {
     let code_hook = uc.add_code_hook(1, 0, |_, _, _| {}).expect("Failed to add empty code hook");
     let mem_hook = uc
         .add_mem_hook(HookType::MEM_READ, 1, 0, |_, _, _, _, _| true)
         .expect("Failed to add empty mem hook");
     if start_addr != 0 {
-        uc.add_code_hook(start_addr, start_addr, move |_, _, _| udbserver_start(port).expect("Failed to start udbserver"))
-            .expect("Failed to add udbserver hook");
+        uc.add_code_hook(start_addr, start_addr, move |_, _, _| {
+            udbserver_start::<T>(port).expect("Failed to start udbserver")
+        })
+        .expect("Failed to add udbserver hook");
     }
     let emu = emu::Emu::new(
-        unsafe { std::mem::transmute::<&mut Unicorn<T>, &'static mut Unicorn<'static, ()>>(uc) },
+        unsafe { std::mem::transmute::<&mut Unicorn<T>, &'static mut Unicorn<'static, T>>(uc) },
         code_hook,
         mem_hook,
     )?;
-    EMU.replace(emu);
+    EMU.replace(Box::new(emu));
     if start_addr == 0 {
-        udbserver_start(port).expect("Failed to start udbserver");
+        udbserver_start::<T>(port).expect("Failed to start udbserver");
     }
     Ok(())
 }
 
-fn udbserver_start(port: u16) -> DynResult<()> {
+fn udbserver_start<T: 'static>(port: u16) -> DynResult<()> {
     if GDBSTUB.is_some() {
         return Ok(());
     }
-    let gdbstub = GdbStubBuilder::new(wait_for_tcp(port)?).build()?.run_state_machine(&mut *EMU.get_mut())?;
-    GDBSTUB.replace(gdbstub);
-    udbserver_loop()
+    let mut emu_any = EMU.get_mut();
+    let emu = emu_any.downcast_mut::<emu::Emu<T>>().expect("Failed to downcast EMU");
+    let gdbstub = GdbStubBuilder::new(wait_for_tcp(port)?).build()?.run_state_machine(emu)?;
+    GDBSTUB.replace(Box::new(gdbstub));
+    udbserver_loop::<T>()
 }
 
-fn udbserver_resume(addr: Option<u64>) -> DynResult<()> {
-    let mut gdb = GDBSTUB.take().unwrap();
+pub(crate) fn udbserver_resume<T: 'static>(addr: Option<u64>) -> DynResult<()> {
+    let gdb_any = GDBSTUB.take().unwrap();
+    let mut gdb = *gdb_any
+        .downcast::<GdbStubStateMachine<emu::Emu<T>, TcpStream>>()
+        .expect("Failed to downcast GDBSTUB");
     let reason = if let Some(watch_addr) = addr {
         SingleThreadStopReason::Watch {
             tid: (),
@@ -73,29 +81,36 @@ fn udbserver_resume(addr: Option<u64>) -> DynResult<()> {
         SingleThreadStopReason::DoneStep
     };
     if let GdbStubStateMachine::Running(gdb_inner) = gdb {
-        match gdb_inner.report_stop(EMU.get_mut().borrow_mut(), reason) {
+        let mut emu_any = EMU.get_mut();
+        let emu = emu_any.downcast_mut::<emu::Emu<T>>().expect("Failed to downcast EMU");
+        match gdb_inner.report_stop(emu.borrow_mut(), reason) {
             Ok(gdb_state) => gdb = gdb_state,
             Err(_) => return Ok(()),
         }
     }
-    GDBSTUB.replace(gdb);
-    udbserver_loop()
+    GDBSTUB.replace(Box::new(gdb));
+    udbserver_loop::<T>()
 }
 
-fn udbserver_loop() -> DynResult<()> {
-    let mut gdb = GDBSTUB.take().unwrap();
+fn udbserver_loop<T: 'static>() -> DynResult<()> {
+    let gdb_any = GDBSTUB.take().unwrap();
+    let mut gdb = *gdb_any
+        .downcast::<GdbStubStateMachine<emu::Emu<T>, TcpStream>>()
+        .expect("Failed to downcast GDBSTUB");
     loop {
         gdb = match gdb {
             GdbStubStateMachine::Idle(mut gdb_inner) => {
                 let byte = gdb_inner.borrow_conn().read()?;
-                gdb_inner.incoming_data(EMU.get_mut().borrow_mut(), byte)?
+                let mut emu_any = EMU.get_mut();
+                let emu = emu_any.downcast_mut::<emu::Emu<T>>().expect("Failed to downcast EMU");
+                gdb_inner.incoming_data(emu.borrow_mut(), byte)?
             }
             GdbStubStateMachine::Running(_) => break,
             GdbStubStateMachine::CtrlCInterrupt(_) => break,
             GdbStubStateMachine::Disconnected(gdb_inner) => return handle_disconnect(gdb_inner.get_reason()),
         }
     }
-    GDBSTUB.replace(gdb);
+    GDBSTUB.replace(Box::new(gdb));
     Ok(())
 }
 

Original file line number	Diff line number	Diff line change
`@@ -33,29 +33,29 @@ fn copy_range_to_buf(data: &[u8], offset: u64, length: usize, buf: &mut [u8]) ->`
`33`	`33`	`copy_to_buf(data, buf)`
`34`	`34`	`}`
`35`	`35`
`36`		`-fn step_cb(uc: &mut Unicorn<()>, _addr: u64, _size: u32) {`
	`36`	`+fn step_cb<T: 'static>(uc: &mut Unicorn<T>, _addr: u64, _size: u32) {`
`37`	`37`	`if *STEP_STATE.get() {`
`38`	`38`	`STEP_STATE.replace(false);`
`39`	`39`	`return;`
`40`	`40`	`}`
`41`	`41`	`if let Some(step_hook) = STEP_HOOK.take() {`
`42`	`42`	`uc.remove_hook(step_hook).expect("Failed to remove step hook");`
`43`	`43`	`}`
`44`		`- crate::udbserver_resume(WATCH_ADDR.take()).expect("Failed to resume udbserver");`
	`44`	`+ crate::udbserver_resume::<T>(WATCH_ADDR.take()).expect("Failed to resume udbserver");`
`45`	`45`	`}`
`46`	`46`
`47`		`-fn watch_cb(uc: &mut Unicorn<()>, _mem_type: MemType, addr: u64, _size: usize, _value: i64) -> bool {`
	`47`	`+fn watch_cb<T: 'static>(uc: &mut Unicorn<T>, _mem_type: MemType, addr: u64, _size: usize, _value: i64) -> bool {`
`48`	`48`	`if WATCH_ADDR.is_none() {`
`49`	`49`	`WATCH_ADDR.replace(addr);`
`50`	`50`	`if STEP_HOOK.is_none() {`
`51`		`- STEP_HOOK.replace(uc.add_code_hook(1, 0, step_cb).expect("Failed to add code hook"));`
	`51`	`+ STEP_HOOK.replace(uc.add_code_hook(1, 0, step_cb::<T>).expect("Failed to add code hook"));`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`	`true`
`55`	`55`	`}`
`56`	`56`
`57`		`-pub struct Emu {`
`58`		`- uc: &'static mut Unicorn<'static, ()>,`
	`57`	`+pub struct Emu<T: 'static> {`
	`58`	`+ uc: &'static mut Unicorn<'static, T>,`
`59`	`59`	`reg: Register,`
`60`	`60`	`code_hook: UcHookId,`
`61`	`61`	`mem_hook: UcHookId,`
`@@ -66,8 +66,8 @@ pub struct Emu {`
`66`	`66`	`wp_rw_hooks: HashMap<u64, HashMap<u64, UcHookId>>,`
`67`	`67`	`}`
`68`	`68`
`69`		`-impl Emu {`
`70`		`- pub fn new(uc: &'static mut Unicorn<'static, ()>, code_hook: UcHookId, mem_hook: UcHookId) -> DynResult<Emu> {`
	`69`	`+impl<T: 'static> Emu<T> {`
	`70`	`+ pub fn new(uc: &'static mut Unicorn<'static, T>, code_hook: UcHookId, mem_hook: UcHookId) -> DynResult<Emu<T>> {`
`71`	`71`	`let arch = uc.get_arch();`
`72`	`72`	`let query_mode = uc.query(Query::MODE).expect("Failed to query mode");`
`73`	`73`	`let mode = Mode::try_from(query_mode as i32).unwrap();`
`@@ -86,14 +86,14 @@ impl Emu {`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
`89`		`-impl Drop for Emu {`
	`89`	`+impl<T: 'static> Drop for Emu<T> {`
`90`	`90`	`fn drop(&mut self) {`
`91`	`91`	`self.uc.remove_hook(self.code_hook).expect("Failed to remove empty code hook");`
`92`	`92`	`self.uc.remove_hook(self.mem_hook).expect("Failed to remove empty mem hook");`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`
`96`		`-impl target::Target for Emu {`
	`96`	`+impl<T: 'static> target::Target for Emu<T> {`
`97`	`97`	`type Arch = arch::GenericArch;`
`98`	`98`	`type Error = &'static str;`
`99`	`99`
`@@ -113,7 +113,7 @@ impl target::Target for Emu {`
`113`	`113`	`}`
`114`	`114`	`}`
`115`	`115`
`116`		`-impl target::ext::base::singlethread::SingleThreadBase for Emu {`
	`116`	`+impl<T: 'static> target::ext::base::singlethread::SingleThreadBase for Emu<T> {`
`117`	`117`	`fn read_registers(&mut self, regs: &mut arch::GenericRegs) -> TargetResult<(), Self> {`
`118`	`118`	`regs.buf = Vec::new();`
`119`	`119`	`for reg in self.reg.list() {`
`@@ -166,7 +166,7 @@ impl target::ext::base::singlethread::SingleThreadBase for Emu {`
`166`	`166`	`}`
`167`	`167`	`}`
`168`	`168`
`169`		`-impl target::ext::base::singlethread::SingleThreadResume for Emu {`
	`169`	`+impl<T: 'static> target::ext::base::singlethread::SingleThreadResume for Emu<T> {`
`170`	`170`	`fn resume(&mut self, _signal: Option<Signal>) -> Result<(), Self::Error> {`
`171`	`171`	`Ok(())`
`172`	`172`	`}`
`@@ -177,20 +177,20 @@ impl target::ext::base::singlethread::SingleThreadResume for Emu {`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`
`180`		`-impl target::ext::base::singlethread::SingleThreadSingleStep for Emu {`
	`180`	`+impl<T: 'static> target::ext::base::singlethread::SingleThreadSingleStep for Emu<T> {`
`181`	`181`	`fn step(&mut self, signal: Option<Signal>) -> Result<(), Self::Error> {`
`182`	`182`	`if signal.is_some() {`
`183`	`183`	`return Err("no support for stepping with signal");`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`STEP_STATE.replace(true);`
`187`		`- STEP_HOOK.replace(self.uc.add_code_hook(1, 0, step_cb).map_err(\|_\| "Failed to add code hook")?);`
	`187`	`+ STEP_HOOK.replace(self.uc.add_code_hook(1, 0, step_cb::<T>).map_err(\|_\| "Failed to add code hook")?);`
`188`	`188`
`189`	`189`	`Ok(())`
`190`	`190`	`}`
`191`	`191`	`}`
`192`	`192`
`193`		`-impl target::ext::breakpoints::Breakpoints for Emu {`
	`193`	`+impl<T: 'static> target::ext::breakpoints::Breakpoints for Emu<T> {`
`194`	`194`	`#[inline(always)]`
`195`	`195`	`fn support_sw_breakpoint(&mut self) -> Option<target::ext::breakpoints::SwBreakpointOps<'_, Self>> {`
`196`	`196`	`Some(self)`
`@@ -209,15 +209,18 @@ impl target::ext::breakpoints::Breakpoints for Emu {`
`209`	`209`
`210`	`210`	`macro_rules! add_breakpoint {`
`211`	`211`	`( $self:ident, $addr:ident, $hook_map:ident ) => {{`
`212`		`- let hook = match $self.uc.add_code_hook($addr.into(), $addr.into(), step_cb) {`
	`212`	`+ let hook = match $self.uc.add_code_hook($addr.into(), $addr.into(), step_cb::<T>) {`
`213`	`213`	`Ok(h) => h,`
`214`	`214`	`Err(_) => return Ok(false),`
`215`	`215`	`};`
`216`	`216`	`$self.$hook_map.insert($addr.into(), hook);`
`217`	`217`	`Ok(true)`
`218`	`218`	`}};`
`219`	`219`	`( $self:ident, $mem_type:ident, $addr:ident, $len:ident, $hook_map:ident ) => {{`
`220`		`- let hook = match $self.uc.add_mem_hook(HookType::$mem_type, $addr.into(), ($addr + $len - 1).into(), watch_cb) {`
	`220`	`+ let hook = match $self`
	`221`	`+ .uc`
	`222`	`+ .add_mem_hook(HookType::$mem_type, $addr.into(), ($addr + $len - 1).into(), watch_cb::<T>)`
	`223`	`+ {`
`221`	`224`	`Ok(h) => h,`
`222`	`225`	`Err(_) => return Ok(false),`
`223`	`226`	`};`
`@@ -253,7 +256,7 @@ macro_rules! remove_breakpoint {`
`253`	`256`	`}};`
`254`	`257`	`}`
`255`	`258`
`256`		`-impl target::ext::breakpoints::SwBreakpoint for Emu {`
	`259`	`+impl<T: 'static> target::ext::breakpoints::SwBreakpoint for Emu<T> {`
`257`	`260`	`fn add_sw_breakpoint(&mut self, addr: u64, _kind: usize) -> TargetResult<bool, Self> {`
`258`	`261`	`add_breakpoint!(self, addr, bp_sw_hooks)`
`259`	`262`	`}`
`@@ -263,7 +266,7 @@ impl target::ext::breakpoints::SwBreakpoint for Emu {`
`263`	`266`	`}`
`264`	`267`	`}`
`265`	`268`
`266`		`-impl target::ext::breakpoints::HwBreakpoint for Emu {`
	`269`	`+impl<T: 'static> target::ext::breakpoints::HwBreakpoint for Emu<T> {`
`267`	`270`	`fn add_hw_breakpoint(&mut self, addr: u64, _kind: usize) -> TargetResult<bool, Self> {`
`268`	`271`	`add_breakpoint!(self, addr, bp_hw_hooks)`
`269`	`272`	`}`
`@@ -273,7 +276,7 @@ impl target::ext::breakpoints::HwBreakpoint for Emu {`
`273`	`276`	`}`
`274`	`277`	`}`
`275`	`278`
`276`		`-impl target::ext::breakpoints::HwWatchpoint for Emu {`
	`279`	`+impl<T: 'static> target::ext::breakpoints::HwWatchpoint for Emu<T> {`
`277`	`280`	`fn add_hw_watchpoint(&mut self, addr: u64, len: u64, kind: WatchKind) -> TargetResult<bool, Self> {`
`278`	`281`	`match kind {`
`279`	`282`	`WatchKind::Read => add_breakpoint!(self, MEM_READ, addr, len, wp_r_hooks),`
`@@ -291,7 +294,7 @@ impl target::ext::breakpoints::HwWatchpoint for Emu {`
`291`	`294`	`}`
`292`	`295`	`}`
`293`	`296`
`294`		`-impl target::ext::base::single_register_access::SingleRegisterAccess<()> for Emu {`
	`297`	`+impl<T: 'static> target::ext::base::single_register_access::SingleRegisterAccess<()> for Emu<T> {`
`295`	`298`	`fn read_register(&mut self, _tid: (), reg_id: arch::GenericRegId, buf: &mut [u8]) -> TargetResult<usize, Self> {`
`296`	`299`	`let reg = self.reg.get(reg_id.0)?;`
`297`	`300`	`if reg.1 <= 8 {`
`@@ -323,7 +326,7 @@ impl target::ext::base::single_register_access::SingleRegisterAccess<()> for Emu`
`323`	`326`	`}`
`324`	`327`	`}`
`325`	`328`
`326`		`-impl target::ext::target_description_xml_override::TargetDescriptionXmlOverride for Emu {`
	`329`	`+impl<T: 'static> target::ext::target_description_xml_override::TargetDescriptionXmlOverride for Emu<T> {`
`327`	`330`	`fn target_description_xml(&self, _annex: &[u8], offset: u64, length: usize, buf: &mut [u8]) -> TargetResult<usize, Self> {`
`328`	`331`	`let xml = self.reg.description_xml().as_bytes();`
`329`	`332`	`Ok(copy_range_to_buf(xml, offset, length, buf))`