Rename (#40)

README.md

@@ -166,15 +166,15 @@ do not need those offsets.
 
 ```rust,ignore
 // for struct EbpfVmMbuff, struct EbpfVmRaw and struct EbpfVmRawData
-pub fn set_prog(&mut self, prog: &'a [u8]) -> Result<(), Error>
+pub fn set_program(&mut self, prog: &'a [u8]) -> Result<(), Error>
 
 // for struct EbpfVmFixedMbuff
-pub fn set_prog(&mut self, prog: &'a [u8],
+pub fn set_program(&mut self, prog: &'a [u8],
                 data_offset: usize,
                 data_end_offset: usize) -> Result<(), Error>
 ```
 
-You can use for example `my_vm.set_prog(my_program);` to change the loaded
+You can use for example `my_vm.set_program(my_program);` to change the loaded
 program after the VM instance creation. This program is checked with the
 verifier attached to the VM. The verifying function of the VM can be changed at
 any moment.
@@ -205,16 +205,16 @@ therefore must use specific helper numbers.
 
 ```rust,ignore
 // for struct EbpfVmMbuff
-pub fn prog_exec(&self,
+pub fn execute_program(&self,
                  mem: &'a mut [u8],
                  mbuff: &'a mut [u8]) -> Result<(u64), Error>
 
 // for struct EbpfVmFixedMbuff and struct EbpfVmRaw
-pub fn prog_exec(&self,
+pub fn execute_program(&self,
                  mem: &'a mut [u8]) -> Result<(u64), Error>
 
 // for struct EbpfVmNoData
-pub fn prog_exec(&self) -> Result<(u64), Error>
+pub fn execute_program(&self) -> Result<(u64), Error>
 ```
 
 Interprets the loaded program. The function takes a reference to the packet
@@ -232,18 +232,18 @@ is called. The generated assembly function is internally stored in the VM.
 
 ```rust,ignore
 // for struct EbpfVmMbuff
-pub unsafe fn prog_exec_jit(&self, mem: &'a mut [u8],
+pub unsafe fn execute_program_jit(&self, mem: &'a mut [u8],
                             mbuff: &'a mut [u8]) -> Result<(u64), Error>
 
 // for struct EbpfVmFixedMbuff and struct EbpfVmRaw
-pub unsafe fn prog_exec_jit(&self, mem: &'a mut [u8]) -> Result<(u64), Error>
+pub unsafe fn execute_program_jit(&self, mem: &'a mut [u8]) -> Result<(u64), Error>
 
 // for struct EbpfVmNoData
-pub unsafe fn prog_exec_jit(&self) -> Result<(u64), Error>
+pub unsafe fn execute_program_jit(&self) -> Result<(u64), Error>
 ```
 
 Calls the JIT-compiled program. The arguments to provide are the same as for
-`prog_exec()`, again depending on the kind of VM that is used. The result of
+`execute_program()`, again depending on the kind of VM that is used. The result of
 the JIT-compiled program should be the same as with the interpreter, but it
 should run faster. Note that if errors occur during the program execution, the
 JIT-compiled version does not handle it as well as the interpreter, and the
@@ -275,7 +275,7 @@ fn main() {
     let vm = rbpf::EbpfVmNoData::new(prog).unwrap();
 
     // Execute (interpret) the program. No argument required for this VM.
-    assert_eq!(vm.prog_exec().unwrap(), 0x3);
+    assert_eq!(vm.execute_program().unwrap(), 0x3);
 }
 ```
 
@@ -306,7 +306,7 @@ fn main() {
 
     // 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(mem).unwrap(), 0x11); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x11); }
 }
 ```
 ### Using a metadata buffer
@@ -347,7 +347,7 @@ fn main() {
 
     // 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(mem, mbuff).unwrap(), 0x2211); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem, mbuff).unwrap(), 0x2211); }
 }
 ```
 
@@ -437,7 +437,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(packet).unwrap();
+    let res = vm.execute_program(packet).unwrap();
     println!("Program returned: {:?} ({:#x})", res, res);
 }
 ```

examples/load_elf.rs

@@ -114,7 +114,7 @@ fn main() {
     let mut vm = rbpf::EbpfVmFixedMbuff::new(Some(prog), 0x40, 0x50).unwrap();
     vm.register_helper(helpers::BPF_TRACE_PRINTK_IDX, helpers::bpf_trace_printf).unwrap();
 
-    let res = vm.prog_exec(packet1).unwrap();
+    let res = vm.execute_program(packet1).unwrap();
     println!("Packet #1, program returned: {:?} ({:#x})", res, res);
     assert_eq!(res, 0xffffffff);
 
@@ -122,14 +122,14 @@ fn main() {
     {
         vm.jit_compile().unwrap();
 
-        let res = unsafe { vm.prog_exec_jit(packet2).unwrap() };
+        let res = unsafe { vm.execute_program_jit(packet2).unwrap() };
         println!("Packet #2, program returned: {:?} ({:#x})", res, res);
         assert_eq!(res, 0);
     }
 
     #[cfg(windows)]
     {
-        let res = vm.prog_exec(packet2).unwrap();
+        let res = vm.execute_program(packet2).unwrap();
         println!("Packet #2, program returned: {:?} ({:#x})", res, res);
         assert_eq!(res, 0);
     }

examples/uptime.rs

@@ -41,7 +41,7 @@ fn main() {
     // Create a VM: this one takes no data. Load prog1 in it.
     let mut vm = rbpf::EbpfVmNoData::new(Some(prog1)).unwrap();
     // Execute prog1.
-    assert_eq!(vm.prog_exec().unwrap(), 0x3);
+    assert_eq!(vm.execute_program().unwrap(), 0x3);
 
     // As struct EbpfVmNoData does not takes any memory area, its return value is mostly
     // deterministic. So we know prog1 will always return 3. There is an exception: when it uses
@@ -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).unwrap();
+    vm.set_program(prog2).unwrap();
     vm.register_helper(helpers::BPF_KTIME_GETNS_IDX, helpers::bpf_time_getns).unwrap();
 
     let time;
@@ -60,12 +60,12 @@ fn main() {
     {
         vm.jit_compile().unwrap();
 
-        time = unsafe { vm.prog_exec_jit().unwrap() };
+        time = unsafe { vm.execute_program_jit().unwrap() };
     }
 
     #[cfg(windows)]
     {
-        time = vm.prog_exec().unwrap();
+        time = vm.execute_program().unwrap();
     }
 
     let days    =  time / 10u64.pow(9)  / 60   / 60  / 24;

src/lib.rs

@@ -92,7 +92,7 @@ struct MetaBuff {
 /// let mut vm = rbpf::EbpfVmMbuff::new(Some(prog)).unwrap();
 ///
 /// // Provide both a reference to the packet data, and to the metadata buffer.
-/// let res = vm.prog_exec(mem, &mut mbuff).unwrap();
+/// let res = vm.execute_program(mem, &mut mbuff).unwrap();
 /// assert_eq!(res, 0x2211);
 /// ```
 pub struct EbpfVmMbuff<'a> {
@@ -149,9 +149,9 @@ impl<'a> EbpfVmMbuff<'a> {
     ///
     /// // Instantiate a VM.
     /// let mut vm = rbpf::EbpfVmMbuff::new(Some(prog1)).unwrap();
-    /// vm.set_prog(prog2).unwrap();
+    /// vm.set_program(prog2).unwrap();
     /// ```
-    pub fn set_prog(&mut self, prog: &'a [u8]) -> Result<(), Error> {
+    pub fn set_program(&mut self, prog: &'a [u8]) -> Result<(), Error> {
         (self.verifier)(prog)?;
         self.prog = Some(prog);
         Ok(())
@@ -268,12 +268,12 @@ impl<'a> EbpfVmMbuff<'a> {
     /// let mut vm = rbpf::EbpfVmMbuff::new(Some(prog)).unwrap();
     ///
     /// // Provide both a reference to the packet data, and to the metadata buffer.
-    /// let res = vm.prog_exec(mem, &mut mbuff).unwrap();
+    /// let res = vm.execute_program(mem, &mut mbuff).unwrap();
     /// assert_eq!(res, 0x2211);
     /// ```
     #[allow(unknown_lints)]
     #[allow(cyclomatic_complexity)]
-    pub fn prog_exec(&self, mem: &[u8], mbuff: &[u8]) -> Result<u64, Error> {
+    pub fn execute_program(&self, mem: &[u8], mbuff: &[u8]) -> Result<u64, Error> {
         const U32MAX: u64 = u32::MAX as u64;
 
         let prog = match self.prog { 
@@ -626,7 +626,7 @@ impl<'a> EbpfVmMbuff<'a> {
     }
 
     /// Execute the previously JIT-compiled program, with the given packet data and metadata
-    /// buffer, in a manner very similar to `prog_exec()`.
+    /// buffer, in a manner very similar to `execute_program()`.
     ///
     /// If the program is made to be compatible with Linux kernel, it is expected to load the
     /// address of the beginning and of the end of the memory area used for packet data from the
@@ -673,11 +673,11 @@ impl<'a> EbpfVmMbuff<'a> {
     /// // Provide both a reference to the packet data, and to the metadata buffer.
     /// # #[cfg(not(windows))]
     /// unsafe {
-    ///     let res = vm.prog_exec_jit(mem, &mut mbuff).unwrap();
+    ///     let res = vm.execute_program_jit(mem, &mut mbuff).unwrap();
     ///     assert_eq!(res, 0x2211);
     /// }
     /// ```
-    pub unsafe fn prog_exec_jit(&self, mem: &mut [u8], mbuff: &'a mut [u8]) -> Result<u64, Error> {
+    pub unsafe fn execute_program_jit(&self, mem: &mut [u8], mbuff: &'a mut [u8]) -> Result<u64, Error> {
         // If packet data is empty, do not send the address of an empty slice; send a null pointer
         //  as first argument instead, as this is uBPF's behavior (empty packet should not happen
         //  in the kernel; anyway the verifier would prevent the use of uninitialized registers).
@@ -703,7 +703,7 @@ impl<'a> EbpfVmMbuff<'a> {
 ///
 /// This struct implements a static internal buffer that is passed to the program. The user has to
 /// indicate the offset values at which the eBPF program expects to find the start and the end of
-/// packet data in the buffer. On calling the `prog_exec()` or `prog_exec_jit()` functions, the
+/// packet data in the buffer. On calling the `execute_program()` or `execute_program_jit()` functions, the
 /// struct automatically updates the addresses in this static buffer, at the appointed offsets, for
 /// the start and the end of the packet data the program is called upon.
 ///
@@ -758,10 +758,10 @@ impl<'a> EbpfVmMbuff<'a> {
 /// let mut vm = rbpf::EbpfVmFixedMbuff::new(Some(prog), 0x40, 0x50).unwrap();
 ///
 /// // Provide only a reference to the packet data. We do not manage the metadata buffer.
-/// let res = vm.prog_exec(mem1).unwrap();
+/// let res = vm.execute_program(mem1).unwrap();
 /// assert_eq!(res, 0xffffffffffffffdd);
 ///
-/// let res = vm.prog_exec(mem2).unwrap();
+/// let res = vm.execute_program(mem2).unwrap();
 /// assert_eq!(res, 0x27);
 /// ```
 pub struct EbpfVmFixedMbuff<'a> {
@@ -832,18 +832,18 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     /// ];
     ///
     /// let mut vm = rbpf::EbpfVmFixedMbuff::new(Some(prog1), 0, 0).unwrap();
-    /// vm.set_prog(prog2, 0x40, 0x50);
+    /// vm.set_program(prog2, 0x40, 0x50);
     ///
-    /// let res = vm.prog_exec(mem).unwrap();
+    /// let res = vm.execute_program(mem).unwrap();
     /// assert_eq!(res, 0x27);
     /// ```
-    pub fn set_prog(&mut self, prog: &'a [u8], data_offset: usize, data_end_offset: usize) -> Result<(), Error> {
+    pub fn set_program(&mut self, prog: &'a [u8], data_offset: usize, data_end_offset: usize) -> Result<(), Error> {
         let get_buff_len = | x: usize, y: usize | if x >= y { x + 8 } else { y + 8 };
         let buffer = vec![0u8; get_buff_len(data_offset, data_end_offset)];
         self.mbuff.buffer = buffer;
         self.mbuff.data_offset = data_offset;
         self.mbuff.data_end_offset = data_end_offset;
-        self.parent.set_prog(prog)?;
+        self.parent.set_program(prog)?;
         Ok(())
     }
 
@@ -920,7 +920,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     /// // 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(mem).unwrap();
+    /// let res = vm.execute_program(mem).unwrap();
     /// assert_eq!(res, 3);
     /// ```
     pub fn register_helper(&mut self, key: u32, function: fn (u64, u64, u64, u64, u64) -> u64) -> Result<(), Error> {
@@ -954,10 +954,10 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     /// let mut vm = rbpf::EbpfVmFixedMbuff::new(Some(prog), 0x40, 0x50).unwrap();
     ///
     /// // Provide only a reference to the packet data. We do not manage the metadata buffer.
-    /// let res = vm.prog_exec(mem).unwrap();
+    /// let res = vm.execute_program(mem).unwrap();
     /// assert_eq!(res, 0xdd);
     /// ```
-    pub fn prog_exec(&mut self, mem: &'a mut [u8]) -> Result<u64, Error> {
+    pub fn execute_program(&mut self, mem: &'a mut [u8]) -> Result<u64, Error> {
         let l = self.mbuff.buffer.len();
         // Can this ever happen? Probably not, should be ensured at mbuff creation.
         if self.mbuff.data_offset + 8 > l || self.mbuff.data_end_offset + 8 > l {
@@ -966,7 +966,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
         }
         LittleEndian::write_u64(&mut self.mbuff.buffer[(self.mbuff.data_offset) .. ], mem.as_ptr() as u64);
         LittleEndian::write_u64(&mut self.mbuff.buffer[(self.mbuff.data_end_offset) .. ], mem.as_ptr() as u64 + mem.len() as u64);
-        self.parent.prog_exec(mem, &self.mbuff.buffer)
+        self.parent.execute_program(mem, &self.mbuff.buffer)
     }
 
     /// JIT-compile the loaded program. No argument required for this.
@@ -1003,7 +1003,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     }
 
     /// Execute the previously JIT-compiled program, with the given packet data, in a manner very
-    /// similar to `prog_exec()`.
+    /// similar to `execute_program()`.
     ///
     /// If the program is made to be compatible with Linux kernel, it is expected to load the
     /// address of the beginning and of the end of the memory area used for packet data from some
@@ -1044,13 +1044,13 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     /// // Provide only a reference to the packet data. We do not manage the metadata buffer.
     /// # #[cfg(not(windows))]
     /// unsafe {
-    ///     let res = vm.prog_exec_jit(mem).unwrap();
+    ///     let res = vm.execute_program_jit(mem).unwrap();
     ///     assert_eq!(res, 0xdd);
     /// }
     /// ```
-    // This struct redefines the `prog_exec_jit()` function, in order to pass the offsets
+    // This struct redefines the `execute_program_jit()` function, in order to pass the offsets
     // associated with the fixed mbuff.
-    pub unsafe fn prog_exec_jit(&mut self, mem: &'a mut [u8]) -> Result<u64, Error> {
+    pub unsafe fn execute_program_jit(&mut self, mem: &'a mut [u8]) -> Result<u64, Error> {
         // If packet data is empty, do not send the address of an empty slice; send a null pointer
         //  as first argument instead, as this is uBPF's behavior (empty packet should not happen
         //  in the kernel; anyway the verifier would prevent the use of uninitialized registers).
@@ -1093,7 +1093,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
 /// let vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
 ///
 /// // Provide only a reference to the packet data.
-/// let res = vm.prog_exec(mem).unwrap();
+/// let res = vm.execute_program(mem).unwrap();
 /// assert_eq!(res, 0x22cc);
 /// ```
 pub struct EbpfVmRaw<'a> {
@@ -1146,13 +1146,13 @@ impl<'a> EbpfVmRaw<'a> {
     /// ];
     ///
     /// let mut vm = rbpf::EbpfVmRaw::new(Some(prog1)).unwrap();
-    /// vm.set_prog(prog2);
+    /// vm.set_program(prog2);
     ///
-    /// let res = vm.prog_exec(mem).unwrap();
+    /// let res = vm.execute_program(mem).unwrap();
     /// assert_eq!(res, 0x22cc);
     /// ```
-    pub fn set_prog(&mut self, prog: &'a [u8]) -> Result<(), Error> {
-        self.parent.set_prog(prog)?;
+    pub fn set_program(&mut self, prog: &'a [u8]) -> Result<(), Error> {
+        self.parent.set_program(prog)?;
         Ok(())
     }
 
@@ -1222,7 +1222,7 @@ impl<'a> EbpfVmRaw<'a> {
     /// // 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(mem).unwrap();
+    /// let res = vm.execute_program(mem).unwrap();
     /// assert_eq!(res, 0x10000000);
     /// ```
     pub fn register_helper(&mut self, key: u32, function: fn (u64, u64, u64, u64, u64) -> u64) -> Result<(), Error> {
@@ -1247,11 +1247,11 @@ impl<'a> EbpfVmRaw<'a> {
     ///
     /// let mut vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
     ///
-    /// let res = vm.prog_exec(mem).unwrap();
+    /// let res = vm.execute_program(mem).unwrap();
     /// assert_eq!(res, 0x22cc);
     /// ```
-    pub fn prog_exec(&self, mem: &'a mut [u8]) -> Result<u64, Error> {
-        self.parent.prog_exec(mem, &[])
+    pub fn execute_program(&self, mem: &'a mut [u8]) -> Result<u64, Error> {
+        self.parent.execute_program(mem, &[])
     }
 
     /// JIT-compile the loaded program. No argument required for this.
@@ -1285,7 +1285,7 @@ impl<'a> EbpfVmRaw<'a> {
     }
 
     /// Execute the previously JIT-compiled program, with the given packet data, in a manner very
-    /// similar to `prog_exec()`.
+    /// similar to `execute_program()`.
     ///
     /// # Safety
     ///
@@ -1317,13 +1317,13 @@ impl<'a> EbpfVmRaw<'a> {
     ///
     /// # #[cfg(not(windows))]
     /// unsafe {
-    ///     let res = vm.prog_exec_jit(mem).unwrap();
+    ///     let res = vm.execute_program_jit(mem).unwrap();
     ///     assert_eq!(res, 0x22cc);
     /// }
     /// ```
-    pub unsafe fn prog_exec_jit(&self, mem: &'a mut [u8]) -> Result<u64, Error> {
+    pub unsafe fn execute_program_jit(&self, mem: &'a mut [u8]) -> Result<u64, Error> {
         let mut mbuff = vec![];
-        self.parent.prog_exec_jit(mem, &mut mbuff)
+        self.parent.execute_program_jit(mem, &mut mbuff)
     }
 }
 
@@ -1363,7 +1363,7 @@ impl<'a> EbpfVmRaw<'a> {
 /// let vm = rbpf::EbpfVmNoData::new(Some(prog)).unwrap();
 ///
 /// // Provide only a reference to the packet data.
-/// let res = vm.prog_exec().unwrap();
+/// let res = vm.execute_program().unwrap();
 /// assert_eq!(res, 0x11);
 /// ```
 pub struct EbpfVmNoData<'a> {
@@ -1411,16 +1411,16 @@ impl<'a> EbpfVmNoData<'a> {
     ///
     /// let mut vm = rbpf::EbpfVmNoData::new(Some(prog1)).unwrap();
     ///
-    /// let res = vm.prog_exec().unwrap();
+    /// let res = vm.execute_program().unwrap();
     /// assert_eq!(res, 0x2211);
     ///
-    /// vm.set_prog(prog2);
+    /// vm.set_program(prog2);
     ///
-    /// let res = vm.prog_exec().unwrap();
+    /// let res = vm.execute_program().unwrap();
     /// assert_eq!(res, 0x1122);
     /// ```
-    pub fn set_prog(&mut self, prog: &'a [u8]) -> Result<(), Error> {
-        self.parent.set_prog(prog)?;
+    pub fn set_program(&mut self, prog: &'a [u8]) -> Result<(), Error> {
+        self.parent.set_program(prog)?;
         Ok(())
     }
 
@@ -1485,7 +1485,7 @@ impl<'a> EbpfVmNoData<'a> {
     /// // Register a helper. This helper will store the result of the square root of r1 into r0.
     /// vm.register_helper(1, helpers::sqrti).unwrap();
     ///
-    /// let res = vm.prog_exec().unwrap();
+    /// let res = vm.execute_program().unwrap();
     /// assert_eq!(res, 0x1000);
     /// ```
     pub fn register_helper(&mut self, key: u32, function: fn (u64, u64, u64, u64, u64) -> u64) -> Result<(), Error> {
@@ -1529,16 +1529,16 @@ impl<'a> EbpfVmNoData<'a> {
     ///
     /// let vm = rbpf::EbpfVmNoData::new(Some(prog)).unwrap();
     ///
-    /// // For this kind of VM, the `prog_exec()` function needs no argument.
-    /// let res = vm.prog_exec().unwrap();
+    /// // For this kind of VM, the `execute_program()` function needs no argument.
+    /// let res = vm.execute_program().unwrap();
     /// assert_eq!(res, 0x1122);
     /// ```
-    pub fn prog_exec(&self) -> Result<(u64), Error> {
-        self.parent.prog_exec(&mut [])
+    pub fn execute_program(&self) -> Result<(u64), Error> {
+        self.parent.execute_program(&mut [])
     }
 
     /// Execute the previously JIT-compiled program, without providing pointers to any memory area
-    /// whatsoever, in a manner very similar to `prog_exec()`.
+    /// whatsoever, in a manner very similar to `execute_program()`.
     ///
     /// # Safety
     ///
@@ -1565,11 +1565,11 @@ impl<'a> EbpfVmNoData<'a> {
     ///
     /// # #[cfg(not(windows))]
     /// unsafe {
-    ///     let res = vm.prog_exec_jit().unwrap();
+    ///     let res = vm.execute_program_jit().unwrap();
     ///     assert_eq!(res, 0x1122);
     /// }
     /// ```
-    pub unsafe fn prog_exec_jit(&self) -> Result<(u64), Error> {
-        self.parent.prog_exec_jit(&mut [])
+    pub unsafe fn execute_program_jit(&self) -> Result<(u64), Error> {
+        self.parent.execute_program_jit(&mut [])
     }
 }

src/verifier.rs

@@ -42,7 +42,7 @@ fn check_prog_len(prog: &[u8]) -> Result<(), Error> {
     }
 
     if prog.is_empty() {
-        reject("no program set, call set_prog() to load one".to_string())?;
+        reject("no program set, call set_program() to load one".to_string())?;
     }
     let last_insn = ebpf::get_insn(prog, (prog.len() / ebpf::INSN_SIZE) - 1);
     if last_insn.opc != ebpf::EXIT {

tests/misc.rs

@@ -168,7 +168,7 @@ fn test_vm_block_port() {
     let mut vm = rbpf::EbpfVmFixedMbuff::new(Some(prog), 0x40, 0x50).unwrap();
     vm.register_helper(helpers::BPF_TRACE_PRINTK_IDX, helpers::bpf_trace_printf).unwrap();
 
-    let res = vm.prog_exec(packet).unwrap();
+    let res = vm.execute_program(packet).unwrap();
     println!("Program returned: {:?} ({:#x})", res, res);
     assert_eq!(res, 0xffffffff);
 }
@@ -252,7 +252,7 @@ fn test_jit_block_port() {
     vm.jit_compile().unwrap();
 
     unsafe {
-        let res = vm.prog_exec_jit(packet).unwrap();
+        let res = vm.execute_program_jit(packet).unwrap();
         println!("Program returned: {:?} ({:#x})", res, res);
         assert_eq!(res, 0xffffffff);
     }
@@ -281,7 +281,7 @@ fn test_vm_mbuff() {
     }
 
     let vm = rbpf::EbpfVmMbuff::new(Some(prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem, &mbuff).unwrap(), 0x2211);
+    assert_eq!(vm.execute_program(mem, &mbuff).unwrap(), 0x2211);
 }
 
 // Program and memory come from uBPF test ldxh.
@@ -308,7 +308,7 @@ fn test_vm_mbuff_with_rust_api() {
     }
 
     let vm = rbpf::EbpfVmMbuff::new(Some(program.into_bytes())).unwrap();
-    assert_eq!(vm.prog_exec(mem, &mbuff).unwrap(), 0x2211);
+    assert_eq!(vm.execute_program(mem, &mbuff).unwrap(), 0x2211);
 }
 
 // Program and memory come from uBPF test ldxh.
@@ -337,7 +337,7 @@ fn test_jit_mbuff() {
     unsafe {
         let mut vm = rbpf::EbpfVmMbuff::new(Some(prog)).unwrap();
         vm.jit_compile().unwrap();
-        assert_eq!(vm.prog_exec_jit(mem, &mut mbuff).unwrap(), 0x2211);
+        assert_eq!(vm.execute_program_jit(mem, &mut mbuff).unwrap(), 0x2211);
     }
 }
 
@@ -353,11 +353,11 @@ fn test_vm_jit_ldabsb() {
         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x33);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x33);
 
     vm.jit_compile().unwrap();
     unsafe {
-        assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x33);
+        assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x33);
     };
 }
 
@@ -373,11 +373,11 @@ fn test_vm_jit_ldabsh() {
         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x4433);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x4433);
 
     vm.jit_compile().unwrap();
     unsafe {
-        assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x4433);
+        assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x4433);
     };
 }
 
@@ -393,11 +393,11 @@ fn test_vm_jit_ldabsw() {
         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x66554433);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x66554433);
     vm.jit_compile().unwrap();
 
     unsafe {
-        assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x66554433);
+        assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x66554433);
     };
 }
 
@@ -413,11 +413,11 @@ fn test_vm_jit_ldabsdw() {
         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0xaa99887766554433);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0xaa99887766554433);
     vm.jit_compile().unwrap();
 
     unsafe {
-        assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0xaa99887766554433);
+        assert_eq!(vm.execute_program_jit(mem).unwrap(), 0xaa99887766554433);
     };
 }
 
@@ -433,7 +433,7 @@ fn test_vm_err_ldabsb_oob() {
         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    vm.prog_exec(mem).unwrap();
+    vm.execute_program(mem).unwrap();
 
     // Memory check not implemented for JIT yet.
 }
@@ -446,7 +446,7 @@ fn test_vm_err_ldabsb_nomem() {
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
     let vm = rbpf::EbpfVmNoData::new(Some(prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 
     // Memory check not implemented for JIT yet.
 }
@@ -464,11 +464,11 @@ fn test_vm_jit_ldindb() {
         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x88);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x88);
 
     vm.jit_compile().unwrap();
     unsafe {
-        assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x88);
+        assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x88);
     };
 }
 
@@ -485,11 +485,11 @@ fn test_vm_jit_ldindh() {
         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x9988);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x9988);
 
     vm.jit_compile().unwrap();
     unsafe {
-        assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x9988);
+        assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x9988);
     };
 }
 
@@ -506,11 +506,11 @@ fn test_vm_jit_ldindw() {
         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x88776655);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x88776655);
     vm.jit_compile().unwrap();
 
     unsafe {
-        assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x88776655);
+        assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x88776655);
     };
 }
 
@@ -527,11 +527,11 @@ fn test_vm_jit_ldinddw() {
         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0xccbbaa9988776655);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0xccbbaa9988776655);
     vm.jit_compile().unwrap();
 
     unsafe {
-        assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0xccbbaa9988776655);
+        assert_eq!(vm.execute_program_jit(mem).unwrap(), 0xccbbaa9988776655);
     };
 }
 
@@ -548,7 +548,7 @@ fn test_vm_err_ldindb_oob() {
         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    vm.prog_exec(mem).unwrap();
+    vm.execute_program(mem).unwrap();
 
     // Memory check not implemented for JIT yet.
 }
@@ -562,7 +562,7 @@ fn test_vm_err_ldindb_nomem() {
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
     let vm = rbpf::EbpfVmNoData::new(Some(prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 
     // Memory check not implemented for JIT yet.
 }
@@ -571,7 +571,7 @@ fn test_vm_err_ldindb_nomem() {
 #[should_panic(expected = "Error: No program set, call prog_set() to load one")]
 fn test_vm_exec_no_program() {
     let vm = rbpf::EbpfVmNoData::new(None).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0xBEE);
+    assert_eq!(vm.execute_program().unwrap(), 0xBEE);
 }
 
 fn verifier_success(_prog: &[u8]) -> Result<(), Error> {
@@ -591,8 +591,8 @@ fn test_verifier_success() {
     ).unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(None).unwrap();
     vm.set_verifier(verifier_success).unwrap();
-    vm.set_prog(&prog).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0xBEE);
+    vm.set_program(&prog).unwrap();
+    assert_eq!(vm.execute_program().unwrap(), 0xBEE);
 }
 
 #[test]
@@ -604,6 +604,6 @@ fn test_verifier_fail() {
     ).unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(None).unwrap();
     vm.set_verifier(verifier_fail).unwrap();
-    vm.set_prog(&prog).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0xBEE);
+    vm.set_program(&prog).unwrap();
+    assert_eq!(vm.execute_program().unwrap(), 0xBEE);
 }

tests/ubpf_jit_x86_64.rs

@@ -40,7 +40,7 @@ fn test_jit_add() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x3); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x3); }
 }
 
 #[test]
@@ -67,7 +67,7 @@ fn test_jit_alu64_arith() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x2a); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x2a); }
 }
 
 #[test]
