Make arrays shared cow v2

examples/starknet.rs

@@ -20,12 +20,14 @@ type Log = (Vec<Felt>, Vec<Felt>);
 type L2ToL1Message = (Felt, Vec<Felt>);
 
 #[derive(Debug, Default)]
+#[allow(dead_code)]
 struct ContractLogs {
     events: VecDeque<Log>,
     l2_to_l1_messages: VecDeque<L2ToL1Message>,
 }
 
 #[derive(Debug, Default)]
+#[allow(dead_code)]
 struct TestingState {
     sequencer_address: Felt,
     caller_address: Felt,
@@ -43,6 +45,7 @@ struct TestingState {
 }
 
 #[derive(Debug, Default)]
+#[allow(dead_code)]
 struct SyscallHandler {
     testing_state: TestingState,
 }

src/arch/x86_64.rs

@@ -20,103 +20,62 @@ fn align_to(buffer: &mut Vec<u8>, align: usize) {
 
 impl AbiArgument for bool {
     fn to_bytes(&self, buffer: &mut Vec<u8>) -> Result<(), Error> {
-        if buffer.len() < 48 {
-            buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
-        } else {
-            align_to(buffer, get_integer_layout(1).align());
-            buffer.push((*self) as u8);
-        }
+        buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
         Ok(())
     }
 }
 
 impl AbiArgument for u8 {
     fn to_bytes(&self, buffer: &mut Vec<u8>) -> Result<(), Error> {
-        if buffer.len() < 48 {
-            buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
-        } else {
-            align_to(buffer, get_integer_layout(8).align());
-            buffer.push(*self);
-        }
+        buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
         Ok(())
     }
 }
 
 impl AbiArgument for i8 {
     fn to_bytes(&self, buffer: &mut Vec<u8>) -> Result<(), Error> {
-        if buffer.len() < 48 {
-            buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
-        } else {
-            align_to(buffer, get_integer_layout(8).align());
-            buffer.extend_from_slice(&self.to_ne_bytes());
-        }
+        buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
         Ok(())
     }
 }
 
 impl AbiArgument for u16 {
     fn to_bytes(&self, buffer: &mut Vec<u8>) -> Result<(), Error> {
-        if buffer.len() < 48 {
-            buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
-        } else {
-            align_to(buffer, get_integer_layout(16).align());
-            buffer.extend_from_slice(&self.to_ne_bytes());
-        }
+        buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
         Ok(())
     }
 }
 
 impl AbiArgument for i16 {
     fn to_bytes(&self, buffer: &mut Vec<u8>) -> Result<(), Error> {
-        if buffer.len() < 48 {
-            buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
-        } else {
-            align_to(buffer, get_integer_layout(16).align());
-            buffer.extend_from_slice(&self.to_ne_bytes());
-        }
+        buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
         Ok(())
     }
 }
 
 impl AbiArgument for u32 {
     fn to_bytes(&self, buffer: &mut Vec<u8>) -> Result<(), Error> {
-        if buffer.len() < 48 {
-            buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
-        } else {
-            align_to(buffer, get_integer_layout(32).align());
-            buffer.extend_from_slice(&self.to_ne_bytes());
-        }
+        buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
         Ok(())
     }
 }
 
 impl AbiArgument for i32 {
     fn to_bytes(&self, buffer: &mut Vec<u8>) -> Result<(), Error> {
-        if buffer.len() < 48 {
-            buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
-        } else {
-            align_to(buffer, get_integer_layout(32).align());
-            buffer.extend_from_slice(&self.to_ne_bytes());
-        }
+        buffer.extend_from_slice(&(*self as u64).to_ne_bytes());
         Ok(())
     }
 }
 
 impl AbiArgument for u64 {
     fn to_bytes(&self, buffer: &mut Vec<u8>) -> Result<(), Error> {
-        if buffer.len() >= 48 {
-            align_to(buffer, get_integer_layout(64).align());
-        }
         buffer.extend_from_slice(&self.to_ne_bytes());
         Ok(())
     }
 }
 
 impl AbiArgument for i64 {
     fn to_bytes(&self, buffer: &mut Vec<u8>) -> Result<(), Error> {
-        if buffer.len() >= 48 {
-            align_to(buffer, get_integer_layout(64).align());
-        }
         buffer.extend_from_slice(&self.to_ne_bytes());
         Ok(())
     }
@@ -127,6 +86,7 @@ impl AbiArgument for u128 {
         if buffer.len() >= 40 {
             align_to(buffer, get_integer_layout(128).align());
         }
+
         buffer.extend_from_slice(&self.to_ne_bytes());
         Ok(())
     }
@@ -137,6 +97,7 @@ impl AbiArgument for i128 {
         if buffer.len() >= 40 {
             align_to(buffer, get_integer_layout(128).align());
         }
+
         buffer.extend_from_slice(&self.to_ne_bytes());
         Ok(())
     }
@@ -164,13 +125,13 @@ impl AbiArgument for [u8; 31] {
     fn to_bytes(&self, buffer: &mut Vec<u8>) -> Result<(), Error> {
         // The `bytes31` type is treated as a 248-bit integer, therefore it follows the same
         // splitting rules as them.
+
         if buffer.len() >= 40 {
             align_to(buffer, get_integer_layout(252).align());
         }
 
         buffer.extend_from_slice(self);
         buffer.push(0);
-
         Ok(())
     }
 }

src/executor.rs

@@ -351,7 +351,6 @@ fn parse_result(
     #[cfg(target_arch = "aarch64")] mut ret_registers: [u64; 4],
 ) -> Result<Value, Error> {
     let type_info = registry.get_type(type_id)?;
-    let debug_name = type_info.info().long_id.to_string();
 
     // Align the pointer to the actual return value.
     if let Some(return_ptr) = &mut return_ptr {
@@ -373,18 +372,20 @@ fn parse_result(
             return_ptr.to_native_assert_error("return pointer should be valid")?,
             type_id,
             registry,
+            true,
         )?),
         CoreTypeConcrete::Box(info) => unsafe {
             let ptr =
                 return_ptr.unwrap_or_else(|| NonNull::new_unchecked(ret_registers[0] as *mut ()));
-            let value = Value::from_ptr(ptr, &info.ty, registry)?;
+            let value = Value::from_ptr(ptr, &info.ty, registry, true)?;
             libc_free(ptr.cast().as_ptr());
             Ok(value)
         },
         CoreTypeConcrete::EcPoint(_) | CoreTypeConcrete::EcState(_) => Ok(Value::from_ptr(
             return_ptr.to_native_assert_error("return pointer should be valid")?,
             type_id,
             registry,
+            true,
         )?),
         CoreTypeConcrete::Felt252(_)
         | CoreTypeConcrete::StarkNet(
@@ -393,7 +394,7 @@ fn parse_result(
             | StarkNetTypeConcrete::StorageAddress(_)
             | StarkNetTypeConcrete::StorageBaseAddress(_),
         ) => match return_ptr {
-            Some(return_ptr) => Ok(Value::from_ptr(return_ptr, type_id, registry)?),
+            Some(return_ptr) => Ok(Value::from_ptr(return_ptr, type_id, registry, true)?),
             None => {
                 #[cfg(target_arch = "x86_64")]
                 // Since x86_64's return values hold at most two different 64bit registers,
@@ -412,7 +413,7 @@ fn parse_result(
             }
         },
         CoreTypeConcrete::Bytes31(_) => match return_ptr {
-            Some(return_ptr) => Ok(Value::from_ptr(return_ptr, type_id, registry)?),
+            Some(return_ptr) => Ok(Value::from_ptr(return_ptr, type_id, registry, true)?),
             None => {
                 #[cfg(target_arch = "x86_64")]
                 // Since x86_64's return values hold at most two different 64bit registers,
@@ -427,7 +428,7 @@ fn parse_result(
             }
         },
         CoreTypeConcrete::BoundedInt(info) => match return_ptr {
-            Some(return_ptr) => Ok(Value::from_ptr(return_ptr, type_id, registry)?),
+            Some(return_ptr) => Ok(Value::from_ptr(return_ptr, type_id, registry, true)?),
             None => {
                 let mut data = if info.range.offset_bit_width() <= 64 {
                     BigInt::from(ret_registers[0])
@@ -499,7 +500,7 @@ fn parse_result(
                 Ok(Value::Null)
             } else {
                 let ptr = NonNull::new_unchecked(ptr);
-                let value = Value::from_ptr(ptr, &info.ty, registry)?;
+                let value = Value::from_ptr(ptr, &info.ty, registry, true)?;
                 libc_free(ptr.as_ptr().cast());
                 Ok(value)
             }
@@ -555,7 +556,7 @@ fn parse_result(
                 }
             };
             let value = match ptr {
-                Ok(ptr) => Box::new(Value::from_ptr(ptr, &info.variants[tag], registry)?),
+                Ok(ptr) => Box::new(Value::from_ptr(ptr, &info.variants[tag], registry, true)?),
                 Err(offset) => {
                     ret_registers.copy_within(offset.., 0);
                     Box::new(parse_result(
@@ -570,27 +571,28 @@ fn parse_result(
             Ok(Value::Enum {
                 tag,
                 value,
-                debug_name: Some(debug_name),
+                debug_name: Some(type_info.info().long_id.to_string()),
             })
         }
         CoreTypeConcrete::Struct(info) => {
             if info.members.is_empty() {
                 Ok(Value::Struct {
                     fields: Vec::new(),
-                    debug_name: Some(debug_name),
+                    debug_name: Some(type_info.info().long_id.to_string()),
                 })
             } else {
                 Ok(Value::from_ptr(
                     return_ptr.to_native_assert_error("return pointer should be valid")?,
                     type_id,
                     registry,
+                    true,
                 )?)
             }
         }
         CoreTypeConcrete::Felt252Dict(_) | CoreTypeConcrete::SquashedFelt252Dict(_) => unsafe {
             let ptr = return_ptr
                 .unwrap_or_else(|| NonNull::new_unchecked((&raw mut ret_registers[0]) as *mut ()));
-            Ok(Value::from_ptr(ptr, type_id, registry)?)
+            Ok(Value::from_ptr(ptr, type_id, registry, true)?)
         },
 
         CoreTypeConcrete::Snapshot(info) => {