[guest/{input,output}stacks] make input/output stacks portable

If we use usize and the guest and host are compiled for different architectures, there will be a mismatch
in sizing between the guest and host, so we should use u64s to address that (tested w/ Nanvix already).

Signed-off-by: danbugs <danilochiarlone@gmail.com>

Author: danbugs

src/hyperlight_guest/src/shared_input_data.rs

@@ -43,10 +43,10 @@ where
     }
 
     // get relative offset to next free address
-    let stack_ptr_rel: usize =
-        usize::from_le_bytes(idb[..8].try_into().expect("Shared input buffer too small"));
+    let stack_ptr_rel: u64 =
+        u64::from_le_bytes(idb[..8].try_into().expect("Shared input buffer too small"));
 
-    if stack_ptr_rel > shared_buffer_size || stack_ptr_rel < 16 {
+    if stack_ptr_rel as usize > shared_buffer_size || stack_ptr_rel < 16 {
         return Err(HyperlightGuestError::new(
             ErrorCode::GuestError,
             format!(
@@ -57,13 +57,13 @@ where
     }
 
     // go back 8 bytes and read. This is the offset to the element on top of stack
-    let last_element_offset_rel = usize::from_le_bytes(
-        idb[stack_ptr_rel - 8..stack_ptr_rel]
+    let last_element_offset_rel = u64::from_le_bytes(
+        idb[stack_ptr_rel as usize - 8..stack_ptr_rel as usize]
             .try_into()
             .expect("Invalid stack pointer in pop_shared_input_data_into"),
     );
 
-    let buffer = &idb[last_element_offset_rel..];
+    let buffer = &idb[last_element_offset_rel as usize..];
 
     // convert the buffer to T
     let type_t = match T::try_from(buffer) {
@@ -80,7 +80,7 @@ where
     idb[..8].copy_from_slice(&last_element_offset_rel.to_le_bytes());
 
     // zero out popped off buffer
-    idb[last_element_offset_rel..stack_ptr_rel].fill(0);
+    idb[last_element_offset_rel as usize..stack_ptr_rel as usize].fill(0);
 
     type_t
 }

src/hyperlight_guest/src/shared_output_data.rs

@@ -38,13 +38,13 @@ pub fn push_shared_output_data(data: Vec<u8>) -> Result<()> {
     }
 
     // get offset to next free address on the stack
-    let stack_ptr_rel: usize =
-        usize::from_le_bytes(odb[..8].try_into().expect("Shared output buffer too small"));
+    let stack_ptr_rel: u64 =
+        u64::from_le_bytes(odb[..8].try_into().expect("Shared output buffer too small"));
 
     // check if the stack pointer is within the bounds of the buffer.
     // It can be equal to the size, but never greater
     // It can never be less than 8. An empty buffer's stack pointer is 8
-    if stack_ptr_rel > shared_buffer_size || stack_ptr_rel < 8 {
+    if stack_ptr_rel as usize > shared_buffer_size || stack_ptr_rel < 8 {
         return Err(HyperlightGuestError::new(
             ErrorCode::GuestError,
             format!(
@@ -56,7 +56,7 @@ pub fn push_shared_output_data(data: Vec<u8>) -> Result<()> {
 
     // check if there is enough space in the buffer
     let size_required = data.len() + 8; // the data plus the pointer pointing to the data
-    let size_available = shared_buffer_size - stack_ptr_rel;
+    let size_available = shared_buffer_size - stack_ptr_rel as usize;
     if size_required > size_available {
         return Err(HyperlightGuestError::new(
             ErrorCode::GuestError,
@@ -68,14 +68,15 @@ pub fn push_shared_output_data(data: Vec<u8>) -> Result<()> {
     }
 
     // write the actual data
-    odb[stack_ptr_rel..stack_ptr_rel + data.len()].copy_from_slice(&data);
+    odb[stack_ptr_rel as usize..stack_ptr_rel as usize + data.len()].copy_from_slice(&data);
 
     // write the offset to the newly written data, to the top of the stack
-    let bytes = stack_ptr_rel.to_le_bytes();
-    odb[stack_ptr_rel + data.len()..stack_ptr_rel + data.len() + 8].copy_from_slice(&bytes);
+    let bytes: [u8; 8] = stack_ptr_rel.to_le_bytes();
+    odb[stack_ptr_rel as usize + data.len()..stack_ptr_rel as usize + data.len() + 8]
+        .copy_from_slice(&bytes);
 
     // update stack pointer to point to next free address
-    let new_stack_ptr_rel = stack_ptr_rel + data.len() + 8;
+    let new_stack_ptr_rel: u64 = (stack_ptr_rel as usize + data.len() + 8) as u64;
     odb[0..8].copy_from_slice(&(new_stack_ptr_rel).to_le_bytes());
 
     Ok(())