@@ -98,7 +98,7 @@ fn test_jit_alu64_bit() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x11); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x11); }
 }
 
 #[test]
@@ -125,7 +125,7 @@ fn test_jit_alu_arith() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x2a); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x2a); }
 }
 
 #[test]
@@ -154,7 +154,7 @@ fn test_jit_alu_bit() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x11); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x11); }
 }
 
 #[test]
@@ -166,7 +166,7 @@ fn test_jit_arsh32_high_shift() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x4); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x4); }
 }
 
 #[test]
@@ -178,7 +178,7 @@ fn test_jit_arsh() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0xffff8000); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0xffff8000); }
 }
 
 #[test]
@@ -192,7 +192,7 @@ fn test_jit_arsh64() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0xfffffffffffffff8); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0xfffffffffffffff8); }
 }
 
 #[test]
@@ -205,7 +205,7 @@ fn test_jit_arsh_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0xffff8000); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0xffff8000); }
 }
 
 #[test]
@@ -219,7 +219,7 @@ fn test_jit_be16() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x1122); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x1122); }
 }
 
 #[test]
@@ -233,7 +233,7 @@ fn test_jit_be16_high() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x1122); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x1122); }
 }
 
 #[test]
@@ -247,7 +247,7 @@ fn test_jit_be32() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x11223344); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x11223344); }
 }
 
 #[test]
