src, tests, examples: replace vec. by slices in unit/doc tests and ex.

README.md

@@ -241,7 +241,7 @@ extern crate rbpf;
 fn main() {
 
     // This is the eBPF program, in the form of bytecode instructions.
-    let prog = vec![
+    let prog = &[
         0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov32 r0, 0
         0xb4, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, // mov32 r1, 2
         0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // add32 r0, 1
@@ -252,7 +252,7 @@ fn main() {
     // Instantiate a struct EbpfVmNoData. This is an eBPF VM for programs that
     // takes no packet data in argument.
     // The eBPF program is passed to the constructor.
-    let vm = rbpf::EbpfVmNoData::new(&prog);
+    let vm = rbpf::EbpfVmNoData::new(prog);
 
     // Execute (interpret) the program. No argument required for this VM.
     assert_eq!(vm.prog_exec(), 0x3);
@@ -267,26 +267,26 @@ This comes from the unit test `test_jit_ldxh`.
 extern crate rbpf;
 
 fn main() {
-    let prog = vec![
+    let prog = &[
         0x71, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // ldxh r0, [r1+2]
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     ];
 
     // Let's use some data.
-    let mut mem = vec![
+    let mem = &mut [
         0xaa, 0xbb, 0x11, 0xcc, 0xdd
     ];
 
     // This is an eBPF VM for programs reading from a given memory area (it
     // directly reads from packet data)
-    let mut vm = rbpf::EbpfVmRaw::new(&prog);
+    let mut vm = rbpf::EbpfVmRaw::new(prog);
 
     // This time we JIT-compile the program.
     vm.jit_compile();
 
     // Then we execute it. For this kind of VM, a reference to the packet data
     // must be passed to the function that executes the program.
-    unsafe { assert_eq!(vm.prog_exec_jit(&mut mem), 0x11); }
+    unsafe { assert_eq!(vm.prog_exec_jit(mem), 0x11); }
 }
 ```
 ### Using a metadata buffer
@@ -298,20 +298,20 @@ This comes from the unit test `test_jit_mbuff` and derives from the unit test
 extern crate rbpf;
 
 fn main() {
-    let prog = vec![
+    let prog = &[
         // Load mem from mbuff at offset 8 into R1
         0x79, 0x11, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
         // ldhx r1[2], r0
         0x69, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let mut mem = vec![
+    let mem = &mut [
         0xaa, 0xbb, 0x11, 0x22, 0xcc, 0xdd
     ];
 
     // Just for the example we create our metadata buffer from scratch, and
     // we store the pointers to packet data start and end in it.
-    let mut mbuff = vec![0u8; 32];
+    let mut mbuff = &mut [0u8; 32];
     unsafe {
         let mut data     = mbuff.as_ptr().offset(8)  as *mut u64;
         let mut data_end = mbuff.as_ptr().offset(24) as *mut u64;
@@ -320,14 +320,14 @@ fn main() {
     }
 
     // This eBPF VM is for program that use a metadata buffer.
-    let mut vm = rbpf::EbpfVmMbuff::new(&prog);
+    let mut vm = rbpf::EbpfVmMbuff::new(prog);
 
     // Here again we JIT-compile the program.
     vm.jit_compile();
 
     // Here we must provide both a reference to the packet data, and to the
     // metadata buffer we use.
-    unsafe { assert_eq!(vm.prog_exec_jit(&mut mem, &mut mbuff), 0x2211); }
+    unsafe { assert_eq!(vm.prog_exec_jit(mem, &mut mbuff), 0x2211); }
 }
 ```
 
@@ -383,7 +383,7 @@ fn main() {
     let prog = &text_scn.data;
 
     // This is our data: a real packet, starting with Ethernet header
-    let mut packet = vec![
+    let packet = &mut [
         0x01, 0x23, 0x45, 0x67, 0x89, 0xab,
         0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54,
         0x08, 0x00,             // ethertype
@@ -418,7 +418,7 @@ fn main() {
     // This kind of VM takes a reference to the packet data, but does not need
     // any reference to the metadata buffer: a fixed buffer is handled
     // internally by the VM.
-    let res = vm.prog_exec(&mut packet);
+    let res = vm.prog_exec(packet);
     println!("Program returned: {:?} ({:#x})", res, res);
 }
 ```

examples/disassemble.rs

@@ -10,7 +10,7 @@ use rbpf::disassembler;
 
 // Simply disassemble a program into human-readable instructions.
 fn main() {
-    let prog = vec![
+    let prog = &[
         0xb7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x79, 0x12, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x79, 0x11, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -37,5 +37,5 @@ fn main() {
         0xb7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    disassembler::disassemble(&prog);
+    disassembler::disassemble(prog);
 }

examples/load_elf.rs

@@ -67,7 +67,7 @@ fn main() {
 
     let prog = &text_scn.data;
 
-    let mut packet1 = vec![
+    let packet1 = &mut [
         0x01, 0x23, 0x45, 0x67, 0x89, 0xab,
         0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54,
         0x08, 0x00, // ethertype
@@ -89,7 +89,7 @@ fn main() {
         0x64, 0x66, 0x0au8
     ];
 
-    let mut packet2 = vec![
+    let mut packet2 = &mut [
         0x01, 0x23, 0x45, 0x67, 0x89, 0xab,
         0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54,
         0x08, 0x00, // ethertype
@@ -114,13 +114,13 @@ fn main() {
     let mut vm = rbpf::EbpfVmFixedMbuff::new(prog, 0x40, 0x50);
     vm.register_helper(helpers::BPF_TRACE_PRINTK_IDX, helpers::bpf_trace_printf);
 
-    let res = vm.prog_exec(&mut packet1);
+    let res = vm.prog_exec(packet1);
     println!("Packet #1, program returned: {:?} ({:#x})", res, res);
     assert_eq!(res, 0xffffffff);
 
     vm.jit_compile();
     unsafe {
-        let res = vm.prog_exec_jit(&mut packet2);
+        let res = vm.prog_exec_jit(packet2);
         println!("Packet #2, program returned: {:?} ({:#x})", res, res);
         assert_eq!(res, 0);
     }

examples/uptime.rs

@@ -15,7 +15,7 @@ use rbpf::helpers;
 //
 // The two eBPF programs are independent and are not related to one another.
 fn main() {
-    let prog1 = vec![
+    let prog1 = &[
         0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov32 r0, 0
         0xb4, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, // mov32 r1, 2
         0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // add32 r0, 1
@@ -28,7 +28,7 @@ fn main() {
     // constant, so that we can remain compatible with programs for the kernel. Here we also cast
     // it to a u8 so as to use it directly in program instructions.
     let hkey = helpers::BPF_KTIME_GETNS_IDX as u8;
-    let prog2 = vec![
+    let prog2 = &[
         0xb7, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov64 r1, 0
         0xb7, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov64 r1, 0
         0xb7, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov64 r1, 0
@@ -39,7 +39,7 @@ fn main() {
     ];
 
     // Create a VM: this one takes no data. Load prog1 in it.
-    let mut vm = rbpf::EbpfVmNoData::new(&prog1);
+    let mut vm = rbpf::EbpfVmNoData::new(prog1);
     // Execute prog1.
     assert_eq!(vm.prog_exec(), 0x3);
 
@@ -51,7 +51,7 @@ fn main() {
     // In the following example we use a helper to get the elapsed time since boot time: we
     // reimplement uptime in eBPF, in Rust. Because why not.
 
-    vm.set_prog(&prog2);
+    vm.set_prog(prog2);
     vm.register_helper(helpers::BPF_KTIME_GETNS_IDX, helpers::bpf_time_getns);
 
     vm.jit_compile();

src/disassembler.rs

@@ -116,14 +116,13 @@ pub struct HLInsn {
 /// ```
 /// use rbpf::disassembler;
 ///
-/// let prog = vec![
+/// let prog = &[
 ///     0x18, 0x00, 0x00, 0x00, 0x88, 0x77, 0x66, 0x55,
 ///     0x00, 0x00, 0x00, 0x00, 0x44, 0x33, 0x22, 0x11,
 ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 /// ];
 ///
-/// let v = disassembler::to_insn_vec(&prog);
-/// disassembler::disassemble(&prog);
+/// let v = disassembler::to_insn_vec(prog);
 /// assert_eq!(v, vec![
 ///     disassembler::HLInsn {
 ///         opc: 0x18,
@@ -308,7 +307,7 @@ pub fn to_insn_vec(prog: &[u8]) -> Vec<HLInsn> {
 ///
 /// ```
 /// use rbpf::disassembler;
-/// let prog = vec![
+/// let prog = &[
 ///     0x07, 0x01, 0x00, 0x00, 0x05, 0x06, 0x00, 0x00,
 ///     0xb7, 0x02, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
 ///     0xbf, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -316,7 +315,7 @@ pub fn to_insn_vec(prog: &[u8]) -> Vec<HLInsn> {
 ///     0x87, 0x08, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
 ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 /// ];
-/// disassembler::disassemble(&prog);
+/// disassembler::disassemble(prog);
 /// ```
 ///
 /// This will produce the following output:

src/ebpf.rs

@@ -389,11 +389,11 @@ pub struct Insn {
 /// ```
 /// use rbpf::ebpf;
 ///
-/// let prog = vec![
+/// let prog = &[
 ///     0xb7, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 ///     ];
-/// let insn = ebpf::get_insn(&prog, 1);
+/// let insn = ebpf::get_insn(prog, 1);
 /// assert_eq!(insn.opc, 0x95);
 /// ```
 ///
@@ -402,11 +402,11 @@ pub struct Insn {
 /// ```rust,should_panic
 /// use rbpf::ebpf;
 ///
-/// let prog = vec![
+/// let prog = &[
 ///     0xb7, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00              // two bytes missing
 ///     ];
-/// let insn = ebpf::get_insn(&prog, 1);
+/// let insn = ebpf::get_insn(prog, 1);
 /// ```
 pub fn get_insn(prog: &[u8], idx: usize) -> Insn {
     // This guard should not be needed in most cases, since the verifier already checks the program
@@ -442,13 +442,13 @@ pub fn get_insn(prog: &[u8], idx: usize) -> Insn {
 /// ```
 /// use rbpf::ebpf;
 ///
-/// let prog = vec![
+/// let prog = &[
 ///     0x18, 0x00, 0x00, 0x00, 0x88, 0x77, 0x66, 0x55,
 ///     0x00, 0x00, 0x00, 0x00, 0x44, 0x33, 0x22, 0x11,
 ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 /// ];
 ///
-/// let v = ebpf::to_insn_vec(&prog);
+/// let v = ebpf::to_insn_vec(prog);
 /// assert_eq!(v, vec![
 ///     ebpf::Insn {
 ///         opc: 0x18,

src/lib.rs

@@ -42,18 +42,18 @@ struct MetaBuff {
 /// # Examples
 ///
 /// ```
-/// let prog = vec![
+/// let prog = &[
 ///     0x79, 0x11, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // Load mem from mbuff at offset 8 into R1.
 ///     0x69, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // ldhx r1[2], r0
 ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
 /// ];
-/// let mut mem = vec![
+/// let mem = &mut [
 ///     0xaa, 0xbb, 0x11, 0x22, 0xcc, 0xdd
 /// ];
 ///
 /// // Just for the example we create our metadata buffer from scratch, and we store the pointers
 /// // to packet data start and end in it.
-/// let mut mbuff = vec![0u8; 32];
+/// let mut mbuff = [0u8; 32];
 /// unsafe {
 ///     let mut data     = mbuff.as_ptr().offset(8)  as *mut u64;
 ///     let mut data_end = mbuff.as_ptr().offset(24) as *mut u64;
@@ -62,10 +62,10 @@ struct MetaBuff {
 /// }
 ///
 /// // Instantiate a VM.
-/// let mut vm = rbpf::EbpfVmMbuff::new(&prog);
+/// let mut vm = rbpf::EbpfVmMbuff::new(prog);
 ///
 /// // Provide both a reference to the packet data, and to the metadata buffer.
-/// let res = vm.prog_exec(&mut mem, &mut mbuff);
+/// let res = vm.prog_exec(mem, &mut mbuff);
 /// assert_eq!(res, 0x2211);
 /// ```
 pub struct EbpfVmMbuff<'a> {
@@ -86,14 +86,14 @@ impl<'a> EbpfVmMbuff<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0x79, 0x11, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // Load mem from mbuff into R1.
     ///     0x69, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // ldhx r1[2], r0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
     /// // Instantiate a VM.
-    /// let mut vm = rbpf::EbpfVmMbuff::new(&prog);
+    /// let mut vm = rbpf::EbpfVmMbuff::new(prog);
     /// ```
     pub fn new(prog: &'a [u8]) -> EbpfVmMbuff<'a> {
         verifier::check(prog);
@@ -119,19 +119,19 @@ impl<'a> EbpfVmMbuff<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog1 = vec![
+    /// let prog1 = &[
     ///     0xb7, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, 0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
-    /// let prog2 = vec![
+    /// let prog2 = &[
     ///     0x79, 0x11, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // Load mem from mbuff into R1.
     ///     0x69, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // ldhx r1[2], r0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
     /// // Instantiate a VM.
-    /// let mut vm = rbpf::EbpfVmMbuff::new(&prog1);
-    /// vm.set_prog(&prog2);
+    /// let mut vm = rbpf::EbpfVmMbuff::new(prog1);
+    /// vm.set_prog(prog2);
     /// ```
     pub fn set_prog(&mut self, prog: &'a [u8]) {
         verifier::check(prog);
@@ -152,7 +152,7 @@ impl<'a> EbpfVmMbuff<'a> {
     ///
     /// // This program was compiled with clang, from a C program containing the following single
     /// // instruction: `return bpf_trace_printk("foo %c %c %c\n", 10, 1, 2, 3);`
-    /// let prog = vec![
+    /// let prog = &[
     ///     0x18, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // load 0 as u64 into r1 (That would be
     ///     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // replaced by tc by the address of
     ///                                                     // the format string, in the .map
@@ -166,7 +166,7 @@ impl<'a> EbpfVmMbuff<'a> {
     /// ];
     ///
     /// // Instantiate a VM.
-    /// let mut vm = rbpf::EbpfVmMbuff::new(&prog);
+    /// let mut vm = rbpf::EbpfVmMbuff::new(prog);
     ///
     /// // Register a helper.
     /// // On running the program this helper will print the content of registers r3, r4 and r5 to
@@ -193,18 +193,18 @@ impl<'a> EbpfVmMbuff<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0x79, 0x11, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // Load mem from mbuff into R1.
     ///     0x69, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // ldhx r1[2], r0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
-    /// let mut mem = vec![
+    /// let mem = &mut [
     ///     0xaa, 0xbb, 0x11, 0x22, 0xcc, 0xdd
     /// ];
     ///
     /// // Just for the example we create our metadata buffer from scratch, and we store the
     /// // pointers to packet data start and end in it.
-    /// let mut mbuff = vec![0u8; 32];
+    /// let mut mbuff = [0u8; 32];
     /// unsafe {
     ///     let mut data     = mbuff.as_ptr().offset(8)  as *mut u64;
     ///     let mut data_end = mbuff.as_ptr().offset(24) as *mut u64;
@@ -213,10 +213,10 @@ impl<'a> EbpfVmMbuff<'a> {
     /// }
     ///
     /// // Instantiate a VM.
-    /// let mut vm = rbpf::EbpfVmMbuff::new(&prog);
+    /// let mut vm = rbpf::EbpfVmMbuff::new(prog);
     ///
     /// // Provide both a reference to the packet data, and to the metadata buffer.
-    /// let res = vm.prog_exec(&mut mem, &mut mbuff);
+    /// let res = vm.prog_exec(mem, &mut mbuff);
     /// assert_eq!(res, 0x2211);
     /// ```
     pub fn prog_exec(&self, mem: &[u8], mbuff: &[u8]) -> u64 {
@@ -496,14 +496,14 @@ impl<'a> EbpfVmMbuff<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0x79, 0x11, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // Load mem from mbuff into R1.
     ///     0x69, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // ldhx r1[2], r0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
     /// // Instantiate a VM.
-    /// let mut vm = rbpf::EbpfVmMbuff::new(&prog);
+    /// let mut vm = rbpf::EbpfVmMbuff::new(prog);
     ///
     /// vm.jit_compile();
     /// ```
@@ -535,18 +535,18 @@ impl<'a> EbpfVmMbuff<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0x79, 0x11, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // Load mem from mbuff into r1.
     ///     0x69, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // ldhx r1[2], r0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
-    /// let mut mem = vec![
+    /// let mem = &mut [
     ///     0xaa, 0xbb, 0x11, 0x22, 0xcc, 0xdd
     /// ];
     ///
     /// // Just for the example we create our metadata buffer from scratch, and we store the
     /// // pointers to packet data start and end in it.
-    /// let mut mbuff = vec![0u8; 32];
+    /// let mut mbuff = [0u8; 32];
     /// unsafe {
     ///     let mut data     = mbuff.as_ptr().offset(8)  as *mut u64;
     ///     let mut data_end = mbuff.as_ptr().offset(24) as *mut u64;
@@ -555,13 +555,13 @@ impl<'a> EbpfVmMbuff<'a> {
     /// }
     ///
     /// // Instantiate a VM.
-    /// let mut vm = rbpf::EbpfVmMbuff::new(&prog);
+    /// let mut vm = rbpf::EbpfVmMbuff::new(prog);
     ///
     /// vm.jit_compile();
     ///
     /// // Provide both a reference to the packet data, and to the metadata buffer.
     /// unsafe {
-    ///     let res = vm.prog_exec_jit(&mut mem, &mut mbuff);
+    ///     let res = vm.prog_exec_jit(mem, &mut mbuff);
     ///     assert_eq!(res, 0x2211);
     /// }
     /// ```
@@ -616,7 +616,7 @@ impl<'a> EbpfVmMbuff<'a> {
 /// Some small modifications have been brought to have it work, see comments.
 ///
 /// ```
-/// let prog = vec![
+/// let prog = &[
 ///     0xb7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, 0
 ///     // Here opcode 0x61 had to be replace by 0x79 so as to load a 8-bytes long address.
 ///     // Also, offset 0x4c had to be replace with e.g. 0x40 so as to prevent the two pointers
@@ -631,21 +631,21 @@ impl<'a> EbpfVmMbuff<'a> {
 ///     0xc7, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, // r0 <<= 56 (arsh) extend byte sign to u64
 ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
 /// ];
-/// let mut mem1 = vec![
+/// let mem1 = &mut [
 ///     0xaa, 0xbb, 0x11, 0x22, 0xcc, 0xdd
 /// ];
-/// let mut mem2 = vec![
+/// let mem2 = &mut [
 ///     0xaa, 0xbb, 0x11, 0x22, 0xcc, 0x27
 /// ];
 ///
 /// // Instantiate a VM. Note that we provide the start and end offsets for mem pointers.
-/// let mut vm = rbpf::EbpfVmFixedMbuff::new(&prog, 0x40, 0x50);
+/// let mut vm = rbpf::EbpfVmFixedMbuff::new(prog, 0x40, 0x50);
 ///
 /// // Provide only a reference to the packet data. We do not manage the metadata buffer.
-/// let res = vm.prog_exec(&mut mem1);
+/// let res = vm.prog_exec(mem1);
 /// assert_eq!(res, 0xffffffffffffffdd);
 ///
-/// let res = vm.prog_exec(&mut mem2);
+/// let res = vm.prog_exec(mem2);
 /// assert_eq!(res, 0x27);
 /// ```
 pub struct EbpfVmFixedMbuff<'a> {
@@ -665,7 +665,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0xb7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, 0
     ///     0x79, 0x12, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, // load mem from r1[0x40] to r2
     ///     0x07, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, // add r2, 5
@@ -676,7 +676,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     /// ];
     ///
     /// // Instantiate a VM. Note that we provide the start and end offsets for mem pointers.
-    /// let mut vm = rbpf::EbpfVmFixedMbuff::new(&prog, 0x40, 0x50);
+    /// let mut vm = rbpf::EbpfVmFixedMbuff::new(prog, 0x40, 0x50);
     /// ```
     pub fn new(prog: &'a [u8], data_offset: usize, data_end_offset: usize) -> EbpfVmFixedMbuff<'a> {
         let parent = EbpfVmMbuff::new(prog);
@@ -705,11 +705,11 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog1 = vec![
+    /// let prog1 = &[
     ///     0xb7, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, 0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
-    /// let prog2 = vec![
+    /// let prog2 = &[
     ///     0xb7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, 0
     ///     0x79, 0x12, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, // load mem from r1[0x40] to r2
     ///     0x07, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, // add r2, 5
@@ -719,14 +719,14 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
-    /// let mut mem = vec![
+    /// let mem = &mut [
     ///     0xaa, 0xbb, 0x11, 0x22, 0xcc, 0x27,
     /// ];
     ///
-    /// let mut vm = rbpf::EbpfVmFixedMbuff::new(&prog1, 0, 0);
-    /// vm.set_prog(&prog2, 0x40, 0x50);
+    /// let mut vm = rbpf::EbpfVmFixedMbuff::new(prog1, 0, 0);
+    /// vm.set_prog(prog2, 0x40, 0x50);
     ///
-    /// let res = vm.prog_exec(&mut mem);
+    /// let res = vm.prog_exec(mem);
     /// assert_eq!(res, 0x27);
     /// ```
     pub fn set_prog(&mut self, prog: &'a [u8], data_offset: usize, data_end_offset: usize) {
@@ -752,7 +752,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     ///
     /// // This program was compiled with clang, from a C program containing the following single
     /// // instruction: `return bpf_trace_printk("foo %c %c %c\n", 10, 1, 2, 3);`
-    /// let prog = vec![
+    /// let prog = &[
     ///     0xb7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, 0
     ///     0x79, 0x12, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, // load mem from r1[0x40] to r2
     ///     0x07, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, // add r2, 5
@@ -767,17 +767,17 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
-    /// let mut mem = vec![
+    /// let mem = &mut [
     ///     0xaa, 0xbb, 0x11, 0x22, 0xcc, 0x09,
     /// ];
     ///
     /// // Instantiate a VM.
-    /// let mut vm = rbpf::EbpfVmFixedMbuff::new(&prog, 0x40, 0x50);
+    /// let mut vm = rbpf::EbpfVmFixedMbuff::new(prog, 0x40, 0x50);
     ///
     /// // Register a helper. This helper will store the result of the square root of r1 into r0.
     /// vm.register_helper(1, helpers::sqrti);
     ///
-    /// let res = vm.prog_exec(&mut mem);
+    /// let res = vm.prog_exec(mem);
     /// assert_eq!(res, 3);
     /// ```
     pub fn register_helper(&mut self, key: u32, function: fn (u64, u64, u64, u64, u64) -> u64) {
@@ -800,7 +800,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0xb7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, 0
     ///     0x79, 0x12, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, // load mem from r1[0x40] to r2
     ///     0x07, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, // add r2, 5
@@ -809,15 +809,15 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     ///     0x71, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // load r2 (= *(mem + 5)) into r0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
-    /// let mut mem = vec![
+    /// let mem = &mut [
     ///     0xaa, 0xbb, 0x11, 0x22, 0xcc, 0xdd
     /// ];
     ///
     /// // Instantiate a VM. Note that we provide the start and end offsets for mem pointers.
-    /// let mut vm = rbpf::EbpfVmFixedMbuff::new(&prog, 0x40, 0x50);
+    /// let mut vm = rbpf::EbpfVmFixedMbuff::new(prog, 0x40, 0x50);
     ///
     /// // Provide only a reference to the packet data. We do not manage the metadata buffer.
-    /// let res = vm.prog_exec(&mut mem);
+    /// let res = vm.prog_exec(mem);
     /// assert_eq!(res, 0xdd);
     /// ```
     pub fn prog_exec(&mut self, mem: &'a mut [u8]) -> u64 {
@@ -849,7 +849,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0xb7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, 0
     ///     0x79, 0x12, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, // load mem from r1[0x40] to r2
     ///     0x07, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, // add r2, 5
@@ -860,7 +860,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     /// ];
     ///
     /// // Instantiate a VM. Note that we provide the start and end offsets for mem pointers.
-    /// let mut vm = rbpf::EbpfVmFixedMbuff::new(&prog, 0x40, 0x50);
+    /// let mut vm = rbpf::EbpfVmFixedMbuff::new(prog, 0x40, 0x50);
     ///
     /// vm.jit_compile();
     /// ```
@@ -892,7 +892,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0xb7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, 0
     ///     0x79, 0x12, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, // load mem from r1[0x40] to r2
     ///     0x07, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, // add r2, 5
@@ -901,18 +901,18 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     ///     0x71, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // load r2 (= *(mem + 5)) into r0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
-    /// let mut mem = vec![
+    /// let mem = &mut [
     ///     0xaa, 0xbb, 0x11, 0x22, 0xcc, 0xdd
     /// ];
     ///
     /// // Instantiate a VM. Note that we provide the start and end offsets for mem pointers.
-    /// let mut vm = rbpf::EbpfVmFixedMbuff::new(&prog, 0x40, 0x50);
+    /// let mut vm = rbpf::EbpfVmFixedMbuff::new(prog, 0x40, 0x50);
     ///
     /// vm.jit_compile();
     ///
     /// // Provide only a reference to the packet data. We do not manage the metadata buffer.
     /// unsafe {
-    ///     let res = vm.prog_exec_jit(&mut mem);
+    ///     let res = vm.prog_exec_jit(mem);
     ///     assert_eq!(res, 0xdd);
     /// }
     /// ```
@@ -938,21 +938,21 @@ impl<'a> EbpfVmFixedMbuff<'a> {
 /// # Examples
 ///
 /// ```
-/// let prog = vec![
+/// let prog = &[
 ///     0x71, 0x11, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, // ldxb r1[0x04], r1
 ///     0x07, 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, // add r1, 0x22
 ///     0xbf, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, r1
 ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
 /// ];
-/// let mut mem = vec![
+/// let mem = &mut [
 ///     0xaa, 0xbb, 0x11, 0x22, 0xcc, 0xdd
 /// ];
 ///
 /// // Instantiate a VM.
-/// let vm = rbpf::EbpfVmRaw::new(&prog);
+/// let vm = rbpf::EbpfVmRaw::new(prog);
 ///
 /// // Provide only a reference to the packet data.
-/// let res = vm.prog_exec(&mut mem);
+/// let res = vm.prog_exec(mem);
 /// assert_eq!(res, 0x22cc);
 /// ```
 pub struct EbpfVmRaw<'a> {
@@ -971,7 +971,7 @@ impl<'a> EbpfVmRaw<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0x71, 0x11, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, // ldxb r1[0x04], r1
     ///     0x07, 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, // add r1, 0x22
     ///     0xbf, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, r1
@@ -979,7 +979,7 @@ impl<'a> EbpfVmRaw<'a> {
     /// ];
     ///
     /// // Instantiate a VM.
-    /// let vm = rbpf::EbpfVmRaw::new(&prog);
+    /// let vm = rbpf::EbpfVmRaw::new(prog);
     /// ```
     pub fn new(prog: &'a [u8]) -> EbpfVmRaw<'a> {
         let parent = EbpfVmMbuff::new(prog);
@@ -997,25 +997,25 @@ impl<'a> EbpfVmRaw<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog1 = vec![
+    /// let prog1 = &[
     ///     0xb7, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, 0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
-    /// let prog2 = vec![
+    /// let prog2 = &[
     ///     0x71, 0x11, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, // ldxb r1[0x04], r1
     ///     0x07, 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, // add r1, 0x22
     ///     0xbf, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, r1
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
-    /// let mut mem = vec![
+    /// let mem = &mut [
     ///     0xaa, 0xbb, 0x11, 0x22, 0xcc, 0x27,
     /// ];
     ///
-    /// let mut vm = rbpf::EbpfVmRaw::new(&prog1);
-    /// vm.set_prog(&prog2);
+    /// let mut vm = rbpf::EbpfVmRaw::new(prog1);
+    /// vm.set_prog(prog2);
     ///
-    /// let res = vm.prog_exec(&mut mem);
+    /// let res = vm.prog_exec(mem);
     /// assert_eq!(res, 0x22cc);
     /// ```
     pub fn set_prog(&mut self, prog: &'a [u8]) {
@@ -1034,7 +1034,7 @@ impl<'a> EbpfVmRaw<'a> {
     /// ```
     /// use rbpf::helpers;
     ///
-    /// let prog = vec![
+    /// let prog = &[
     ///     0x79, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ldxdw r1, r1[0x00]
     ///     0xb7, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r2, 0
     ///     0xb7, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r3, 0
@@ -1044,17 +1044,17 @@ impl<'a> EbpfVmRaw<'a> {
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
-    /// let mut mem = vec![
+    /// let mem = &mut [
     ///     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
     /// ];
     ///
     /// // Instantiate a VM.
-    /// let mut vm = rbpf::EbpfVmRaw::new(&prog);
+    /// let mut vm = rbpf::EbpfVmRaw::new(prog);
     ///
     /// // Register a helper. This helper will store the result of the square root of r1 into r0.
     /// vm.register_helper(1, helpers::sqrti);
     ///
-    /// let res = vm.prog_exec(&mut mem);
+    /// let res = vm.prog_exec(mem);
     /// assert_eq!(res, 0x10000000);
     /// ```
     pub fn register_helper(&mut self, key: u32, function: fn (u64, u64, u64, u64, u64) -> u64) {
@@ -1072,20 +1072,20 @@ impl<'a> EbpfVmRaw<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0x71, 0x11, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, // ldxb r1[0x04], r1
     ///     0x07, 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, // add r1, 0x22
     ///     0xbf, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, r1
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
-    /// let mut mem = vec![
+    /// let mem = &mut [
     ///     0xaa, 0xbb, 0x11, 0x22, 0xcc, 0x27
     /// ];
     ///
-    /// let mut vm = rbpf::EbpfVmRaw::new(&prog);
+    /// let mut vm = rbpf::EbpfVmRaw::new(prog);
     ///
-    /// let res = vm.prog_exec(&mut mem);
+    /// let res = vm.prog_exec(mem);
     /// assert_eq!(res, 0x22cc);
     /// ```
     pub fn prog_exec(&self, mem: &'a mut [u8]) -> u64 {
@@ -1105,14 +1105,14 @@ impl<'a> EbpfVmRaw<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0x71, 0x11, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, // ldxb r1[0x04], r1
     ///     0x07, 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, // add r1, 0x22
     ///     0xbf, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, r1
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
-    /// let mut vm = rbpf::EbpfVmRaw::new(&prog);
+    /// let mut vm = rbpf::EbpfVmRaw::new(prog);
     ///
     /// vm.jit_compile();
     /// ```
@@ -1139,23 +1139,23 @@ impl<'a> EbpfVmRaw<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0x71, 0x11, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, // ldxb r1[0x04], r1
     ///     0x07, 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, // add r1, 0x22
     ///     0xbf, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, r1
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
-    /// let mut mem = vec![
+    /// let mem = &mut [
     ///     0xaa, 0xbb, 0x11, 0x22, 0xcc, 0x27
     /// ];
     ///
-    /// let mut vm = rbpf::EbpfVmRaw::new(&prog);
+    /// let mut vm = rbpf::EbpfVmRaw::new(prog);
     ///
     /// vm.jit_compile();
     ///
     /// unsafe {
-    ///     let res = vm.prog_exec_jit(&mut mem);
+    ///     let res = vm.prog_exec_jit(mem);
     ///     assert_eq!(res, 0x22cc);
     /// }
     /// ```
@@ -1171,7 +1171,7 @@ impl<'a> EbpfVmRaw<'a> {
 /// # Examples
 ///
 /// ```
-/// let prog = vec![
+/// let prog = &[
 ///     0xb7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, 0
 ///     0xb7, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // mov r1, 1
 ///     0xb7, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, // mov r2, 2
@@ -1198,7 +1198,7 @@ impl<'a> EbpfVmRaw<'a> {
 /// ];
 ///
 /// // Instantiate a VM.
-/// let vm = rbpf::EbpfVmNoData::new(&prog);
+/// let vm = rbpf::EbpfVmNoData::new(prog);
 ///
 /// // Provide only a reference to the packet data.
 /// let res = vm.prog_exec();
@@ -1220,14 +1220,14 @@ impl<'a> EbpfVmNoData<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0xb7, 0x00, 0x00, 0x00, 0x11, 0x22, 0x00, 0x00, // mov r0, 0x2211
     ///     0xdc, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // be16 r0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
     /// // Instantiate a VM.
-    /// let vm = rbpf::EbpfVmNoData::new(&prog);
+    /// let vm = rbpf::EbpfVmNoData::new(prog);
     /// ```
     pub fn new(prog: &'a [u8]) -> EbpfVmNoData<'a> {
         let parent = EbpfVmRaw::new(prog);
@@ -1245,22 +1245,22 @@ impl<'a> EbpfVmNoData<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog1 = vec![
+    /// let prog1 = &[
     ///     0xb7, 0x00, 0x00, 0x00, 0x11, 0x22, 0x00, 0x00, // mov r0, 0x2211
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
-    /// let prog2 = vec![
+    /// let prog2 = &[
     ///     0xb7, 0x00, 0x00, 0x00, 0x11, 0x22, 0x00, 0x00, // mov r0, 0x2211
     ///     0xdc, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // be16 r0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
-    /// let mut vm = rbpf::EbpfVmNoData::new(&prog1);
+    /// let mut vm = rbpf::EbpfVmNoData::new(prog1);
     ///
     /// let res = vm.prog_exec();
     /// assert_eq!(res, 0x2211);
     ///
-    /// vm.set_prog(&prog2);
+    /// vm.set_prog(prog2);
     ///
     /// let res = vm.prog_exec();
     /// assert_eq!(res, 0x1122);
@@ -1281,7 +1281,7 @@ impl<'a> EbpfVmNoData<'a> {
     /// ```
     /// use rbpf::helpers;
     ///
-    /// let prog = vec![
+    /// let prog = &[
     ///     0xb7, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, // mov r1, 0x010000000
     ///     0xb7, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r2, 0
     ///     0xb7, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r3, 0
@@ -1291,7 +1291,7 @@ impl<'a> EbpfVmNoData<'a> {
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
-    /// let mut vm = rbpf::EbpfVmNoData::new(&prog);
+    /// let mut vm = rbpf::EbpfVmNoData::new(prog);
     ///
     /// // Register a helper. This helper will store the result of the square root of r1 into r0.
     /// vm.register_helper(1, helpers::sqrti);
@@ -1316,13 +1316,13 @@ impl<'a> EbpfVmNoData<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0xb7, 0x00, 0x00, 0x00, 0x11, 0x22, 0x00, 0x00, // mov r0, 0x2211
     ///     0xdc, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // be16 r0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
-    /// let mut vm = rbpf::EbpfVmNoData::new(&prog);
+    /// let mut vm = rbpf::EbpfVmNoData::new(prog);
     ///
     ///
     /// vm.jit_compile();
@@ -1342,13 +1342,13 @@ impl<'a> EbpfVmNoData<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0xb7, 0x00, 0x00, 0x00, 0x11, 0x22, 0x00, 0x00, // mov r0, 0x2211
     ///     0xdc, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // be16 r0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
-    /// let vm = rbpf::EbpfVmNoData::new(&prog);
+    /// let vm = rbpf::EbpfVmNoData::new(prog);
     ///
     /// // For this kind of VM, the `prog_exec()` function needs no argument.
     /// let res = vm.prog_exec();
@@ -1377,13 +1377,13 @@ impl<'a> EbpfVmNoData<'a> {
     /// # Examples
     ///
     /// ```
-    /// let prog = vec![
+    /// let prog = &[
     ///     0xb7, 0x00, 0x00, 0x00, 0x11, 0x22, 0x00, 0x00, // mov r0, 0x2211
     ///     0xdc, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // be16 r0
     ///     0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
     /// ];
     ///
-    /// let mut vm = rbpf::EbpfVmNoData::new(&prog);
+    /// let mut vm = rbpf::EbpfVmNoData::new(prog);
     ///
     /// vm.jit_compile();
     ///

tests/misc.rs

@@ -111,7 +111,7 @@ fn test_vm_block_port() {
     // let prog = &text_scn.data;
     // ---
 
-    let prog = vec![
+    let prog = &[
         0xb7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x79, 0x12, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x79 instead of 0x61
         0x79, 0x11, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x79 instead of 0x61, 0x40 i.o. 0x4c
@@ -139,7 +139,7 @@ fn test_vm_block_port() {
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
 
-    let mut packet = vec![
+    let packet = &mut [
         0x01, 0x23, 0x45, 0x67, 0x89, 0xab,
         0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54,
         0x08, 0x00, // ethertype
@@ -161,10 +161,10 @@ fn test_vm_block_port() {
         0x64, 0x66, 0x0au8
     ];
 
-    let mut vm = rbpf::EbpfVmFixedMbuff::new(&prog, 0x40, 0x50);
+    let mut vm = rbpf::EbpfVmFixedMbuff::new(prog, 0x40, 0x50);
     vm.register_helper(helpers::BPF_TRACE_PRINTK_IDX, helpers::bpf_trace_printf);
 
-    let res = vm.prog_exec(&mut packet);
+    let res = vm.prog_exec(packet);
     println!("Program returned: {:?} ({:#x})", res, res);
     assert_eq!(res, 0xffffffff);
 }
@@ -192,7 +192,7 @@ fn test_jit_block_port() {
     // let prog = &text_scn.data;
     // ---
 
-    let prog = vec![
+    let prog = &[
         0xb7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x79, 0x12, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x79 instead of 0x61
         0x79, 0x11, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x79 instead of 0x61, 0x40 i.o. 0x4c
@@ -220,7 +220,7 @@ fn test_jit_block_port() {
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
 
-    let mut packet = vec![
+    let packet = &mut [
         0x01, 0x23, 0x45, 0x67, 0x89, 0xab,
         0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54,
         0x08, 0x00, // ethertype
@@ -242,12 +242,12 @@ fn test_jit_block_port() {
         0x64, 0x66, 0x0au8
     ];
 
-    let mut vm = rbpf::EbpfVmFixedMbuff::new(&prog, 0x40, 0x50);
+    let mut vm = rbpf::EbpfVmFixedMbuff::new(prog, 0x40, 0x50);
     vm.register_helper(helpers::BPF_TRACE_PRINTK_IDX, helpers::bpf_trace_printf);
     vm.jit_compile();
 
     unsafe {
-        let res = vm.prog_exec_jit(&mut packet);
+        let res = vm.prog_exec_jit(packet);
         println!("Program returned: {:?} ({:#x})", res, res);
         assert_eq!(res, 0xffffffff);
     }
@@ -256,18 +256,18 @@ fn test_jit_block_port() {
 // Program and memory come from uBPF test ldxh.
 #[test]
 fn test_vm_mbuff() {
-    let prog = vec![
+    let prog = &[
         // Load mem from mbuff into R1
         0x79, 0x11, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
         // ldhx r1[2], r0
         0x69, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let mem = vec![
+    let mem = &[
         0xaa, 0xbb, 0x11, 0x22, 0xcc, 0xdd
     ];
 
-    let mbuff = vec![0u8; 32];
+    let mbuff = [0u8; 32];
     unsafe {
         let mut data     = mbuff.as_ptr().offset(8)  as *mut u64;
         let mut data_end = mbuff.as_ptr().offset(24) as *mut u64;
@@ -275,25 +275,25 @@ fn test_vm_mbuff() {
         *data_end = mem.as_ptr() as u64 + mem.len() as u64;
     }
 
-    let vm = rbpf::EbpfVmMbuff::new(&prog);
-    assert_eq!(vm.prog_exec(&mem, &mbuff), 0x2211);
+    let vm = rbpf::EbpfVmMbuff::new(prog);
+    assert_eq!(vm.prog_exec(mem, &mbuff), 0x2211);
 }
 
 // Program and memory come from uBPF test ldxh.
 #[test]
 fn test_jit_mbuff() {
-    let prog = vec![
+    let prog = &[
         // Load mem from mbuff into R1
         0x79, 0x11, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
         // ldhx r1[2], r0
         0x69, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let mut mem = vec![
+    let mem = &mut [
         0xaa, 0xbb, 0x11, 0x22, 0xcc, 0xdd
     ];
 
-    let mut mbuff = vec![0u8; 32];
+    let mut mbuff = [0u8; 32];
     unsafe {
         let mut data     = mbuff.as_ptr().offset(8)  as *mut u64;
         let mut data_end = mbuff.as_ptr().offset(24) as *mut u64;
@@ -302,8 +302,8 @@ fn test_jit_mbuff() {
     }
 
     unsafe {
-        let mut vm = rbpf::EbpfVmMbuff::new(&prog);
+        let mut vm = rbpf::EbpfVmMbuff::new(prog);
         vm.jit_compile();
-        assert_eq!(vm.prog_exec_jit(&mut mem, &mut mbuff), 0x2211);
+        assert_eq!(vm.prog_exec_jit(mem, &mut mbuff), 0x2211);
     }
 }

tests/ubpf_verifier.rs

@@ -28,102 +28,102 @@ use rbpf::ebpf;
 #[test]
 #[should_panic(expected = "[Verifier] Error: division by 0 (insn #1)")]
 fn test_verifier_err_div_by_zero_imm() {
-    let prog = vec![
+    let prog = &[
         0xb4, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
         0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let vm = rbpf::EbpfVmNoData::new(&prog);
+    let vm = rbpf::EbpfVmNoData::new(prog);
     vm.prog_exec();
 }
 
 #[test]
 #[should_panic(expected = "[Verifier] Error: unsupported argument for LE/BE (insn #0)")]
 fn test_verifier_err_endian_size() {
-    let prog = vec![
+    let prog = &[
         0xdc, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
         0xb7, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let vm = rbpf::EbpfVmNoData::new(&prog);
+    let vm = rbpf::EbpfVmNoData::new(prog);
     vm.prog_exec();
 }
 
 #[test]
 #[should_panic(expected = "[Verifier] Error: incomplete LD_DW instruction (insn #0)")]
 fn test_verifier_err_incomplete_lddw() { // Note: ubpf has test-err-incomplete-lddw2, which is the same
-    let prog = vec![
+    let prog = &[
         0x18, 0x00, 0x00, 0x00, 0x88, 0x77, 0x66, 0x55,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let vm = rbpf::EbpfVmNoData::new(&prog);
+    let vm = rbpf::EbpfVmNoData::new(prog);
     vm.prog_exec();
 }
 
 #[test]
 #[should_panic(expected = "[Verifier] Error: infinite loop")]
 fn test_verifier_err_infinite_loop() {
-    let prog = vec![
+    let prog = &[
         0x05, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let vm = rbpf::EbpfVmNoData::new(&prog);
+    let vm = rbpf::EbpfVmNoData::new(prog);
     vm.prog_exec();
 }
 
 #[test]
 #[should_panic(expected = "[Verifier] Error: invalid destination register (insn #0)")]
 fn test_verifier_err_invalid_reg_dst() {
-    let prog = vec![
+    let prog = &[
         0xb7, 0x0b, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let vm = rbpf::EbpfVmNoData::new(&prog);
+    let vm = rbpf::EbpfVmNoData::new(prog);
     vm.prog_exec();
 }
 
 #[test]
 #[should_panic(expected = "[Verifier] Error: invalid source register (insn #0)")]
 fn test_verifier_err_invalid_reg_src() {
-    let prog = vec![
+    let prog = &[
         0xbf, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let vm = rbpf::EbpfVmNoData::new(&prog);
+    let vm = rbpf::EbpfVmNoData::new(prog);
     vm.prog_exec();
 }
 
 #[test]
 #[should_panic(expected = "[Verifier] Error: jump to middle of LD_DW at #2 (insn #0)")]
 fn test_verifier_err_jmp_lddw() {
-    let prog = vec![
+    let prog = &[
         0x05, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x18, 0x00, 0x00, 0x00, 0x88, 0x77, 0x66, 0x55,
         0x00, 0x00, 0x00, 0x00, 0x44, 0x33, 0x22, 0x11,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let vm = rbpf::EbpfVmNoData::new(&prog);
+    let vm = rbpf::EbpfVmNoData::new(prog);
     vm.prog_exec();
 }
 
 #[test]
 #[should_panic(expected = "[Verifier] Error: jump out of code to #3 (insn #0)")]
 fn test_verifier_err_jmp_out() {
-    let prog = vec![
+    let prog = &[
         0x05, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let vm = rbpf::EbpfVmNoData::new(&prog);
+    let vm = rbpf::EbpfVmNoData::new(prog);
     vm.prog_exec();
 }
 
 #[test]
 #[should_panic(expected = "[Verifier] Error: program does not end with “EXIT” instruction")]
 fn test_verifier_err_no_exit() {
-    let prog = vec![
+    let prog = &[
         0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let vm = rbpf::EbpfVmNoData::new(&prog);
+    let vm = rbpf::EbpfVmNoData::new(prog);
     vm.prog_exec();
 }
 
@@ -146,21 +146,21 @@ fn test_verifier_err_too_many_instructions() {
 #[test]
 #[should_panic(expected = "[Verifier] Error: unknown eBPF opcode 0x6 (insn #0)")]
 fn test_verifier_err_unknown_opcode() {
-    let prog = vec![
+    let prog = &[
         0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let vm = rbpf::EbpfVmNoData::new(&prog);
+    let vm = rbpf::EbpfVmNoData::new(prog);
     vm.prog_exec();
 }
 
 #[test]
 #[should_panic(expected = "[Verifier] Error: cannot write into register r10 (insn #0)")]
 fn test_verifier_err_write_r10() {
-    let prog = vec![
+    let prog = &[
         0xb7, 0x0a, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
-    let vm = rbpf::EbpfVmNoData::new(&prog);
+    let vm = rbpf::EbpfVmNoData::new(prog);
     vm.prog_exec();
 }