@@ -261,7 +261,7 @@ fn test_jit_be32_high() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x11223344); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x11223344); }
 }
 
 #[test]
@@ -275,7 +275,7 @@ fn test_jit_be64() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x1122334455667788); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x1122334455667788); }
 }
 
 #[test]
@@ -291,7 +291,7 @@ fn test_jit_call() {
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.register_helper(0, helpers::gather_bytes).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x0102030405); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x0102030405); }
 }
 
 #[test]
@@ -310,7 +310,7 @@ fn test_jit_call_memfrob() {
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.register_helper(1, helpers::memfrob).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x102292e2f2c0708); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x102292e2f2c0708); }
 }
 
 // TODO: helpers::trash_registers needs asm!().
@@ -333,7 +333,7 @@ fn test_jit_call_memfrob() {
     //let mut vm = rbpf::EbpfVmNoData::new(Some(prog)).unwrap();
     //vm.register_helper(2, helpers::trash_registers);
     //vm.jit_compile().unwrap();
-    //unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x4321); }
+    //unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x4321); }
 //}
 
 #[test]
@@ -345,7 +345,7 @@ fn test_jit_div32_high_divisor() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x3); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x3); }
 }
 
 #[test]
@@ -356,7 +356,7 @@ fn test_jit_div32_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x3); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x3); }
 }
 
 #[test]
@@ -368,7 +368,7 @@ fn test_jit_div32_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x3); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x3); }
 }
 
 #[test]
@@ -380,7 +380,7 @@ fn test_jit_div64_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x300000000); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x300000000); }
 }
 
 #[test]
@@ -393,7 +393,7 @@ fn test_jit_div64_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x300000000); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x300000000); }
 }
 
 #[test]
@@ -405,7 +405,7 @@ fn test_jit_early_exit() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x3); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x3); }
 }
 
 // uBPF limits the number of user functions at 64. We don't.
@@ -426,7 +426,7 @@ fn test_jit_err_call_unreg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { vm.prog_exec_jit().unwrap(); }
+    unsafe { vm.execute_program_jit().unwrap(); }
 }
 
 // TODO: Should panic!() instead, but I could not make it panic in JIT-compiled code, so the
@@ -441,7 +441,7 @@ fn test_jit_err_div64_by_zero_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0xffffffffffffffff); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0xffffffffffffffff); }
 }
 
 // TODO: Same remark as above
@@ -455,7 +455,7 @@ fn test_jit_err_div_by_zero_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0xffffffffffffffff); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0xffffffffffffffff); }
 }
 
 // TODO: Same remark as above
@@ -469,7 +469,7 @@ fn test_jit_err_mod64_by_zero_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0xffffffffffffffff); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0xffffffffffffffff); }
 }
 
 // TODO: Same remark as above
@@ -483,7 +483,7 @@ fn test_jit_err_mod_by_zero_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0xffffffffffffffff); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0xffffffffffffffff); }
 }
 
 // TODO SKIP: JIT disabled for this testcase (stack oob check not implemented)
@@ -496,7 +496,7 @@ fn test_jit_err_mod_by_zero_reg() {
 //     ];
 //     let mut vm = rbpf::EbpfVmNoData::new(Some(prog)).unwrap();
 //     vm.jit_compile().unwrap();
-//     unsafe { vm.prog_exec_jit().unwrap(); }
+//     unsafe { vm.execute_program_jit().unwrap(); }
 // }
 
 #[test]
@@ -506,7 +506,7 @@ fn test_jit_exit() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x0); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x0); }
 }
 
 #[test]
@@ -518,7 +518,7 @@ fn test_jit_ja() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -534,7 +534,7 @@ fn test_jit_jeq_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -551,7 +551,7 @@ fn test_jit_jeq_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -567,7 +567,7 @@ fn test_jit_jge_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -584,7 +584,7 @@ fn test_jit_jle_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -603,7 +603,7 @@ fn test_jit_jle_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -619,7 +619,7 @@ fn test_jit_jgt_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -637,7 +637,7 @@ fn test_jit_jgt_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -653,7 +653,7 @@ fn test_jit_jlt_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -671,7 +671,7 @@ fn test_jit_jlt_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -686,7 +686,7 @@ fn test_jit_jit_bounce() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -703,7 +703,7 @@ fn test_jit_jne_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -719,7 +719,7 @@ fn test_jit_jset_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -736,7 +736,7 @@ fn test_jit_jset_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -753,7 +753,7 @@ fn test_jit_jsge_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -772,7 +772,7 @@ fn test_jit_jsge_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -789,7 +789,7 @@ fn test_jit_jsle_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -809,7 +809,7 @@ fn test_jit_jsle_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -825,7 +825,7 @@ fn test_jit_jsgt_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -842,7 +842,7 @@ fn test_jit_jsgt_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -858,7 +858,7 @@ fn test_jit_jslt_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -876,7 +876,7 @@ fn test_jit_jslt_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -886,7 +886,7 @@ fn test_jit_lddw() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1122334455667788); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1122334455667788); }
 }
 
 #[test]
@@ -896,7 +896,7 @@ fn test_jit_lddw2() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x80000000); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x80000000); }
 }
 
 #[test]
@@ -939,7 +939,7 @@ fn test_jit_ldxb_all() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x9876543210); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x9876543210); }
 }
 
 #[test]
@@ -952,7 +952,7 @@ fn test_jit_ldxb() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x11); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x11); }
 }
 
 #[test]
@@ -966,7 +966,7 @@ fn test_jit_ldxdw() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x8877665544332211); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x8877665544332211); }
 }
 
 #[test]
@@ -1020,7 +1020,7 @@ fn test_jit_ldxh_all() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x9876543210); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x9876543210); }
 }
 
 #[test]
@@ -1064,7 +1064,7 @@ fn test_jit_ldxh_all2() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x3ff); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x3ff); }
 }
 
 #[test]
@@ -1077,7 +1077,7 @@ fn test_jit_ldxh() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x2211); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x2211); }
 }
 
 #[test]
@@ -1092,7 +1092,7 @@ fn test_jit_ldxh_same_reg() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x1234); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x1234); }
 }
 
 #[test]
@@ -1138,7 +1138,7 @@ fn test_jit_ldxw_all() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x030f0f); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x030f0f); }
 }
 
 #[test]
@@ -1151,7 +1151,7 @@ fn test_jit_ldxw() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x44332211); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x44332211); }
 }
 
 #[test]
@@ -1165,7 +1165,7 @@ fn test_jit_le16() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x1122); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x1122); }
 }
 
 #[test]
@@ -1179,7 +1179,7 @@ fn test_jit_le32() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x11223344); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x11223344); }
 }
 
 #[test]
@@ -1193,7 +1193,7 @@ fn test_jit_le64() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x1122334455667788); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x1122334455667788); }
 }
 
 #[test]
@@ -1205,7 +1205,7 @@ fn test_jit_lsh_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x10); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x10); }
 }
 
 #[test]
@@ -1218,7 +1218,7 @@ fn test_jit_mod() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x5); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x5); }
 }
 
 #[test]
@@ -1229,7 +1229,7 @@ fn test_jit_mod32() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x0); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x0); }
 }
 
 #[test]
@@ -1246,7 +1246,7 @@ fn test_jit_mod64() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x30ba5a04); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x30ba5a04); }
 }
 
 #[test]
@@ -1257,7 +1257,7 @@ fn test_jit_mov() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -1268,7 +1268,7 @@ fn test_jit_mul32_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0xc); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0xc); }
 }
 
 #[test]
@@ -1280,7 +1280,7 @@ fn test_jit_mul32_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0xc); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0xc); }
 }
 
 #[test]
@@ -1292,7 +1292,7 @@ fn test_jit_mul32_reg_overflow() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x4); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x4); }
 }
 
 #[test]
@@ -1303,7 +1303,7 @@ fn test_jit_mul64_imm() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x100000004); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x100000004); }
 }
 
 #[test]
@@ -1315,7 +1315,7 @@ fn test_jit_mul64_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x100000004); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x100000004); }
 }
 
 #[test]
@@ -1333,7 +1333,7 @@ fn test_jit_mul_loop() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x75db9c97); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x75db9c97); }
 }
 
 #[test]
@@ -1344,7 +1344,7 @@ fn test_jit_neg64() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0xfffffffffffffffe); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0xfffffffffffffffe); }
 }
 
 #[test]
@@ -1355,7 +1355,7 @@ fn test_jit_neg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0xfffffffe); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0xfffffffe); }
 }
 
 #[test]
@@ -1379,7 +1379,7 @@ fn test_jit_prime() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -1391,7 +1391,7 @@ fn test_jit_rhs32() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x00ffffff); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x00ffffff); }
 }
 
 #[test]
@@ -1403,7 +1403,7 @@ fn test_jit_rsh_reg() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x1); }
 }
 
 #[test]
@@ -1420,7 +1420,7 @@ fn test_jit_stack() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0xcd); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0xcd); }
 }
 
 #[test]
@@ -1446,7 +1446,7 @@ fn test_jit_stack2() {
     vm.register_helper(0, helpers::gather_bytes).unwrap();
     vm.register_helper(1, helpers::memfrob).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x01020304); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x01020304); }
 }
 
 #[test]
@@ -1460,7 +1460,7 @@ fn test_jit_stb() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x11); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x11); }
 }
 
 #[test]
@@ -1475,7 +1475,7 @@ fn test_jit_stdw() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x44332211); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x44332211); }
 }
 
 #[test]
@@ -1489,7 +1489,7 @@ fn test_jit_sth() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x2211); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x2211); }
 }
 
 #[test]
@@ -1526,7 +1526,7 @@ fn test_jit_string_stack() {
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.register_helper(4, helpers::strcmp).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit().unwrap(), 0x0); }
+    unsafe { assert_eq!(vm.execute_program_jit().unwrap(), 0x0); }
 }
 
 #[test]
@@ -1540,7 +1540,7 @@ fn test_jit_stw() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x44332211); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x44332211); }
 }
 
 #[test]
@@ -1555,7 +1555,7 @@ fn test_jit_stxb() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x11); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x11); }
 }
 
 #[test]
@@ -1585,7 +1585,7 @@ fn test_jit_stxb_all() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0xf0f2f3f4f5f6f7f8); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0xf0f2f3f4f5f6f7f8); }
 }
 
 #[test]
@@ -1604,7 +1604,7 @@ fn test_jit_stxb_all2() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0xf1f9); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0xf1f9); }
 }
 
 #[test]
@@ -1637,7 +1637,7 @@ fn test_jit_stxb_chain() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x2a); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x2a); }
 }
 
 #[test]
@@ -1655,7 +1655,7 @@ fn test_jit_stxdw() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x8877665544332211); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x8877665544332211); }
 }
 
 #[test]
@@ -1670,7 +1670,7 @@ fn test_jit_stxh() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x2211); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x2211); }
 }
 
 #[test]
@@ -1685,7 +1685,7 @@ fn test_jit_stxw() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x44332211); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x44332211); }
 }
 
 #[test]
@@ -1719,7 +1719,7 @@ fn test_jit_subnet() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x1); }
 }
 
 
@@ -1765,7 +1765,7 @@ fn test_jit_tcp_port80_match() {
     let prog = &PROG_TCP_PORT_80;
     let mut vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x1); }
 }
 
 #[test]
@@ -1788,7 +1788,7 @@ fn test_jit_tcp_port80_nomatch() {
     let prog = &PROG_TCP_PORT_80;
     let mut vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x0); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x0); }
 }
 
 #[test]
@@ -1811,7 +1811,7 @@ fn test_jit_tcp_port80_nomatch_ethertype() {
     let prog = &PROG_TCP_PORT_80;
     let mut vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x0); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x0); }
 }
 
 #[test]
@@ -1834,7 +1834,7 @@ fn test_jit_tcp_port80_nomatch_proto() {
     let prog = &PROG_TCP_PORT_80;
     let mut vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem).unwrap(), 0x0); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem).unwrap(), 0x0); }
 }
 
 #[test]
@@ -1843,7 +1843,7 @@ fn test_jit_tcp_sack_match() {
     let prog = assemble(TCP_SACK_ASM).unwrap();
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem.as_mut_slice()).unwrap(), 0x1); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem.as_mut_slice()).unwrap(), 0x1); }
 }
 
 #[test]
@@ -1852,5 +1852,5 @@ fn test_jit_tcp_sack_nomatch() {
     let prog = assemble(TCP_SACK_ASM).unwrap();
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.jit_compile().unwrap();
-    unsafe { assert_eq!(vm.prog_exec_jit(mem.as_mut_slice()).unwrap(), 0x0); }
+    unsafe { assert_eq!(vm.execute_program_jit(mem.as_mut_slice()).unwrap(), 0x0); }
 }

tests/ubpf_verifier.rs

@@ -34,7 +34,7 @@ fn test_verifier_err_div_by_zero_imm() {
         div32 r0, 0
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -46,7 +46,7 @@ fn test_verifier_err_endian_size() {
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
     let vm = rbpf::EbpfVmNoData::new(Some(prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -57,7 +57,7 @@ fn test_verifier_err_incomplete_lddw() { // Note: ubpf has test-err-incomplete-l
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
     let vm = rbpf::EbpfVmNoData::new(Some(prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -67,7 +67,7 @@ fn test_verifier_err_infinite_loop() {
         ja -1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -77,7 +77,7 @@ fn test_verifier_err_invalid_reg_dst() {
         mov r11, 1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -87,7 +87,7 @@ fn test_verifier_err_invalid_reg_src() {
         mov r0, r11
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -98,7 +98,7 @@ fn test_verifier_err_jmp_lddw() {
         lddw r0, 0x1122334455667788
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -108,7 +108,7 @@ fn test_verifier_err_jmp_out() {
         ja +2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -117,7 +117,7 @@ fn test_verifier_err_no_exit() {
     let prog = assemble("
         mov32 r0, 0").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -133,7 +133,7 @@ fn test_verifier_err_too_many_instructions() {
     prog.append(&mut vec![ 0x95, 0, 0, 0, 0, 0, 0, 0 ]);
 
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -144,7 +144,7 @@ fn test_verifier_err_unknown_opcode() {
         0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ];
     let vm = rbpf::EbpfVmNoData::new(Some(prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -154,5 +154,5 @@ fn test_verifier_err_write_r10() {
         mov r10, 1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }

tests/ubpf_vm.rs

@@ -38,7 +38,7 @@ fn test_vm_add() {
         add32 r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x3);
+    assert_eq!(vm.execute_program().unwrap(), 0x3);
 }
 
 #[test]
@@ -64,7 +64,7 @@ fn test_vm_alu64_arith() {
         div r0, r4
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x2a);
+    assert_eq!(vm.execute_program().unwrap(), 0x2a);
 }
 
 #[test]
@@ -94,7 +94,7 @@ fn test_vm_alu64_bit() {
         xor r0, r2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x11);
+    assert_eq!(vm.execute_program().unwrap(), 0x11);
 }
 
 #[test]
@@ -120,7 +120,7 @@ fn test_vm_alu_arith() {
         div32 r0, r4
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x2a);
+    assert_eq!(vm.execute_program().unwrap(), 0x2a);
 }
 
 #[test]
@@ -148,7 +148,7 @@ fn test_vm_alu_bit() {
         xor32 r0, r2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x11);
+    assert_eq!(vm.execute_program().unwrap(), 0x11);
 }
 
 #[test]
@@ -159,7 +159,7 @@ fn test_vm_arsh32_high_shift() {
         arsh32 r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x4);
+    assert_eq!(vm.execute_program().unwrap(), 0x4);
 }
 
 #[test]
@@ -170,7 +170,7 @@ fn test_vm_arsh() {
         arsh32 r0, 16
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0xffff8000);
+    assert_eq!(vm.execute_program().unwrap(), 0xffff8000);
 }
 
 #[test]
@@ -183,7 +183,7 @@ fn test_vm_arsh64() {
         arsh r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0xfffffffffffffff8);
+    assert_eq!(vm.execute_program().unwrap(), 0xfffffffffffffff8);
 }
 
 #[test]
@@ -195,7 +195,7 @@ fn test_vm_arsh_reg() {
         arsh32 r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0xffff8000);
+    assert_eq!(vm.execute_program().unwrap(), 0xffff8000);
 }
 
 #[test]
@@ -208,7 +208,7 @@ fn test_vm_be16() {
         0x11, 0x22
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x1122);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x1122);
 }
 
 #[test]
@@ -221,7 +221,7 @@ fn test_vm_be16_high() {
         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x1122);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x1122);
 }
 
 #[test]
@@ -234,7 +234,7 @@ fn test_vm_be32() {
         0x11, 0x22, 0x33, 0x44
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x11223344);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x11223344);
 }
 
 #[test]
@@ -247,7 +247,7 @@ fn test_vm_be32_high() {
         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x11223344);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x11223344);
 }
 
 #[test]
@@ -260,7 +260,7 @@ fn test_vm_be64() {
         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x1122334455667788);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x1122334455667788);
 }
 
 #[test]
@@ -275,7 +275,7 @@ fn test_vm_call() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.register_helper(0, helpers::gather_bytes).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x0102030405);
+    assert_eq!(vm.execute_program().unwrap(), 0x0102030405);
 }
 
 #[test]
@@ -293,7 +293,7 @@ fn test_vm_call_memfrob() {
     ];
     let mut vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
     vm.register_helper(1, helpers::memfrob).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x102292e2f2c0708);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x102292e2f2c0708);
 }
 
 // TODO: helpers::trash_registers needs asm!().
@@ -315,7 +315,7 @@ fn test_vm_call_memfrob() {
     //];
     //let mut vm = rbpf::EbpfVmNoData::new(Some(prog)).unwrap();
     //vm.register_helper(2, helpers::trash_registers);
-    //assert_eq!(vm.prog_exec().unwrap(), 0x4321);
+    //assert_eq!(vm.execute_program().unwrap(), 0x4321);
 //}
 
 #[test]
@@ -326,7 +326,7 @@ fn test_vm_div32_high_divisor() {
         div32 r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x3);
+    assert_eq!(vm.execute_program().unwrap(), 0x3);
 }
 
 #[test]
@@ -336,7 +336,7 @@ fn test_vm_div32_imm() {
         div32 r0, 4
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x3);
+    assert_eq!(vm.execute_program().unwrap(), 0x3);
 }
 
 #[test]
@@ -347,7 +347,7 @@ fn test_vm_div32_reg() {
         div32 r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x3);
+    assert_eq!(vm.execute_program().unwrap(), 0x3);
 }
 
 #[test]
@@ -358,7 +358,7 @@ fn test_vm_div64_imm() {
         div r0, 4
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x300000000);
+    assert_eq!(vm.execute_program().unwrap(), 0x300000000);
 }
 
 #[test]
@@ -370,7 +370,7 @@ fn test_vm_div64_reg() {
         div r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x300000000);
+    assert_eq!(vm.execute_program().unwrap(), 0x300000000);
 }
 
 #[test]
@@ -381,7 +381,7 @@ fn test_vm_early_exit() {
         mov r0, 4
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x3);
+    assert_eq!(vm.execute_program().unwrap(), 0x3);
 }
 
 // uBPF limits the number of user functions at 64. We don't.
@@ -401,7 +401,7 @@ fn test_vm_err_call_unreg() {
         call 63
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -413,7 +413,7 @@ fn test_vm_err_div64_by_zero_reg() {
         div r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -425,7 +425,7 @@ fn test_vm_err_div_by_zero_reg() {
         div32 r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -437,7 +437,7 @@ fn test_vm_err_mod64_by_zero_reg() {
         mod r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -449,7 +449,7 @@ fn test_vm_err_mod_by_zero_reg() {
         mod32 r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -459,7 +459,7 @@ fn test_vm_err_stack_out_of_bound() {
         stb [r10], 0
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    vm.prog_exec().unwrap();
+    vm.execute_program().unwrap();
 }
 
 #[test]
@@ -468,7 +468,7 @@ fn test_vm_exit() {
         mov r0, 0
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x0);
+    assert_eq!(vm.execute_program().unwrap(), 0x0);
 }
 
 #[test]
@@ -479,7 +479,7 @@ fn test_vm_ja() {
         mov r0, 2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -494,7 +494,7 @@ fn test_vm_jeq_imm() {
         mov32 r0, 2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -510,7 +510,7 @@ fn test_vm_jeq_reg() {
         mov32 r0, 2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -525,7 +525,7 @@ fn test_vm_jge_imm() {
         mov32 r0, 2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -541,7 +541,7 @@ fn test_vm_jle_imm() {
         mov32 r0, 1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -559,7 +559,7 @@ fn test_vm_jle_reg() {
         mov r0, 1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -574,7 +574,7 @@ fn test_vm_jgt_imm() {
         mov32 r0, 1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -591,7 +591,7 @@ fn test_vm_jgt_reg() {
         mov r0, 1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -606,7 +606,7 @@ fn test_vm_jlt_imm() {
         mov32 r0, 1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -623,7 +623,7 @@ fn test_vm_jlt_reg() {
         mov r0, 1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -637,7 +637,7 @@ fn test_vm_jit_bounce() {
         mov r0, r9
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -653,7 +653,7 @@ fn test_vm_jne_reg() {
         mov32 r0, 2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -668,7 +668,7 @@ fn test_vm_jset_imm() {
         mov32 r0, 2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -684,7 +684,7 @@ fn test_vm_jset_reg() {
         mov32 r0, 2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -700,7 +700,7 @@ fn test_vm_jsge_imm() {
         mov32 r0, 2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -718,7 +718,7 @@ fn test_vm_jsge_reg() {
         mov32 r0, 2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -734,7 +734,7 @@ fn test_vm_jsle_imm() {
         mov32 r0, 2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -753,7 +753,7 @@ fn test_vm_jsle_reg() {
         mov32 r0, 2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -768,7 +768,7 @@ fn test_vm_jsgt_imm() {
         mov32 r0, 2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -784,7 +784,7 @@ fn test_vm_jsgt_reg() {
         mov32 r0, 2
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -799,7 +799,7 @@ fn test_vm_jslt_imm() {
         mov32 r0, 1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -816,7 +816,7 @@ fn test_vm_jslt_reg() {
         mov32 r0, 1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -824,7 +824,7 @@ fn test_vm_lddw() {
     let prog = assemble("lddw r0, 0x1122334455667788
                          exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1122334455667788);
+    assert_eq!(vm.execute_program().unwrap(), 0x1122334455667788);
 }
 
 #[test]
@@ -833,7 +833,7 @@ fn test_vm_lddw2() {
         lddw r0, 0x0000000080000000
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x80000000);
+    assert_eq!(vm.execute_program().unwrap(), 0x80000000);
 }
 
 #[test]
@@ -875,7 +875,7 @@ fn test_vm_ldxb_all() {
         0x08, 0x09
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x9876543210);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x9876543210);
 }
 
 #[test]
@@ -887,7 +887,7 @@ fn test_vm_ldxb() {
         0xaa, 0xbb, 0x11, 0xcc, 0xdd
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x11);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x11);
 }
 
 #[test]
@@ -900,7 +900,7 @@ fn test_vm_ldxdw() {
         0x77, 0x88, 0xcc, 0xdd
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x8877665544332211);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x8877665544332211);
 }
 
 #[test]
@@ -953,7 +953,7 @@ fn test_vm_ldxh_all() {
         0x00, 0x08, 0x00, 0x09
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x9876543210);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x9876543210);
 }
 
 #[test]
@@ -996,7 +996,7 @@ fn test_vm_ldxh_all2() {
         0x01, 0x00, 0x02, 0x00
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x3ff);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x3ff);
 }
 
 #[test]
@@ -1008,7 +1008,7 @@ fn test_vm_ldxh() {
         0xaa, 0xbb, 0x11, 0x22, 0xcc, 0xdd
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x2211);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x2211);
 }
 
 #[test]
@@ -1022,7 +1022,7 @@ fn test_vm_ldxh_same_reg() {
         0xff, 0xff
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x1234);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x1234);
 }
 
 #[test]
@@ -1067,7 +1067,7 @@ fn test_vm_ldxw_all() {
         0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x030f0f);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x030f0f);
 }
 
 #[test]
@@ -1079,7 +1079,7 @@ fn test_vm_ldxw() {
         0xaa, 0xbb, 0x11, 0x22, 0x33, 0x44, 0xcc, 0xdd
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x44332211);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x44332211);
 }
 
 #[test]
@@ -1092,7 +1092,7 @@ fn test_vm_le16() {
         0x22, 0x11
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x1122);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x1122);
 }
 
 #[test]
@@ -1105,7 +1105,7 @@ fn test_vm_le32() {
         0x44, 0x33, 0x22, 0x11
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x11223344);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x11223344);
 }
 
 #[test]
@@ -1118,7 +1118,7 @@ fn test_vm_le64() {
         0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x1122334455667788);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x1122334455667788);
 }
 
 #[test]
@@ -1129,7 +1129,7 @@ fn test_vm_lsh_reg() {
         lsh r0, r7
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x10);
+    assert_eq!(vm.execute_program().unwrap(), 0x10);
 }
 
 #[test]
@@ -1141,7 +1141,7 @@ fn test_vm_mod() {
         mod32 r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x5);
+    assert_eq!(vm.execute_program().unwrap(), 0x5);
 }
 
 #[test]
@@ -1151,7 +1151,7 @@ fn test_vm_mod32() {
         mod32 r0, 3
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x0);
+    assert_eq!(vm.execute_program().unwrap(), 0x0);
 }
 
 #[test]
@@ -1167,7 +1167,7 @@ fn test_vm_mod64() {
         mod r0, 0x658f1778
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x30ba5a04);
+    assert_eq!(vm.execute_program().unwrap(), 0x30ba5a04);
 }
 
 #[test]
@@ -1177,7 +1177,7 @@ fn test_vm_mov() {
         mov32 r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -1187,7 +1187,7 @@ fn test_vm_mul32_imm() {
         mul32 r0, 4
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0xc);
+    assert_eq!(vm.execute_program().unwrap(), 0xc);
 }
 
 #[test]
@@ -1198,7 +1198,7 @@ fn test_vm_mul32_reg() {
         mul32 r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0xc);
+    assert_eq!(vm.execute_program().unwrap(), 0xc);
 }
 
 #[test]
@@ -1209,7 +1209,7 @@ fn test_vm_mul32_reg_overflow() {
         mul32 r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x4);
+    assert_eq!(vm.execute_program().unwrap(), 0x4);
 }
 
 #[test]
@@ -1219,7 +1219,7 @@ fn test_vm_mul64_imm() {
         mul r0, 4
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x100000004);
+    assert_eq!(vm.execute_program().unwrap(), 0x100000004);
 }
 
 #[test]
@@ -1230,7 +1230,7 @@ fn test_vm_mul64_reg() {
         mul r0, r1
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x100000004);
+    assert_eq!(vm.execute_program().unwrap(), 0x100000004);
 }
 
 #[test]
@@ -1247,7 +1247,7 @@ fn test_vm_mul_loop() {
         jne r1, 0x0, -3
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x75db9c97);
+    assert_eq!(vm.execute_program().unwrap(), 0x75db9c97);
 }
 
 #[test]
@@ -1257,7 +1257,7 @@ fn test_vm_neg64() {
         neg r0
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0xfffffffffffffffe);
+    assert_eq!(vm.execute_program().unwrap(), 0xfffffffffffffffe);
 }
 
 #[test]
@@ -1267,7 +1267,7 @@ fn test_vm_neg() {
         neg32 r0
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0xfffffffe);
+    assert_eq!(vm.execute_program().unwrap(), 0xfffffffe);
 }
 
 #[test]
@@ -1290,7 +1290,7 @@ fn test_vm_prime() {
         jne r4, 0x0, -10
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -1301,7 +1301,7 @@ fn test_vm_rhs32() {
         rsh32 r0, 8
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x00ffffff);
+    assert_eq!(vm.execute_program().unwrap(), 0x00ffffff);
 }
 
 #[test]
@@ -1312,7 +1312,7 @@ fn test_vm_rsh_reg() {
         rsh r0, r7
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x1);
+    assert_eq!(vm.execute_program().unwrap(), 0x1);
 }
 
 #[test]
@@ -1328,7 +1328,7 @@ fn test_vm_stack() {
         ldxdw r0, [r2-16]
         exit").unwrap();
     let vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0xcd);
+    assert_eq!(vm.execute_program().unwrap(), 0xcd);
 }
 
 #[test]
@@ -1353,7 +1353,7 @@ fn test_vm_stack2() {
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.register_helper(0, helpers::gather_bytes).unwrap();
     vm.register_helper(1, helpers::memfrob).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x01020304);
+    assert_eq!(vm.execute_program().unwrap(), 0x01020304);
 }
 
 #[test]
@@ -1366,7 +1366,7 @@ fn test_vm_stb() {
         0xaa, 0xbb, 0xff, 0xcc, 0xdd
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x11);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x11);
 }
 
 #[test]
@@ -1380,7 +1380,7 @@ fn test_vm_stdw() {
         0xff, 0xff, 0xcc, 0xdd
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x44332211);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x44332211);
 }
 
 #[test]
@@ -1393,7 +1393,7 @@ fn test_vm_sth() {
         0xaa, 0xbb, 0xff, 0xff, 0xcc, 0xdd
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x2211);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x2211);
 }
 
 #[test]
@@ -1429,7 +1429,7 @@ fn test_vm_string_stack() {
         exit").unwrap();
     let mut vm = rbpf::EbpfVmNoData::new(Some(&prog)).unwrap();
     vm.register_helper(4, helpers::strcmp).unwrap();
-    assert_eq!(vm.prog_exec().unwrap(), 0x0);
+    assert_eq!(vm.execute_program().unwrap(), 0x0);
 }
 
 #[test]
@@ -1442,7 +1442,7 @@ fn test_vm_stw() {
         0xaa, 0xbb, 0xff, 0xff, 0xff, 0xff, 0xcc, 0xdd
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x44332211);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x44332211);
 }
 
 #[test]
@@ -1456,7 +1456,7 @@ fn test_vm_stxb() {
         0xaa, 0xbb, 0xff, 0xcc, 0xdd
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x11);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x11);
 }
 
 #[test]
@@ -1485,7 +1485,7 @@ fn test_vm_stxb_all() {
         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0xf0f2f3f4f5f6f7f8);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0xf0f2f3f4f5f6f7f8);
 }
 
 #[test]
@@ -1503,7 +1503,7 @@ fn test_vm_stxb_all2() {
         0xff, 0xff
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0xf1f9);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0xf1f9);
 }
 
 #[test]
@@ -1535,7 +1535,7 @@ fn test_vm_stxb_chain() {
         0x00, 0x00
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x2a);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x2a);
 }
 
 #[test]
@@ -1552,7 +1552,7 @@ fn test_vm_stxdw() {
         0xff, 0xff, 0xcc, 0xdd
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x8877665544332211);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x8877665544332211);
 }
 
 #[test]
@@ -1566,7 +1566,7 @@ fn test_vm_stxh() {
         0xaa, 0xbb, 0xff, 0xff, 0xcc, 0xdd
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x2211);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x2211);
 }
 
 #[test]
@@ -1580,7 +1580,7 @@ fn test_vm_stxw() {
         0xaa, 0xbb, 0xff, 0xff, 0xff, 0xff, 0xcc, 0xdd
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x44332211);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x44332211);
 }
 
 #[test]
@@ -1613,7 +1613,7 @@ fn test_vm_subnet() {
         0x03, 0x00
     ];
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x1);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x1);
 }
 
 
@@ -1658,7 +1658,7 @@ fn test_vm_tcp_port80_match() {
     ];
     let prog = &PROG_TCP_PORT_80;
     let vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x1);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x1);
 }
 
 #[test]
@@ -1680,7 +1680,7 @@ fn test_vm_tcp_port80_nomatch() {
     ];
     let prog = &PROG_TCP_PORT_80;
     let vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x0);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x0);
 }
 
 #[test]
@@ -1702,7 +1702,7 @@ fn test_vm_tcp_port80_nomatch_ethertype() {
     ];
     let prog = &PROG_TCP_PORT_80;
     let vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x0);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x0);
 }
 
 #[test]
@@ -1724,7 +1724,7 @@ fn test_vm_tcp_port80_nomatch_proto() {
     ];
     let prog = &PROG_TCP_PORT_80;
     let vm = rbpf::EbpfVmRaw::new(Some(prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem).unwrap(), 0x0);
+    assert_eq!(vm.execute_program(mem).unwrap(), 0x0);
 }
 
 #[test]
@@ -1732,7 +1732,7 @@ fn test_vm_tcp_sack_match() {
     let mut mem = TCP_SACK_MATCH.to_vec();
     let prog = assemble(TCP_SACK_ASM).unwrap();
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem.as_mut_slice()).unwrap(), 0x1);
+    assert_eq!(vm.execute_program(mem.as_mut_slice()).unwrap(), 0x1);
 }
 
 #[test]
@@ -1740,5 +1740,5 @@ fn test_vm_tcp_sack_nomatch() {
     let mut mem = TCP_SACK_NOMATCH.to_vec();
     let prog = assemble(TCP_SACK_ASM).unwrap();
     let vm = rbpf::EbpfVmRaw::new(Some(&prog)).unwrap();
-    assert_eq!(vm.prog_exec(mem.as_mut_slice()).unwrap(), 0x0);
+    assert_eq!(vm.execute_program(mem.as_mut_slice()).unwrap(), 0x0);
 }