Module cairo_native::executor
source · Expand description
§Executors
+Module cairo_native::executor
source · Expand description
§Executors
This module provides methods to execute the programs, either via JIT or compiled ahead of time. It also provides a cache to avoid recompiling previously compiled programs.
Structs§
- Please look at the module level docs.
- A MLIR JIT execution engine in the context of Cairo Native.
Struct cairo_native::executor::AotContractExecutor
source · pub struct AotContractExecutor { /* private fields */ }Expand description
Please look at the module level docs.
-Implementations§
Implementations§
source§impl AotContractExecutor
impl AotContractExecutor
sourcepub fn new(
sierra_program: &Program,
entry_points: &ContractEntryPoints,
opt_level: OptLevel,
-) -> Result<Self, Error>
pub fn new( sierra_program: &Program, entry_points: &ContractEntryPoints, opt_level: OptLevel, -) -> Result<Self, Error>
Create the executor from a sierra program with the given optimization level. +) -> Result<Self>
Create the executor from a sierra program with the given optimization level.
You can save the library on the desired location later using save.
If not saved, the path is treated as
a temporary file an deleted when dropped.
If you loaded a ContractExecutor using [load] then it will not be treated as a temp file.
sourcepub fn save(&mut self, to: impl AsRef<Path>) -> Result<(), Error>
pub fn save(&mut self, to: impl AsRef<Path>) -> Result<(), Error>
Save the library to the desired path, alongside it is saved also a json file with additional info.
-sourcepub fn save(&mut self, to: impl AsRef<Path>) -> Result<()>
pub fn save(&mut self, to: impl AsRef<Path>) -> Result<()>
Save the library to the desired path, alongside it is saved also a json file with additional info.
+sourcepub fn load(library_path: &Path) -> Result<Self>
pub fn load(library_path: &Path) -> Result<Self>
Load the executor from an already compiled library with the additional info json file.
+sourcepub fn run(
&self,
selector: Felt,
args: &[Felt],
gas: u64,
builtin_costs: Option<BuiltinCosts>,
syscall_handler: impl StarknetSyscallHandler,
-) -> Result<ContractExecutionResult, Error>
pub fn run( &self, selector: Felt, args: &[Felt], gas: u64, builtin_costs: Option<BuiltinCosts>, syscall_handler: impl StarknetSyscallHandler, -) -> Result<ContractExecutionResult, Error>
Runs the entry point by the given selector.
+) -> Result<ContractExecutionResult>Runs the entry point by the given selector.
- selector: The selector of the entry point to run.
- args: The calldata. @@ -26,11 +26,11 @@
- syscall_handler: The syscall handler implementation to use when executing the contract.
The entry point gas cost is not deducted from the gas counter.
-pub fn find_function_ptr( +
pub fn find_function_ptr( &self, function_id: &FunctionId, is_for_contract_executor: bool, -) -> Result<*mut c_void, Error>
pub fn find_symbol_ptr(&self, name: &str) -> Option<*mut c_void>
Trait Implementations§
source§impl Clone for AotContractExecutor
impl Clone for AotContractExecutor
source§fn clone(&self) -> AotContractExecutor
fn clone(&self) -> AotContractExecutor
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source. Read moresource§impl Debug for AotContractExecutor
impl Debug for AotContractExecutor
Auto Trait Implementations§
impl Freeze for AotContractExecutor
impl RefUnwindSafe for AotContractExecutor
impl Send for AotContractExecutor
impl Sync for AotContractExecutor
impl Unpin for AotContractExecutor
impl UnwindSafe for AotContractExecutor
Blanket Implementations§
Trait Implementations§
source§impl Clone for AotContractExecutor
impl Clone for AotContractExecutor
source§fn clone(&self) -> AotContractExecutor
fn clone(&self) -> AotContractExecutor
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source. Read moresource§impl Debug for AotContractExecutor
impl Debug for AotContractExecutor
Auto Trait Implementations§
impl Freeze for AotContractExecutor
impl RefUnwindSafe for AotContractExecutor
impl Send for AotContractExecutor
impl Sync for AotContractExecutor
impl Unpin for AotContractExecutor
impl UnwindSafe for AotContractExecutor
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
diff --git a/cairo_native/starknet/constant.SYSCALL_HANDLER_VTABLE.html b/cairo_native/starknet/constant.SYSCALL_HANDLER_VTABLE.html
index 827698b82..20aa63d89 100644
--- a/cairo_native/starknet/constant.SYSCALL_HANDLER_VTABLE.html
+++ b/cairo_native/starknet/constant.SYSCALL_HANDLER_VTABLE.html
@@ -1 +1 @@
-SYSCALL_HANDLER_VTABLE in cairo_native::starknet - Rust Constant cairo_native::starknet::SYSCALL_HANDLER_VTABLE
source · pub const SYSCALL_HANDLER_VTABLE: LocalKey<Cell<*mut ()>>;
SYSCALL_HANDLER_VTABLE in cairo_native::starknet - Rust Constant cairo_native::starknet::SYSCALL_HANDLER_VTABLE
source · pub const SYSCALL_HANDLER_VTABLE: LocalKey<Cell<*mut ()>>;
cairo_native__vtable_cheatcode in cairo_native::starknet - Rust Function cairo_native::starknet::cairo_native__vtable_cheatcode
source · pub extern "C" fn cairo_native__vtable_cheatcode(
+cairo_native__vtable_cheatcode in cairo_native::starknet - Rust Function cairo_native::starknet::cairo_native__vtable_cheatcode
source · pub extern "C" fn cairo_native__vtable_cheatcode(
result_ptr: &mut ArrayAbi<Felt252Abi>,
selector: &Felt252Abi,
input: &ArrayAbi<Felt252Abi>,
diff --git a/cairo_native/starknet/index.html b/cairo_native/starknet/index.html
index 494cb1417..81181e74c 100644
--- a/cairo_native/starknet/index.html
+++ b/cairo_native/starknet/index.html
@@ -1,2 +1,2 @@
-cairo_native::starknet - Rust Module cairo_native::starknet
source · Expand description
Starknet related code for cairo_native
+cairo_native::starknet - Rust Help Rustdoc help
BackHelp Rustdoc help
BackSettings Rustdoc settings
BackSettings Rustdoc settings
Back//! # Implementations of `AbiArgument` for the `x86_64` architecture.
//!
//! The x86_64 architecture uses 6 64-bit registers for arguments. This means that the first 48
@@ -271,93 +232,55 @@
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(())
}
@@ -365,9 +288,6 @@
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(())
}
@@ -378,6 +298,7 @@
if buffer.len() >= 40 {
align_to(buffer, get_integer_layout(128).align());
}
+
buffer.extend_from_slice(&self.to_ne_bytes());
Ok(())
}
@@ -388,6 +309,7 @@
if buffer.len() >= 40 {
align_to(buffer, get_integer_layout(128).align());
}
+
buffer.extend_from_slice(&self.to_ne_bytes());
Ok(())
}
@@ -415,13 +337,13 @@
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(())
}
}
diff --git a/src/cairo_native/executor.rs.html b/src/cairo_native/executor.rs.html
index 79b0e4508..73a2f1b74 100644
--- a/src/cairo_native/executor.rs.html
+++ b/src/cairo_native/executor.rs.html
@@ -766,6 +766,8 @@
766
767
768
+769
+770
//! # Executors
//!
//! This module provides methods to execute the programs, either via JIT or compiled ahead
@@ -1119,7 +1121,6 @@
#[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 {
@@ -1141,11 +1142,12 @@
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)
},
@@ -1153,6 +1155,7 @@
return_ptr.to_native_assert_error("return pointer should be valid")?,
type_id,
registry,
+ true,
)?),
CoreTypeConcrete::Felt252(_)
| CoreTypeConcrete::StarkNet(
@@ -1161,7 +1164,7 @@
| 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,
@@ -1180,7 +1183,7 @@
}
},
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,
@@ -1195,7 +1198,7 @@
}
},
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])
@@ -1267,7 +1270,7 @@
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)
}
@@ -1323,7 +1326,7 @@
}
};
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(
@@ -1338,27 +1341,28 @@
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) => {
diff --git a/src/cairo_native/executor/contract.rs.html b/src/cairo_native/executor/contract.rs.html
index 67b25e846..2ccbbdc54 100644
--- a/src/cairo_native/executor/contract.rs.html
+++ b/src/cairo_native/executor/contract.rs.html
@@ -831,6 +831,24 @@
831
832
833
+834
+835
+836
+837
+838
+839
+840
+841
+842
+843
+844
+845
+846
+847
+848
+849
+850
+851
//! A specialized executor for Starknet contracts, avoiding the overhead of storing the sierra program registry and
//! enabling efficient serialization of the program/data once compiled.
//!
@@ -867,7 +885,7 @@
use crate::{
arch::AbiArgument,
context::NativeContext,
- error::{panic::ToNativeAssertError, Error},
+ error::{panic::ToNativeAssertError, Error, Result},
execution_result::{BuiltinStats, ContractExecutionResult},
executor::invoke_trampoline,
metadata::gas::MetadataComputationConfig,
@@ -979,7 +997,7 @@
sierra_program: &Program,
entry_points: &ContractEntryPoints,
opt_level: OptLevel,
- ) -> Result<Self, Error> {
+ ) -> Result<Self> {
let native_context = NativeContext::new();
let mut entry_point_selector_to_id = BTreeMap::new();
@@ -1094,7 +1112,7 @@
}
/// Save the library to the desired path, alongside it is saved also a json file with additional info.
- pub fn save(&mut self, to: impl AsRef<Path>) -> Result<(), Error> {
+ pub fn save(&mut self, to: impl AsRef<Path>) -> Result<()> {
let to = to.as_ref();
std::fs::copy(&self.path, to)?;
@@ -1109,7 +1127,7 @@
}
/// Load the executor from an already compiled library with the additional info json file.
- pub fn load(library_path: &Path) -> Result<Self, Error> {
+ pub fn load(library_path: &Path) -> Result<Self> {
let info_str = std::fs::read_to_string(library_path.with_extension("json"))?;
let contract_info: NativeContractInfo = serde_json::from_str(&info_str)?;
Ok(Self {
@@ -1136,7 +1154,7 @@
gas: u64,
builtin_costs: Option<BuiltinCosts>,
mut syscall_handler: impl StarknetSyscallHandler,
- ) -> Result<ContractExecutionResult, Error> {
+ ) -> Result<ContractExecutionResult> {
let arena = Bump::new();
let mut invoke_data = Vec::<u8>::new();
@@ -1150,12 +1168,7 @@
};
let function_ptr = self.find_function_ptr(&function_id, true)?;
- let builtin_costs = builtin_costs.unwrap_or_default();
- let builtin_costs_stack: [u64; 7] = builtin_costs.into();
- // Note: the ptr into a slice is valid, it can be used with cast()
- // Care should be taken if you dereference it and take the .as_ptr() of the slice, since when you
- // deref it, it will be a copy on the stack, so you will get the ptr of the value in the stack.
- let builtin_costs: *mut [u64; 7] = Box::into_raw(Box::new(builtin_costs_stack));
+ let builtin_costs: [u64; 7] = builtin_costs.unwrap_or_default().into();
let set_costs_builtin = unsafe {
self.library
.get::<extern "C" fn(*const u64) -> *const u64>(
@@ -1163,7 +1176,7 @@
)?
};
// We may be inside a recursive contract, save the possible saved builtin costs to restore it after our call.
- let old_builtincosts_ptr = set_costs_builtin(builtin_costs.cast());
+ let old_builtincosts_ptr = set_costs_builtin(builtin_costs.as_ptr());
// it can vary from contract to contract thats why we need to store/ load it.
let builtins_size: usize = self.contract_info.entry_points_info[&function_id.id]
@@ -1189,7 +1202,7 @@
}
BuiltinType::BuiltinCosts => {
// todo: check if valid
- builtin_costs_stack.as_ptr().to_bytes(&mut invoke_data)?;
+ builtin_costs.as_ptr().to_bytes(&mut invoke_data)?;
}
BuiltinType::System => {
(&mut syscall_handler as *mut StarknetSyscallHandlerCallbacks<_>)
@@ -1202,18 +1215,42 @@
}
let felt_layout = get_integer_layout(252).pad_to_align();
- let ptr: *mut () = unsafe { libc_malloc(felt_layout.size() * args.len()).cast() };
+ let refcount_offset = get_integer_layout(32)
+ .align_to(felt_layout.align())
+ .unwrap()
+ .pad_to_align()
+ .size();
+
+ let ptr = match args.len() {
+ 0 => std::ptr::null_mut(),
+ _ => unsafe {
+ let ptr: *mut () =
+ libc_malloc(felt_layout.size() * args.len() + refcount_offset).cast();
+
+ // Write reference count.
+ ptr.cast::<u32>().write(1);
+ ptr.byte_add(refcount_offset)
+ },
+ };
let len: u32 = args
.len()
.try_into()
.to_native_assert_error("number of arguments should fit into a u32")?;
ptr.to_bytes(&mut invoke_data)?;
- 0u32.to_bytes(&mut invoke_data)?; // start
- len.to_bytes(&mut invoke_data)?; // end
- len.to_bytes(&mut invoke_data)?; // cap
+ if cfg!(target_arch = "aarch64") {
+ 0u32.to_bytes(&mut invoke_data)?; // start
+ len.to_bytes(&mut invoke_data)?; // end
+ len.to_bytes(&mut invoke_data)?; // cap
+ } else if cfg!(target_arch = "x86_64") {
+ (0u32 as u64).to_bytes(&mut invoke_data)?; // start
+ (len as u64).to_bytes(&mut invoke_data)?; // end
+ (len as u64).to_bytes(&mut invoke_data)?; // cap
+ } else {
+ unreachable!("unsupported architecture");
+ }
- for (idx, elem) in args.iter().enumerate() {
+ for (idx, elem) in args.iter().enumerate() {
let f = elem.to_bytes_le();
unsafe {
std::ptr::copy_nonoverlapping(
@@ -1354,7 +1391,12 @@
}
if !array_ptr.is_null() {
- unsafe { libc_free(array_ptr.cast()) };
+ unsafe {
+ let ptr = array_ptr.byte_sub(refcount_offset);
+ assert_eq!(ptr.cast::<u32>().read(), 1);
+
+ libc_free(ptr.cast());
+ }
}
let error_msg = if tag != 0 {
@@ -1371,14 +1413,8 @@
None
};
- // Restore the old ptr and get back our builtincost box and free it.
- let our_builtincosts_ptr = set_costs_builtin(old_builtincosts_ptr);
-
- if !our_builtincosts_ptr.is_null() && old_builtincosts_ptr.is_aligned() {
- unsafe {
- let _ = Box::<[u64; 7]>::from_raw(our_builtincosts_ptr.cast_mut().cast());
- };
- }
+ // Restore the original builtin costs pointer.
+ set_costs_builtin(old_builtincosts_ptr);
#[cfg(feature = "with-mem-tracing")]
crate::utils::mem_tracing::report_stats();
@@ -1395,7 +1431,7 @@
&self,
function_id: &FunctionId,
is_for_contract_executor: bool,
- ) -> Result<*mut c_void, Error> {
+ ) -> Result<*mut c_void> {
let function_name = generate_function_name(function_id, is_for_contract_executor);
let function_name = format!("_mlir_ciface_{function_name}");
diff --git a/src/cairo_native/libfuncs.rs.html b/src/cairo_native/libfuncs.rs.html
index e8fb9dcdb..78455dd94 100644
--- a/src/cairo_native/libfuncs.rs.html
+++ b/src/cairo_native/libfuncs.rs.html
@@ -632,9 +632,9 @@
Self::Const(selector) => self::r#const::build(
context, registry, entry, location, helper, metadata, selector,
),
- Self::Coupon(info) => {
- self::coupon::build(context, registry, entry, location, helper, metadata, info)
- }
+ Self::Coupon(selector) => self::coupon::build(
+ context, registry, entry, location, helper, metadata, selector,
+ ),
Self::CouponCall(info) => self::function_call::build(
context, registry, entry, location, helper, metadata, info,
),
diff --git a/src/cairo_native/libfuncs/array.rs.html b/src/cairo_native/libfuncs/array.rs.html
index c7616528f..070d7878a 100644
--- a/src/cairo_native/libfuncs/array.rs.html
+++ b/src/cairo_native/libfuncs/array.rs.html
@@ -2513,44 +2513,474 @@
2513
2514
2515
+2516
+2517
+2518
+2519
+2520
+2521
+2522
+2523
+2524
+2525
+2526
+2527
+2528
+2529
+2530
+2531
+2532
+2533
+2534
+2535
+2536
+2537
+2538
+2539
+2540
+2541
+2542
+2543
+2544
+2545
+2546
+2547
+2548
+2549
+2550
+2551
+2552
+2553
+2554
+2555
+2556
+2557
+2558
+2559
+2560
+2561
+2562
+2563
+2564
+2565
+2566
+2567
+2568
+2569
+2570
+2571
+2572
+2573
+2574
+2575
+2576
+2577
+2578
+2579
+2580
+2581
+2582
+2583
+2584
+2585
+2586
+2587
+2588
+2589
+2590
+2591
+2592
+2593
+2594
+2595
+2596
+2597
+2598
+2599
+2600
+2601
+2602
+2603
+2604
+2605
+2606
+2607
+2608
+2609
+2610
+2611
+2612
+2613
+2614
+2615
+2616
+2617
+2618
+2619
+2620
+2621
+2622
+2623
+2624
+2625
+2626
+2627
+2628
+2629
+2630
+2631
+2632
+2633
+2634
+2635
+2636
+2637
+2638
+2639
+2640
+2641
+2642
+2643
+2644
+2645
+2646
+2647
+2648
+2649
+2650
+2651
+2652
+2653
+2654
+2655
+2656
+2657
+2658
+2659
+2660
+2661
+2662
+2663
+2664
+2665
+2666
+2667
+2668
+2669
+2670
+2671
+2672
+2673
+2674
+2675
+2676
+2677
+2678
+2679
+2680
+2681
+2682
+2683
+2684
+2685
+2686
+2687
+2688
+2689
+2690
+2691
+2692
+2693
+2694
+2695
+2696
+2697
+2698
+2699
+2700
+2701
+2702
+2703
+2704
+2705
+2706
+2707
+2708
+2709
+2710
+2711
+2712
+2713
+2714
+2715
+2716
+2717
+2718
+2719
+2720
+2721
+2722
+2723
+2724
+2725
+2726
+2727
+2728
+2729
+2730
+2731
+2732
+2733
+2734
+2735
+2736
+2737
+2738
+2739
+2740
+2741
+2742
+2743
+2744
+2745
+2746
+2747
+2748
+2749
+2750
+2751
+2752
+2753
+2754
+2755
+2756
+2757
+2758
+2759
+2760
+2761
+2762
+2763
+2764
+2765
+2766
+2767
+2768
+2769
+2770
+2771
+2772
+2773
+2774
+2775
+2776
+2777
+2778
+2779
+2780
+2781
+2782
+2783
+2784
+2785
+2786
+2787
+2788
+2789
+2790
+2791
+2792
+2793
+2794
+2795
+2796
+2797
+2798
+2799
+2800
+2801
+2802
+2803
+2804
+2805
+2806
+2807
+2808
+2809
+2810
+2811
+2812
+2813
+2814
+2815
+2816
+2817
+2818
+2819
+2820
+2821
+2822
+2823
+2824
+2825
+2826
+2827
+2828
+2829
+2830
+2831
+2832
+2833
+2834
+2835
+2836
+2837
+2838
+2839
+2840
+2841
+2842
+2843
+2844
+2845
+2846
+2847
+2848
+2849
+2850
+2851
+2852
+2853
+2854
+2855
+2856
+2857
+2858
+2859
+2860
+2861
+2862
+2863
+2864
+2865
+2866
+2867
+2868
+2869
+2870
+2871
+2872
+2873
+2874
+2875
+2876
+2877
+2878
+2879
+2880
+2881
+2882
+2883
+2884
+2885
+2886
+2887
+2888
+2889
+2890
+2891
+2892
+2893
+2894
+2895
+2896
+2897
+2898
+2899
+2900
+2901
+2902
+2903
+2904
+2905
+2906
+2907
+2908
+2909
+2910
+2911
+2912
+2913
+2914
+2915
+2916
+2917
+2918
+2919
+2920
+2921
+2922
+2923
+2924
+2925
+2926
+2927
+2928
+2929
+2930
+2931
+2932
+2933
+2934
+2935
+2936
+2937
+2938
+2939
+2940
+2941
+2942
+2943
+2944
+2945
+2946
+2947
+2948
+2949
+2950
+2951
+2952
//! # Array libfuncs
-// TODO: A future possible improvement would be to put the array behind a double pointer and a
-// reference counter, to avoid unnecessary clones.
-
use super::LibfuncHelper;
use crate::{
- error::{panic::ToNativeAssertError, Error, Result},
+ error::{Error, Result, SierraAssertError},
metadata::{
- drop_overrides::DropOverridesMeta, realloc_bindings::ReallocBindingsMeta, MetadataStorage,
+ drop_overrides::DropOverridesMeta, dup_overrides::DupOverridesMeta,
+ realloc_bindings::ReallocBindingsMeta, MetadataStorage,
},
- native_assert, native_panic,
- types::TypeBuilder,
- utils::{BlockExt, GepIndex, ProgramRegistryExt},
+ utils::{get_integer_layout, BlockExt, GepIndex, ProgramRegistryExt},
};
use cairo_lang_sierra::{
extensions::{
array::{ArrayConcreteLibfunc, ConcreteMultiPopLibfunc},
core::{CoreLibfunc, CoreType, CoreTypeConcrete},
lib_func::{SignatureAndTypeConcreteLibfunc, SignatureOnlyConcreteLibfunc},
- ConcreteLibfunc,
+ types::InfoAndTypeConcreteType,
},
program_registry::ProgramRegistry,
};
use melior::{
dialect::{
arith::{self, CmpiPredicate},
- cf,
- llvm::{self, r#type::pointer},
- ods, scf,
+ cf, llvm, ods, scf,
},
ir::{
- attribute::{DenseI32ArrayAttribute, IntegerAttribute},
- r#type::IntegerType,
- Block, Location, Region, Value, ValueLike,
+ attribute::IntegerAttribute, r#type::IntegerType, Block, Location, Region, Value, ValueLike,
},
Context,
};
+use std::alloc::Layout;
/// Select and call the correct libfunc builder function from the selector.
pub fn build<'ctx, 'this>(
@@ -2566,15 +2996,33 @@
ArrayConcreteLibfunc::New(info) => {
build_new(context, registry, entry, location, helper, metadata, info)
}
- ArrayConcreteLibfunc::Append(info) => {
- build_append(context, registry, entry, location, helper, metadata, info)
+ ArrayConcreteLibfunc::SpanFromTuple(info) => {
+ build_span_from_tuple(context, registry, entry, location, helper, metadata, info)
}
- ArrayConcreteLibfunc::PopFront(info) => {
- build_pop_front(context, registry, entry, location, helper, metadata, info)
+ ArrayConcreteLibfunc::TupleFromSpan(info) => {
+ build_tuple_from_span(context, registry, entry, location, helper, metadata, info)
}
- ArrayConcreteLibfunc::PopFrontConsume(info) => {
- build_pop_front_consume(context, registry, entry, location, helper, metadata, info)
+ ArrayConcreteLibfunc::Append(info) => {
+ build_append(context, registry, entry, location, helper, metadata, info)
}
+ ArrayConcreteLibfunc::PopFront(info) => build_pop::<false, false>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Single(info),
+ ),
+ ArrayConcreteLibfunc::PopFrontConsume(info) => build_pop::<true, false>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Single(info),
+ ),
ArrayConcreteLibfunc::Get(info) => {
build_get(context, registry, entry, location, helper, metadata, info)
}
@@ -2584,23 +3032,41 @@
ArrayConcreteLibfunc::Len(info) => {
build_len(context, registry, entry, location, helper, metadata, info)
}
- ArrayConcreteLibfunc::SnapshotPopFront(info) => {
- build_snapshot_pop_front(context, registry, entry, location, helper, metadata, info)
- }
- ArrayConcreteLibfunc::SnapshotPopBack(info) => {
- build_snapshot_pop_back(context, registry, entry, location, helper, metadata, info)
- }
- ArrayConcreteLibfunc::SpanFromTuple(info) => {
- build_span_from_tuple(context, registry, entry, location, helper, metadata, info)
- }
- ArrayConcreteLibfunc::TupleFromSpan(info) => {
- build_tuple_from_span(context, registry, entry, location, helper, metadata, info)
- }
- ArrayConcreteLibfunc::SnapshotMultiPopFront(info) => build_snapshot_multi_pop_front(
- context, registry, entry, location, helper, metadata, info,
+ ArrayConcreteLibfunc::SnapshotPopFront(info) => build_pop::<false, false>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Single(info),
+ ),
+ ArrayConcreteLibfunc::SnapshotPopBack(info) => build_pop::<false, true>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Single(info),
),
- ArrayConcreteLibfunc::SnapshotMultiPopBack(info) => build_snapshot_multi_pop_back(
- context, registry, entry, location, helper, metadata, info,
+ ArrayConcreteLibfunc::SnapshotMultiPopFront(info) => build_pop::<false, false>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Multi(info),
+ ),
+ ArrayConcreteLibfunc::SnapshotMultiPopBack(info) => build_pop::<false, true>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Multi(info),
),
}
}
@@ -2608,37 +3074,33 @@
/// Generate MLIR operations for the `array_new` libfunc.
pub fn build_new<'ctx, 'this>(
context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+ _registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
location: Location<'ctx>,
helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureOnlyConcreteLibfunc,
+ _metadata: &mut MetadataStorage,
+ _info: &SignatureOnlyConcreteLibfunc,
) -> Result<()> {
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.branch_signatures()[0].vars[0].ty,
- )?;
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
- let ptr = entry
- .append_op_result(ods::llvm::mlir_zero(context, pointer(context, 0), location).into())?;
+ let nullptr = entry.append_op_result(llvm::zero(ptr_ty, location))?;
+ let k0 = entry.const_int_from_type(context, location, 0, len_ty)?;
- let k0 = entry.const_int(context, location, 0, 32)?;
- let value = entry.append_op_result(llvm::undef(array_ty, location))?;
- let value = entry.insert_value(context, location, value, ptr, 0)?;
- let value = entry.insert_value(context, location, value, k0, 1)?;
- let value = entry.insert_value(context, location, value, k0, 2)?;
- let value = entry.insert_value(context, location, value, k0, 3)?;
+ let value = entry.append_op_result(llvm::undef(
+ llvm::r#type::r#struct(context, &[ptr_ty, len_ty, len_ty, len_ty], false),
+ location,
+ ))?;
+ let value = entry.insert_values(context, location, value, &[nullptr, k0, k0, k0])?;
entry.append_operation(helper.br(0, &[value], location));
Ok(())
}
-/// Generate MLIR operations for the `array_append` libfunc.
-pub fn build_append<'ctx, 'this>(
+/// Generate MLIR operations for the `span_from_tuple` libfunc.
+///
+/// Note: The `&info.ty` field has the entire `[T; N]` tuple. It is not the `T` in `Array<T>`.
+pub fn build_span_from_tuple<'ctx, 'this>(
context: &'ctx Context,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
@@ -2647,237 +3109,264 @@
metadata: &mut MetadataStorage,
info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- // Algorithm:
- // - If array_end < capacity, then append.
- // - If array_end == capacity:
- // - If array_start == 0: realloc, then append.
- // - If array_start != 0: memmove, then append.
-
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
+ metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ let tuple_len = {
+ let CoreTypeConcrete::Struct(info) = registry.get_type(&info.ty)? else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ info.members.len()
+ };
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
- let elem_stride = elem_layout.pad_to_align().size();
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
+ let (_, tuple_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
- let k1 = entry.const_int(context, location, 1, 32)?;
+ let array_len_bytes = tuple_layout.pad_to_align().size();
+ let array_len_bytes_with_offset = entry.const_int(
+ context,
+ location,
+ array_len_bytes + calc_refcount_offset(tuple_layout),
+ 64,
+ )?;
+ let array_len_bytes = entry.const_int(context, location, array_len_bytes, 64)?;
+ let array_len = entry.const_int_from_type(context, location, tuple_len, len_ty)?;
- let elem_stride = entry.const_int(context, location, elem_stride, 64)?;
+ let k0 = entry.const_int_from_type(context, location, 0, len_ty)?;
+ let k1 = entry.const_int_from_type(context, location, 1, len_ty)?;
- let array_end = entry.extract_value(context, location, entry.arg(0)?, len_ty, 2)?;
- let array_capacity = entry.extract_value(context, location, entry.arg(0)?, len_ty, 3)?;
+ let array_ptr = entry.append_op_result(llvm::zero(ptr_ty, location))?;
+ let array_ptr = entry.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ array_ptr,
+ array_len_bytes_with_offset,
+ location,
+ )?)?;
+ entry.store(context, location, array_ptr, k1)?;
- let has_tail_space = entry.cmpi(
+ let array_ptr = entry.gep(
context,
- CmpiPredicate::Ult,
- array_end,
- array_capacity,
location,
+ array_ptr,
+ &[GepIndex::Const(calc_refcount_offset(tuple_layout) as i32)],
+ IntegerType::new(context, 8).into(),
)?;
+ entry.memcpy(
+ context,
+ location,
+ entry.argument(0)?.into(),
+ array_ptr,
+ array_len_bytes,
+ );
+ entry.append_operation(ReallocBindingsMeta::free(
+ context,
+ entry.argument(0)?.into(),
+ location,
+ )?);
- let handle_block = helper.append_block(Block::new(&[]));
- let memmove_block = helper.append_block(Block::new(&[]));
- let realloc_block = helper.append_block(Block::new(&[]));
- let append_block = helper.append_block(Block::new(&[(array_ty, location)]));
-
- entry.append_operation(cf::cond_br(
+ let value = entry.append_op_result(llvm::undef(
+ llvm::r#type::r#struct(context, &[ptr_ty, len_ty, len_ty, len_ty], false),
+ location,
+ ))?;
+ let value = entry.insert_values(
context,
- has_tail_space,
- append_block,
- handle_block,
- &[entry.arg(0)?],
- &[],
location,
- ));
+ value,
+ &[array_ptr, k0, array_len, array_len],
+ )?;
- {
- let k0 = handle_block.const_int(context, location, 0, 32)?;
- let array_start =
- handle_block.extract_value(context, location, entry.arg(0)?, len_ty, 1)?;
+ entry.append_operation(helper.br(0, &[value], location));
+ Ok(())
+}
- let has_head_space =
- handle_block.cmpi(context, CmpiPredicate::Ne, array_start, k0, location)?;
- handle_block.append_operation(cf::cond_br(
- context,
- has_head_space,
- memmove_block,
- realloc_block,
- &[],
- &[],
- location,
- ));
- }
+/// Generate MLIR operations for the `tuple_from_span` libfunc.
+///
+/// Note: The `&info.ty` field has the entire `[T; N]` tuple. It is not the `T` in `Array<T>`.
+pub fn build_tuple_from_span<'ctx, 'this>(
+ context: &'ctx Context,
+ registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+ entry: &'this Block<'ctx>,
+ location: Location<'ctx>,
+ helper: &LibfuncHelper<'ctx, 'this>,
+ metadata: &mut MetadataStorage,
+ info: &SignatureAndTypeConcreteLibfunc,
+) -> Result<()> {
+ metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
- {
- let array_start =
- memmove_block.extract_value(context, location, entry.arg(0)?, len_ty, 1)?;
+ let elem_id = {
+ let CoreTypeConcrete::Snapshot(info) =
+ registry.get_type(&info.signature.param_signatures[0].ty)?
+ else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
+ let CoreTypeConcrete::Array(info) = registry.get_type(&info.ty)? else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
- let start_offset =
- memmove_block.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let start_offset = memmove_block.muli(start_offset, elem_stride, location)?;
+ &info.ty
+ };
+ let tuple_len_const = {
+ let CoreTypeConcrete::Struct(param) = registry.get_type(&info.ty)? else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
- let dst_ptr = memmove_block.extract_value(context, location, entry.arg(0)?, ptr_ty, 0)?;
- let src_ptr = memmove_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- dst_ptr,
- &[start_offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
+ param.members.len()
+ };
- let array_len =
- memmove_block.append_op_result(arith::subi(array_end, array_start, location))?;
- let memmove_len =
- memmove_block.extui(array_len, IntegerType::new(context, 64).into(), location)?;
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
+ let (_, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, elem_id)?;
+ let (tuple_ty, tuple_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
- let memmove_len = memmove_block.muli(memmove_len, elem_stride, location)?;
- memmove_block.append_operation(
- ods::llvm::intr_memmove(
- context,
- dst_ptr,
- src_ptr,
- memmove_len,
- IntegerAttribute::new(IntegerType::new(context, 1).into(), 0),
- location,
- )
- .into(),
- );
+ let array_ptr = entry.extract_value(context, location, entry.argument(0)?.into(), ptr_ty, 0)?;
+ let array_start =
+ entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 2)?;
- let k0 = memmove_block.const_int_from_type(context, location, 0, len_ty)?;
- let value = memmove_block.insert_value(context, location, entry.arg(0)?, k0, 1)?;
- let value = memmove_block.insert_value(context, location, value, array_len, 2)?;
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
+ let tuple_len = entry.const_int_from_type(context, location, tuple_len_const, len_ty)?;
+ let len_matches = entry.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Eq,
+ array_len,
+ tuple_len,
+ location,
+ ))?;
- memmove_block.append_operation(cf::br(append_block, &[value], location));
- }
+ let valid_block = helper.append_block(Block::new(&[]));
+ let error_block = helper.append_block(Block::new(&[]));
+ entry.append_operation(cf::cond_br(
+ context,
+ len_matches,
+ valid_block,
+ error_block,
+ &[],
+ &[],
+ location,
+ ));
+
+ // Ensure the type's clone and drop implementations are registered.
+ registry.build_type(
+ context,
+ helper,
+ registry,
+ metadata,
+ &info.signature.param_signatures[0].ty,
+ )?;
{
- let k8 = realloc_block.const_int(context, location, 8, 32)?;
- let k1024 = realloc_block.const_int(context, location, 1024, 32)?;
-
- // Array allocation growth formula:
- // new_len = max(8, old_len + min(1024, 2 * old_len));
- let new_capacity = realloc_block.shli(array_end, k1, location)?;
- let new_capacity =
- realloc_block.append_op_result(arith::minui(new_capacity, k1024, location))?;
- let new_capacity = realloc_block.addi(new_capacity, array_end, location)?;
- let new_capacity =
- realloc_block.append_op_result(arith::maxui(new_capacity, k8, location))?;
-
- let realloc_size = {
- let new_capacity = realloc_block.extui(
- new_capacity,
- IntegerType::new(context, 64).into(),
- location,
- )?;
- realloc_block.muli(new_capacity, elem_stride, location)?
- };
+ let value_size = valid_block.const_int(context, location, tuple_layout.size(), 64)?;
- let ptr = realloc_block.extract_value(context, location, entry.arg(0)?, ptr_ty, 0)?;
- let ptr = realloc_block.append_op_result(ReallocBindingsMeta::realloc(
- context,
- ptr,
- realloc_size,
- location,
+ let value = valid_block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let value = valid_block.append_op_result(ReallocBindingsMeta::realloc(
+ context, value, value_size, location,
)?)?;
- // No need to memmove, guaranteed by the fact that if we needed to memmove we'd have gone
- // through the memmove block instead of reallocating.
-
- let value = realloc_block.insert_value(context, location, entry.arg(0)?, ptr, 0)?;
- let value = realloc_block.insert_value(context, location, value, new_capacity, 3)?;
-
- realloc_block.append_operation(cf::br(append_block, &[value], location));
- }
-
- {
- let ptr = append_block.extract_value(context, location, append_block.arg(0)?, ptr_ty, 0)?;
- let array_end =
- append_block.extract_value(context, location, append_block.arg(0)?, len_ty, 2)?;
+ let is_shared = is_shared(context, valid_block, location, array_ptr, elem_layout)?;
- let offset =
- append_block.extui(array_end, IntegerType::new(context, 64).into(), location)?;
- let offset = append_block.muli(offset, elem_stride, location)?;
- let ptr = append_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
+ let array_start_offset = valid_block.append_op_result(arith::extui(
+ array_start,
+ IntegerType::new(context, 64).into(),
location,
))?;
+ let array_start_offset = valid_block.append_op_result(arith::muli(
+ array_start_offset,
+ valid_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?,
+ location,
+ ))?;
+ let array_ptr = valid_block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(array_start_offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
- append_block.store(context, location, ptr, entry.arg(1)?)?;
-
- let array_len = append_block.addi(array_end, k1, location)?;
- let value =
- append_block.insert_value(context, location, append_block.arg(0)?, array_len, 2)?;
-
- append_block.append_operation(helper.br(0, &[value], location));
- }
-
- Ok(())
-}
+ valid_block.append_operation(scf::r#if(
+ is_shared,
+ &[],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(&info.ty) => {
+ let src_ptr = array_ptr;
+ let dst_ptr = value;
+
+ let value = block.load(context, location, src_ptr, tuple_ty)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, &info.ty, value)?;
+ block.store(context, location, src_ptr, values.0)?;
+ block.store(context, location, dst_ptr, values.1)?;
+ }
+ _ => block.memcpy(context, location, array_ptr, value, value_size),
+ }
-/// Generate MLIR operations for the `array_len` libfunc.
-pub fn build_len<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ // The following unwrap should be unreachable because an array always has a drop
+ // implementation.
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
+ context,
+ &block,
+ location,
+ &info.signature.param_signatures[0].ty,
+ entry.argument(0)?.into(),
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
- let array_value = entry.arg(0)?;
+ block.memcpy(context, location, array_ptr, value, value_size);
- let array_start = entry.extract_value(context, location, array_value, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, array_value, len_ty, 2)?;
+ let array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
+ IntegerType::new(context, 8).into(),
+ )?;
+ block.append_operation(ReallocBindingsMeta::free(context, array_ptr, location)?);
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
- let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
+ valid_block.append_operation(helper.br(0, &[value], location));
+ }
- match metadata.get::<DropOverridesMeta>() {
- Some(drop_overrides_meta)
- if drop_overrides_meta.is_overriden(&info.signature.param_signatures[0].ty) =>
- {
- drop_overrides_meta.invoke_override(
+ {
+ metadata
+ .get::<DropOverridesMeta>()
+ .ok_or(Error::MissingMetadata)?
+ .invoke_override(
context,
- entry,
+ error_block,
location,
&info.signature.param_signatures[0].ty,
- entry.arg(0)?,
+ entry.argument(0)?.into(),
)?;
- }
- _ => {}
+
+ error_block.append_operation(helper.br(1, &[], location));
}
- entry.append_operation(helper.br(0, &[array_len], location));
Ok(())
}
-/// Generate MLIR operations for the `array_get` libfunc.
-pub fn build_get<'ctx, 'this>(
+/// Generate MLIR operations for the `array_append` libfunc.
+pub fn build_append<'ctx, 'this>(
context: &'ctx Context,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
@@ -2886,720 +3375,1116 @@
metadata: &mut MetadataStorage,
info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let range_check = super::increment_builtin_counter(context, entry, location, entry.arg(0)?)?;
-
- let array_ty = registry.build_type(
+ /*
+ * 1. Check if shared.
+ * 2. If shared:
+ * 1. Deep clone with space for at least 1 extra element.
+ * 3. If not shared:
+ * 1. Either realloc, move or do nothing.
+ * 4. Append element.
+ */
+
+ metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
+
+ let self_ty = registry.build_type(
context,
helper,
registry,
metadata,
- &info.param_signatures()[1].ty,
+ &info.signature.param_signatures[0].ty,
)?;
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
- let elem_stride = elem_layout.pad_to_align().size();
- let elem_ty = elem_ty.build(context, helper, registry, metadata, &info.ty)?;
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ let (elem_ty, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
+ let elem_stride = entry.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let value = entry.arg(1)?;
- let index = entry.arg(2)?;
+ let k0 = entry.const_int(context, location, 0, 32)?;
+ let k1 = entry.const_int(context, location, 1, 32)?;
- let array_start = entry.extract_value(context, location, value, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, value, len_ty, 2)?;
+ let array_ptr = entry.extract_value(context, location, entry.argument(0)?.into(), ptr_ty, 0)?;
+ let array_start =
+ entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 2)?;
+ let array_capacity =
+ entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 3)?;
let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let is_valid = entry.cmpi(context, CmpiPredicate::Ult, index, array_len, location)?;
+ let array_size = entry.append_op_result(arith::extui(
+ array_len,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let array_size = entry.append_op_result(arith::muli(array_size, elem_stride, location))?;
- let valid_block = helper.append_block(Block::new(&[]));
- let error_block = helper.append_block(Block::new(&[]));
- entry.append_operation(cf::cond_br(
+ let data_offset = entry.append_op_result(arith::extui(
+ array_start,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let data_offset = entry.append_op_result(arith::muli(data_offset, elem_stride, location))?;
+ let data_ptr = entry.gep(
context,
- is_valid,
- valid_block,
- error_block,
- &[],
- &[],
location,
- ));
+ array_ptr,
+ &[GepIndex::Value(data_offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
- {
- let ptr = valid_block.extract_value(context, location, value, ptr_ty, 0)?;
+ fn compute_next_capacity<'ctx, 'this>(
+ context: &'ctx Context,
+ block: &'this Block<'ctx>,
+ location: Location<'ctx>,
+ elem_stride: Value<'ctx, 'this>,
+ array_end: Value<'ctx, 'this>,
+ ) -> Result<(Value<'ctx, 'this>, Value<'ctx, 'this>)> {
+ let len_ty = IntegerType::new(context, 32).into();
+
+ let k1 = block.const_int_from_type(context, location, 1, len_ty)?;
+ let k8 = block.const_int_from_type(context, location, 8, len_ty)?;
+ let k1024 = block.const_int_from_type(context, location, 1024, len_ty)?;
+
+ let realloc_len = block.append_op_result(arith::shli(array_end, k1, location))?;
+ let realloc_len = block.append_op_result(arith::minui(realloc_len, k1024, location))?;
+ let realloc_len = block.append_op_result(arith::addi(realloc_len, array_end, location))?;
+ let realloc_len = block.append_op_result(arith::maxui(realloc_len, k8, location))?;
+
+ let realloc_size = block.append_op_result(arith::extui(
+ realloc_len,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let realloc_size =
+ block.append_op_result(arith::muli(realloc_size, elem_stride, location))?;
- let array_start =
- valid_block.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let index = {
- let index = valid_block.extui(index, IntegerType::new(context, 64).into(), location)?;
- valid_block.addi(array_start, index, location)?
- };
+ Result::Ok((realloc_len, realloc_size))
+ }
- let elem_stride = valid_block.const_int(context, location, elem_stride, 64)?;
- let elem_offset = valid_block.muli(elem_stride, index, location)?;
+ let is_empty = entry.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Eq,
+ array_capacity,
+ k0,
+ location,
+ ))?;
- let elem_ptr = valid_block.gep(
- context,
- location,
- ptr,
- &[GepIndex::Value(elem_offset)],
- IntegerType::new(context, 8).into(),
- )?;
+ let is_shared = entry.append_op_result(scf::r#if(
+ is_empty,
+ &[IntegerType::new(context, 1).into()],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let elem_size = valid_block.const_int(context, location, elem_layout.size(), 64)?;
+ let k0 = block.const_int(context, location, 0, 1)?;
- let target_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
- )?;
- let target_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context, target_ptr, elem_size, location,
- )?)?;
- assert_nonnull(
- context,
- valid_block,
- location,
- target_ptr,
- "realloc returned nullptr",
- )?;
+ block.append_operation(scf::r#yield(&[k0], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- // There's no need to clone it since we're moving it out of the array.
- valid_block.memcpy(context, location, elem_ptr, target_ptr, elem_size);
+ let is_shared = is_shared(context, entry, location, array_ptr, elem_layout)?;
- match metadata.get::<DropOverridesMeta>() {
- Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
- let array_end =
- valid_block.extui(array_end, IntegerType::new(context, 64).into(), location)?;
+ block.append_operation(scf::r#yield(&[is_shared], location));
+ region
+ },
+ location,
+ ))?;
- let array_start = valid_block.muli(array_start, elem_stride, location)?;
- let array_end = valid_block.muli(array_end, elem_stride, location)?;
+ let value = entry.append_op_result(scf::r#if(
+ is_shared,
+ &[self_ty],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- valid_block.append_operation(scf::r#for(
- array_start,
- array_end,
- elem_stride,
- {
- let region = Region::new();
- let block = region.append_block(Block::new(&[(
- IntegerType::new(context, 64).into(),
- location,
- )]));
+ let has_space = block.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ugt,
+ array_capacity,
+ array_len,
+ location,
+ ))?;
- let value_ptr = block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[block.arg(0)?],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
+ let op = block.append_operation(scf::r#if(
+ has_space,
+ &[len_ty, IntegerType::new(context, 64).into()],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let is_target_element = block.append_op_result(
- ods::llvm::icmp(
- context,
- IntegerType::new(context, 1).into(),
- value_ptr,
- elem_ptr,
- IntegerAttribute::new(IntegerType::new(context, 64).into(), 0)
- .into(),
- location,
- )
- .into(),
- )?;
- block.append_operation(scf::r#if(
- is_target_element,
- &[],
- {
- let region = Region::new();
- let block = region.append_block(Block::new(&[]));
+ let clone_size = block.append_op_result(arith::extui(
+ array_capacity,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let clone_size =
+ block.append_op_result(arith::muli(clone_size, elem_stride, location))?;
+
+ block.append_operation(scf::r#yield(&[array_capacity, clone_size], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let (realloc_capacity, realloc_size) =
+ compute_next_capacity(context, &block, location, elem_stride, array_end)?;
+
+ block.append_operation(scf::r#yield(
+ &[realloc_capacity, realloc_size],
+ location,
+ ));
+ region
+ },
+ location,
+ ));
+ let clone_capacity = op.result(0)?.into();
+ let clone_size = op.result(1)?.into();
- block.append_operation(scf::r#yield(&[], location));
- region
- },
- {
- let region = Region::new();
- let block = region.append_block(Block::new(&[]));
+ let clone_size_with_refcount = block.append_op_result(arith::addi(
+ clone_size,
+ block.const_int(context, location, calc_refcount_offset(elem_layout), 64)?,
+ location,
+ ))?;
- let value = block.load(context, location, value_ptr, elem_ty)?;
- drop_overrides_meta
- .invoke_override(context, &block, location, &info.ty, value)?;
+ let clone_ptr = block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let clone_ptr = block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ clone_ptr,
+ clone_size_with_refcount,
+ location,
+ )?)?;
+ block.store(context, location, clone_ptr, k1)?;
- block.append_operation(scf::r#yield(&[], location));
- region
- },
- location,
- ));
+ let clone_ptr = block.gep(
+ context,
+ location,
+ clone_ptr,
+ &[GepIndex::Const(calc_refcount_offset(elem_layout) as i32)],
+ IntegerType::new(context, 8).into(),
+ )?;
- block.append_operation(scf::r#yield(&[], location));
- region
- },
- location,
- ));
- }
- _ => {}
- }
- valid_block.append_operation(ReallocBindingsMeta::free(context, ptr, location)?);
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(&info.ty) => {
+ let k0 = block.const_int(context, location, 0, 64)?;
+ block.append_operation(scf::r#for(
+ k0,
+ array_size,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
- valid_block.append_operation(helper.br(0, &[range_check, target_ptr], location));
- }
+ let offset = block.argument(0)?.into();
+ let source_ptr = block.gep(
+ context,
+ location,
+ data_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let target_ptr = block.gep(
+ context,
+ location,
+ clone_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let value = block.load(context, location, source_ptr, elem_ty)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, &info.ty, value)?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, target_ptr, values.1)?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ }
+ _ => block.memcpy(context, location, array_ptr, clone_ptr, clone_size),
+ }
- metadata
- .get::<DropOverridesMeta>()
- .ok_or(Error::MissingMetadata)?
- .invoke_override(
- context,
- error_block,
- location,
- &info.param_signatures()[1].ty,
- value,
- )?;
- error_block.append_operation(helper.br(1, &[range_check], location));
+ let clone_value = block.append_op_result(llvm::zero(self_ty, location))?;
+ let clone_value = block.insert_values(
+ context,
+ location,
+ clone_value,
+ &[clone_ptr, k0, array_len, clone_capacity],
+ )?;
- Ok(())
-}
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
+ context,
+ &block,
+ location,
+ &info.signature.param_signatures[0].ty,
+ entry.argument(0)?.into(),
+ )?;
-/// Generate MLIR operations for the `array_pop_front` libfunc.
-pub fn build_pop_front<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
+ block.append_operation(scf::r#yield(&[clone_value], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ let has_tail_space = block.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ult,
+ array_end,
+ array_capacity,
+ location,
+ ))?;
+ let array_value = block.append_op_result(scf::r#if(
+ has_tail_space,
+ &[self_ty],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ block.append_operation(scf::r#yield(&[entry.argument(0)?.into()], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let has_head_space = block.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ugt,
+ array_start,
+ k0,
+ location,
+ ))?;
+ let array_value = block.append_op_result(scf::r#if(
+ has_head_space,
+ &[self_ty],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ block.append_operation(
+ ods::llvm::intr_memmove(
+ context,
+ array_ptr,
+ data_ptr,
+ array_size,
+ IntegerAttribute::new(IntegerType::new(context, 1).into(), 0),
+ location,
+ )
+ .into(),
+ );
+
+ let array_value = block.insert_value(
+ context,
+ location,
+ entry.argument(0)?.into(),
+ k0,
+ 1,
+ )?;
+ let array_value =
+ block.insert_value(context, location, array_value, array_len, 2)?;
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let offset_array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let array_ptr = block.append_op_result(arith::select(
+ is_empty,
+ array_ptr,
+ offset_array_ptr,
+ location,
+ ))?;
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
+ let (realloc_len, realloc_size) = compute_next_capacity(
+ context,
+ &block,
+ location,
+ elem_stride,
+ array_end,
+ )?;
+ let realloc_size_with_refcount =
+ block.append_op_result(arith::addi(
+ realloc_size,
+ block.const_int(
+ context,
+ location,
+ calc_refcount_offset(elem_layout),
+ 64,
+ )?,
+ location,
+ ))?;
+
+ let array_ptr =
+ block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ array_ptr,
+ realloc_size_with_refcount,
+ location,
+ )?)?;
+
+ let ref_count = block.load(context, location, array_ptr, len_ty)?;
+ let ref_count = block.append_op_result(arith::select(
+ is_empty, k1, ref_count, location,
+ ))?;
+ block.store(context, location, array_ptr, ref_count)?;
+
+ let array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(calc_refcount_offset(elem_layout) as i32)],
+ IntegerType::new(context, 8).into(),
+ )?;
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ let array_value = block.insert_value(
+ context,
+ location,
+ entry.argument(0)?.into(),
+ array_ptr,
+ 0,
+ )?;
+ let array_value = block.insert_value(
+ context,
+ location,
+ array_value,
+ realloc_len,
+ 3,
+ )?;
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ location,
+ ))?;
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ location,
+ ))?;
- let value = entry.arg(0)?;
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ location,
+ ))?;
- let array_start = entry.extract_value(context, location, value, len_ty, 1)?;
+ let array_ptr = entry.extract_value(context, location, value, ptr_ty, 0)?;
let array_end = entry.extract_value(context, location, value, len_ty, 2)?;
- let is_empty = entry.cmpi(context, CmpiPredicate::Eq, array_start, array_end, location)?;
-
- let valid_block = helper.append_block(Block::new(&[]));
- let empty_block = helper.append_block(Block::new(&[]));
- entry.append_operation(cf::cond_br(
+ let data_offset = entry.append_op_result(arith::extui(
+ array_end,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let data_offset = entry.append_op_result(arith::muli(data_offset, elem_stride, location))?;
+ let data_ptr = entry.gep(
context,
- is_empty,
- empty_block,
- valid_block,
- &[],
- &[],
location,
- ));
-
- {
- let ptr = valid_block.extract_value(context, location, value, ptr_ty, 0)?;
-
- let elem_size = valid_block.const_int(context, location, elem_layout.size(), 64)?;
- let elem_offset =
- valid_block.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let elem_offset = valid_block.muli(elem_offset, elem_size, location)?;
- let ptr = valid_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[elem_offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
-
- let target_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
- )?;
- let target_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context, target_ptr, elem_size, location,
- )?)?;
- assert_nonnull(
- context,
- valid_block,
- location,
- target_ptr,
- "realloc returned nullptr",
- )?;
-
- valid_block.memcpy(context, location, ptr, target_ptr, elem_size);
-
- let k1 = valid_block.const_int(context, location, 1, 32)?;
- let new_start = valid_block.addi(array_start, k1, location)?;
- let value = valid_block.insert_value(context, location, value, new_start, 1)?;
+ array_ptr,
+ &[GepIndex::Value(data_offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ entry.store(context, location, data_ptr, entry.argument(1)?.into())?;
- valid_block.append_operation(helper.br(0, &[value, target_ptr], location));
- }
+ let array_end = entry.append_op_result(arith::addi(array_end, k1, location))?;
+ let value = entry.insert_value(context, location, value, array_end, 2)?;
- empty_block.append_operation(helper.br(1, &[value], location));
+ entry.append_operation(helper.br(0, &[value], location));
Ok(())
}
-/// Generate MLIR operations for the `array_pop_front_consume` libfunc.
-pub fn build_pop_front_consume<'ctx, 'this>(
+#[derive(Clone, Copy)]
+enum PopInfo<'a> {
+ Single(&'a SignatureAndTypeConcreteLibfunc),
+ Multi(&'a ConcreteMultiPopLibfunc),
+}
+
+/// Generate MLIR operations for the `array_pop_*` libfuncs.
+///
+/// Template arguments:
+/// - Consume: Whether to consume or not the array on failure.
+/// - Reverse: False for front-popping, true for back-popping.
+///
+/// The `info` argument contains how many items to pop.
+fn build_pop<'ctx, 'this, const CONSUME: bool, const REVERSE: bool>(
context: &'ctx Context,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
location: Location<'ctx>,
helper: &LibfuncHelper<'ctx, 'this>,
metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
+ info: PopInfo,
) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
+ /*
+ * 1. Check if there's enough data to pop.
+ * 2. If there is not enough data, maybe consume and return.
+ * 3. Allocate output.
+ * 4. Clone or copy the popped data.
+ * - Clone if shared.
+ * - Copy if not shared.
+ */
+
+ metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
+
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ let (self_ty, elem_ty, array_value, extract_len, mut branch_values) = match info {
+ PopInfo::Single(info) => (
+ &info.signature.param_signatures[0].ty,
+ &info.ty,
+ entry.argument(0)?.into(),
+ 1,
+ Vec::new(),
+ ),
+ PopInfo::Multi(ConcreteMultiPopLibfunc {
+ popped_ty,
+ signature,
+ }) => {
+ let range_check = super::increment_builtin_counter(
+ context,
+ entry,
+ location,
+ entry.argument(0)?.into(),
+ )?;
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
+ let CoreTypeConcrete::Snapshot(InfoAndTypeConcreteType { ty, .. }) =
+ registry.get_type(&signature.param_signatures[1].ty)?
+ else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
+
+ let CoreTypeConcrete::Array(InfoAndTypeConcreteType { ty, .. }) =
+ registry.get_type(ty)?
+ else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
+
+ let CoreTypeConcrete::Struct(info) = registry.get_type(popped_ty)? else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
+ debug_assert!(info.members.iter().all(|member_ty| member_ty == ty));
+
+ (
+ &signature.param_signatures[1].ty,
+ ty,
+ entry.argument(1)?.into(),
+ info.members.len(),
+ vec![range_check],
+ )
+ }
+ };
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ registry.build_type(context, helper, registry, metadata, self_ty)?;
+ let extract_len_value = entry.const_int_from_type(context, location, extract_len, len_ty)?;
- let value = entry.arg(0)?;
+ let (elem_type, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, elem_ty)?;
- let array_start = entry.extract_value(context, location, value, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, value, len_ty, 2)?;
+ let array_start = entry.extract_value(context, location, array_value, len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, array_value, len_ty, 2)?;
- let is_empty = entry.cmpi(context, CmpiPredicate::Eq, array_start, array_end, location)?;
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
+ let has_enough_data = entry.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ule,
+ extract_len_value,
+ array_len,
+ location,
+ ))?;
let valid_block = helper.append_block(Block::new(&[]));
- let empty_block = helper.append_block(Block::new(&[]));
+ let error_block = helper.append_block(Block::new(&[]));
entry.append_operation(cf::cond_br(
context,
- is_empty,
- empty_block,
+ has_enough_data,
valid_block,
+ error_block,
&[],
&[],
location,
));
{
- let ptr = valid_block.extract_value(context, location, value, ptr_ty, 0)?;
+ // Clone branch_values so that it doesn't interfere with the other branch.
+ let mut branch_values = branch_values.clone();
- let elem_size = valid_block.const_int(context, location, elem_layout.size(), 64)?;
- let elem_offset =
- valid_block.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let elem_offset = valid_block.muli(elem_offset, elem_size, location)?;
- let ptr = valid_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[elem_offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
-
- let target_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
- )?;
- let target_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context, target_ptr, elem_size, location,
- )?)?;
- assert_nonnull(
+ let value_size = valid_block.const_int(
context,
- valid_block,
location,
- target_ptr,
- "realloc returned nullptr",
+ elem_layout.pad_to_align().size() * extract_len,
+ 64,
)?;
- valid_block.memcpy(context, location, ptr, target_ptr, elem_size);
+ let value_ptr = valid_block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let value_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
+ context, value_ptr, value_size, location,
+ )?)?;
- let k1 = valid_block.const_int(context, location, 1, 32)?;
- let new_start = valid_block.addi(array_start, k1, location)?;
- let value = valid_block.insert_value(context, location, value, new_start, 1)?;
+ let array_ptr = valid_block.extract_value(context, location, array_value, ptr_ty, 0)?;
+ let is_shared = is_shared(context, valid_block, location, array_ptr, elem_layout)?;
- valid_block.append_operation(helper.br(0, &[value, target_ptr], location));
- }
+ let data_ptr = {
+ let offset_elems = if REVERSE {
+ valid_block.append_op_result(arith::subi(array_end, extract_len_value, location))?
+ } else {
+ array_start
+ };
- metadata
- .get::<DropOverridesMeta>()
- .ok_or(Error::MissingMetadata)?
- .invoke_override(
- context,
- empty_block,
- location,
- &info.param_signatures()[0].ty,
- value,
- )?;
- empty_block.append_operation(helper.br(1, &[], location));
-
- Ok(())
-}
-
-/// Generate MLIR operations for the `array_snapshot_pop_front` libfunc.
-pub fn build_snapshot_pop_front<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- build_pop_front(context, registry, entry, location, helper, metadata, info)
-}
+ let offset = valid_block.append_op_result(arith::extui(
+ offset_elems,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let elem_stride =
+ valid_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
+ let offset =
+ valid_block.append_op_result(arith::muli(offset, elem_stride, location))?;
-/// Generate MLIR operations for the `array_snapshot_pop_back` libfunc.
-pub fn build_snapshot_pop_back<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
+ valid_block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?
+ };
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ let new_array_ptr = valid_block.append_op_result(scf::r#if(
+ is_shared,
+ &[ptr_ty],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let k0 = block.const_int(context, location, 0, 64)?;
+ let k1 = block.const_int_from_type(context, location, 1, len_ty)?;
+
+ let elem_stride =
+ block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(elem_ty) => {
+ block.append_operation(scf::r#for(
+ k0,
+ value_size,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let offset = block.argument(0)?.into();
+ let source_ptr = block.gep(
+ context,
+ location,
+ data_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let target_ptr = block.gep(
+ context,
+ location,
+ value_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let value = block.load(context, location, source_ptr, elem_type)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, elem_ty, value)?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, target_ptr, values.1)?;
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ }
+ _ => block.memcpy(context, location, data_ptr, value_ptr, value_size),
+ }
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ let array_ptr = {
+ let array_len_bytes =
+ block.append_op_result(arith::subi(array_len, k1, location))?;
+ let array_len_bytes = block.append_op_result(arith::extui(
+ array_len_bytes,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let array_len_bytes = block.append_op_result(arith::muli(
+ array_len_bytes,
+ elem_stride,
+ location,
+ ))?;
+ let array_len_bytes = block.append_op_result(arith::addi(
+ array_len_bytes,
+ block.const_int(
+ context,
+ location,
+ calc_refcount_offset(elem_layout),
+ 64,
+ )?,
+ location,
+ ))?;
+
+ let clone_ptr = block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let clone_ptr = block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ clone_ptr,
+ array_len_bytes,
+ location,
+ )?)?;
+ block.store(context, location, clone_ptr, k1)?;
+
+ let clone_ptr = block.gep(
+ context,
+ location,
+ clone_ptr,
+ &[GepIndex::Const(calc_refcount_offset(elem_layout) as i32)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let data_ptr = if REVERSE {
+ data_ptr
+ } else {
+ let offset = block.append_op_result(arith::extui(
+ extract_len_value,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let offset =
+ block.append_op_result(arith::muli(offset, elem_stride, location))?;
- let value = entry.arg(0)?;
+ block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?
+ };
+
+ let others_len = block.append_op_result(arith::subi(
+ array_len,
+ extract_len_value,
+ location,
+ ))?;
+ let others_len = block.append_op_result(arith::extui(
+ others_len,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let others_size =
+ block.append_op_result(arith::muli(others_len, elem_stride, location))?;
+
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) => {
+ block.append_operation(scf::r#for(
+ k0,
+ others_size,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let offset = block.argument(0)?.into();
+ let source_ptr = block.gep(
+ context,
+ location,
+ data_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let target_ptr = block.gep(
+ context,
+ location,
+ clone_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let value =
+ block.load(context, location, source_ptr, elem_type)?;
+ let values = dup_overrides_meta.invoke_override(
+ context, &block, location, elem_ty, value,
+ )?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, target_ptr, values.1)?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ }
+ _ => block.memcpy(context, location, data_ptr, clone_ptr, others_size),
+ }
- let array_start = entry.extract_value(context, location, value, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, value, len_ty, 2)?;
- let is_empty = entry.cmpi(context, CmpiPredicate::Eq, array_start, array_end, location)?;
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(context, &block, location, self_ty, array_value)?;
- let valid_block = helper.append_block(Block::new(&[]));
- let empty_block = helper.append_block(Block::new(&[]));
- entry.append_operation(cf::cond_br(
- context,
- is_empty,
- empty_block,
- valid_block,
- &[],
- &[],
- location,
- ));
+ clone_ptr
+ };
- {
- let k1 = valid_block.const_int(context, location, 1, 32)?;
- let new_end = valid_block.append_op_result(arith::subi(array_end, k1, location))?;
+ block.append_operation(scf::r#yield(&[array_ptr], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let ptr = valid_block.extract_value(context, location, value, ptr_ty, 0)?;
+ block.memcpy(context, location, data_ptr, value_ptr, value_size);
- let elem_size = valid_block.const_int(context, location, elem_layout.size(), 64)?;
- let elem_offset =
- valid_block.extui(new_end, IntegerType::new(context, 64).into(), location)?;
- let elem_offset = valid_block.muli(elem_offset, elem_size, location)?;
- let ptr = valid_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[elem_offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
+ block.append_operation(scf::r#yield(&[array_ptr], location));
+ region
+ },
location,
))?;
- let target_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
+ let array_value =
+ valid_block.insert_value(context, location, array_value, new_array_ptr, 0)?;
+
+ let has_realloc = valid_block.append_op_result(
+ ods::llvm::icmp(
+ context,
+ IntegerType::new(context, 1).into(),
+ array_ptr,
+ new_array_ptr,
+ IntegerAttribute::new(IntegerType::new(context, 64).into(), 1).into(),
+ location,
+ )
+ .into(),
)?;
- let target_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context, target_ptr, elem_size, location,
- )?)?;
- assert_nonnull(
- context,
- valid_block,
+ let array_value = valid_block.append_op_result(scf::r#if(
+ has_realloc,
+ &[array_value.r#type()],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let k0 = block.const_int_from_type(context, location, 0, len_ty)?;
+ let array_len =
+ block.append_op_result(arith::subi(array_len, extract_len_value, location))?;
+
+ let array_value = block.insert_value(context, location, array_value, k0, 1)?;
+ let array_value =
+ block.insert_value(context, location, array_value, array_len, 2)?;
+ let array_value =
+ block.insert_value(context, location, array_value, array_len, 3)?;
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let array_value = if REVERSE {
+ let array_end = block.append_op_result(arith::subi(
+ array_end,
+ extract_len_value,
+ location,
+ ))?;
+ block.insert_value(context, location, array_value, array_end, 2)?
+ } else {
+ let array_start = block.append_op_result(arith::addi(
+ array_start,
+ extract_len_value,
+ location,
+ ))?;
+ block.insert_value(context, location, array_value, array_start, 1)?
+ };
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
location,
- target_ptr,
- "realloc returned nullptr",
- )?;
+ ))?;
+
+ branch_values.push(array_value);
+ branch_values.push(value_ptr);
- valid_block.memcpy(context, location, ptr, target_ptr, elem_size);
+ valid_block.append_operation(helper.br(0, &branch_values, location));
+ }
- let value = valid_block.insert_value(context, location, value, new_end, 2)?;
+ {
+ if CONSUME {
+ let self_ty = match info {
+ PopInfo::Single(info) => &info.signature.param_signatures[0].ty,
+ PopInfo::Multi(info) => &info.signature.param_signatures[1].ty,
+ };
+
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(context, error_block, location, self_ty, array_value)?;
+ } else {
+ branch_values.push(array_value);
+ }
- valid_block.append_operation(helper.br(0, &[value, target_ptr], location));
+ error_block.append_operation(helper.br(1, &branch_values, location));
}
- empty_block.append_operation(helper.br(1, &[value], location));
Ok(())
}
-pub fn build_snapshot_multi_pop_front<'ctx, 'this>(
+/// Generate MLIR operations for the `array_get` libfunc.
+pub fn build_get<'ctx, 'this>(
context: &'ctx Context,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
location: Location<'ctx>,
helper: &LibfuncHelper<'ctx, 'this>,
metadata: &mut MetadataStorage,
- info: &ConcreteMultiPopLibfunc,
+ info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let range_check = entry.arg(0)?;
-
- // Get type information
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
- let array_ty = registry.build_type(
+ // Build the type so that the drop impl invocation works properly.
+ registry.build_type(
context,
helper,
registry,
metadata,
- &info.param_signatures()[1].ty,
+ &info.signature.param_signatures[1].ty,
)?;
- let popped_cty = registry.get_type(&info.popped_ty)?;
- let popped_size = popped_cty.layout(registry)?.size();
- let popped_size_value = entry.const_int(context, location, popped_size, 64)?;
-
- let popped_ctys = popped_cty
- .fields()
- .expect("popped type should be a tuple (ergo, has fields)");
- let popped_len = popped_ctys.len();
-
- let array_ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let array_start_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
- let array_end_ty = crate::ffi::get_struct_field_type_at(&array_ty, 2);
+ let range_check =
+ super::increment_builtin_counter(context, entry, location, entry.argument(0)?.into())?;
- // Get array information
+ let array_start =
+ entry.extract_value(context, location, entry.argument(1)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(1)?.into(), len_ty, 2)?;
- let array = entry.arg(1)?;
- let array_ptr = entry.extract_value(context, location, array, array_ptr_ty, 0)?;
- let array_start = entry.extract_value(context, location, array, array_start_ty, 1)?;
- let array_end = entry.extract_value(context, location, array, array_end_ty, 2)?;
-
- // Check if operation is valid:
- // if array.end - array.start < popped_len {
- // return
- // }
-
- let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let popped_len_value = entry.const_int(context, location, popped_len, 32)?;
- let is_valid = entry.cmpi(
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
+ let is_valid = entry.append_op_result(arith::cmpi(
context,
- CmpiPredicate::Uge,
+ CmpiPredicate::Ult,
+ entry.argument(2)?.into(),
array_len,
- popped_len_value,
location,
- )?;
+ ))?;
let valid_block = helper.append_block(Block::new(&[]));
- let invalid_block = helper.append_block(Block::new(&[]));
-
+ let error_block = helper.append_block(Block::new(&[]));
entry.append_operation(cf::cond_br(
context,
is_valid,
valid_block,
- invalid_block,
+ error_block,
&[],
&[],
location,
));
{
- // Get pointer to first element to pop
-
- let popped_ptr = {
- let single_popped_ty =
- registry.build_type(context, helper, registry, metadata, &popped_ctys[0])?;
-
- valid_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- array_ptr,
- &[array_start],
- single_popped_ty,
- llvm::r#type::pointer(context, 0),
- location,
- ))?
- };
-
- // Allocate memory for return array
-
- let return_ptr = {
- let null_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
- )?;
- valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context,
- null_ptr,
- popped_size_value,
- location,
- )?)?
- };
-
- valid_block.memcpy(context, location, popped_ptr, return_ptr, popped_size_value);
-
- // Update array start (removing popped elements)
-
- let array = {
- let new_array_start = valid_block.addi(array_start, popped_len_value, location)?;
-
- valid_block.insert_value(context, location, array, new_array_start, 1)?
- };
-
- valid_block.append_operation(helper.br(0, &[range_check, array, return_ptr], location));
- }
-
- invalid_block.append_operation(helper.br(1, &[range_check, array], location));
-
- Ok(())
-}
-
-pub fn build_snapshot_multi_pop_back<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &ConcreteMultiPopLibfunc,
-) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let range_check = entry.arg(0)?;
-
- // Get type information
-
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[1].ty,
- )?;
-
- let popped_cty = registry.get_type(&info.popped_ty)?;
- let popped_size = popped_cty.layout(registry)?.size();
- let popped_size_value = entry.const_int(context, location, popped_size, 64)?;
+ let (elem_ty, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
+ let elem_stride =
+ valid_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let popped_ctys = popped_cty
- .fields()
- .expect("popped type should be a tuple (ergo, has fields)");
- let popped_len = popped_ctys.len();
+ let value_ptr = valid_block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let value_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ value_ptr,
+ elem_stride,
+ location,
+ )?)?;
- let array_ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let array_start_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
- let array_end_ty = crate::ffi::get_struct_field_type_at(&array_ty, 2);
+ let array_ptr =
+ valid_block.extract_value(context, location, entry.argument(1)?.into(), ptr_ty, 0)?;
+ let is_shared = is_shared(context, valid_block, location, array_ptr, elem_layout)?;
- // Get array information
+ let offset = valid_block.append_op_result(arith::addi(
+ array_start,
+ entry.argument(2)?.into(),
+ location,
+ ))?;
+ let offset = valid_block.append_op_result(arith::extui(
+ offset,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let offset = valid_block.append_op_result(arith::muli(offset, elem_stride, location))?;
- let array = entry.arg(1)?;
- let array_ptr = entry.extract_value(context, location, array, array_ptr_ty, 0)?;
- let array_start = entry.extract_value(context, location, array, array_start_ty, 1)?;
- let array_end = entry.extract_value(context, location, array, array_end_ty, 2)?;
+ let source_ptr = valid_block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
- // Check if operation is valid:
- // if array.end - array.start < popped_len {
- // return
- // }
+ valid_block.append_operation(scf::r#if(
+ is_shared,
+ &[],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(&info.ty) => {
+ let value = block.load(context, location, source_ptr, elem_ty)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, &info.ty, value)?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, value_ptr, values.1)?;
+ }
+ _ => block.memcpy(context, location, source_ptr, value_ptr, elem_stride),
+ }
- let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let popped_len_value = entry.const_int(context, location, popped_len, 32)?;
- let is_valid = entry.cmpi(
- context,
- CmpiPredicate::Uge,
- array_len,
- popped_len_value,
- location,
- )?;
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
+ context,
+ &block,
+ location,
+ &info.signature.param_signatures[1].ty,
+ entry.argument(1)?.into(),
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ block.memcpy(context, location, source_ptr, value_ptr, elem_stride);
+
+ match metadata.get::<DropOverridesMeta>() {
+ Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
+ let drop_loop = |o0, o1| {
+ block.append_operation(scf::r#for(
+ o0,
+ o1,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let value_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(block.argument(0)?.into())],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let value =
+ block.load(context, location, value_ptr, elem_ty)?;
+ drop_overrides_meta.invoke_override(
+ context, &block, location, &info.ty, value,
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
- let valid_block = helper.append_block(Block::new(&[]));
- let invalid_block = helper.append_block(Block::new(&[]));
+ Result::Ok(())
+ };
- entry.append_operation(cf::cond_br(
- context,
- is_valid,
- valid_block,
- invalid_block,
- &[],
- &[],
- location,
- ));
+ let o0 = block.append_op_result(arith::extui(
+ array_start,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::addi(
+ array_start,
+ entry.argument(2)?.into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::extui(
+ o1,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o0 = block.append_op_result(arith::muli(o0, elem_stride, location))?;
+ let o1 = block.append_op_result(arith::muli(o1, elem_stride, location))?;
+ drop_loop(o0, o1)?;
- {
- // Get pointer to first element to pop
+ let o0 = block.append_op_result(arith::addi(o1, elem_stride, location))?;
+ let o1 = block.append_op_result(arith::extui(
+ array_end,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::muli(o1, elem_stride, location))?;
+ drop_loop(o0, o1)?;
+ }
+ _ => {}
+ }
- let popped_ptr = {
- let single_popped_ty =
- registry.build_type(context, helper, registry, metadata, &popped_ctys[0])?;
+ let array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
+ IntegerType::new(context, 8).into(),
+ )?;
+ block.append_operation(ReallocBindingsMeta::free(context, array_ptr, location)?);
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
- let popped_start =
- valid_block.append_op_result(arith::subi(array_end, popped_len_value, location))?;
+ valid_block.append_operation(helper.br(0, &[range_check, value_ptr], location));
+ }
- valid_block.append_op_result(llvm::get_element_ptr_dynamic(
+ {
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
context,
- array_ptr,
- &[popped_start],
- single_popped_ty,
- llvm::r#type::pointer(context, 0),
+ error_block,
location,
- ))?
- };
-
- // Allocate memory for return array
-
- let return_ptr = {
- let null_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
+ &info.signature.param_signatures[1].ty,
+ entry.argument(1)?.into(),
)?;
- valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context,
- null_ptr,
- popped_size_value,
- location,
- )?)?
- };
-
- valid_block.memcpy(context, location, popped_ptr, return_ptr, popped_size_value);
- // Update array end (removing popped elements)
-
- let array = {
- let new_array_end =
- valid_block.append_op_result(arith::subi(array_end, popped_len_value, location))?;
-
- valid_block.insert_value(context, location, array, new_array_end, 2)?
- };
-
- valid_block.append_operation(helper.br(0, &[range_check, array, return_ptr], location));
+ error_block.append_operation(helper.br(1, &[range_check], location));
}
- invalid_block.append_operation(helper.br(1, &[range_check, array], location));
-
Ok(())
}
@@ -3613,39 +4498,61 @@
metadata: &mut MetadataStorage,
info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- let range_check = super::increment_builtin_counter(context, entry, location, entry.arg(0)?)?;
+ // Signature:
+ // Params: RangeCheck, Snapshot<Array<felt252>>, u32, u32
+ // Branches:
+ // 0: RangeCheck, Snapshot<Array<felt252>>
+ // 1: RangeCheck
+ let ptr_ty = llvm::r#type::pointer(context, 0);
let len_ty = IntegerType::new(context, 32).into();
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
+ let self_ty = registry.build_type(
+ context,
+ helper,
+ registry,
+ metadata,
+ &info.signature.param_signatures[1].ty,
+ )?;
+
+ let range_check =
+ super::increment_builtin_counter(context, entry, location, entry.argument(0)?.into())?;
- let array_start = entry.extract_value(context, location, entry.arg(1)?, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, entry.arg(1)?, len_ty, 2)?;
+ let k0 = entry.const_int_from_type(context, location, 0, len_ty)?;
+ let k1 = entry.const_int_from_type(context, location, 1, len_ty)?;
+
+ let array_start =
+ entry.extract_value(context, location, entry.argument(1)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(1)?.into(), len_ty, 2)?;
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let slice_start = entry.arg(2)?;
- let slice_len = entry.arg(3)?;
- let slice_end = entry.addi(slice_start, slice_len, location)?;
+ let slice_start = entry.argument(2)?.into();
+ let slice_len = entry.argument(3)?.into();
+ let slice_end = entry.append_op_result(arith::addi(slice_start, slice_len, location))?;
- let slice_start = entry.addi(array_start, slice_start, location)?;
- let slice_end = entry.addi(array_start, slice_end, location)?;
- let lhs_bound = entry.cmpi(
+ let slice_lhs_bound = entry.append_op_result(arith::cmpi(
context,
- CmpiPredicate::Uge,
+ CmpiPredicate::Ule,
slice_start,
- array_start,
+ array_len,
location,
- )?;
- let rhs_bound = entry.cmpi(context, CmpiPredicate::Ule, slice_end, array_end, location)?;
-
- let is_valid = entry.append_op_result(arith::andi(lhs_bound, rhs_bound, location))?;
+ ))?;
+ let slice_rhs_bound = entry.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ule,
+ slice_end,
+ array_len,
+ location,
+ ))?;
+ let slice_bounds =
+ entry.append_op_result(arith::andi(slice_lhs_bound, slice_rhs_bound, location))?;
- let slice_block = helper.append_block(Block::new(&[]));
+ let valid_block = helper.append_block(Block::new(&[]));
let error_block = helper.append_block(Block::new(&[]));
entry.append_operation(cf::cond_br(
context,
- is_valid,
- slice_block,
+ slice_bounds,
+ valid_block,
error_block,
&[],
&[],
@@ -3653,89 +4560,229 @@
));
{
- let elem_ty = elem_ty.build(context, helper, registry, metadata, &info.ty)?;
+ let (elem_ty, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
+ let elem_stride =
+ valid_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let value = entry.arg(1)?;
- let value = slice_block.insert_value(context, location, value, slice_start, 1)?;
- let value = slice_block.insert_value(context, location, value, slice_end, 2)?;
+ let slice_size = valid_block.append_op_result(arith::extui(
+ slice_len,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let slice_size =
+ valid_block.append_op_result(arith::muli(elem_stride, slice_size, location))?;
+ let slice_size_with_offset = valid_block.append_op_result(arith::addi(
+ slice_size,
+ valid_block.const_int(context, location, calc_refcount_offset(elem_layout), 64)?,
+ location,
+ ))?;
- let elem_stride =
- slice_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let prepare = |value| {
- let value = slice_block.extui(value, IntegerType::new(context, 64).into(), location)?;
- slice_block.muli(value, elem_stride, location)
- };
+ let slice_ptr = valid_block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let slice_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ slice_ptr,
+ slice_size_with_offset,
+ location,
+ )?)?;
+ valid_block.store(context, location, slice_ptr, k1)?;
- let ptr = slice_block.extract_value(
+ let slice_ptr = valid_block.gep(
context,
location,
- entry.arg(1)?,
- llvm::r#type::pointer(context, 0),
- 0,
+ slice_ptr,
+ &[GepIndex::Const(calc_refcount_offset(elem_layout) as i32)],
+ IntegerType::new(context, 8).into(),
)?;
- let make_region = |drop_overrides_meta: &DropOverridesMeta| {
- let region = Region::new();
- let block = region.append_block(Block::new(&[(
- IntegerType::new(context, 64).into(),
- location,
- )]));
- let value_ptr = block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[block.arg(0)?],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
+ let array_ptr =
+ valid_block.extract_value(context, location, entry.argument(1)?.into(), ptr_ty, 0)?;
+ let is_shared = is_shared(context, valid_block, location, array_ptr, elem_layout)?;
- let value = block.load(context, location, value_ptr, elem_ty)?;
- drop_overrides_meta.invoke_override(context, &block, location, &info.ty, value)?;
+ let offset =
+ valid_block.append_op_result(arith::addi(array_start, slice_start, location))?;
+ let offset = valid_block.append_op_result(arith::extui(
+ offset,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let offset = valid_block.append_op_result(arith::muli(offset, elem_stride, location))?;
- block.append_operation(scf::r#yield(&[], location));
- Result::Ok(region)
- };
+ let source_ptr = valid_block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
- let array_start = prepare(array_start)?;
- let array_end = prepare(array_end)?;
- let slice_start = prepare(slice_start)?;
- let slice_end = prepare(slice_end)?;
-
- match metadata.get::<DropOverridesMeta>() {
- Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
- slice_block.append_operation(scf::r#for(
- array_start,
- slice_start,
- elem_stride,
- make_region(drop_overrides_meta)?,
- location,
- ));
- slice_block.append_operation(scf::r#for(
- slice_end,
- array_end,
- elem_stride,
- make_region(drop_overrides_meta)?,
- location,
- ));
- }
- _ => {}
- };
+ valid_block.append_operation(scf::r#if(
+ is_shared,
+ &[],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(&info.ty) => {
+ let k0 = valid_block.const_int(context, location, 0, 64)?;
+ valid_block.append_operation(scf::r#for(
+ k0,
+ slice_size,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let offset = block.argument(0)?.into();
+ let source_ptr = block.gep(
+ context,
+ location,
+ source_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let target_ptr = block.gep(
+ context,
+ location,
+ slice_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let value = block.load(context, location, source_ptr, elem_ty)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, &info.ty, value)?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, target_ptr, values.1)?;
- slice_block.append_operation(helper.br(0, &[range_check, value], location));
- }
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ }
+ _ => block.memcpy(context, location, source_ptr, slice_ptr, slice_size),
+ }
- {
- registry.build_type(
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
+ context,
+ &block,
+ location,
+ &info.signature.param_signatures[1].ty,
+ entry.argument(1)?.into(),
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ block.memcpy(context, location, source_ptr, slice_ptr, slice_size);
+
+ match metadata.get::<DropOverridesMeta>() {
+ Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
+ let drop_loop = |o0, o1| {
+ block.append_operation(scf::r#for(
+ o0,
+ o1,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let value_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(block.argument(0)?.into())],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let value =
+ block.load(context, location, value_ptr, elem_ty)?;
+ drop_overrides_meta.invoke_override(
+ context, &block, location, &info.ty, value,
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+
+ Result::Ok(())
+ };
+
+ let o0 = block.append_op_result(arith::extui(
+ array_start,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::addi(
+ array_start,
+ slice_start,
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::extui(
+ o1,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o0 = block.append_op_result(arith::muli(o0, elem_stride, location))?;
+ let o1 = block.append_op_result(arith::muli(o1, elem_stride, location))?;
+ drop_loop(o0, o1)?;
+
+ let o0 = block.append_op_result(arith::addi(o1, slice_size, location))?;
+ let o1 = block.append_op_result(arith::extui(
+ array_end,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::muli(o1, elem_stride, location))?;
+ drop_loop(o0, o1)?;
+ }
+ _ => {}
+ }
+
+ let array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
+ IntegerType::new(context, 8).into(),
+ )?;
+ block.append_operation(ReallocBindingsMeta::free(context, array_ptr, location)?);
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+
+ let slice_value = valid_block.append_op_result(llvm::undef(self_ty, location))?;
+ let slice_value = valid_block.insert_values(
context,
- helper,
- registry,
- metadata,
- &info.signature.param_signatures[1].ty,
+ location,
+ slice_value,
+ &[slice_ptr, k0, slice_len, slice_len],
)?;
- // The metadata get will never fail because an array always has a drop implementation,
- // which at this point is always inserted thanks to the `build_type()` just above.
- metadata
+ valid_block.append_operation(helper.br(0, &[range_check, slice_value], location));
+ }
+
+ {
+ metadata
.get::<DropOverridesMeta>()
.ok_or(Error::MissingMetadata)?
.invoke_override(
@@ -3743,7 +4790,7 @@
error_block,
location,
&info.signature.param_signatures[1].ty,
- entry.arg(1)?,
+ entry.argument(1)?.into(),
)?;
error_block.append_operation(helper.br(1, &[range_check], location));
@@ -3752,309 +4799,137 @@
Ok(())
}
-/// Generate MLIR operations for the `span_from_tuple` libfunc.
-pub fn build_span_from_tuple<'ctx, 'this>(
+/// Generate MLIR operations for the `array_len` libfunc.
+pub fn build_len<'ctx, 'this>(
context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+ _registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
location: Location<'ctx>,
helper: &LibfuncHelper<'ctx, 'this>,
metadata: &mut MetadataStorage,
info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- // tuple to array span (t,t,t) -> &[t,t,t]
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let struct_type_info = registry.get_type(&info.ty)?;
-
- let struct_ty = registry.build_type(context, helper, registry, metadata, &info.ty)?;
-
- let container: Value = {
- // load box
- entry.load(context, location, entry.arg(0)?, struct_ty)?
- };
- // TODO: Maybe reuse the pointer?
- entry.append_operation(ReallocBindingsMeta::free(context, entry.arg(0)?, location)?);
-
- let fields = struct_type_info.fields().expect("should have fields");
- let (field_ty, field_layout) =
- registry.build_type_with_layout(context, helper, registry, metadata, &fields[0])?;
- let field_stride = field_layout.pad_to_align().size();
-
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.branch_signatures()[0].vars[0].ty,
- )?;
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
-
- let array_len_value = entry.const_int_from_type(context, location, fields.len(), len_ty)?;
-
- let array_container = entry.append_op_result(llvm::undef(array_ty, location))?;
-
- let k0 = entry.const_int_from_type(context, location, 0, len_ty)?;
-
- let array_container = entry.insert_value(context, location, array_container, k0, 1)?;
- let array_container =
- entry.insert_value(context, location, array_container, array_len_value, 2)?;
- let array_container =
- entry.insert_value(context, location, array_container, array_len_value, 3)?;
-
- let ptr = entry
- .append_op_result(ods::llvm::mlir_zero(context, pointer(context, 0), location).into())?;
-
- let field_size: Value = entry.const_int(context, location, field_stride, 64)?;
- let array_len_value_i64 = entry.extui(array_len_value, field_size.r#type(), location)?;
- let total_size = entry.muli(field_size, array_len_value_i64, location)?;
+ let len_ty = IntegerType::new(context, 32).into();
- let ptr = entry.append_op_result(ReallocBindingsMeta::realloc(
- context, ptr, total_size, location,
- )?)?;
+ let array_start =
+ entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 2)?;
- for (i, _) in fields.iter().enumerate() {
- let value: Value = entry.extract_value(context, location, container, field_ty, i)?;
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let target_ptr = entry.append_op_result(llvm::get_element_ptr(
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
context,
- ptr,
- DenseI32ArrayAttribute::new(context, &[i as i32]),
- field_ty,
- pointer(context, 0),
+ entry,
location,
- ))?;
-
- entry.store(context, location, target_ptr, value)?;
- }
-
- let array_container = entry.insert_value(context, location, array_container, ptr, 0)?;
-
- entry.append_operation(helper.br(0, &[array_container], location));
+ &info.signature.param_signatures[0].ty,
+ entry.argument(0)?.into(),
+ )?;
+ entry.append_operation(helper.br(0, &[array_len], location));
Ok(())
}
-fn assert_nonnull<'ctx, 'this>(
+fn calc_refcount_offset(layout: Layout) -> usize {
+ get_integer_layout(32)
+ .align_to(layout.align())
+ .unwrap()
+ .pad_to_align()
+ .size()
+}
+
+fn is_shared<'ctx, 'this>(
context: &'ctx Context,
- entry: &'this Block<'ctx>,
+ block: &'this Block<'ctx>,
location: Location<'ctx>,
- ptr: Value<'ctx, 'this>,
- msg: &str,
-) -> Result<()> {
- let null_ptr =
- entry.append_op_result(ods::llvm::mlir_zero(context, ptr.r#type(), location).into())?;
-
- let ptr_is_not_null = entry.append_op_result(
- ods::llvm::icmp(
+ array_ptr: Value<'ctx, 'this>,
+ elem_layout: Layout,
+) -> Result<Value<'ctx, 'this>> {
+ let k0 = block.const_int(context, location, 0, 64)?;
+ let ptr_as_int = block.append_op_result(
+ ods::llvm::ptrtoint(
context,
- IntegerType::new(context, 1).into(),
- ptr,
- null_ptr,
- IntegerAttribute::new(IntegerType::new(context, 64).into(), 1).into(),
+ IntegerType::new(context, 64).into(),
+ array_ptr,
location,
)
.into(),
)?;
-
- entry.append_operation(cf::assert(context, ptr_is_not_null, msg, location));
- Ok(())
-}
-
-pub fn build_tuple_from_span<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- // Tasks:
- // - Check if sizes match.
- // - If they do not match, jump to branch [1].
- // - If they do match:
- // - If start == 0 && capacity == len -> reuse the pointer
- // - Otherwise, realloc + memcpy + free.
-
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let array_ty = registry.get_type(&info.signature.param_signatures[0].ty)?;
- let (elem_id, elem_ty) = match array_ty {
- CoreTypeConcrete::Array(info) => (&info.ty, registry.get_type(&info.ty)?),
- CoreTypeConcrete::Snapshot(info) => match registry.get_type(&info.ty)? {
- CoreTypeConcrete::Array(info) => (&info.ty, registry.get_type(&info.ty)?),
- _ => native_panic!(
- "matched an unexpected CoreTypeConcrete that is not a Array or Snapshot"
- ),
- },
- _ => {
- native_panic!("matched an unexpected CoreTypeConcrete that is not a Array or Snapshot")
- }
- };
- let elem_layout = elem_ty.layout(registry)?;
-
- let array_start = entry.extract_value(
- context,
- location,
- entry.arg(0)?,
- IntegerType::new(context, 32).into(),
- 1,
- )?;
- let array_end = entry.extract_value(
- context,
- location,
- entry.arg(0)?,
- IntegerType::new(context, 32).into(),
- 2,
- )?;
-
- let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let (tuple_len, tuple_len_val) = {
- let fields = registry
- .get_type(&info.ty)?
- .fields()
- .to_native_assert_error("missing field")?;
-
- native_assert!(
- fields.iter().all(|f| f.id == elem_id.id),
- "all the elements of the array must have the same type"
- );
-
- (
- entry.const_int(context, location, fields.len(), 32)?,
- fields.len(),
- )
- };
-
- let len_matches = entry.cmpi(context, CmpiPredicate::Eq, array_len, tuple_len, location)?;
-
- let block_ok = helper.append_block(Block::new(&[]));
- let block_err = helper.append_block(Block::new(&[]));
- entry.append_operation(cf::cond_br(
+ let ptr_is_null = block.append_op_result(arith::cmpi(
context,
- len_matches,
- block_ok,
- block_err,
- &[],
- &[],
+ CmpiPredicate::Eq,
+ ptr_as_int,
+ k0,
location,
- ));
-
- {
- let k0 = block_ok.const_int(context, location, 0, 32)?;
- let starts_at_zero =
- block_ok.cmpi(context, CmpiPredicate::Eq, array_start, k0, location)?;
-
- let array_cap = block_ok.extract_value(
- context,
- location,
- entry.arg(0)?,
- IntegerType::new(context, 32).into(),
- 3,
- )?;
- let capacity_matches =
- block_ok.cmpi(context, CmpiPredicate::Eq, array_cap, tuple_len, location)?;
+ ))?;
- let array_ptr = block_ok.extract_value(
- context,
- location,
- entry.arg(0)?,
- llvm::r#type::pointer(context, 0),
- 0,
- )?;
- let should_forward_pointer =
- block_ok.append_op_result(arith::andi(starts_at_zero, capacity_matches, location))?;
+ let is_shared = block.append_op_result(scf::r#if(
+ ptr_is_null,
+ &[IntegerType::new(context, 1).into()],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let block_clone = helper.append_block(Block::new(&[]));
- let block_forward = helper.append_block(Block::new(&[]));
- block_ok.append_operation(cf::cond_br(
- context,
- should_forward_pointer,
- block_forward,
- block_clone,
- &[],
- &[],
- location,
- ));
+ let k0 = block.const_int(context, location, 0, 1)?;
+ block.append_operation(scf::r#yield(&[k0], location));
+ region
+ },
{
- let elem_stride =
- block_clone.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let tuple_len =
- block_clone.extui(tuple_len, IntegerType::new(context, 64).into(), location)?;
- let tuple_len = block_clone.muli(tuple_len, elem_stride, location)?;
-
- let box_ptr = block_clone
- .append_op_result(llvm::zero(llvm::r#type::pointer(context, 0), location))?;
- let box_ptr = block_clone.append_op_result(ReallocBindingsMeta::realloc(
- context, box_ptr, tuple_len, location,
- )?)?;
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let elem_offset =
- block_clone.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let elem_offset = block_clone.muli(elem_offset, elem_stride, location)?;
- let elem_ptr = block_clone.append_op_result(llvm::get_element_ptr_dynamic(
+ let array_ptr = block.gep(
context,
+ location,
array_ptr,
- &[elem_offset],
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
+ )?;
+ let ref_count = block.load(
+ context,
location,
- ))?;
+ array_ptr,
+ IntegerType::new(context, 32).into(),
+ )?;
- block_clone.append_operation(
- ods::llvm::intr_memcpy_inline(
+ #[cfg(debug_assertions)]
+ {
+ let k0 = block.const_int(context, location, 0, 32)?;
+ let is_nonzero = block.append_op_result(arith::cmpi(
context,
- box_ptr,
- elem_ptr,
- IntegerAttribute::new(
- IntegerType::new(context, 64).into(),
- (tuple_len_val * elem_layout.pad_to_align().size()) as i64,
- ),
- IntegerAttribute::new(IntegerType::new(context, 1).into(), 0),
+ CmpiPredicate::Ne,
+ ref_count,
+ k0,
location,
- )
- .into(),
- );
-
- block_clone.append_operation(ReallocBindingsMeta::free(context, array_ptr, location)?);
- block_clone.append_operation(helper.br(0, &[box_ptr], location));
- }
+ ))?;
- block_forward.append_operation(helper.br(0, &[array_ptr], location));
- }
-
- {
- registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.signature.param_signatures[0].ty,
- )?;
+ block.append_operation(cf::assert(
+ context,
+ is_nonzero,
+ "ref_count must not be zero",
+ location,
+ ));
+ }
- // The metadata get will never fail because an array always has a drop implementation,
- // which at this point is always inserted thanks to the `build_type()` just above.
- metadata
- .get::<DropOverridesMeta>()
- .ok_or(Error::MissingMetadata)?
- .invoke_override(
+ let k1 = block.const_int(context, location, 1, 32)?;
+ let is_shared = block.append_op_result(arith::cmpi(
context,
- block_err,
+ CmpiPredicate::Ne,
+ ref_count,
+ k1,
location,
- &info.signature.param_signatures[0].ty,
- entry.arg(0)?,
- )?;
+ ))?;
- block_err.append_operation(helper.br(1, &[], location));
- }
+ block.append_operation(scf::r#yield(&[is_shared], location));
+ region
+ },
+ location,
+ ))?;
- Ok(())
+ Ok(is_shared)
}
#[cfg(test)]
@@ -4365,7 +5240,6 @@
//data.append(5_u32);
*slice.get(0).unwrap().unbox()
}
-
);
let result = run_program(&program, "run_test", &[]).return_value;
diff --git a/src/cairo_native/metadata/debug_utils.rs.html b/src/cairo_native/metadata/debug_utils.rs.html
index ca4f3df8a..343e1c931 100644
--- a/src/cairo_native/metadata/debug_utils.rs.html
+++ b/src/cairo_native/metadata/debug_utils.rs.html
@@ -1563,7 +1563,7 @@
unsafe extern "C" fn dump_mem_impl(ptr: *const (), len: u64) {
println!("[DEBUG] Memory dump at {ptr:?}:");
for chunk in (0..len).step_by(8) {
- print!(" {ptr:?}:");
+ print!(" {:?}:", ptr.byte_add(chunk as usize));
for offset in chunk..chunk + 8 {
print!(" {:02x}", ptr.byte_add(offset as usize).cast::<u8>().read());
}
diff --git a/src/cairo_native/starknet.rs.html b/src/cairo_native/starknet.rs.html
index 4725ec488..b936c8a27 100644
--- a/src/cairo_native/starknet.rs.html
+++ b/src/cairo_native/starknet.rs.html
@@ -1703,6 +1703,33 @@
1703
1704
1705
+1706
+1707
+1708
+1709
+1710
+1711
+1712
+1713
+1714
+1715
+1716
+1717
+1718
+1719
+1720
+1721
+1722
+1723
+1724
+1725
+1726
+1727
+1728
+1729
+1730
+1731
+1732
//! Starknet related code for `cairo_native`
use serde::{Deserialize, Serialize};
@@ -2245,12 +2272,11 @@
// TODO: Move to the correct place or remove if unused.
pub(crate) mod handler {
use super::*;
- use crate::utils::{libc_free, libc_malloc};
+ use crate::utils::{get_integer_layout, libc_free, libc_malloc};
use std::{
alloc::Layout,
- ffi::c_void,
fmt::Debug,
- mem::{size_of, ManuallyDrop, MaybeUninit},
+ mem::{self, size_of, ManuallyDrop, MaybeUninit},
ptr::{null_mut, NonNull},
};
@@ -2614,7 +2640,17 @@
capacity: 0,
},
_ => {
- let ptr = libc_malloc(Layout::array::<E>(data.len()).unwrap().size()) as *mut E;
+ let refcount_offset = get_integer_layout(32)
+ .align_to(mem::align_of::<E>())
+ .unwrap()
+ .pad_to_align()
+ .size();
+ let ptr = libc_malloc(
+ Layout::array::<E>(data.len()).unwrap().size() + refcount_offset,
+ ) as *mut E;
+
+ ptr.cast::<u32>().write(1);
+ let ptr = ptr.byte_add(refcount_offset);
let len: u32 = data.len().try_into().unwrap();
for (i, val) in data.iter().enumerate() {
@@ -2631,6 +2667,24 @@
}
}
+ unsafe fn drop_mlir_array<E>(data: &ArrayAbi<E>) {
+ if data.ptr.is_null() {
+ return;
+ }
+
+ let refcount_offset = get_integer_layout(32)
+ .align_to(mem::align_of::<E>())
+ .unwrap()
+ .pad_to_align()
+ .size();
+
+ let ptr = data.ptr.byte_sub(refcount_offset);
+ match ptr.cast::<u32>().read() {
+ 1 => libc_free(ptr.cast()),
+ n => ptr.cast::<u32>().write(n - 1),
+ }
+ }
+
fn wrap_error<E>(e: &[Felt]) -> SyscallResultAbi<E> {
SyscallResultAbi {
err: ManuallyDrop::new(SyscallResultAbiErr {
@@ -2673,7 +2727,7 @@
let input_vec: Vec<_> = input.into();
unsafe {
- libc_free(input.ptr as *mut c_void);
+ Self::drop_mlir_array(input);
}
let result = ptr
@@ -2860,7 +2914,7 @@
let calldata_vec: Vec<_> = calldata.into();
unsafe {
- libc_free(calldata.ptr as *mut c_void);
+ Self::drop_mlir_array(calldata);
}
let result = ptr.deploy(
@@ -2920,7 +2974,7 @@
let calldata_vec: Vec<Felt> = calldata.into();
unsafe {
- libc_free(calldata.ptr as *mut c_void);
+ Self::drop_mlir_array(calldata);
}
let result = ptr.library_call(class_hash, function_selector, &calldata_vec, gas);
@@ -2954,7 +3008,7 @@
let calldata_vec: Vec<Felt> = calldata.into();
unsafe {
- libc_free(calldata.ptr as *mut c_void);
+ Self::drop_mlir_array(calldata);
}
let result = ptr.call_contract(address, entry_point_selector, &calldata_vec, gas);
@@ -3028,13 +3082,13 @@
let keys_vec: Vec<_> = keys.into();
unsafe {
- libc_free(keys.ptr as *mut c_void);
+ Self::drop_mlir_array(keys);
}
let data_vec: Vec<_> = data.into();
unsafe {
- libc_free(data.ptr as *mut c_void);
+ Self::drop_mlir_array(data);
}
let result = ptr.emit_event(&keys_vec, &data_vec, gas);
@@ -3061,7 +3115,7 @@
let payload_vec: Vec<_> = payload.into();
unsafe {
- libc_free(payload.ptr as *mut c_void);
+ Self::drop_mlir_array(payload);
}
let result = ptr.send_message_to_l1(to_address, &payload_vec, gas);
@@ -3096,7 +3150,7 @@
let result = ptr.keccak(input_vec, gas);
unsafe {
- libc_free(input.ptr as *mut c_void);
+ Self::drop_mlir_array(input);
}
*result_ptr = match result {
diff --git a/src/cairo_native/types.rs.html b/src/cairo_native/types.rs.html
index b080dc46b..87b16786e 100644
--- a/src/cairo_native/types.rs.html
+++ b/src/cairo_native/types.rs.html
@@ -1011,16 +1011,6 @@
1011
1012
1013
-1014
-1015
-1016
-1017
-1018
-1019
-1020
-1021
-1022
-1023
impl<T> CloneToUninit for Twhere
diff --git a/cairo_native/starknet/constant.SYSCALL_HANDLER_VTABLE.html b/cairo_native/starknet/constant.SYSCALL_HANDLER_VTABLE.html
index 827698b82..20aa63d89 100644
--- a/cairo_native/starknet/constant.SYSCALL_HANDLER_VTABLE.html
+++ b/cairo_native/starknet/constant.SYSCALL_HANDLER_VTABLE.html
@@ -1 +1 @@
-SYSCALL_HANDLER_VTABLE in cairo_native::starknet - Rust Constant cairo_native::starknet::SYSCALL_HANDLER_VTABLE
source · pub const SYSCALL_HANDLER_VTABLE: LocalKey<Cell<*mut ()>>;
SYSCALL_HANDLER_VTABLE in cairo_native::starknet - Rust Constant cairo_native::starknet::SYSCALL_HANDLER_VTABLE
source · pub const SYSCALL_HANDLER_VTABLE: LocalKey<Cell<*mut ()>>;
cairo_native__vtable_cheatcode in cairo_native::starknet - Rust Function cairo_native::starknet::cairo_native__vtable_cheatcode
source · pub extern "C" fn cairo_native__vtable_cheatcode(
+cairo_native__vtable_cheatcode in cairo_native::starknet - Rust Function cairo_native::starknet::cairo_native__vtable_cheatcode
source · pub extern "C" fn cairo_native__vtable_cheatcode(
result_ptr: &mut ArrayAbi<Felt252Abi>,
selector: &Felt252Abi,
input: &ArrayAbi<Felt252Abi>,
diff --git a/cairo_native/starknet/index.html b/cairo_native/starknet/index.html
index 494cb1417..81181e74c 100644
--- a/cairo_native/starknet/index.html
+++ b/cairo_native/starknet/index.html
@@ -1,2 +1,2 @@
-cairo_native::starknet - Rust Module cairo_native::starknet
source · Expand description
Starknet related code for cairo_native
+cairo_native::starknet - Rust Help Rustdoc help
BackHelp Rustdoc help
BackSettings Rustdoc settings
BackSettings Rustdoc settings
Back//! # Implementations of `AbiArgument` for the `x86_64` architecture.
//!
//! The x86_64 architecture uses 6 64-bit registers for arguments. This means that the first 48
@@ -271,93 +232,55 @@
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(())
}
@@ -365,9 +288,6 @@
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(())
}
@@ -378,6 +298,7 @@
if buffer.len() >= 40 {
align_to(buffer, get_integer_layout(128).align());
}
+
buffer.extend_from_slice(&self.to_ne_bytes());
Ok(())
}
@@ -388,6 +309,7 @@
if buffer.len() >= 40 {
align_to(buffer, get_integer_layout(128).align());
}
+
buffer.extend_from_slice(&self.to_ne_bytes());
Ok(())
}
@@ -415,13 +337,13 @@
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(())
}
}
diff --git a/src/cairo_native/executor.rs.html b/src/cairo_native/executor.rs.html
index 79b0e4508..73a2f1b74 100644
--- a/src/cairo_native/executor.rs.html
+++ b/src/cairo_native/executor.rs.html
@@ -766,6 +766,8 @@
766
767
768
+769
+770
//! # Executors
//!
//! This module provides methods to execute the programs, either via JIT or compiled ahead
@@ -1119,7 +1121,6 @@
#[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 {
@@ -1141,11 +1142,12 @@
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)
},
@@ -1153,6 +1155,7 @@
return_ptr.to_native_assert_error("return pointer should be valid")?,
type_id,
registry,
+ true,
)?),
CoreTypeConcrete::Felt252(_)
| CoreTypeConcrete::StarkNet(
@@ -1161,7 +1164,7 @@
| 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,
@@ -1180,7 +1183,7 @@
}
},
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,
@@ -1195,7 +1198,7 @@
}
},
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])
@@ -1267,7 +1270,7 @@
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)
}
@@ -1323,7 +1326,7 @@
}
};
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(
@@ -1338,27 +1341,28 @@
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) => {
diff --git a/src/cairo_native/executor/contract.rs.html b/src/cairo_native/executor/contract.rs.html
index 67b25e846..2ccbbdc54 100644
--- a/src/cairo_native/executor/contract.rs.html
+++ b/src/cairo_native/executor/contract.rs.html
@@ -831,6 +831,24 @@
831
832
833
+834
+835
+836
+837
+838
+839
+840
+841
+842
+843
+844
+845
+846
+847
+848
+849
+850
+851
//! A specialized executor for Starknet contracts, avoiding the overhead of storing the sierra program registry and
//! enabling efficient serialization of the program/data once compiled.
//!
@@ -867,7 +885,7 @@
use crate::{
arch::AbiArgument,
context::NativeContext,
- error::{panic::ToNativeAssertError, Error},
+ error::{panic::ToNativeAssertError, Error, Result},
execution_result::{BuiltinStats, ContractExecutionResult},
executor::invoke_trampoline,
metadata::gas::MetadataComputationConfig,
@@ -979,7 +997,7 @@
sierra_program: &Program,
entry_points: &ContractEntryPoints,
opt_level: OptLevel,
- ) -> Result<Self, Error> {
+ ) -> Result<Self> {
let native_context = NativeContext::new();
let mut entry_point_selector_to_id = BTreeMap::new();
@@ -1094,7 +1112,7 @@
}
/// Save the library to the desired path, alongside it is saved also a json file with additional info.
- pub fn save(&mut self, to: impl AsRef<Path>) -> Result<(), Error> {
+ pub fn save(&mut self, to: impl AsRef<Path>) -> Result<()> {
let to = to.as_ref();
std::fs::copy(&self.path, to)?;
@@ -1109,7 +1127,7 @@
}
/// Load the executor from an already compiled library with the additional info json file.
- pub fn load(library_path: &Path) -> Result<Self, Error> {
+ pub fn load(library_path: &Path) -> Result<Self> {
let info_str = std::fs::read_to_string(library_path.with_extension("json"))?;
let contract_info: NativeContractInfo = serde_json::from_str(&info_str)?;
Ok(Self {
@@ -1136,7 +1154,7 @@
gas: u64,
builtin_costs: Option<BuiltinCosts>,
mut syscall_handler: impl StarknetSyscallHandler,
- ) -> Result<ContractExecutionResult, Error> {
+ ) -> Result<ContractExecutionResult> {
let arena = Bump::new();
let mut invoke_data = Vec::<u8>::new();
@@ -1150,12 +1168,7 @@
};
let function_ptr = self.find_function_ptr(&function_id, true)?;
- let builtin_costs = builtin_costs.unwrap_or_default();
- let builtin_costs_stack: [u64; 7] = builtin_costs.into();
- // Note: the ptr into a slice is valid, it can be used with cast()
- // Care should be taken if you dereference it and take the .as_ptr() of the slice, since when you
- // deref it, it will be a copy on the stack, so you will get the ptr of the value in the stack.
- let builtin_costs: *mut [u64; 7] = Box::into_raw(Box::new(builtin_costs_stack));
+ let builtin_costs: [u64; 7] = builtin_costs.unwrap_or_default().into();
let set_costs_builtin = unsafe {
self.library
.get::<extern "C" fn(*const u64) -> *const u64>(
@@ -1163,7 +1176,7 @@
)?
};
// We may be inside a recursive contract, save the possible saved builtin costs to restore it after our call.
- let old_builtincosts_ptr = set_costs_builtin(builtin_costs.cast());
+ let old_builtincosts_ptr = set_costs_builtin(builtin_costs.as_ptr());
// it can vary from contract to contract thats why we need to store/ load it.
let builtins_size: usize = self.contract_info.entry_points_info[&function_id.id]
@@ -1189,7 +1202,7 @@
}
BuiltinType::BuiltinCosts => {
// todo: check if valid
- builtin_costs_stack.as_ptr().to_bytes(&mut invoke_data)?;
+ builtin_costs.as_ptr().to_bytes(&mut invoke_data)?;
}
BuiltinType::System => {
(&mut syscall_handler as *mut StarknetSyscallHandlerCallbacks<_>)
@@ -1202,18 +1215,42 @@
}
let felt_layout = get_integer_layout(252).pad_to_align();
- let ptr: *mut () = unsafe { libc_malloc(felt_layout.size() * args.len()).cast() };
+ let refcount_offset = get_integer_layout(32)
+ .align_to(felt_layout.align())
+ .unwrap()
+ .pad_to_align()
+ .size();
+
+ let ptr = match args.len() {
+ 0 => std::ptr::null_mut(),
+ _ => unsafe {
+ let ptr: *mut () =
+ libc_malloc(felt_layout.size() * args.len() + refcount_offset).cast();
+
+ // Write reference count.
+ ptr.cast::<u32>().write(1);
+ ptr.byte_add(refcount_offset)
+ },
+ };
let len: u32 = args
.len()
.try_into()
.to_native_assert_error("number of arguments should fit into a u32")?;
ptr.to_bytes(&mut invoke_data)?;
- 0u32.to_bytes(&mut invoke_data)?; // start
- len.to_bytes(&mut invoke_data)?; // end
- len.to_bytes(&mut invoke_data)?; // cap
+ if cfg!(target_arch = "aarch64") {
+ 0u32.to_bytes(&mut invoke_data)?; // start
+ len.to_bytes(&mut invoke_data)?; // end
+ len.to_bytes(&mut invoke_data)?; // cap
+ } else if cfg!(target_arch = "x86_64") {
+ (0u32 as u64).to_bytes(&mut invoke_data)?; // start
+ (len as u64).to_bytes(&mut invoke_data)?; // end
+ (len as u64).to_bytes(&mut invoke_data)?; // cap
+ } else {
+ unreachable!("unsupported architecture");
+ }
- for (idx, elem) in args.iter().enumerate() {
+ for (idx, elem) in args.iter().enumerate() {
let f = elem.to_bytes_le();
unsafe {
std::ptr::copy_nonoverlapping(
@@ -1354,7 +1391,12 @@
}
if !array_ptr.is_null() {
- unsafe { libc_free(array_ptr.cast()) };
+ unsafe {
+ let ptr = array_ptr.byte_sub(refcount_offset);
+ assert_eq!(ptr.cast::<u32>().read(), 1);
+
+ libc_free(ptr.cast());
+ }
}
let error_msg = if tag != 0 {
@@ -1371,14 +1413,8 @@
None
};
- // Restore the old ptr and get back our builtincost box and free it.
- let our_builtincosts_ptr = set_costs_builtin(old_builtincosts_ptr);
-
- if !our_builtincosts_ptr.is_null() && old_builtincosts_ptr.is_aligned() {
- unsafe {
- let _ = Box::<[u64; 7]>::from_raw(our_builtincosts_ptr.cast_mut().cast());
- };
- }
+ // Restore the original builtin costs pointer.
+ set_costs_builtin(old_builtincosts_ptr);
#[cfg(feature = "with-mem-tracing")]
crate::utils::mem_tracing::report_stats();
@@ -1395,7 +1431,7 @@
&self,
function_id: &FunctionId,
is_for_contract_executor: bool,
- ) -> Result<*mut c_void, Error> {
+ ) -> Result<*mut c_void> {
let function_name = generate_function_name(function_id, is_for_contract_executor);
let function_name = format!("_mlir_ciface_{function_name}");
diff --git a/src/cairo_native/libfuncs.rs.html b/src/cairo_native/libfuncs.rs.html
index e8fb9dcdb..78455dd94 100644
--- a/src/cairo_native/libfuncs.rs.html
+++ b/src/cairo_native/libfuncs.rs.html
@@ -632,9 +632,9 @@
Self::Const(selector) => self::r#const::build(
context, registry, entry, location, helper, metadata, selector,
),
- Self::Coupon(info) => {
- self::coupon::build(context, registry, entry, location, helper, metadata, info)
- }
+ Self::Coupon(selector) => self::coupon::build(
+ context, registry, entry, location, helper, metadata, selector,
+ ),
Self::CouponCall(info) => self::function_call::build(
context, registry, entry, location, helper, metadata, info,
),
diff --git a/src/cairo_native/libfuncs/array.rs.html b/src/cairo_native/libfuncs/array.rs.html
index c7616528f..070d7878a 100644
--- a/src/cairo_native/libfuncs/array.rs.html
+++ b/src/cairo_native/libfuncs/array.rs.html
@@ -2513,44 +2513,474 @@
2513
2514
2515
+2516
+2517
+2518
+2519
+2520
+2521
+2522
+2523
+2524
+2525
+2526
+2527
+2528
+2529
+2530
+2531
+2532
+2533
+2534
+2535
+2536
+2537
+2538
+2539
+2540
+2541
+2542
+2543
+2544
+2545
+2546
+2547
+2548
+2549
+2550
+2551
+2552
+2553
+2554
+2555
+2556
+2557
+2558
+2559
+2560
+2561
+2562
+2563
+2564
+2565
+2566
+2567
+2568
+2569
+2570
+2571
+2572
+2573
+2574
+2575
+2576
+2577
+2578
+2579
+2580
+2581
+2582
+2583
+2584
+2585
+2586
+2587
+2588
+2589
+2590
+2591
+2592
+2593
+2594
+2595
+2596
+2597
+2598
+2599
+2600
+2601
+2602
+2603
+2604
+2605
+2606
+2607
+2608
+2609
+2610
+2611
+2612
+2613
+2614
+2615
+2616
+2617
+2618
+2619
+2620
+2621
+2622
+2623
+2624
+2625
+2626
+2627
+2628
+2629
+2630
+2631
+2632
+2633
+2634
+2635
+2636
+2637
+2638
+2639
+2640
+2641
+2642
+2643
+2644
+2645
+2646
+2647
+2648
+2649
+2650
+2651
+2652
+2653
+2654
+2655
+2656
+2657
+2658
+2659
+2660
+2661
+2662
+2663
+2664
+2665
+2666
+2667
+2668
+2669
+2670
+2671
+2672
+2673
+2674
+2675
+2676
+2677
+2678
+2679
+2680
+2681
+2682
+2683
+2684
+2685
+2686
+2687
+2688
+2689
+2690
+2691
+2692
+2693
+2694
+2695
+2696
+2697
+2698
+2699
+2700
+2701
+2702
+2703
+2704
+2705
+2706
+2707
+2708
+2709
+2710
+2711
+2712
+2713
+2714
+2715
+2716
+2717
+2718
+2719
+2720
+2721
+2722
+2723
+2724
+2725
+2726
+2727
+2728
+2729
+2730
+2731
+2732
+2733
+2734
+2735
+2736
+2737
+2738
+2739
+2740
+2741
+2742
+2743
+2744
+2745
+2746
+2747
+2748
+2749
+2750
+2751
+2752
+2753
+2754
+2755
+2756
+2757
+2758
+2759
+2760
+2761
+2762
+2763
+2764
+2765
+2766
+2767
+2768
+2769
+2770
+2771
+2772
+2773
+2774
+2775
+2776
+2777
+2778
+2779
+2780
+2781
+2782
+2783
+2784
+2785
+2786
+2787
+2788
+2789
+2790
+2791
+2792
+2793
+2794
+2795
+2796
+2797
+2798
+2799
+2800
+2801
+2802
+2803
+2804
+2805
+2806
+2807
+2808
+2809
+2810
+2811
+2812
+2813
+2814
+2815
+2816
+2817
+2818
+2819
+2820
+2821
+2822
+2823
+2824
+2825
+2826
+2827
+2828
+2829
+2830
+2831
+2832
+2833
+2834
+2835
+2836
+2837
+2838
+2839
+2840
+2841
+2842
+2843
+2844
+2845
+2846
+2847
+2848
+2849
+2850
+2851
+2852
+2853
+2854
+2855
+2856
+2857
+2858
+2859
+2860
+2861
+2862
+2863
+2864
+2865
+2866
+2867
+2868
+2869
+2870
+2871
+2872
+2873
+2874
+2875
+2876
+2877
+2878
+2879
+2880
+2881
+2882
+2883
+2884
+2885
+2886
+2887
+2888
+2889
+2890
+2891
+2892
+2893
+2894
+2895
+2896
+2897
+2898
+2899
+2900
+2901
+2902
+2903
+2904
+2905
+2906
+2907
+2908
+2909
+2910
+2911
+2912
+2913
+2914
+2915
+2916
+2917
+2918
+2919
+2920
+2921
+2922
+2923
+2924
+2925
+2926
+2927
+2928
+2929
+2930
+2931
+2932
+2933
+2934
+2935
+2936
+2937
+2938
+2939
+2940
+2941
+2942
+2943
+2944
+2945
+2946
+2947
+2948
+2949
+2950
+2951
+2952
//! # Array libfuncs
-// TODO: A future possible improvement would be to put the array behind a double pointer and a
-// reference counter, to avoid unnecessary clones.
-
use super::LibfuncHelper;
use crate::{
- error::{panic::ToNativeAssertError, Error, Result},
+ error::{Error, Result, SierraAssertError},
metadata::{
- drop_overrides::DropOverridesMeta, realloc_bindings::ReallocBindingsMeta, MetadataStorage,
+ drop_overrides::DropOverridesMeta, dup_overrides::DupOverridesMeta,
+ realloc_bindings::ReallocBindingsMeta, MetadataStorage,
},
- native_assert, native_panic,
- types::TypeBuilder,
- utils::{BlockExt, GepIndex, ProgramRegistryExt},
+ utils::{get_integer_layout, BlockExt, GepIndex, ProgramRegistryExt},
};
use cairo_lang_sierra::{
extensions::{
array::{ArrayConcreteLibfunc, ConcreteMultiPopLibfunc},
core::{CoreLibfunc, CoreType, CoreTypeConcrete},
lib_func::{SignatureAndTypeConcreteLibfunc, SignatureOnlyConcreteLibfunc},
- ConcreteLibfunc,
+ types::InfoAndTypeConcreteType,
},
program_registry::ProgramRegistry,
};
use melior::{
dialect::{
arith::{self, CmpiPredicate},
- cf,
- llvm::{self, r#type::pointer},
- ods, scf,
+ cf, llvm, ods, scf,
},
ir::{
- attribute::{DenseI32ArrayAttribute, IntegerAttribute},
- r#type::IntegerType,
- Block, Location, Region, Value, ValueLike,
+ attribute::IntegerAttribute, r#type::IntegerType, Block, Location, Region, Value, ValueLike,
},
Context,
};
+use std::alloc::Layout;
/// Select and call the correct libfunc builder function from the selector.
pub fn build<'ctx, 'this>(
@@ -2566,15 +2996,33 @@
ArrayConcreteLibfunc::New(info) => {
build_new(context, registry, entry, location, helper, metadata, info)
}
- ArrayConcreteLibfunc::Append(info) => {
- build_append(context, registry, entry, location, helper, metadata, info)
+ ArrayConcreteLibfunc::SpanFromTuple(info) => {
+ build_span_from_tuple(context, registry, entry, location, helper, metadata, info)
}
- ArrayConcreteLibfunc::PopFront(info) => {
- build_pop_front(context, registry, entry, location, helper, metadata, info)
+ ArrayConcreteLibfunc::TupleFromSpan(info) => {
+ build_tuple_from_span(context, registry, entry, location, helper, metadata, info)
}
- ArrayConcreteLibfunc::PopFrontConsume(info) => {
- build_pop_front_consume(context, registry, entry, location, helper, metadata, info)
+ ArrayConcreteLibfunc::Append(info) => {
+ build_append(context, registry, entry, location, helper, metadata, info)
}
+ ArrayConcreteLibfunc::PopFront(info) => build_pop::<false, false>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Single(info),
+ ),
+ ArrayConcreteLibfunc::PopFrontConsume(info) => build_pop::<true, false>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Single(info),
+ ),
ArrayConcreteLibfunc::Get(info) => {
build_get(context, registry, entry, location, helper, metadata, info)
}
@@ -2584,23 +3032,41 @@
ArrayConcreteLibfunc::Len(info) => {
build_len(context, registry, entry, location, helper, metadata, info)
}
- ArrayConcreteLibfunc::SnapshotPopFront(info) => {
- build_snapshot_pop_front(context, registry, entry, location, helper, metadata, info)
- }
- ArrayConcreteLibfunc::SnapshotPopBack(info) => {
- build_snapshot_pop_back(context, registry, entry, location, helper, metadata, info)
- }
- ArrayConcreteLibfunc::SpanFromTuple(info) => {
- build_span_from_tuple(context, registry, entry, location, helper, metadata, info)
- }
- ArrayConcreteLibfunc::TupleFromSpan(info) => {
- build_tuple_from_span(context, registry, entry, location, helper, metadata, info)
- }
- ArrayConcreteLibfunc::SnapshotMultiPopFront(info) => build_snapshot_multi_pop_front(
- context, registry, entry, location, helper, metadata, info,
+ ArrayConcreteLibfunc::SnapshotPopFront(info) => build_pop::<false, false>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Single(info),
+ ),
+ ArrayConcreteLibfunc::SnapshotPopBack(info) => build_pop::<false, true>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Single(info),
),
- ArrayConcreteLibfunc::SnapshotMultiPopBack(info) => build_snapshot_multi_pop_back(
- context, registry, entry, location, helper, metadata, info,
+ ArrayConcreteLibfunc::SnapshotMultiPopFront(info) => build_pop::<false, false>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Multi(info),
+ ),
+ ArrayConcreteLibfunc::SnapshotMultiPopBack(info) => build_pop::<false, true>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Multi(info),
),
}
}
@@ -2608,37 +3074,33 @@
/// Generate MLIR operations for the `array_new` libfunc.
pub fn build_new<'ctx, 'this>(
context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+ _registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
location: Location<'ctx>,
helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureOnlyConcreteLibfunc,
+ _metadata: &mut MetadataStorage,
+ _info: &SignatureOnlyConcreteLibfunc,
) -> Result<()> {
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.branch_signatures()[0].vars[0].ty,
- )?;
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
- let ptr = entry
- .append_op_result(ods::llvm::mlir_zero(context, pointer(context, 0), location).into())?;
+ let nullptr = entry.append_op_result(llvm::zero(ptr_ty, location))?;
+ let k0 = entry.const_int_from_type(context, location, 0, len_ty)?;
- let k0 = entry.const_int(context, location, 0, 32)?;
- let value = entry.append_op_result(llvm::undef(array_ty, location))?;
- let value = entry.insert_value(context, location, value, ptr, 0)?;
- let value = entry.insert_value(context, location, value, k0, 1)?;
- let value = entry.insert_value(context, location, value, k0, 2)?;
- let value = entry.insert_value(context, location, value, k0, 3)?;
+ let value = entry.append_op_result(llvm::undef(
+ llvm::r#type::r#struct(context, &[ptr_ty, len_ty, len_ty, len_ty], false),
+ location,
+ ))?;
+ let value = entry.insert_values(context, location, value, &[nullptr, k0, k0, k0])?;
entry.append_operation(helper.br(0, &[value], location));
Ok(())
}
-/// Generate MLIR operations for the `array_append` libfunc.
-pub fn build_append<'ctx, 'this>(
+/// Generate MLIR operations for the `span_from_tuple` libfunc.
+///
+/// Note: The `&info.ty` field has the entire `[T; N]` tuple. It is not the `T` in `Array<T>`.
+pub fn build_span_from_tuple<'ctx, 'this>(
context: &'ctx Context,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
@@ -2647,237 +3109,264 @@
metadata: &mut MetadataStorage,
info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- // Algorithm:
- // - If array_end < capacity, then append.
- // - If array_end == capacity:
- // - If array_start == 0: realloc, then append.
- // - If array_start != 0: memmove, then append.
-
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
+ metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ let tuple_len = {
+ let CoreTypeConcrete::Struct(info) = registry.get_type(&info.ty)? else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ info.members.len()
+ };
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
- let elem_stride = elem_layout.pad_to_align().size();
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
+ let (_, tuple_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
- let k1 = entry.const_int(context, location, 1, 32)?;
+ let array_len_bytes = tuple_layout.pad_to_align().size();
+ let array_len_bytes_with_offset = entry.const_int(
+ context,
+ location,
+ array_len_bytes + calc_refcount_offset(tuple_layout),
+ 64,
+ )?;
+ let array_len_bytes = entry.const_int(context, location, array_len_bytes, 64)?;
+ let array_len = entry.const_int_from_type(context, location, tuple_len, len_ty)?;
- let elem_stride = entry.const_int(context, location, elem_stride, 64)?;
+ let k0 = entry.const_int_from_type(context, location, 0, len_ty)?;
+ let k1 = entry.const_int_from_type(context, location, 1, len_ty)?;
- let array_end = entry.extract_value(context, location, entry.arg(0)?, len_ty, 2)?;
- let array_capacity = entry.extract_value(context, location, entry.arg(0)?, len_ty, 3)?;
+ let array_ptr = entry.append_op_result(llvm::zero(ptr_ty, location))?;
+ let array_ptr = entry.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ array_ptr,
+ array_len_bytes_with_offset,
+ location,
+ )?)?;
+ entry.store(context, location, array_ptr, k1)?;
- let has_tail_space = entry.cmpi(
+ let array_ptr = entry.gep(
context,
- CmpiPredicate::Ult,
- array_end,
- array_capacity,
location,
+ array_ptr,
+ &[GepIndex::Const(calc_refcount_offset(tuple_layout) as i32)],
+ IntegerType::new(context, 8).into(),
)?;
+ entry.memcpy(
+ context,
+ location,
+ entry.argument(0)?.into(),
+ array_ptr,
+ array_len_bytes,
+ );
+ entry.append_operation(ReallocBindingsMeta::free(
+ context,
+ entry.argument(0)?.into(),
+ location,
+ )?);
- let handle_block = helper.append_block(Block::new(&[]));
- let memmove_block = helper.append_block(Block::new(&[]));
- let realloc_block = helper.append_block(Block::new(&[]));
- let append_block = helper.append_block(Block::new(&[(array_ty, location)]));
-
- entry.append_operation(cf::cond_br(
+ let value = entry.append_op_result(llvm::undef(
+ llvm::r#type::r#struct(context, &[ptr_ty, len_ty, len_ty, len_ty], false),
+ location,
+ ))?;
+ let value = entry.insert_values(
context,
- has_tail_space,
- append_block,
- handle_block,
- &[entry.arg(0)?],
- &[],
location,
- ));
+ value,
+ &[array_ptr, k0, array_len, array_len],
+ )?;
- {
- let k0 = handle_block.const_int(context, location, 0, 32)?;
- let array_start =
- handle_block.extract_value(context, location, entry.arg(0)?, len_ty, 1)?;
+ entry.append_operation(helper.br(0, &[value], location));
+ Ok(())
+}
- let has_head_space =
- handle_block.cmpi(context, CmpiPredicate::Ne, array_start, k0, location)?;
- handle_block.append_operation(cf::cond_br(
- context,
- has_head_space,
- memmove_block,
- realloc_block,
- &[],
- &[],
- location,
- ));
- }
+/// Generate MLIR operations for the `tuple_from_span` libfunc.
+///
+/// Note: The `&info.ty` field has the entire `[T; N]` tuple. It is not the `T` in `Array<T>`.
+pub fn build_tuple_from_span<'ctx, 'this>(
+ context: &'ctx Context,
+ registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+ entry: &'this Block<'ctx>,
+ location: Location<'ctx>,
+ helper: &LibfuncHelper<'ctx, 'this>,
+ metadata: &mut MetadataStorage,
+ info: &SignatureAndTypeConcreteLibfunc,
+) -> Result<()> {
+ metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
- {
- let array_start =
- memmove_block.extract_value(context, location, entry.arg(0)?, len_ty, 1)?;
+ let elem_id = {
+ let CoreTypeConcrete::Snapshot(info) =
+ registry.get_type(&info.signature.param_signatures[0].ty)?
+ else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
+ let CoreTypeConcrete::Array(info) = registry.get_type(&info.ty)? else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
- let start_offset =
- memmove_block.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let start_offset = memmove_block.muli(start_offset, elem_stride, location)?;
+ &info.ty
+ };
+ let tuple_len_const = {
+ let CoreTypeConcrete::Struct(param) = registry.get_type(&info.ty)? else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
- let dst_ptr = memmove_block.extract_value(context, location, entry.arg(0)?, ptr_ty, 0)?;
- let src_ptr = memmove_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- dst_ptr,
- &[start_offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
+ param.members.len()
+ };
- let array_len =
- memmove_block.append_op_result(arith::subi(array_end, array_start, location))?;
- let memmove_len =
- memmove_block.extui(array_len, IntegerType::new(context, 64).into(), location)?;
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
+ let (_, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, elem_id)?;
+ let (tuple_ty, tuple_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
- let memmove_len = memmove_block.muli(memmove_len, elem_stride, location)?;
- memmove_block.append_operation(
- ods::llvm::intr_memmove(
- context,
- dst_ptr,
- src_ptr,
- memmove_len,
- IntegerAttribute::new(IntegerType::new(context, 1).into(), 0),
- location,
- )
- .into(),
- );
+ let array_ptr = entry.extract_value(context, location, entry.argument(0)?.into(), ptr_ty, 0)?;
+ let array_start =
+ entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 2)?;
- let k0 = memmove_block.const_int_from_type(context, location, 0, len_ty)?;
- let value = memmove_block.insert_value(context, location, entry.arg(0)?, k0, 1)?;
- let value = memmove_block.insert_value(context, location, value, array_len, 2)?;
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
+ let tuple_len = entry.const_int_from_type(context, location, tuple_len_const, len_ty)?;
+ let len_matches = entry.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Eq,
+ array_len,
+ tuple_len,
+ location,
+ ))?;
- memmove_block.append_operation(cf::br(append_block, &[value], location));
- }
+ let valid_block = helper.append_block(Block::new(&[]));
+ let error_block = helper.append_block(Block::new(&[]));
+ entry.append_operation(cf::cond_br(
+ context,
+ len_matches,
+ valid_block,
+ error_block,
+ &[],
+ &[],
+ location,
+ ));
+
+ // Ensure the type's clone and drop implementations are registered.
+ registry.build_type(
+ context,
+ helper,
+ registry,
+ metadata,
+ &info.signature.param_signatures[0].ty,
+ )?;
{
- let k8 = realloc_block.const_int(context, location, 8, 32)?;
- let k1024 = realloc_block.const_int(context, location, 1024, 32)?;
-
- // Array allocation growth formula:
- // new_len = max(8, old_len + min(1024, 2 * old_len));
- let new_capacity = realloc_block.shli(array_end, k1, location)?;
- let new_capacity =
- realloc_block.append_op_result(arith::minui(new_capacity, k1024, location))?;
- let new_capacity = realloc_block.addi(new_capacity, array_end, location)?;
- let new_capacity =
- realloc_block.append_op_result(arith::maxui(new_capacity, k8, location))?;
-
- let realloc_size = {
- let new_capacity = realloc_block.extui(
- new_capacity,
- IntegerType::new(context, 64).into(),
- location,
- )?;
- realloc_block.muli(new_capacity, elem_stride, location)?
- };
+ let value_size = valid_block.const_int(context, location, tuple_layout.size(), 64)?;
- let ptr = realloc_block.extract_value(context, location, entry.arg(0)?, ptr_ty, 0)?;
- let ptr = realloc_block.append_op_result(ReallocBindingsMeta::realloc(
- context,
- ptr,
- realloc_size,
- location,
+ let value = valid_block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let value = valid_block.append_op_result(ReallocBindingsMeta::realloc(
+ context, value, value_size, location,
)?)?;
- // No need to memmove, guaranteed by the fact that if we needed to memmove we'd have gone
- // through the memmove block instead of reallocating.
-
- let value = realloc_block.insert_value(context, location, entry.arg(0)?, ptr, 0)?;
- let value = realloc_block.insert_value(context, location, value, new_capacity, 3)?;
-
- realloc_block.append_operation(cf::br(append_block, &[value], location));
- }
-
- {
- let ptr = append_block.extract_value(context, location, append_block.arg(0)?, ptr_ty, 0)?;
- let array_end =
- append_block.extract_value(context, location, append_block.arg(0)?, len_ty, 2)?;
+ let is_shared = is_shared(context, valid_block, location, array_ptr, elem_layout)?;
- let offset =
- append_block.extui(array_end, IntegerType::new(context, 64).into(), location)?;
- let offset = append_block.muli(offset, elem_stride, location)?;
- let ptr = append_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
+ let array_start_offset = valid_block.append_op_result(arith::extui(
+ array_start,
+ IntegerType::new(context, 64).into(),
location,
))?;
+ let array_start_offset = valid_block.append_op_result(arith::muli(
+ array_start_offset,
+ valid_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?,
+ location,
+ ))?;
+ let array_ptr = valid_block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(array_start_offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
- append_block.store(context, location, ptr, entry.arg(1)?)?;
-
- let array_len = append_block.addi(array_end, k1, location)?;
- let value =
- append_block.insert_value(context, location, append_block.arg(0)?, array_len, 2)?;
-
- append_block.append_operation(helper.br(0, &[value], location));
- }
-
- Ok(())
-}
+ valid_block.append_operation(scf::r#if(
+ is_shared,
+ &[],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(&info.ty) => {
+ let src_ptr = array_ptr;
+ let dst_ptr = value;
+
+ let value = block.load(context, location, src_ptr, tuple_ty)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, &info.ty, value)?;
+ block.store(context, location, src_ptr, values.0)?;
+ block.store(context, location, dst_ptr, values.1)?;
+ }
+ _ => block.memcpy(context, location, array_ptr, value, value_size),
+ }
-/// Generate MLIR operations for the `array_len` libfunc.
-pub fn build_len<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ // The following unwrap should be unreachable because an array always has a drop
+ // implementation.
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
+ context,
+ &block,
+ location,
+ &info.signature.param_signatures[0].ty,
+ entry.argument(0)?.into(),
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
- let array_value = entry.arg(0)?;
+ block.memcpy(context, location, array_ptr, value, value_size);
- let array_start = entry.extract_value(context, location, array_value, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, array_value, len_ty, 2)?;
+ let array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
+ IntegerType::new(context, 8).into(),
+ )?;
+ block.append_operation(ReallocBindingsMeta::free(context, array_ptr, location)?);
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
- let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
+ valid_block.append_operation(helper.br(0, &[value], location));
+ }
- match metadata.get::<DropOverridesMeta>() {
- Some(drop_overrides_meta)
- if drop_overrides_meta.is_overriden(&info.signature.param_signatures[0].ty) =>
- {
- drop_overrides_meta.invoke_override(
+ {
+ metadata
+ .get::<DropOverridesMeta>()
+ .ok_or(Error::MissingMetadata)?
+ .invoke_override(
context,
- entry,
+ error_block,
location,
&info.signature.param_signatures[0].ty,
- entry.arg(0)?,
+ entry.argument(0)?.into(),
)?;
- }
- _ => {}
+
+ error_block.append_operation(helper.br(1, &[], location));
}
- entry.append_operation(helper.br(0, &[array_len], location));
Ok(())
}
-/// Generate MLIR operations for the `array_get` libfunc.
-pub fn build_get<'ctx, 'this>(
+/// Generate MLIR operations for the `array_append` libfunc.
+pub fn build_append<'ctx, 'this>(
context: &'ctx Context,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
@@ -2886,720 +3375,1116 @@
metadata: &mut MetadataStorage,
info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let range_check = super::increment_builtin_counter(context, entry, location, entry.arg(0)?)?;
-
- let array_ty = registry.build_type(
+ /*
+ * 1. Check if shared.
+ * 2. If shared:
+ * 1. Deep clone with space for at least 1 extra element.
+ * 3. If not shared:
+ * 1. Either realloc, move or do nothing.
+ * 4. Append element.
+ */
+
+ metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
+
+ let self_ty = registry.build_type(
context,
helper,
registry,
metadata,
- &info.param_signatures()[1].ty,
+ &info.signature.param_signatures[0].ty,
)?;
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
- let elem_stride = elem_layout.pad_to_align().size();
- let elem_ty = elem_ty.build(context, helper, registry, metadata, &info.ty)?;
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ let (elem_ty, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
+ let elem_stride = entry.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let value = entry.arg(1)?;
- let index = entry.arg(2)?;
+ let k0 = entry.const_int(context, location, 0, 32)?;
+ let k1 = entry.const_int(context, location, 1, 32)?;
- let array_start = entry.extract_value(context, location, value, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, value, len_ty, 2)?;
+ let array_ptr = entry.extract_value(context, location, entry.argument(0)?.into(), ptr_ty, 0)?;
+ let array_start =
+ entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 2)?;
+ let array_capacity =
+ entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 3)?;
let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let is_valid = entry.cmpi(context, CmpiPredicate::Ult, index, array_len, location)?;
+ let array_size = entry.append_op_result(arith::extui(
+ array_len,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let array_size = entry.append_op_result(arith::muli(array_size, elem_stride, location))?;
- let valid_block = helper.append_block(Block::new(&[]));
- let error_block = helper.append_block(Block::new(&[]));
- entry.append_operation(cf::cond_br(
+ let data_offset = entry.append_op_result(arith::extui(
+ array_start,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let data_offset = entry.append_op_result(arith::muli(data_offset, elem_stride, location))?;
+ let data_ptr = entry.gep(
context,
- is_valid,
- valid_block,
- error_block,
- &[],
- &[],
location,
- ));
+ array_ptr,
+ &[GepIndex::Value(data_offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
- {
- let ptr = valid_block.extract_value(context, location, value, ptr_ty, 0)?;
+ fn compute_next_capacity<'ctx, 'this>(
+ context: &'ctx Context,
+ block: &'this Block<'ctx>,
+ location: Location<'ctx>,
+ elem_stride: Value<'ctx, 'this>,
+ array_end: Value<'ctx, 'this>,
+ ) -> Result<(Value<'ctx, 'this>, Value<'ctx, 'this>)> {
+ let len_ty = IntegerType::new(context, 32).into();
+
+ let k1 = block.const_int_from_type(context, location, 1, len_ty)?;
+ let k8 = block.const_int_from_type(context, location, 8, len_ty)?;
+ let k1024 = block.const_int_from_type(context, location, 1024, len_ty)?;
+
+ let realloc_len = block.append_op_result(arith::shli(array_end, k1, location))?;
+ let realloc_len = block.append_op_result(arith::minui(realloc_len, k1024, location))?;
+ let realloc_len = block.append_op_result(arith::addi(realloc_len, array_end, location))?;
+ let realloc_len = block.append_op_result(arith::maxui(realloc_len, k8, location))?;
+
+ let realloc_size = block.append_op_result(arith::extui(
+ realloc_len,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let realloc_size =
+ block.append_op_result(arith::muli(realloc_size, elem_stride, location))?;
- let array_start =
- valid_block.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let index = {
- let index = valid_block.extui(index, IntegerType::new(context, 64).into(), location)?;
- valid_block.addi(array_start, index, location)?
- };
+ Result::Ok((realloc_len, realloc_size))
+ }
- let elem_stride = valid_block.const_int(context, location, elem_stride, 64)?;
- let elem_offset = valid_block.muli(elem_stride, index, location)?;
+ let is_empty = entry.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Eq,
+ array_capacity,
+ k0,
+ location,
+ ))?;
- let elem_ptr = valid_block.gep(
- context,
- location,
- ptr,
- &[GepIndex::Value(elem_offset)],
- IntegerType::new(context, 8).into(),
- )?;
+ let is_shared = entry.append_op_result(scf::r#if(
+ is_empty,
+ &[IntegerType::new(context, 1).into()],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let elem_size = valid_block.const_int(context, location, elem_layout.size(), 64)?;
+ let k0 = block.const_int(context, location, 0, 1)?;
- let target_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
- )?;
- let target_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context, target_ptr, elem_size, location,
- )?)?;
- assert_nonnull(
- context,
- valid_block,
- location,
- target_ptr,
- "realloc returned nullptr",
- )?;
+ block.append_operation(scf::r#yield(&[k0], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- // There's no need to clone it since we're moving it out of the array.
- valid_block.memcpy(context, location, elem_ptr, target_ptr, elem_size);
+ let is_shared = is_shared(context, entry, location, array_ptr, elem_layout)?;
- match metadata.get::<DropOverridesMeta>() {
- Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
- let array_end =
- valid_block.extui(array_end, IntegerType::new(context, 64).into(), location)?;
+ block.append_operation(scf::r#yield(&[is_shared], location));
+ region
+ },
+ location,
+ ))?;
- let array_start = valid_block.muli(array_start, elem_stride, location)?;
- let array_end = valid_block.muli(array_end, elem_stride, location)?;
+ let value = entry.append_op_result(scf::r#if(
+ is_shared,
+ &[self_ty],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- valid_block.append_operation(scf::r#for(
- array_start,
- array_end,
- elem_stride,
- {
- let region = Region::new();
- let block = region.append_block(Block::new(&[(
- IntegerType::new(context, 64).into(),
- location,
- )]));
+ let has_space = block.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ugt,
+ array_capacity,
+ array_len,
+ location,
+ ))?;
- let value_ptr = block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[block.arg(0)?],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
+ let op = block.append_operation(scf::r#if(
+ has_space,
+ &[len_ty, IntegerType::new(context, 64).into()],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let is_target_element = block.append_op_result(
- ods::llvm::icmp(
- context,
- IntegerType::new(context, 1).into(),
- value_ptr,
- elem_ptr,
- IntegerAttribute::new(IntegerType::new(context, 64).into(), 0)
- .into(),
- location,
- )
- .into(),
- )?;
- block.append_operation(scf::r#if(
- is_target_element,
- &[],
- {
- let region = Region::new();
- let block = region.append_block(Block::new(&[]));
+ let clone_size = block.append_op_result(arith::extui(
+ array_capacity,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let clone_size =
+ block.append_op_result(arith::muli(clone_size, elem_stride, location))?;
+
+ block.append_operation(scf::r#yield(&[array_capacity, clone_size], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let (realloc_capacity, realloc_size) =
+ compute_next_capacity(context, &block, location, elem_stride, array_end)?;
+
+ block.append_operation(scf::r#yield(
+ &[realloc_capacity, realloc_size],
+ location,
+ ));
+ region
+ },
+ location,
+ ));
+ let clone_capacity = op.result(0)?.into();
+ let clone_size = op.result(1)?.into();
- block.append_operation(scf::r#yield(&[], location));
- region
- },
- {
- let region = Region::new();
- let block = region.append_block(Block::new(&[]));
+ let clone_size_with_refcount = block.append_op_result(arith::addi(
+ clone_size,
+ block.const_int(context, location, calc_refcount_offset(elem_layout), 64)?,
+ location,
+ ))?;
- let value = block.load(context, location, value_ptr, elem_ty)?;
- drop_overrides_meta
- .invoke_override(context, &block, location, &info.ty, value)?;
+ let clone_ptr = block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let clone_ptr = block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ clone_ptr,
+ clone_size_with_refcount,
+ location,
+ )?)?;
+ block.store(context, location, clone_ptr, k1)?;
- block.append_operation(scf::r#yield(&[], location));
- region
- },
- location,
- ));
+ let clone_ptr = block.gep(
+ context,
+ location,
+ clone_ptr,
+ &[GepIndex::Const(calc_refcount_offset(elem_layout) as i32)],
+ IntegerType::new(context, 8).into(),
+ )?;
- block.append_operation(scf::r#yield(&[], location));
- region
- },
- location,
- ));
- }
- _ => {}
- }
- valid_block.append_operation(ReallocBindingsMeta::free(context, ptr, location)?);
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(&info.ty) => {
+ let k0 = block.const_int(context, location, 0, 64)?;
+ block.append_operation(scf::r#for(
+ k0,
+ array_size,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
- valid_block.append_operation(helper.br(0, &[range_check, target_ptr], location));
- }
+ let offset = block.argument(0)?.into();
+ let source_ptr = block.gep(
+ context,
+ location,
+ data_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let target_ptr = block.gep(
+ context,
+ location,
+ clone_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let value = block.load(context, location, source_ptr, elem_ty)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, &info.ty, value)?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, target_ptr, values.1)?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ }
+ _ => block.memcpy(context, location, array_ptr, clone_ptr, clone_size),
+ }
- metadata
- .get::<DropOverridesMeta>()
- .ok_or(Error::MissingMetadata)?
- .invoke_override(
- context,
- error_block,
- location,
- &info.param_signatures()[1].ty,
- value,
- )?;
- error_block.append_operation(helper.br(1, &[range_check], location));
+ let clone_value = block.append_op_result(llvm::zero(self_ty, location))?;
+ let clone_value = block.insert_values(
+ context,
+ location,
+ clone_value,
+ &[clone_ptr, k0, array_len, clone_capacity],
+ )?;
- Ok(())
-}
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
+ context,
+ &block,
+ location,
+ &info.signature.param_signatures[0].ty,
+ entry.argument(0)?.into(),
+ )?;
-/// Generate MLIR operations for the `array_pop_front` libfunc.
-pub fn build_pop_front<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
+ block.append_operation(scf::r#yield(&[clone_value], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ let has_tail_space = block.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ult,
+ array_end,
+ array_capacity,
+ location,
+ ))?;
+ let array_value = block.append_op_result(scf::r#if(
+ has_tail_space,
+ &[self_ty],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ block.append_operation(scf::r#yield(&[entry.argument(0)?.into()], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let has_head_space = block.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ugt,
+ array_start,
+ k0,
+ location,
+ ))?;
+ let array_value = block.append_op_result(scf::r#if(
+ has_head_space,
+ &[self_ty],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ block.append_operation(
+ ods::llvm::intr_memmove(
+ context,
+ array_ptr,
+ data_ptr,
+ array_size,
+ IntegerAttribute::new(IntegerType::new(context, 1).into(), 0),
+ location,
+ )
+ .into(),
+ );
+
+ let array_value = block.insert_value(
+ context,
+ location,
+ entry.argument(0)?.into(),
+ k0,
+ 1,
+ )?;
+ let array_value =
+ block.insert_value(context, location, array_value, array_len, 2)?;
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let offset_array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let array_ptr = block.append_op_result(arith::select(
+ is_empty,
+ array_ptr,
+ offset_array_ptr,
+ location,
+ ))?;
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
+ let (realloc_len, realloc_size) = compute_next_capacity(
+ context,
+ &block,
+ location,
+ elem_stride,
+ array_end,
+ )?;
+ let realloc_size_with_refcount =
+ block.append_op_result(arith::addi(
+ realloc_size,
+ block.const_int(
+ context,
+ location,
+ calc_refcount_offset(elem_layout),
+ 64,
+ )?,
+ location,
+ ))?;
+
+ let array_ptr =
+ block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ array_ptr,
+ realloc_size_with_refcount,
+ location,
+ )?)?;
+
+ let ref_count = block.load(context, location, array_ptr, len_ty)?;
+ let ref_count = block.append_op_result(arith::select(
+ is_empty, k1, ref_count, location,
+ ))?;
+ block.store(context, location, array_ptr, ref_count)?;
+
+ let array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(calc_refcount_offset(elem_layout) as i32)],
+ IntegerType::new(context, 8).into(),
+ )?;
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ let array_value = block.insert_value(
+ context,
+ location,
+ entry.argument(0)?.into(),
+ array_ptr,
+ 0,
+ )?;
+ let array_value = block.insert_value(
+ context,
+ location,
+ array_value,
+ realloc_len,
+ 3,
+ )?;
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ location,
+ ))?;
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ location,
+ ))?;
- let value = entry.arg(0)?;
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ location,
+ ))?;
- let array_start = entry.extract_value(context, location, value, len_ty, 1)?;
+ let array_ptr = entry.extract_value(context, location, value, ptr_ty, 0)?;
let array_end = entry.extract_value(context, location, value, len_ty, 2)?;
- let is_empty = entry.cmpi(context, CmpiPredicate::Eq, array_start, array_end, location)?;
-
- let valid_block = helper.append_block(Block::new(&[]));
- let empty_block = helper.append_block(Block::new(&[]));
- entry.append_operation(cf::cond_br(
+ let data_offset = entry.append_op_result(arith::extui(
+ array_end,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let data_offset = entry.append_op_result(arith::muli(data_offset, elem_stride, location))?;
+ let data_ptr = entry.gep(
context,
- is_empty,
- empty_block,
- valid_block,
- &[],
- &[],
location,
- ));
-
- {
- let ptr = valid_block.extract_value(context, location, value, ptr_ty, 0)?;
-
- let elem_size = valid_block.const_int(context, location, elem_layout.size(), 64)?;
- let elem_offset =
- valid_block.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let elem_offset = valid_block.muli(elem_offset, elem_size, location)?;
- let ptr = valid_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[elem_offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
-
- let target_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
- )?;
- let target_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context, target_ptr, elem_size, location,
- )?)?;
- assert_nonnull(
- context,
- valid_block,
- location,
- target_ptr,
- "realloc returned nullptr",
- )?;
-
- valid_block.memcpy(context, location, ptr, target_ptr, elem_size);
-
- let k1 = valid_block.const_int(context, location, 1, 32)?;
- let new_start = valid_block.addi(array_start, k1, location)?;
- let value = valid_block.insert_value(context, location, value, new_start, 1)?;
+ array_ptr,
+ &[GepIndex::Value(data_offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ entry.store(context, location, data_ptr, entry.argument(1)?.into())?;
- valid_block.append_operation(helper.br(0, &[value, target_ptr], location));
- }
+ let array_end = entry.append_op_result(arith::addi(array_end, k1, location))?;
+ let value = entry.insert_value(context, location, value, array_end, 2)?;
- empty_block.append_operation(helper.br(1, &[value], location));
+ entry.append_operation(helper.br(0, &[value], location));
Ok(())
}
-/// Generate MLIR operations for the `array_pop_front_consume` libfunc.
-pub fn build_pop_front_consume<'ctx, 'this>(
+#[derive(Clone, Copy)]
+enum PopInfo<'a> {
+ Single(&'a SignatureAndTypeConcreteLibfunc),
+ Multi(&'a ConcreteMultiPopLibfunc),
+}
+
+/// Generate MLIR operations for the `array_pop_*` libfuncs.
+///
+/// Template arguments:
+/// - Consume: Whether to consume or not the array on failure.
+/// - Reverse: False for front-popping, true for back-popping.
+///
+/// The `info` argument contains how many items to pop.
+fn build_pop<'ctx, 'this, const CONSUME: bool, const REVERSE: bool>(
context: &'ctx Context,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
location: Location<'ctx>,
helper: &LibfuncHelper<'ctx, 'this>,
metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
+ info: PopInfo,
) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
+ /*
+ * 1. Check if there's enough data to pop.
+ * 2. If there is not enough data, maybe consume and return.
+ * 3. Allocate output.
+ * 4. Clone or copy the popped data.
+ * - Clone if shared.
+ * - Copy if not shared.
+ */
+
+ metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
+
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ let (self_ty, elem_ty, array_value, extract_len, mut branch_values) = match info {
+ PopInfo::Single(info) => (
+ &info.signature.param_signatures[0].ty,
+ &info.ty,
+ entry.argument(0)?.into(),
+ 1,
+ Vec::new(),
+ ),
+ PopInfo::Multi(ConcreteMultiPopLibfunc {
+ popped_ty,
+ signature,
+ }) => {
+ let range_check = super::increment_builtin_counter(
+ context,
+ entry,
+ location,
+ entry.argument(0)?.into(),
+ )?;
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
+ let CoreTypeConcrete::Snapshot(InfoAndTypeConcreteType { ty, .. }) =
+ registry.get_type(&signature.param_signatures[1].ty)?
+ else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
+
+ let CoreTypeConcrete::Array(InfoAndTypeConcreteType { ty, .. }) =
+ registry.get_type(ty)?
+ else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
+
+ let CoreTypeConcrete::Struct(info) = registry.get_type(popped_ty)? else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
+ debug_assert!(info.members.iter().all(|member_ty| member_ty == ty));
+
+ (
+ &signature.param_signatures[1].ty,
+ ty,
+ entry.argument(1)?.into(),
+ info.members.len(),
+ vec![range_check],
+ )
+ }
+ };
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ registry.build_type(context, helper, registry, metadata, self_ty)?;
+ let extract_len_value = entry.const_int_from_type(context, location, extract_len, len_ty)?;
- let value = entry.arg(0)?;
+ let (elem_type, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, elem_ty)?;
- let array_start = entry.extract_value(context, location, value, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, value, len_ty, 2)?;
+ let array_start = entry.extract_value(context, location, array_value, len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, array_value, len_ty, 2)?;
- let is_empty = entry.cmpi(context, CmpiPredicate::Eq, array_start, array_end, location)?;
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
+ let has_enough_data = entry.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ule,
+ extract_len_value,
+ array_len,
+ location,
+ ))?;
let valid_block = helper.append_block(Block::new(&[]));
- let empty_block = helper.append_block(Block::new(&[]));
+ let error_block = helper.append_block(Block::new(&[]));
entry.append_operation(cf::cond_br(
context,
- is_empty,
- empty_block,
+ has_enough_data,
valid_block,
+ error_block,
&[],
&[],
location,
));
{
- let ptr = valid_block.extract_value(context, location, value, ptr_ty, 0)?;
+ // Clone branch_values so that it doesn't interfere with the other branch.
+ let mut branch_values = branch_values.clone();
- let elem_size = valid_block.const_int(context, location, elem_layout.size(), 64)?;
- let elem_offset =
- valid_block.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let elem_offset = valid_block.muli(elem_offset, elem_size, location)?;
- let ptr = valid_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[elem_offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
-
- let target_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
- )?;
- let target_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context, target_ptr, elem_size, location,
- )?)?;
- assert_nonnull(
+ let value_size = valid_block.const_int(
context,
- valid_block,
location,
- target_ptr,
- "realloc returned nullptr",
+ elem_layout.pad_to_align().size() * extract_len,
+ 64,
)?;
- valid_block.memcpy(context, location, ptr, target_ptr, elem_size);
+ let value_ptr = valid_block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let value_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
+ context, value_ptr, value_size, location,
+ )?)?;
- let k1 = valid_block.const_int(context, location, 1, 32)?;
- let new_start = valid_block.addi(array_start, k1, location)?;
- let value = valid_block.insert_value(context, location, value, new_start, 1)?;
+ let array_ptr = valid_block.extract_value(context, location, array_value, ptr_ty, 0)?;
+ let is_shared = is_shared(context, valid_block, location, array_ptr, elem_layout)?;
- valid_block.append_operation(helper.br(0, &[value, target_ptr], location));
- }
+ let data_ptr = {
+ let offset_elems = if REVERSE {
+ valid_block.append_op_result(arith::subi(array_end, extract_len_value, location))?
+ } else {
+ array_start
+ };
- metadata
- .get::<DropOverridesMeta>()
- .ok_or(Error::MissingMetadata)?
- .invoke_override(
- context,
- empty_block,
- location,
- &info.param_signatures()[0].ty,
- value,
- )?;
- empty_block.append_operation(helper.br(1, &[], location));
-
- Ok(())
-}
-
-/// Generate MLIR operations for the `array_snapshot_pop_front` libfunc.
-pub fn build_snapshot_pop_front<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- build_pop_front(context, registry, entry, location, helper, metadata, info)
-}
+ let offset = valid_block.append_op_result(arith::extui(
+ offset_elems,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let elem_stride =
+ valid_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
+ let offset =
+ valid_block.append_op_result(arith::muli(offset, elem_stride, location))?;
-/// Generate MLIR operations for the `array_snapshot_pop_back` libfunc.
-pub fn build_snapshot_pop_back<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
+ valid_block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?
+ };
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ let new_array_ptr = valid_block.append_op_result(scf::r#if(
+ is_shared,
+ &[ptr_ty],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let k0 = block.const_int(context, location, 0, 64)?;
+ let k1 = block.const_int_from_type(context, location, 1, len_ty)?;
+
+ let elem_stride =
+ block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(elem_ty) => {
+ block.append_operation(scf::r#for(
+ k0,
+ value_size,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let offset = block.argument(0)?.into();
+ let source_ptr = block.gep(
+ context,
+ location,
+ data_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let target_ptr = block.gep(
+ context,
+ location,
+ value_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let value = block.load(context, location, source_ptr, elem_type)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, elem_ty, value)?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, target_ptr, values.1)?;
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ }
+ _ => block.memcpy(context, location, data_ptr, value_ptr, value_size),
+ }
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ let array_ptr = {
+ let array_len_bytes =
+ block.append_op_result(arith::subi(array_len, k1, location))?;
+ let array_len_bytes = block.append_op_result(arith::extui(
+ array_len_bytes,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let array_len_bytes = block.append_op_result(arith::muli(
+ array_len_bytes,
+ elem_stride,
+ location,
+ ))?;
+ let array_len_bytes = block.append_op_result(arith::addi(
+ array_len_bytes,
+ block.const_int(
+ context,
+ location,
+ calc_refcount_offset(elem_layout),
+ 64,
+ )?,
+ location,
+ ))?;
+
+ let clone_ptr = block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let clone_ptr = block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ clone_ptr,
+ array_len_bytes,
+ location,
+ )?)?;
+ block.store(context, location, clone_ptr, k1)?;
+
+ let clone_ptr = block.gep(
+ context,
+ location,
+ clone_ptr,
+ &[GepIndex::Const(calc_refcount_offset(elem_layout) as i32)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let data_ptr = if REVERSE {
+ data_ptr
+ } else {
+ let offset = block.append_op_result(arith::extui(
+ extract_len_value,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let offset =
+ block.append_op_result(arith::muli(offset, elem_stride, location))?;
- let value = entry.arg(0)?;
+ block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?
+ };
+
+ let others_len = block.append_op_result(arith::subi(
+ array_len,
+ extract_len_value,
+ location,
+ ))?;
+ let others_len = block.append_op_result(arith::extui(
+ others_len,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let others_size =
+ block.append_op_result(arith::muli(others_len, elem_stride, location))?;
+
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) => {
+ block.append_operation(scf::r#for(
+ k0,
+ others_size,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let offset = block.argument(0)?.into();
+ let source_ptr = block.gep(
+ context,
+ location,
+ data_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let target_ptr = block.gep(
+ context,
+ location,
+ clone_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let value =
+ block.load(context, location, source_ptr, elem_type)?;
+ let values = dup_overrides_meta.invoke_override(
+ context, &block, location, elem_ty, value,
+ )?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, target_ptr, values.1)?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ }
+ _ => block.memcpy(context, location, data_ptr, clone_ptr, others_size),
+ }
- let array_start = entry.extract_value(context, location, value, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, value, len_ty, 2)?;
- let is_empty = entry.cmpi(context, CmpiPredicate::Eq, array_start, array_end, location)?;
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(context, &block, location, self_ty, array_value)?;
- let valid_block = helper.append_block(Block::new(&[]));
- let empty_block = helper.append_block(Block::new(&[]));
- entry.append_operation(cf::cond_br(
- context,
- is_empty,
- empty_block,
- valid_block,
- &[],
- &[],
- location,
- ));
+ clone_ptr
+ };
- {
- let k1 = valid_block.const_int(context, location, 1, 32)?;
- let new_end = valid_block.append_op_result(arith::subi(array_end, k1, location))?;
+ block.append_operation(scf::r#yield(&[array_ptr], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let ptr = valid_block.extract_value(context, location, value, ptr_ty, 0)?;
+ block.memcpy(context, location, data_ptr, value_ptr, value_size);
- let elem_size = valid_block.const_int(context, location, elem_layout.size(), 64)?;
- let elem_offset =
- valid_block.extui(new_end, IntegerType::new(context, 64).into(), location)?;
- let elem_offset = valid_block.muli(elem_offset, elem_size, location)?;
- let ptr = valid_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[elem_offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
+ block.append_operation(scf::r#yield(&[array_ptr], location));
+ region
+ },
location,
))?;
- let target_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
+ let array_value =
+ valid_block.insert_value(context, location, array_value, new_array_ptr, 0)?;
+
+ let has_realloc = valid_block.append_op_result(
+ ods::llvm::icmp(
+ context,
+ IntegerType::new(context, 1).into(),
+ array_ptr,
+ new_array_ptr,
+ IntegerAttribute::new(IntegerType::new(context, 64).into(), 1).into(),
+ location,
+ )
+ .into(),
)?;
- let target_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context, target_ptr, elem_size, location,
- )?)?;
- assert_nonnull(
- context,
- valid_block,
+ let array_value = valid_block.append_op_result(scf::r#if(
+ has_realloc,
+ &[array_value.r#type()],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let k0 = block.const_int_from_type(context, location, 0, len_ty)?;
+ let array_len =
+ block.append_op_result(arith::subi(array_len, extract_len_value, location))?;
+
+ let array_value = block.insert_value(context, location, array_value, k0, 1)?;
+ let array_value =
+ block.insert_value(context, location, array_value, array_len, 2)?;
+ let array_value =
+ block.insert_value(context, location, array_value, array_len, 3)?;
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let array_value = if REVERSE {
+ let array_end = block.append_op_result(arith::subi(
+ array_end,
+ extract_len_value,
+ location,
+ ))?;
+ block.insert_value(context, location, array_value, array_end, 2)?
+ } else {
+ let array_start = block.append_op_result(arith::addi(
+ array_start,
+ extract_len_value,
+ location,
+ ))?;
+ block.insert_value(context, location, array_value, array_start, 1)?
+ };
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
location,
- target_ptr,
- "realloc returned nullptr",
- )?;
+ ))?;
+
+ branch_values.push(array_value);
+ branch_values.push(value_ptr);
- valid_block.memcpy(context, location, ptr, target_ptr, elem_size);
+ valid_block.append_operation(helper.br(0, &branch_values, location));
+ }
- let value = valid_block.insert_value(context, location, value, new_end, 2)?;
+ {
+ if CONSUME {
+ let self_ty = match info {
+ PopInfo::Single(info) => &info.signature.param_signatures[0].ty,
+ PopInfo::Multi(info) => &info.signature.param_signatures[1].ty,
+ };
+
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(context, error_block, location, self_ty, array_value)?;
+ } else {
+ branch_values.push(array_value);
+ }
- valid_block.append_operation(helper.br(0, &[value, target_ptr], location));
+ error_block.append_operation(helper.br(1, &branch_values, location));
}
- empty_block.append_operation(helper.br(1, &[value], location));
Ok(())
}
-pub fn build_snapshot_multi_pop_front<'ctx, 'this>(
+/// Generate MLIR operations for the `array_get` libfunc.
+pub fn build_get<'ctx, 'this>(
context: &'ctx Context,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
location: Location<'ctx>,
helper: &LibfuncHelper<'ctx, 'this>,
metadata: &mut MetadataStorage,
- info: &ConcreteMultiPopLibfunc,
+ info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let range_check = entry.arg(0)?;
-
- // Get type information
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
- let array_ty = registry.build_type(
+ // Build the type so that the drop impl invocation works properly.
+ registry.build_type(
context,
helper,
registry,
metadata,
- &info.param_signatures()[1].ty,
+ &info.signature.param_signatures[1].ty,
)?;
- let popped_cty = registry.get_type(&info.popped_ty)?;
- let popped_size = popped_cty.layout(registry)?.size();
- let popped_size_value = entry.const_int(context, location, popped_size, 64)?;
-
- let popped_ctys = popped_cty
- .fields()
- .expect("popped type should be a tuple (ergo, has fields)");
- let popped_len = popped_ctys.len();
-
- let array_ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let array_start_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
- let array_end_ty = crate::ffi::get_struct_field_type_at(&array_ty, 2);
+ let range_check =
+ super::increment_builtin_counter(context, entry, location, entry.argument(0)?.into())?;
- // Get array information
+ let array_start =
+ entry.extract_value(context, location, entry.argument(1)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(1)?.into(), len_ty, 2)?;
- let array = entry.arg(1)?;
- let array_ptr = entry.extract_value(context, location, array, array_ptr_ty, 0)?;
- let array_start = entry.extract_value(context, location, array, array_start_ty, 1)?;
- let array_end = entry.extract_value(context, location, array, array_end_ty, 2)?;
-
- // Check if operation is valid:
- // if array.end - array.start < popped_len {
- // return
- // }
-
- let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let popped_len_value = entry.const_int(context, location, popped_len, 32)?;
- let is_valid = entry.cmpi(
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
+ let is_valid = entry.append_op_result(arith::cmpi(
context,
- CmpiPredicate::Uge,
+ CmpiPredicate::Ult,
+ entry.argument(2)?.into(),
array_len,
- popped_len_value,
location,
- )?;
+ ))?;
let valid_block = helper.append_block(Block::new(&[]));
- let invalid_block = helper.append_block(Block::new(&[]));
-
+ let error_block = helper.append_block(Block::new(&[]));
entry.append_operation(cf::cond_br(
context,
is_valid,
valid_block,
- invalid_block,
+ error_block,
&[],
&[],
location,
));
{
- // Get pointer to first element to pop
-
- let popped_ptr = {
- let single_popped_ty =
- registry.build_type(context, helper, registry, metadata, &popped_ctys[0])?;
-
- valid_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- array_ptr,
- &[array_start],
- single_popped_ty,
- llvm::r#type::pointer(context, 0),
- location,
- ))?
- };
-
- // Allocate memory for return array
-
- let return_ptr = {
- let null_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
- )?;
- valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context,
- null_ptr,
- popped_size_value,
- location,
- )?)?
- };
-
- valid_block.memcpy(context, location, popped_ptr, return_ptr, popped_size_value);
-
- // Update array start (removing popped elements)
-
- let array = {
- let new_array_start = valid_block.addi(array_start, popped_len_value, location)?;
-
- valid_block.insert_value(context, location, array, new_array_start, 1)?
- };
-
- valid_block.append_operation(helper.br(0, &[range_check, array, return_ptr], location));
- }
-
- invalid_block.append_operation(helper.br(1, &[range_check, array], location));
-
- Ok(())
-}
-
-pub fn build_snapshot_multi_pop_back<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &ConcreteMultiPopLibfunc,
-) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let range_check = entry.arg(0)?;
-
- // Get type information
-
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[1].ty,
- )?;
-
- let popped_cty = registry.get_type(&info.popped_ty)?;
- let popped_size = popped_cty.layout(registry)?.size();
- let popped_size_value = entry.const_int(context, location, popped_size, 64)?;
+ let (elem_ty, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
+ let elem_stride =
+ valid_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let popped_ctys = popped_cty
- .fields()
- .expect("popped type should be a tuple (ergo, has fields)");
- let popped_len = popped_ctys.len();
+ let value_ptr = valid_block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let value_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ value_ptr,
+ elem_stride,
+ location,
+ )?)?;
- let array_ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let array_start_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
- let array_end_ty = crate::ffi::get_struct_field_type_at(&array_ty, 2);
+ let array_ptr =
+ valid_block.extract_value(context, location, entry.argument(1)?.into(), ptr_ty, 0)?;
+ let is_shared = is_shared(context, valid_block, location, array_ptr, elem_layout)?;
- // Get array information
+ let offset = valid_block.append_op_result(arith::addi(
+ array_start,
+ entry.argument(2)?.into(),
+ location,
+ ))?;
+ let offset = valid_block.append_op_result(arith::extui(
+ offset,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let offset = valid_block.append_op_result(arith::muli(offset, elem_stride, location))?;
- let array = entry.arg(1)?;
- let array_ptr = entry.extract_value(context, location, array, array_ptr_ty, 0)?;
- let array_start = entry.extract_value(context, location, array, array_start_ty, 1)?;
- let array_end = entry.extract_value(context, location, array, array_end_ty, 2)?;
+ let source_ptr = valid_block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
- // Check if operation is valid:
- // if array.end - array.start < popped_len {
- // return
- // }
+ valid_block.append_operation(scf::r#if(
+ is_shared,
+ &[],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(&info.ty) => {
+ let value = block.load(context, location, source_ptr, elem_ty)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, &info.ty, value)?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, value_ptr, values.1)?;
+ }
+ _ => block.memcpy(context, location, source_ptr, value_ptr, elem_stride),
+ }
- let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let popped_len_value = entry.const_int(context, location, popped_len, 32)?;
- let is_valid = entry.cmpi(
- context,
- CmpiPredicate::Uge,
- array_len,
- popped_len_value,
- location,
- )?;
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
+ context,
+ &block,
+ location,
+ &info.signature.param_signatures[1].ty,
+ entry.argument(1)?.into(),
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ block.memcpy(context, location, source_ptr, value_ptr, elem_stride);
+
+ match metadata.get::<DropOverridesMeta>() {
+ Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
+ let drop_loop = |o0, o1| {
+ block.append_operation(scf::r#for(
+ o0,
+ o1,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let value_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(block.argument(0)?.into())],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let value =
+ block.load(context, location, value_ptr, elem_ty)?;
+ drop_overrides_meta.invoke_override(
+ context, &block, location, &info.ty, value,
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
- let valid_block = helper.append_block(Block::new(&[]));
- let invalid_block = helper.append_block(Block::new(&[]));
+ Result::Ok(())
+ };
- entry.append_operation(cf::cond_br(
- context,
- is_valid,
- valid_block,
- invalid_block,
- &[],
- &[],
- location,
- ));
+ let o0 = block.append_op_result(arith::extui(
+ array_start,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::addi(
+ array_start,
+ entry.argument(2)?.into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::extui(
+ o1,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o0 = block.append_op_result(arith::muli(o0, elem_stride, location))?;
+ let o1 = block.append_op_result(arith::muli(o1, elem_stride, location))?;
+ drop_loop(o0, o1)?;
- {
- // Get pointer to first element to pop
+ let o0 = block.append_op_result(arith::addi(o1, elem_stride, location))?;
+ let o1 = block.append_op_result(arith::extui(
+ array_end,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::muli(o1, elem_stride, location))?;
+ drop_loop(o0, o1)?;
+ }
+ _ => {}
+ }
- let popped_ptr = {
- let single_popped_ty =
- registry.build_type(context, helper, registry, metadata, &popped_ctys[0])?;
+ let array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
+ IntegerType::new(context, 8).into(),
+ )?;
+ block.append_operation(ReallocBindingsMeta::free(context, array_ptr, location)?);
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
- let popped_start =
- valid_block.append_op_result(arith::subi(array_end, popped_len_value, location))?;
+ valid_block.append_operation(helper.br(0, &[range_check, value_ptr], location));
+ }
- valid_block.append_op_result(llvm::get_element_ptr_dynamic(
+ {
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
context,
- array_ptr,
- &[popped_start],
- single_popped_ty,
- llvm::r#type::pointer(context, 0),
+ error_block,
location,
- ))?
- };
-
- // Allocate memory for return array
-
- let return_ptr = {
- let null_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
+ &info.signature.param_signatures[1].ty,
+ entry.argument(1)?.into(),
)?;
- valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context,
- null_ptr,
- popped_size_value,
- location,
- )?)?
- };
-
- valid_block.memcpy(context, location, popped_ptr, return_ptr, popped_size_value);
- // Update array end (removing popped elements)
-
- let array = {
- let new_array_end =
- valid_block.append_op_result(arith::subi(array_end, popped_len_value, location))?;
-
- valid_block.insert_value(context, location, array, new_array_end, 2)?
- };
-
- valid_block.append_operation(helper.br(0, &[range_check, array, return_ptr], location));
+ error_block.append_operation(helper.br(1, &[range_check], location));
}
- invalid_block.append_operation(helper.br(1, &[range_check, array], location));
-
Ok(())
}
@@ -3613,39 +4498,61 @@
metadata: &mut MetadataStorage,
info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- let range_check = super::increment_builtin_counter(context, entry, location, entry.arg(0)?)?;
+ // Signature:
+ // Params: RangeCheck, Snapshot<Array<felt252>>, u32, u32
+ // Branches:
+ // 0: RangeCheck, Snapshot<Array<felt252>>
+ // 1: RangeCheck
+ let ptr_ty = llvm::r#type::pointer(context, 0);
let len_ty = IntegerType::new(context, 32).into();
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
+ let self_ty = registry.build_type(
+ context,
+ helper,
+ registry,
+ metadata,
+ &info.signature.param_signatures[1].ty,
+ )?;
+
+ let range_check =
+ super::increment_builtin_counter(context, entry, location, entry.argument(0)?.into())?;
- let array_start = entry.extract_value(context, location, entry.arg(1)?, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, entry.arg(1)?, len_ty, 2)?;
+ let k0 = entry.const_int_from_type(context, location, 0, len_ty)?;
+ let k1 = entry.const_int_from_type(context, location, 1, len_ty)?;
+
+ let array_start =
+ entry.extract_value(context, location, entry.argument(1)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(1)?.into(), len_ty, 2)?;
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let slice_start = entry.arg(2)?;
- let slice_len = entry.arg(3)?;
- let slice_end = entry.addi(slice_start, slice_len, location)?;
+ let slice_start = entry.argument(2)?.into();
+ let slice_len = entry.argument(3)?.into();
+ let slice_end = entry.append_op_result(arith::addi(slice_start, slice_len, location))?;
- let slice_start = entry.addi(array_start, slice_start, location)?;
- let slice_end = entry.addi(array_start, slice_end, location)?;
- let lhs_bound = entry.cmpi(
+ let slice_lhs_bound = entry.append_op_result(arith::cmpi(
context,
- CmpiPredicate::Uge,
+ CmpiPredicate::Ule,
slice_start,
- array_start,
+ array_len,
location,
- )?;
- let rhs_bound = entry.cmpi(context, CmpiPredicate::Ule, slice_end, array_end, location)?;
-
- let is_valid = entry.append_op_result(arith::andi(lhs_bound, rhs_bound, location))?;
+ ))?;
+ let slice_rhs_bound = entry.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ule,
+ slice_end,
+ array_len,
+ location,
+ ))?;
+ let slice_bounds =
+ entry.append_op_result(arith::andi(slice_lhs_bound, slice_rhs_bound, location))?;
- let slice_block = helper.append_block(Block::new(&[]));
+ let valid_block = helper.append_block(Block::new(&[]));
let error_block = helper.append_block(Block::new(&[]));
entry.append_operation(cf::cond_br(
context,
- is_valid,
- slice_block,
+ slice_bounds,
+ valid_block,
error_block,
&[],
&[],
@@ -3653,89 +4560,229 @@
));
{
- let elem_ty = elem_ty.build(context, helper, registry, metadata, &info.ty)?;
+ let (elem_ty, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
+ let elem_stride =
+ valid_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let value = entry.arg(1)?;
- let value = slice_block.insert_value(context, location, value, slice_start, 1)?;
- let value = slice_block.insert_value(context, location, value, slice_end, 2)?;
+ let slice_size = valid_block.append_op_result(arith::extui(
+ slice_len,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let slice_size =
+ valid_block.append_op_result(arith::muli(elem_stride, slice_size, location))?;
+ let slice_size_with_offset = valid_block.append_op_result(arith::addi(
+ slice_size,
+ valid_block.const_int(context, location, calc_refcount_offset(elem_layout), 64)?,
+ location,
+ ))?;
- let elem_stride =
- slice_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let prepare = |value| {
- let value = slice_block.extui(value, IntegerType::new(context, 64).into(), location)?;
- slice_block.muli(value, elem_stride, location)
- };
+ let slice_ptr = valid_block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let slice_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ slice_ptr,
+ slice_size_with_offset,
+ location,
+ )?)?;
+ valid_block.store(context, location, slice_ptr, k1)?;
- let ptr = slice_block.extract_value(
+ let slice_ptr = valid_block.gep(
context,
location,
- entry.arg(1)?,
- llvm::r#type::pointer(context, 0),
- 0,
+ slice_ptr,
+ &[GepIndex::Const(calc_refcount_offset(elem_layout) as i32)],
+ IntegerType::new(context, 8).into(),
)?;
- let make_region = |drop_overrides_meta: &DropOverridesMeta| {
- let region = Region::new();
- let block = region.append_block(Block::new(&[(
- IntegerType::new(context, 64).into(),
- location,
- )]));
- let value_ptr = block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[block.arg(0)?],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
+ let array_ptr =
+ valid_block.extract_value(context, location, entry.argument(1)?.into(), ptr_ty, 0)?;
+ let is_shared = is_shared(context, valid_block, location, array_ptr, elem_layout)?;
- let value = block.load(context, location, value_ptr, elem_ty)?;
- drop_overrides_meta.invoke_override(context, &block, location, &info.ty, value)?;
+ let offset =
+ valid_block.append_op_result(arith::addi(array_start, slice_start, location))?;
+ let offset = valid_block.append_op_result(arith::extui(
+ offset,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let offset = valid_block.append_op_result(arith::muli(offset, elem_stride, location))?;
- block.append_operation(scf::r#yield(&[], location));
- Result::Ok(region)
- };
+ let source_ptr = valid_block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
- let array_start = prepare(array_start)?;
- let array_end = prepare(array_end)?;
- let slice_start = prepare(slice_start)?;
- let slice_end = prepare(slice_end)?;
-
- match metadata.get::<DropOverridesMeta>() {
- Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
- slice_block.append_operation(scf::r#for(
- array_start,
- slice_start,
- elem_stride,
- make_region(drop_overrides_meta)?,
- location,
- ));
- slice_block.append_operation(scf::r#for(
- slice_end,
- array_end,
- elem_stride,
- make_region(drop_overrides_meta)?,
- location,
- ));
- }
- _ => {}
- };
+ valid_block.append_operation(scf::r#if(
+ is_shared,
+ &[],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(&info.ty) => {
+ let k0 = valid_block.const_int(context, location, 0, 64)?;
+ valid_block.append_operation(scf::r#for(
+ k0,
+ slice_size,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let offset = block.argument(0)?.into();
+ let source_ptr = block.gep(
+ context,
+ location,
+ source_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let target_ptr = block.gep(
+ context,
+ location,
+ slice_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let value = block.load(context, location, source_ptr, elem_ty)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, &info.ty, value)?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, target_ptr, values.1)?;
- slice_block.append_operation(helper.br(0, &[range_check, value], location));
- }
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ }
+ _ => block.memcpy(context, location, source_ptr, slice_ptr, slice_size),
+ }
- {
- registry.build_type(
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
+ context,
+ &block,
+ location,
+ &info.signature.param_signatures[1].ty,
+ entry.argument(1)?.into(),
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ block.memcpy(context, location, source_ptr, slice_ptr, slice_size);
+
+ match metadata.get::<DropOverridesMeta>() {
+ Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
+ let drop_loop = |o0, o1| {
+ block.append_operation(scf::r#for(
+ o0,
+ o1,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let value_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(block.argument(0)?.into())],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let value =
+ block.load(context, location, value_ptr, elem_ty)?;
+ drop_overrides_meta.invoke_override(
+ context, &block, location, &info.ty, value,
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+
+ Result::Ok(())
+ };
+
+ let o0 = block.append_op_result(arith::extui(
+ array_start,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::addi(
+ array_start,
+ slice_start,
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::extui(
+ o1,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o0 = block.append_op_result(arith::muli(o0, elem_stride, location))?;
+ let o1 = block.append_op_result(arith::muli(o1, elem_stride, location))?;
+ drop_loop(o0, o1)?;
+
+ let o0 = block.append_op_result(arith::addi(o1, slice_size, location))?;
+ let o1 = block.append_op_result(arith::extui(
+ array_end,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::muli(o1, elem_stride, location))?;
+ drop_loop(o0, o1)?;
+ }
+ _ => {}
+ }
+
+ let array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
+ IntegerType::new(context, 8).into(),
+ )?;
+ block.append_operation(ReallocBindingsMeta::free(context, array_ptr, location)?);
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+
+ let slice_value = valid_block.append_op_result(llvm::undef(self_ty, location))?;
+ let slice_value = valid_block.insert_values(
context,
- helper,
- registry,
- metadata,
- &info.signature.param_signatures[1].ty,
+ location,
+ slice_value,
+ &[slice_ptr, k0, slice_len, slice_len],
)?;
- // The metadata get will never fail because an array always has a drop implementation,
- // which at this point is always inserted thanks to the `build_type()` just above.
- metadata
+ valid_block.append_operation(helper.br(0, &[range_check, slice_value], location));
+ }
+
+ {
+ metadata
.get::<DropOverridesMeta>()
.ok_or(Error::MissingMetadata)?
.invoke_override(
@@ -3743,7 +4790,7 @@
error_block,
location,
&info.signature.param_signatures[1].ty,
- entry.arg(1)?,
+ entry.argument(1)?.into(),
)?;
error_block.append_operation(helper.br(1, &[range_check], location));
@@ -3752,309 +4799,137 @@
Ok(())
}
-/// Generate MLIR operations for the `span_from_tuple` libfunc.
-pub fn build_span_from_tuple<'ctx, 'this>(
+/// Generate MLIR operations for the `array_len` libfunc.
+pub fn build_len<'ctx, 'this>(
context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+ _registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
location: Location<'ctx>,
helper: &LibfuncHelper<'ctx, 'this>,
metadata: &mut MetadataStorage,
info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- // tuple to array span (t,t,t) -> &[t,t,t]
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let struct_type_info = registry.get_type(&info.ty)?;
-
- let struct_ty = registry.build_type(context, helper, registry, metadata, &info.ty)?;
-
- let container: Value = {
- // load box
- entry.load(context, location, entry.arg(0)?, struct_ty)?
- };
- // TODO: Maybe reuse the pointer?
- entry.append_operation(ReallocBindingsMeta::free(context, entry.arg(0)?, location)?);
-
- let fields = struct_type_info.fields().expect("should have fields");
- let (field_ty, field_layout) =
- registry.build_type_with_layout(context, helper, registry, metadata, &fields[0])?;
- let field_stride = field_layout.pad_to_align().size();
-
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.branch_signatures()[0].vars[0].ty,
- )?;
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
-
- let array_len_value = entry.const_int_from_type(context, location, fields.len(), len_ty)?;
-
- let array_container = entry.append_op_result(llvm::undef(array_ty, location))?;
-
- let k0 = entry.const_int_from_type(context, location, 0, len_ty)?;
-
- let array_container = entry.insert_value(context, location, array_container, k0, 1)?;
- let array_container =
- entry.insert_value(context, location, array_container, array_len_value, 2)?;
- let array_container =
- entry.insert_value(context, location, array_container, array_len_value, 3)?;
-
- let ptr = entry
- .append_op_result(ods::llvm::mlir_zero(context, pointer(context, 0), location).into())?;
-
- let field_size: Value = entry.const_int(context, location, field_stride, 64)?;
- let array_len_value_i64 = entry.extui(array_len_value, field_size.r#type(), location)?;
- let total_size = entry.muli(field_size, array_len_value_i64, location)?;
+ let len_ty = IntegerType::new(context, 32).into();
- let ptr = entry.append_op_result(ReallocBindingsMeta::realloc(
- context, ptr, total_size, location,
- )?)?;
+ let array_start =
+ entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 2)?;
- for (i, _) in fields.iter().enumerate() {
- let value: Value = entry.extract_value(context, location, container, field_ty, i)?;
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let target_ptr = entry.append_op_result(llvm::get_element_ptr(
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
context,
- ptr,
- DenseI32ArrayAttribute::new(context, &[i as i32]),
- field_ty,
- pointer(context, 0),
+ entry,
location,
- ))?;
-
- entry.store(context, location, target_ptr, value)?;
- }
-
- let array_container = entry.insert_value(context, location, array_container, ptr, 0)?;
-
- entry.append_operation(helper.br(0, &[array_container], location));
+ &info.signature.param_signatures[0].ty,
+ entry.argument(0)?.into(),
+ )?;
+ entry.append_operation(helper.br(0, &[array_len], location));
Ok(())
}
-fn assert_nonnull<'ctx, 'this>(
+fn calc_refcount_offset(layout: Layout) -> usize {
+ get_integer_layout(32)
+ .align_to(layout.align())
+ .unwrap()
+ .pad_to_align()
+ .size()
+}
+
+fn is_shared<'ctx, 'this>(
context: &'ctx Context,
- entry: &'this Block<'ctx>,
+ block: &'this Block<'ctx>,
location: Location<'ctx>,
- ptr: Value<'ctx, 'this>,
- msg: &str,
-) -> Result<()> {
- let null_ptr =
- entry.append_op_result(ods::llvm::mlir_zero(context, ptr.r#type(), location).into())?;
-
- let ptr_is_not_null = entry.append_op_result(
- ods::llvm::icmp(
+ array_ptr: Value<'ctx, 'this>,
+ elem_layout: Layout,
+) -> Result<Value<'ctx, 'this>> {
+ let k0 = block.const_int(context, location, 0, 64)?;
+ let ptr_as_int = block.append_op_result(
+ ods::llvm::ptrtoint(
context,
- IntegerType::new(context, 1).into(),
- ptr,
- null_ptr,
- IntegerAttribute::new(IntegerType::new(context, 64).into(), 1).into(),
+ IntegerType::new(context, 64).into(),
+ array_ptr,
location,
)
.into(),
)?;
-
- entry.append_operation(cf::assert(context, ptr_is_not_null, msg, location));
- Ok(())
-}
-
-pub fn build_tuple_from_span<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- // Tasks:
- // - Check if sizes match.
- // - If they do not match, jump to branch [1].
- // - If they do match:
- // - If start == 0 && capacity == len -> reuse the pointer
- // - Otherwise, realloc + memcpy + free.
-
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let array_ty = registry.get_type(&info.signature.param_signatures[0].ty)?;
- let (elem_id, elem_ty) = match array_ty {
- CoreTypeConcrete::Array(info) => (&info.ty, registry.get_type(&info.ty)?),
- CoreTypeConcrete::Snapshot(info) => match registry.get_type(&info.ty)? {
- CoreTypeConcrete::Array(info) => (&info.ty, registry.get_type(&info.ty)?),
- _ => native_panic!(
- "matched an unexpected CoreTypeConcrete that is not a Array or Snapshot"
- ),
- },
- _ => {
- native_panic!("matched an unexpected CoreTypeConcrete that is not a Array or Snapshot")
- }
- };
- let elem_layout = elem_ty.layout(registry)?;
-
- let array_start = entry.extract_value(
- context,
- location,
- entry.arg(0)?,
- IntegerType::new(context, 32).into(),
- 1,
- )?;
- let array_end = entry.extract_value(
- context,
- location,
- entry.arg(0)?,
- IntegerType::new(context, 32).into(),
- 2,
- )?;
-
- let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let (tuple_len, tuple_len_val) = {
- let fields = registry
- .get_type(&info.ty)?
- .fields()
- .to_native_assert_error("missing field")?;
-
- native_assert!(
- fields.iter().all(|f| f.id == elem_id.id),
- "all the elements of the array must have the same type"
- );
-
- (
- entry.const_int(context, location, fields.len(), 32)?,
- fields.len(),
- )
- };
-
- let len_matches = entry.cmpi(context, CmpiPredicate::Eq, array_len, tuple_len, location)?;
-
- let block_ok = helper.append_block(Block::new(&[]));
- let block_err = helper.append_block(Block::new(&[]));
- entry.append_operation(cf::cond_br(
+ let ptr_is_null = block.append_op_result(arith::cmpi(
context,
- len_matches,
- block_ok,
- block_err,
- &[],
- &[],
+ CmpiPredicate::Eq,
+ ptr_as_int,
+ k0,
location,
- ));
-
- {
- let k0 = block_ok.const_int(context, location, 0, 32)?;
- let starts_at_zero =
- block_ok.cmpi(context, CmpiPredicate::Eq, array_start, k0, location)?;
-
- let array_cap = block_ok.extract_value(
- context,
- location,
- entry.arg(0)?,
- IntegerType::new(context, 32).into(),
- 3,
- )?;
- let capacity_matches =
- block_ok.cmpi(context, CmpiPredicate::Eq, array_cap, tuple_len, location)?;
+ ))?;
- let array_ptr = block_ok.extract_value(
- context,
- location,
- entry.arg(0)?,
- llvm::r#type::pointer(context, 0),
- 0,
- )?;
- let should_forward_pointer =
- block_ok.append_op_result(arith::andi(starts_at_zero, capacity_matches, location))?;
+ let is_shared = block.append_op_result(scf::r#if(
+ ptr_is_null,
+ &[IntegerType::new(context, 1).into()],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let block_clone = helper.append_block(Block::new(&[]));
- let block_forward = helper.append_block(Block::new(&[]));
- block_ok.append_operation(cf::cond_br(
- context,
- should_forward_pointer,
- block_forward,
- block_clone,
- &[],
- &[],
- location,
- ));
+ let k0 = block.const_int(context, location, 0, 1)?;
+ block.append_operation(scf::r#yield(&[k0], location));
+ region
+ },
{
- let elem_stride =
- block_clone.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let tuple_len =
- block_clone.extui(tuple_len, IntegerType::new(context, 64).into(), location)?;
- let tuple_len = block_clone.muli(tuple_len, elem_stride, location)?;
-
- let box_ptr = block_clone
- .append_op_result(llvm::zero(llvm::r#type::pointer(context, 0), location))?;
- let box_ptr = block_clone.append_op_result(ReallocBindingsMeta::realloc(
- context, box_ptr, tuple_len, location,
- )?)?;
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let elem_offset =
- block_clone.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let elem_offset = block_clone.muli(elem_offset, elem_stride, location)?;
- let elem_ptr = block_clone.append_op_result(llvm::get_element_ptr_dynamic(
+ let array_ptr = block.gep(
context,
+ location,
array_ptr,
- &[elem_offset],
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
+ )?;
+ let ref_count = block.load(
+ context,
location,
- ))?;
+ array_ptr,
+ IntegerType::new(context, 32).into(),
+ )?;
- block_clone.append_operation(
- ods::llvm::intr_memcpy_inline(
+ #[cfg(debug_assertions)]
+ {
+ let k0 = block.const_int(context, location, 0, 32)?;
+ let is_nonzero = block.append_op_result(arith::cmpi(
context,
- box_ptr,
- elem_ptr,
- IntegerAttribute::new(
- IntegerType::new(context, 64).into(),
- (tuple_len_val * elem_layout.pad_to_align().size()) as i64,
- ),
- IntegerAttribute::new(IntegerType::new(context, 1).into(), 0),
+ CmpiPredicate::Ne,
+ ref_count,
+ k0,
location,
- )
- .into(),
- );
-
- block_clone.append_operation(ReallocBindingsMeta::free(context, array_ptr, location)?);
- block_clone.append_operation(helper.br(0, &[box_ptr], location));
- }
+ ))?;
- block_forward.append_operation(helper.br(0, &[array_ptr], location));
- }
-
- {
- registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.signature.param_signatures[0].ty,
- )?;
+ block.append_operation(cf::assert(
+ context,
+ is_nonzero,
+ "ref_count must not be zero",
+ location,
+ ));
+ }
- // The metadata get will never fail because an array always has a drop implementation,
- // which at this point is always inserted thanks to the `build_type()` just above.
- metadata
- .get::<DropOverridesMeta>()
- .ok_or(Error::MissingMetadata)?
- .invoke_override(
+ let k1 = block.const_int(context, location, 1, 32)?;
+ let is_shared = block.append_op_result(arith::cmpi(
context,
- block_err,
+ CmpiPredicate::Ne,
+ ref_count,
+ k1,
location,
- &info.signature.param_signatures[0].ty,
- entry.arg(0)?,
- )?;
+ ))?;
- block_err.append_operation(helper.br(1, &[], location));
- }
+ block.append_operation(scf::r#yield(&[is_shared], location));
+ region
+ },
+ location,
+ ))?;
- Ok(())
+ Ok(is_shared)
}
#[cfg(test)]
@@ -4365,7 +5240,6 @@
//data.append(5_u32);
*slice.get(0).unwrap().unbox()
}
-
);
let result = run_program(&program, "run_test", &[]).return_value;
diff --git a/src/cairo_native/metadata/debug_utils.rs.html b/src/cairo_native/metadata/debug_utils.rs.html
index ca4f3df8a..343e1c931 100644
--- a/src/cairo_native/metadata/debug_utils.rs.html
+++ b/src/cairo_native/metadata/debug_utils.rs.html
@@ -1563,7 +1563,7 @@
unsafe extern "C" fn dump_mem_impl(ptr: *const (), len: u64) {
println!("[DEBUG] Memory dump at {ptr:?}:");
for chunk in (0..len).step_by(8) {
- print!(" {ptr:?}:");
+ print!(" {:?}:", ptr.byte_add(chunk as usize));
for offset in chunk..chunk + 8 {
print!(" {:02x}", ptr.byte_add(offset as usize).cast::<u8>().read());
}
diff --git a/src/cairo_native/starknet.rs.html b/src/cairo_native/starknet.rs.html
index 4725ec488..b936c8a27 100644
--- a/src/cairo_native/starknet.rs.html
+++ b/src/cairo_native/starknet.rs.html
@@ -1703,6 +1703,33 @@
1703
1704
1705
+1706
+1707
+1708
+1709
+1710
+1711
+1712
+1713
+1714
+1715
+1716
+1717
+1718
+1719
+1720
+1721
+1722
+1723
+1724
+1725
+1726
+1727
+1728
+1729
+1730
+1731
+1732
//! Starknet related code for `cairo_native`
use serde::{Deserialize, Serialize};
@@ -2245,12 +2272,11 @@
// TODO: Move to the correct place or remove if unused.
pub(crate) mod handler {
use super::*;
- use crate::utils::{libc_free, libc_malloc};
+ use crate::utils::{get_integer_layout, libc_free, libc_malloc};
use std::{
alloc::Layout,
- ffi::c_void,
fmt::Debug,
- mem::{size_of, ManuallyDrop, MaybeUninit},
+ mem::{self, size_of, ManuallyDrop, MaybeUninit},
ptr::{null_mut, NonNull},
};
@@ -2614,7 +2640,17 @@
capacity: 0,
},
_ => {
- let ptr = libc_malloc(Layout::array::<E>(data.len()).unwrap().size()) as *mut E;
+ let refcount_offset = get_integer_layout(32)
+ .align_to(mem::align_of::<E>())
+ .unwrap()
+ .pad_to_align()
+ .size();
+ let ptr = libc_malloc(
+ Layout::array::<E>(data.len()).unwrap().size() + refcount_offset,
+ ) as *mut E;
+
+ ptr.cast::<u32>().write(1);
+ let ptr = ptr.byte_add(refcount_offset);
let len: u32 = data.len().try_into().unwrap();
for (i, val) in data.iter().enumerate() {
@@ -2631,6 +2667,24 @@
}
}
+ unsafe fn drop_mlir_array<E>(data: &ArrayAbi<E>) {
+ if data.ptr.is_null() {
+ return;
+ }
+
+ let refcount_offset = get_integer_layout(32)
+ .align_to(mem::align_of::<E>())
+ .unwrap()
+ .pad_to_align()
+ .size();
+
+ let ptr = data.ptr.byte_sub(refcount_offset);
+ match ptr.cast::<u32>().read() {
+ 1 => libc_free(ptr.cast()),
+ n => ptr.cast::<u32>().write(n - 1),
+ }
+ }
+
fn wrap_error<E>(e: &[Felt]) -> SyscallResultAbi<E> {
SyscallResultAbi {
err: ManuallyDrop::new(SyscallResultAbiErr {
@@ -2673,7 +2727,7 @@
let input_vec: Vec<_> = input.into();
unsafe {
- libc_free(input.ptr as *mut c_void);
+ Self::drop_mlir_array(input);
}
let result = ptr
@@ -2860,7 +2914,7 @@
let calldata_vec: Vec<_> = calldata.into();
unsafe {
- libc_free(calldata.ptr as *mut c_void);
+ Self::drop_mlir_array(calldata);
}
let result = ptr.deploy(
@@ -2920,7 +2974,7 @@
let calldata_vec: Vec<Felt> = calldata.into();
unsafe {
- libc_free(calldata.ptr as *mut c_void);
+ Self::drop_mlir_array(calldata);
}
let result = ptr.library_call(class_hash, function_selector, &calldata_vec, gas);
@@ -2954,7 +3008,7 @@
let calldata_vec: Vec<Felt> = calldata.into();
unsafe {
- libc_free(calldata.ptr as *mut c_void);
+ Self::drop_mlir_array(calldata);
}
let result = ptr.call_contract(address, entry_point_selector, &calldata_vec, gas);
@@ -3028,13 +3082,13 @@
let keys_vec: Vec<_> = keys.into();
unsafe {
- libc_free(keys.ptr as *mut c_void);
+ Self::drop_mlir_array(keys);
}
let data_vec: Vec<_> = data.into();
unsafe {
- libc_free(data.ptr as *mut c_void);
+ Self::drop_mlir_array(data);
}
let result = ptr.emit_event(&keys_vec, &data_vec, gas);
@@ -3061,7 +3115,7 @@
let payload_vec: Vec<_> = payload.into();
unsafe {
- libc_free(payload.ptr as *mut c_void);
+ Self::drop_mlir_array(payload);
}
let result = ptr.send_message_to_l1(to_address, &payload_vec, gas);
@@ -3096,7 +3150,7 @@
let result = ptr.keccak(input_vec, gas);
unsafe {
- libc_free(input.ptr as *mut c_void);
+ Self::drop_mlir_array(input);
}
*result_ptr = match result {
diff --git a/src/cairo_native/types.rs.html b/src/cairo_native/types.rs.html
index b080dc46b..87b16786e 100644
--- a/src/cairo_native/types.rs.html
+++ b/src/cairo_native/types.rs.html
@@ -1011,16 +1011,6 @@
1011
1012
1013
-1014
-1015
-1016
-1017
-1018
-1019
-1020
-1021
-1022
-1023
Constant cairo_native::starknet::SYSCALL_HANDLER_VTABLE
source · pub const SYSCALL_HANDLER_VTABLE: LocalKey<Cell<*mut ()>>;Constant cairo_native::starknet::SYSCALL_HANDLER_VTABLE
source · pub const SYSCALL_HANDLER_VTABLE: LocalKey<Cell<*mut ()>>;Function cairo_native::starknet::cairo_native__vtable_cheatcode
source · pub extern "C" fn cairo_native__vtable_cheatcode(
+cairo_native__vtable_cheatcode in cairo_native::starknet - Rust Function cairo_native::starknet::cairo_native__vtable_cheatcode
source · pub extern "C" fn cairo_native__vtable_cheatcode(
result_ptr: &mut ArrayAbi<Felt252Abi>,
selector: &Felt252Abi,
input: &ArrayAbi<Felt252Abi>,
diff --git a/cairo_native/starknet/index.html b/cairo_native/starknet/index.html
index 494cb1417..81181e74c 100644
--- a/cairo_native/starknet/index.html
+++ b/cairo_native/starknet/index.html
@@ -1,2 +1,2 @@
-cairo_native::starknet - Rust Module cairo_native::starknet
source · Expand description
Starknet related code for cairo_native
+cairo_native::starknet - Rust Help Rustdoc help
BackHelp Rustdoc help
BackSettings Rustdoc settings
BackSettings Rustdoc settings
Back//! # Implementations of `AbiArgument` for the `x86_64` architecture.
//!
//! The x86_64 architecture uses 6 64-bit registers for arguments. This means that the first 48
@@ -271,93 +232,55 @@
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(())
}
@@ -365,9 +288,6 @@
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(())
}
@@ -378,6 +298,7 @@
if buffer.len() >= 40 {
align_to(buffer, get_integer_layout(128).align());
}
+
buffer.extend_from_slice(&self.to_ne_bytes());
Ok(())
}
@@ -388,6 +309,7 @@
if buffer.len() >= 40 {
align_to(buffer, get_integer_layout(128).align());
}
+
buffer.extend_from_slice(&self.to_ne_bytes());
Ok(())
}
@@ -415,13 +337,13 @@
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(())
}
}
diff --git a/src/cairo_native/executor.rs.html b/src/cairo_native/executor.rs.html
index 79b0e4508..73a2f1b74 100644
--- a/src/cairo_native/executor.rs.html
+++ b/src/cairo_native/executor.rs.html
@@ -766,6 +766,8 @@
766
767
768
+769
+770
//! # Executors
//!
//! This module provides methods to execute the programs, either via JIT or compiled ahead
@@ -1119,7 +1121,6 @@
#[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 {
@@ -1141,11 +1142,12 @@
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)
},
@@ -1153,6 +1155,7 @@
return_ptr.to_native_assert_error("return pointer should be valid")?,
type_id,
registry,
+ true,
)?),
CoreTypeConcrete::Felt252(_)
| CoreTypeConcrete::StarkNet(
@@ -1161,7 +1164,7 @@
| 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,
@@ -1180,7 +1183,7 @@
}
},
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,
@@ -1195,7 +1198,7 @@
}
},
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])
@@ -1267,7 +1270,7 @@
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)
}
@@ -1323,7 +1326,7 @@
}
};
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(
@@ -1338,27 +1341,28 @@
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) => {
diff --git a/src/cairo_native/executor/contract.rs.html b/src/cairo_native/executor/contract.rs.html
index 67b25e846..2ccbbdc54 100644
--- a/src/cairo_native/executor/contract.rs.html
+++ b/src/cairo_native/executor/contract.rs.html
@@ -831,6 +831,24 @@
831
832
833
+834
+835
+836
+837
+838
+839
+840
+841
+842
+843
+844
+845
+846
+847
+848
+849
+850
+851
//! A specialized executor for Starknet contracts, avoiding the overhead of storing the sierra program registry and
//! enabling efficient serialization of the program/data once compiled.
//!
@@ -867,7 +885,7 @@
use crate::{
arch::AbiArgument,
context::NativeContext,
- error::{panic::ToNativeAssertError, Error},
+ error::{panic::ToNativeAssertError, Error, Result},
execution_result::{BuiltinStats, ContractExecutionResult},
executor::invoke_trampoline,
metadata::gas::MetadataComputationConfig,
@@ -979,7 +997,7 @@
sierra_program: &Program,
entry_points: &ContractEntryPoints,
opt_level: OptLevel,
- ) -> Result<Self, Error> {
+ ) -> Result<Self> {
let native_context = NativeContext::new();
let mut entry_point_selector_to_id = BTreeMap::new();
@@ -1094,7 +1112,7 @@
}
/// Save the library to the desired path, alongside it is saved also a json file with additional info.
- pub fn save(&mut self, to: impl AsRef<Path>) -> Result<(), Error> {
+ pub fn save(&mut self, to: impl AsRef<Path>) -> Result<()> {
let to = to.as_ref();
std::fs::copy(&self.path, to)?;
@@ -1109,7 +1127,7 @@
}
/// Load the executor from an already compiled library with the additional info json file.
- pub fn load(library_path: &Path) -> Result<Self, Error> {
+ pub fn load(library_path: &Path) -> Result<Self> {
let info_str = std::fs::read_to_string(library_path.with_extension("json"))?;
let contract_info: NativeContractInfo = serde_json::from_str(&info_str)?;
Ok(Self {
@@ -1136,7 +1154,7 @@
gas: u64,
builtin_costs: Option<BuiltinCosts>,
mut syscall_handler: impl StarknetSyscallHandler,
- ) -> Result<ContractExecutionResult, Error> {
+ ) -> Result<ContractExecutionResult> {
let arena = Bump::new();
let mut invoke_data = Vec::<u8>::new();
@@ -1150,12 +1168,7 @@
};
let function_ptr = self.find_function_ptr(&function_id, true)?;
- let builtin_costs = builtin_costs.unwrap_or_default();
- let builtin_costs_stack: [u64; 7] = builtin_costs.into();
- // Note: the ptr into a slice is valid, it can be used with cast()
- // Care should be taken if you dereference it and take the .as_ptr() of the slice, since when you
- // deref it, it will be a copy on the stack, so you will get the ptr of the value in the stack.
- let builtin_costs: *mut [u64; 7] = Box::into_raw(Box::new(builtin_costs_stack));
+ let builtin_costs: [u64; 7] = builtin_costs.unwrap_or_default().into();
let set_costs_builtin = unsafe {
self.library
.get::<extern "C" fn(*const u64) -> *const u64>(
@@ -1163,7 +1176,7 @@
)?
};
// We may be inside a recursive contract, save the possible saved builtin costs to restore it after our call.
- let old_builtincosts_ptr = set_costs_builtin(builtin_costs.cast());
+ let old_builtincosts_ptr = set_costs_builtin(builtin_costs.as_ptr());
// it can vary from contract to contract thats why we need to store/ load it.
let builtins_size: usize = self.contract_info.entry_points_info[&function_id.id]
@@ -1189,7 +1202,7 @@
}
BuiltinType::BuiltinCosts => {
// todo: check if valid
- builtin_costs_stack.as_ptr().to_bytes(&mut invoke_data)?;
+ builtin_costs.as_ptr().to_bytes(&mut invoke_data)?;
}
BuiltinType::System => {
(&mut syscall_handler as *mut StarknetSyscallHandlerCallbacks<_>)
@@ -1202,18 +1215,42 @@
}
let felt_layout = get_integer_layout(252).pad_to_align();
- let ptr: *mut () = unsafe { libc_malloc(felt_layout.size() * args.len()).cast() };
+ let refcount_offset = get_integer_layout(32)
+ .align_to(felt_layout.align())
+ .unwrap()
+ .pad_to_align()
+ .size();
+
+ let ptr = match args.len() {
+ 0 => std::ptr::null_mut(),
+ _ => unsafe {
+ let ptr: *mut () =
+ libc_malloc(felt_layout.size() * args.len() + refcount_offset).cast();
+
+ // Write reference count.
+ ptr.cast::<u32>().write(1);
+ ptr.byte_add(refcount_offset)
+ },
+ };
let len: u32 = args
.len()
.try_into()
.to_native_assert_error("number of arguments should fit into a u32")?;
ptr.to_bytes(&mut invoke_data)?;
- 0u32.to_bytes(&mut invoke_data)?; // start
- len.to_bytes(&mut invoke_data)?; // end
- len.to_bytes(&mut invoke_data)?; // cap
+ if cfg!(target_arch = "aarch64") {
+ 0u32.to_bytes(&mut invoke_data)?; // start
+ len.to_bytes(&mut invoke_data)?; // end
+ len.to_bytes(&mut invoke_data)?; // cap
+ } else if cfg!(target_arch = "x86_64") {
+ (0u32 as u64).to_bytes(&mut invoke_data)?; // start
+ (len as u64).to_bytes(&mut invoke_data)?; // end
+ (len as u64).to_bytes(&mut invoke_data)?; // cap
+ } else {
+ unreachable!("unsupported architecture");
+ }
- for (idx, elem) in args.iter().enumerate() {
+ for (idx, elem) in args.iter().enumerate() {
let f = elem.to_bytes_le();
unsafe {
std::ptr::copy_nonoverlapping(
@@ -1354,7 +1391,12 @@
}
if !array_ptr.is_null() {
- unsafe { libc_free(array_ptr.cast()) };
+ unsafe {
+ let ptr = array_ptr.byte_sub(refcount_offset);
+ assert_eq!(ptr.cast::<u32>().read(), 1);
+
+ libc_free(ptr.cast());
+ }
}
let error_msg = if tag != 0 {
@@ -1371,14 +1413,8 @@
None
};
- // Restore the old ptr and get back our builtincost box and free it.
- let our_builtincosts_ptr = set_costs_builtin(old_builtincosts_ptr);
-
- if !our_builtincosts_ptr.is_null() && old_builtincosts_ptr.is_aligned() {
- unsafe {
- let _ = Box::<[u64; 7]>::from_raw(our_builtincosts_ptr.cast_mut().cast());
- };
- }
+ // Restore the original builtin costs pointer.
+ set_costs_builtin(old_builtincosts_ptr);
#[cfg(feature = "with-mem-tracing")]
crate::utils::mem_tracing::report_stats();
@@ -1395,7 +1431,7 @@
&self,
function_id: &FunctionId,
is_for_contract_executor: bool,
- ) -> Result<*mut c_void, Error> {
+ ) -> Result<*mut c_void> {
let function_name = generate_function_name(function_id, is_for_contract_executor);
let function_name = format!("_mlir_ciface_{function_name}");
diff --git a/src/cairo_native/libfuncs.rs.html b/src/cairo_native/libfuncs.rs.html
index e8fb9dcdb..78455dd94 100644
--- a/src/cairo_native/libfuncs.rs.html
+++ b/src/cairo_native/libfuncs.rs.html
@@ -632,9 +632,9 @@
Self::Const(selector) => self::r#const::build(
context, registry, entry, location, helper, metadata, selector,
),
- Self::Coupon(info) => {
- self::coupon::build(context, registry, entry, location, helper, metadata, info)
- }
+ Self::Coupon(selector) => self::coupon::build(
+ context, registry, entry, location, helper, metadata, selector,
+ ),
Self::CouponCall(info) => self::function_call::build(
context, registry, entry, location, helper, metadata, info,
),
diff --git a/src/cairo_native/libfuncs/array.rs.html b/src/cairo_native/libfuncs/array.rs.html
index c7616528f..070d7878a 100644
--- a/src/cairo_native/libfuncs/array.rs.html
+++ b/src/cairo_native/libfuncs/array.rs.html
@@ -2513,44 +2513,474 @@
2513
2514
2515
+2516
+2517
+2518
+2519
+2520
+2521
+2522
+2523
+2524
+2525
+2526
+2527
+2528
+2529
+2530
+2531
+2532
+2533
+2534
+2535
+2536
+2537
+2538
+2539
+2540
+2541
+2542
+2543
+2544
+2545
+2546
+2547
+2548
+2549
+2550
+2551
+2552
+2553
+2554
+2555
+2556
+2557
+2558
+2559
+2560
+2561
+2562
+2563
+2564
+2565
+2566
+2567
+2568
+2569
+2570
+2571
+2572
+2573
+2574
+2575
+2576
+2577
+2578
+2579
+2580
+2581
+2582
+2583
+2584
+2585
+2586
+2587
+2588
+2589
+2590
+2591
+2592
+2593
+2594
+2595
+2596
+2597
+2598
+2599
+2600
+2601
+2602
+2603
+2604
+2605
+2606
+2607
+2608
+2609
+2610
+2611
+2612
+2613
+2614
+2615
+2616
+2617
+2618
+2619
+2620
+2621
+2622
+2623
+2624
+2625
+2626
+2627
+2628
+2629
+2630
+2631
+2632
+2633
+2634
+2635
+2636
+2637
+2638
+2639
+2640
+2641
+2642
+2643
+2644
+2645
+2646
+2647
+2648
+2649
+2650
+2651
+2652
+2653
+2654
+2655
+2656
+2657
+2658
+2659
+2660
+2661
+2662
+2663
+2664
+2665
+2666
+2667
+2668
+2669
+2670
+2671
+2672
+2673
+2674
+2675
+2676
+2677
+2678
+2679
+2680
+2681
+2682
+2683
+2684
+2685
+2686
+2687
+2688
+2689
+2690
+2691
+2692
+2693
+2694
+2695
+2696
+2697
+2698
+2699
+2700
+2701
+2702
+2703
+2704
+2705
+2706
+2707
+2708
+2709
+2710
+2711
+2712
+2713
+2714
+2715
+2716
+2717
+2718
+2719
+2720
+2721
+2722
+2723
+2724
+2725
+2726
+2727
+2728
+2729
+2730
+2731
+2732
+2733
+2734
+2735
+2736
+2737
+2738
+2739
+2740
+2741
+2742
+2743
+2744
+2745
+2746
+2747
+2748
+2749
+2750
+2751
+2752
+2753
+2754
+2755
+2756
+2757
+2758
+2759
+2760
+2761
+2762
+2763
+2764
+2765
+2766
+2767
+2768
+2769
+2770
+2771
+2772
+2773
+2774
+2775
+2776
+2777
+2778
+2779
+2780
+2781
+2782
+2783
+2784
+2785
+2786
+2787
+2788
+2789
+2790
+2791
+2792
+2793
+2794
+2795
+2796
+2797
+2798
+2799
+2800
+2801
+2802
+2803
+2804
+2805
+2806
+2807
+2808
+2809
+2810
+2811
+2812
+2813
+2814
+2815
+2816
+2817
+2818
+2819
+2820
+2821
+2822
+2823
+2824
+2825
+2826
+2827
+2828
+2829
+2830
+2831
+2832
+2833
+2834
+2835
+2836
+2837
+2838
+2839
+2840
+2841
+2842
+2843
+2844
+2845
+2846
+2847
+2848
+2849
+2850
+2851
+2852
+2853
+2854
+2855
+2856
+2857
+2858
+2859
+2860
+2861
+2862
+2863
+2864
+2865
+2866
+2867
+2868
+2869
+2870
+2871
+2872
+2873
+2874
+2875
+2876
+2877
+2878
+2879
+2880
+2881
+2882
+2883
+2884
+2885
+2886
+2887
+2888
+2889
+2890
+2891
+2892
+2893
+2894
+2895
+2896
+2897
+2898
+2899
+2900
+2901
+2902
+2903
+2904
+2905
+2906
+2907
+2908
+2909
+2910
+2911
+2912
+2913
+2914
+2915
+2916
+2917
+2918
+2919
+2920
+2921
+2922
+2923
+2924
+2925
+2926
+2927
+2928
+2929
+2930
+2931
+2932
+2933
+2934
+2935
+2936
+2937
+2938
+2939
+2940
+2941
+2942
+2943
+2944
+2945
+2946
+2947
+2948
+2949
+2950
+2951
+2952
//! # Array libfuncs
-// TODO: A future possible improvement would be to put the array behind a double pointer and a
-// reference counter, to avoid unnecessary clones.
-
use super::LibfuncHelper;
use crate::{
- error::{panic::ToNativeAssertError, Error, Result},
+ error::{Error, Result, SierraAssertError},
metadata::{
- drop_overrides::DropOverridesMeta, realloc_bindings::ReallocBindingsMeta, MetadataStorage,
+ drop_overrides::DropOverridesMeta, dup_overrides::DupOverridesMeta,
+ realloc_bindings::ReallocBindingsMeta, MetadataStorage,
},
- native_assert, native_panic,
- types::TypeBuilder,
- utils::{BlockExt, GepIndex, ProgramRegistryExt},
+ utils::{get_integer_layout, BlockExt, GepIndex, ProgramRegistryExt},
};
use cairo_lang_sierra::{
extensions::{
array::{ArrayConcreteLibfunc, ConcreteMultiPopLibfunc},
core::{CoreLibfunc, CoreType, CoreTypeConcrete},
lib_func::{SignatureAndTypeConcreteLibfunc, SignatureOnlyConcreteLibfunc},
- ConcreteLibfunc,
+ types::InfoAndTypeConcreteType,
},
program_registry::ProgramRegistry,
};
use melior::{
dialect::{
arith::{self, CmpiPredicate},
- cf,
- llvm::{self, r#type::pointer},
- ods, scf,
+ cf, llvm, ods, scf,
},
ir::{
- attribute::{DenseI32ArrayAttribute, IntegerAttribute},
- r#type::IntegerType,
- Block, Location, Region, Value, ValueLike,
+ attribute::IntegerAttribute, r#type::IntegerType, Block, Location, Region, Value, ValueLike,
},
Context,
};
+use std::alloc::Layout;
/// Select and call the correct libfunc builder function from the selector.
pub fn build<'ctx, 'this>(
@@ -2566,15 +2996,33 @@
ArrayConcreteLibfunc::New(info) => {
build_new(context, registry, entry, location, helper, metadata, info)
}
- ArrayConcreteLibfunc::Append(info) => {
- build_append(context, registry, entry, location, helper, metadata, info)
+ ArrayConcreteLibfunc::SpanFromTuple(info) => {
+ build_span_from_tuple(context, registry, entry, location, helper, metadata, info)
}
- ArrayConcreteLibfunc::PopFront(info) => {
- build_pop_front(context, registry, entry, location, helper, metadata, info)
+ ArrayConcreteLibfunc::TupleFromSpan(info) => {
+ build_tuple_from_span(context, registry, entry, location, helper, metadata, info)
}
- ArrayConcreteLibfunc::PopFrontConsume(info) => {
- build_pop_front_consume(context, registry, entry, location, helper, metadata, info)
+ ArrayConcreteLibfunc::Append(info) => {
+ build_append(context, registry, entry, location, helper, metadata, info)
}
+ ArrayConcreteLibfunc::PopFront(info) => build_pop::<false, false>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Single(info),
+ ),
+ ArrayConcreteLibfunc::PopFrontConsume(info) => build_pop::<true, false>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Single(info),
+ ),
ArrayConcreteLibfunc::Get(info) => {
build_get(context, registry, entry, location, helper, metadata, info)
}
@@ -2584,23 +3032,41 @@
ArrayConcreteLibfunc::Len(info) => {
build_len(context, registry, entry, location, helper, metadata, info)
}
- ArrayConcreteLibfunc::SnapshotPopFront(info) => {
- build_snapshot_pop_front(context, registry, entry, location, helper, metadata, info)
- }
- ArrayConcreteLibfunc::SnapshotPopBack(info) => {
- build_snapshot_pop_back(context, registry, entry, location, helper, metadata, info)
- }
- ArrayConcreteLibfunc::SpanFromTuple(info) => {
- build_span_from_tuple(context, registry, entry, location, helper, metadata, info)
- }
- ArrayConcreteLibfunc::TupleFromSpan(info) => {
- build_tuple_from_span(context, registry, entry, location, helper, metadata, info)
- }
- ArrayConcreteLibfunc::SnapshotMultiPopFront(info) => build_snapshot_multi_pop_front(
- context, registry, entry, location, helper, metadata, info,
+ ArrayConcreteLibfunc::SnapshotPopFront(info) => build_pop::<false, false>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Single(info),
+ ),
+ ArrayConcreteLibfunc::SnapshotPopBack(info) => build_pop::<false, true>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Single(info),
),
- ArrayConcreteLibfunc::SnapshotMultiPopBack(info) => build_snapshot_multi_pop_back(
- context, registry, entry, location, helper, metadata, info,
+ ArrayConcreteLibfunc::SnapshotMultiPopFront(info) => build_pop::<false, false>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Multi(info),
+ ),
+ ArrayConcreteLibfunc::SnapshotMultiPopBack(info) => build_pop::<false, true>(
+ context,
+ registry,
+ entry,
+ location,
+ helper,
+ metadata,
+ PopInfo::Multi(info),
),
}
}
@@ -2608,37 +3074,33 @@
/// Generate MLIR operations for the `array_new` libfunc.
pub fn build_new<'ctx, 'this>(
context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+ _registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
location: Location<'ctx>,
helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureOnlyConcreteLibfunc,
+ _metadata: &mut MetadataStorage,
+ _info: &SignatureOnlyConcreteLibfunc,
) -> Result<()> {
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.branch_signatures()[0].vars[0].ty,
- )?;
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
- let ptr = entry
- .append_op_result(ods::llvm::mlir_zero(context, pointer(context, 0), location).into())?;
+ let nullptr = entry.append_op_result(llvm::zero(ptr_ty, location))?;
+ let k0 = entry.const_int_from_type(context, location, 0, len_ty)?;
- let k0 = entry.const_int(context, location, 0, 32)?;
- let value = entry.append_op_result(llvm::undef(array_ty, location))?;
- let value = entry.insert_value(context, location, value, ptr, 0)?;
- let value = entry.insert_value(context, location, value, k0, 1)?;
- let value = entry.insert_value(context, location, value, k0, 2)?;
- let value = entry.insert_value(context, location, value, k0, 3)?;
+ let value = entry.append_op_result(llvm::undef(
+ llvm::r#type::r#struct(context, &[ptr_ty, len_ty, len_ty, len_ty], false),
+ location,
+ ))?;
+ let value = entry.insert_values(context, location, value, &[nullptr, k0, k0, k0])?;
entry.append_operation(helper.br(0, &[value], location));
Ok(())
}
-/// Generate MLIR operations for the `array_append` libfunc.
-pub fn build_append<'ctx, 'this>(
+/// Generate MLIR operations for the `span_from_tuple` libfunc.
+///
+/// Note: The `&info.ty` field has the entire `[T; N]` tuple. It is not the `T` in `Array<T>`.
+pub fn build_span_from_tuple<'ctx, 'this>(
context: &'ctx Context,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
@@ -2647,237 +3109,264 @@
metadata: &mut MetadataStorage,
info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- // Algorithm:
- // - If array_end < capacity, then append.
- // - If array_end == capacity:
- // - If array_start == 0: realloc, then append.
- // - If array_start != 0: memmove, then append.
-
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
+ metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ let tuple_len = {
+ let CoreTypeConcrete::Struct(info) = registry.get_type(&info.ty)? else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ info.members.len()
+ };
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
- let elem_stride = elem_layout.pad_to_align().size();
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
+ let (_, tuple_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
- let k1 = entry.const_int(context, location, 1, 32)?;
+ let array_len_bytes = tuple_layout.pad_to_align().size();
+ let array_len_bytes_with_offset = entry.const_int(
+ context,
+ location,
+ array_len_bytes + calc_refcount_offset(tuple_layout),
+ 64,
+ )?;
+ let array_len_bytes = entry.const_int(context, location, array_len_bytes, 64)?;
+ let array_len = entry.const_int_from_type(context, location, tuple_len, len_ty)?;
- let elem_stride = entry.const_int(context, location, elem_stride, 64)?;
+ let k0 = entry.const_int_from_type(context, location, 0, len_ty)?;
+ let k1 = entry.const_int_from_type(context, location, 1, len_ty)?;
- let array_end = entry.extract_value(context, location, entry.arg(0)?, len_ty, 2)?;
- let array_capacity = entry.extract_value(context, location, entry.arg(0)?, len_ty, 3)?;
+ let array_ptr = entry.append_op_result(llvm::zero(ptr_ty, location))?;
+ let array_ptr = entry.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ array_ptr,
+ array_len_bytes_with_offset,
+ location,
+ )?)?;
+ entry.store(context, location, array_ptr, k1)?;
- let has_tail_space = entry.cmpi(
+ let array_ptr = entry.gep(
context,
- CmpiPredicate::Ult,
- array_end,
- array_capacity,
location,
+ array_ptr,
+ &[GepIndex::Const(calc_refcount_offset(tuple_layout) as i32)],
+ IntegerType::new(context, 8).into(),
)?;
+ entry.memcpy(
+ context,
+ location,
+ entry.argument(0)?.into(),
+ array_ptr,
+ array_len_bytes,
+ );
+ entry.append_operation(ReallocBindingsMeta::free(
+ context,
+ entry.argument(0)?.into(),
+ location,
+ )?);
- let handle_block = helper.append_block(Block::new(&[]));
- let memmove_block = helper.append_block(Block::new(&[]));
- let realloc_block = helper.append_block(Block::new(&[]));
- let append_block = helper.append_block(Block::new(&[(array_ty, location)]));
-
- entry.append_operation(cf::cond_br(
+ let value = entry.append_op_result(llvm::undef(
+ llvm::r#type::r#struct(context, &[ptr_ty, len_ty, len_ty, len_ty], false),
+ location,
+ ))?;
+ let value = entry.insert_values(
context,
- has_tail_space,
- append_block,
- handle_block,
- &[entry.arg(0)?],
- &[],
location,
- ));
+ value,
+ &[array_ptr, k0, array_len, array_len],
+ )?;
- {
- let k0 = handle_block.const_int(context, location, 0, 32)?;
- let array_start =
- handle_block.extract_value(context, location, entry.arg(0)?, len_ty, 1)?;
+ entry.append_operation(helper.br(0, &[value], location));
+ Ok(())
+}
- let has_head_space =
- handle_block.cmpi(context, CmpiPredicate::Ne, array_start, k0, location)?;
- handle_block.append_operation(cf::cond_br(
- context,
- has_head_space,
- memmove_block,
- realloc_block,
- &[],
- &[],
- location,
- ));
- }
+/// Generate MLIR operations for the `tuple_from_span` libfunc.
+///
+/// Note: The `&info.ty` field has the entire `[T; N]` tuple. It is not the `T` in `Array<T>`.
+pub fn build_tuple_from_span<'ctx, 'this>(
+ context: &'ctx Context,
+ registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+ entry: &'this Block<'ctx>,
+ location: Location<'ctx>,
+ helper: &LibfuncHelper<'ctx, 'this>,
+ metadata: &mut MetadataStorage,
+ info: &SignatureAndTypeConcreteLibfunc,
+) -> Result<()> {
+ metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
- {
- let array_start =
- memmove_block.extract_value(context, location, entry.arg(0)?, len_ty, 1)?;
+ let elem_id = {
+ let CoreTypeConcrete::Snapshot(info) =
+ registry.get_type(&info.signature.param_signatures[0].ty)?
+ else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
+ let CoreTypeConcrete::Array(info) = registry.get_type(&info.ty)? else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
- let start_offset =
- memmove_block.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let start_offset = memmove_block.muli(start_offset, elem_stride, location)?;
+ &info.ty
+ };
+ let tuple_len_const = {
+ let CoreTypeConcrete::Struct(param) = registry.get_type(&info.ty)? else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
- let dst_ptr = memmove_block.extract_value(context, location, entry.arg(0)?, ptr_ty, 0)?;
- let src_ptr = memmove_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- dst_ptr,
- &[start_offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
+ param.members.len()
+ };
- let array_len =
- memmove_block.append_op_result(arith::subi(array_end, array_start, location))?;
- let memmove_len =
- memmove_block.extui(array_len, IntegerType::new(context, 64).into(), location)?;
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
+ let (_, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, elem_id)?;
+ let (tuple_ty, tuple_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
- let memmove_len = memmove_block.muli(memmove_len, elem_stride, location)?;
- memmove_block.append_operation(
- ods::llvm::intr_memmove(
- context,
- dst_ptr,
- src_ptr,
- memmove_len,
- IntegerAttribute::new(IntegerType::new(context, 1).into(), 0),
- location,
- )
- .into(),
- );
+ let array_ptr = entry.extract_value(context, location, entry.argument(0)?.into(), ptr_ty, 0)?;
+ let array_start =
+ entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 2)?;
- let k0 = memmove_block.const_int_from_type(context, location, 0, len_ty)?;
- let value = memmove_block.insert_value(context, location, entry.arg(0)?, k0, 1)?;
- let value = memmove_block.insert_value(context, location, value, array_len, 2)?;
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
+ let tuple_len = entry.const_int_from_type(context, location, tuple_len_const, len_ty)?;
+ let len_matches = entry.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Eq,
+ array_len,
+ tuple_len,
+ location,
+ ))?;
- memmove_block.append_operation(cf::br(append_block, &[value], location));
- }
+ let valid_block = helper.append_block(Block::new(&[]));
+ let error_block = helper.append_block(Block::new(&[]));
+ entry.append_operation(cf::cond_br(
+ context,
+ len_matches,
+ valid_block,
+ error_block,
+ &[],
+ &[],
+ location,
+ ));
+
+ // Ensure the type's clone and drop implementations are registered.
+ registry.build_type(
+ context,
+ helper,
+ registry,
+ metadata,
+ &info.signature.param_signatures[0].ty,
+ )?;
{
- let k8 = realloc_block.const_int(context, location, 8, 32)?;
- let k1024 = realloc_block.const_int(context, location, 1024, 32)?;
-
- // Array allocation growth formula:
- // new_len = max(8, old_len + min(1024, 2 * old_len));
- let new_capacity = realloc_block.shli(array_end, k1, location)?;
- let new_capacity =
- realloc_block.append_op_result(arith::minui(new_capacity, k1024, location))?;
- let new_capacity = realloc_block.addi(new_capacity, array_end, location)?;
- let new_capacity =
- realloc_block.append_op_result(arith::maxui(new_capacity, k8, location))?;
-
- let realloc_size = {
- let new_capacity = realloc_block.extui(
- new_capacity,
- IntegerType::new(context, 64).into(),
- location,
- )?;
- realloc_block.muli(new_capacity, elem_stride, location)?
- };
+ let value_size = valid_block.const_int(context, location, tuple_layout.size(), 64)?;
- let ptr = realloc_block.extract_value(context, location, entry.arg(0)?, ptr_ty, 0)?;
- let ptr = realloc_block.append_op_result(ReallocBindingsMeta::realloc(
- context,
- ptr,
- realloc_size,
- location,
+ let value = valid_block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let value = valid_block.append_op_result(ReallocBindingsMeta::realloc(
+ context, value, value_size, location,
)?)?;
- // No need to memmove, guaranteed by the fact that if we needed to memmove we'd have gone
- // through the memmove block instead of reallocating.
-
- let value = realloc_block.insert_value(context, location, entry.arg(0)?, ptr, 0)?;
- let value = realloc_block.insert_value(context, location, value, new_capacity, 3)?;
-
- realloc_block.append_operation(cf::br(append_block, &[value], location));
- }
-
- {
- let ptr = append_block.extract_value(context, location, append_block.arg(0)?, ptr_ty, 0)?;
- let array_end =
- append_block.extract_value(context, location, append_block.arg(0)?, len_ty, 2)?;
+ let is_shared = is_shared(context, valid_block, location, array_ptr, elem_layout)?;
- let offset =
- append_block.extui(array_end, IntegerType::new(context, 64).into(), location)?;
- let offset = append_block.muli(offset, elem_stride, location)?;
- let ptr = append_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
+ let array_start_offset = valid_block.append_op_result(arith::extui(
+ array_start,
+ IntegerType::new(context, 64).into(),
location,
))?;
+ let array_start_offset = valid_block.append_op_result(arith::muli(
+ array_start_offset,
+ valid_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?,
+ location,
+ ))?;
+ let array_ptr = valid_block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(array_start_offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
- append_block.store(context, location, ptr, entry.arg(1)?)?;
-
- let array_len = append_block.addi(array_end, k1, location)?;
- let value =
- append_block.insert_value(context, location, append_block.arg(0)?, array_len, 2)?;
-
- append_block.append_operation(helper.br(0, &[value], location));
- }
-
- Ok(())
-}
+ valid_block.append_operation(scf::r#if(
+ is_shared,
+ &[],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(&info.ty) => {
+ let src_ptr = array_ptr;
+ let dst_ptr = value;
+
+ let value = block.load(context, location, src_ptr, tuple_ty)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, &info.ty, value)?;
+ block.store(context, location, src_ptr, values.0)?;
+ block.store(context, location, dst_ptr, values.1)?;
+ }
+ _ => block.memcpy(context, location, array_ptr, value, value_size),
+ }
-/// Generate MLIR operations for the `array_len` libfunc.
-pub fn build_len<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ // The following unwrap should be unreachable because an array always has a drop
+ // implementation.
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
+ context,
+ &block,
+ location,
+ &info.signature.param_signatures[0].ty,
+ entry.argument(0)?.into(),
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
- let array_value = entry.arg(0)?;
+ block.memcpy(context, location, array_ptr, value, value_size);
- let array_start = entry.extract_value(context, location, array_value, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, array_value, len_ty, 2)?;
+ let array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
+ IntegerType::new(context, 8).into(),
+ )?;
+ block.append_operation(ReallocBindingsMeta::free(context, array_ptr, location)?);
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
- let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
+ valid_block.append_operation(helper.br(0, &[value], location));
+ }
- match metadata.get::<DropOverridesMeta>() {
- Some(drop_overrides_meta)
- if drop_overrides_meta.is_overriden(&info.signature.param_signatures[0].ty) =>
- {
- drop_overrides_meta.invoke_override(
+ {
+ metadata
+ .get::<DropOverridesMeta>()
+ .ok_or(Error::MissingMetadata)?
+ .invoke_override(
context,
- entry,
+ error_block,
location,
&info.signature.param_signatures[0].ty,
- entry.arg(0)?,
+ entry.argument(0)?.into(),
)?;
- }
- _ => {}
+
+ error_block.append_operation(helper.br(1, &[], location));
}
- entry.append_operation(helper.br(0, &[array_len], location));
Ok(())
}
-/// Generate MLIR operations for the `array_get` libfunc.
-pub fn build_get<'ctx, 'this>(
+/// Generate MLIR operations for the `array_append` libfunc.
+pub fn build_append<'ctx, 'this>(
context: &'ctx Context,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
@@ -2886,720 +3375,1116 @@
metadata: &mut MetadataStorage,
info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let range_check = super::increment_builtin_counter(context, entry, location, entry.arg(0)?)?;
-
- let array_ty = registry.build_type(
+ /*
+ * 1. Check if shared.
+ * 2. If shared:
+ * 1. Deep clone with space for at least 1 extra element.
+ * 3. If not shared:
+ * 1. Either realloc, move or do nothing.
+ * 4. Append element.
+ */
+
+ metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
+
+ let self_ty = registry.build_type(
context,
helper,
registry,
metadata,
- &info.param_signatures()[1].ty,
+ &info.signature.param_signatures[0].ty,
)?;
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
- let elem_stride = elem_layout.pad_to_align().size();
- let elem_ty = elem_ty.build(context, helper, registry, metadata, &info.ty)?;
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ let (elem_ty, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
+ let elem_stride = entry.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let value = entry.arg(1)?;
- let index = entry.arg(2)?;
+ let k0 = entry.const_int(context, location, 0, 32)?;
+ let k1 = entry.const_int(context, location, 1, 32)?;
- let array_start = entry.extract_value(context, location, value, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, value, len_ty, 2)?;
+ let array_ptr = entry.extract_value(context, location, entry.argument(0)?.into(), ptr_ty, 0)?;
+ let array_start =
+ entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 2)?;
+ let array_capacity =
+ entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 3)?;
let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let is_valid = entry.cmpi(context, CmpiPredicate::Ult, index, array_len, location)?;
+ let array_size = entry.append_op_result(arith::extui(
+ array_len,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let array_size = entry.append_op_result(arith::muli(array_size, elem_stride, location))?;
- let valid_block = helper.append_block(Block::new(&[]));
- let error_block = helper.append_block(Block::new(&[]));
- entry.append_operation(cf::cond_br(
+ let data_offset = entry.append_op_result(arith::extui(
+ array_start,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let data_offset = entry.append_op_result(arith::muli(data_offset, elem_stride, location))?;
+ let data_ptr = entry.gep(
context,
- is_valid,
- valid_block,
- error_block,
- &[],
- &[],
location,
- ));
+ array_ptr,
+ &[GepIndex::Value(data_offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
- {
- let ptr = valid_block.extract_value(context, location, value, ptr_ty, 0)?;
+ fn compute_next_capacity<'ctx, 'this>(
+ context: &'ctx Context,
+ block: &'this Block<'ctx>,
+ location: Location<'ctx>,
+ elem_stride: Value<'ctx, 'this>,
+ array_end: Value<'ctx, 'this>,
+ ) -> Result<(Value<'ctx, 'this>, Value<'ctx, 'this>)> {
+ let len_ty = IntegerType::new(context, 32).into();
+
+ let k1 = block.const_int_from_type(context, location, 1, len_ty)?;
+ let k8 = block.const_int_from_type(context, location, 8, len_ty)?;
+ let k1024 = block.const_int_from_type(context, location, 1024, len_ty)?;
+
+ let realloc_len = block.append_op_result(arith::shli(array_end, k1, location))?;
+ let realloc_len = block.append_op_result(arith::minui(realloc_len, k1024, location))?;
+ let realloc_len = block.append_op_result(arith::addi(realloc_len, array_end, location))?;
+ let realloc_len = block.append_op_result(arith::maxui(realloc_len, k8, location))?;
+
+ let realloc_size = block.append_op_result(arith::extui(
+ realloc_len,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let realloc_size =
+ block.append_op_result(arith::muli(realloc_size, elem_stride, location))?;
- let array_start =
- valid_block.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let index = {
- let index = valid_block.extui(index, IntegerType::new(context, 64).into(), location)?;
- valid_block.addi(array_start, index, location)?
- };
+ Result::Ok((realloc_len, realloc_size))
+ }
- let elem_stride = valid_block.const_int(context, location, elem_stride, 64)?;
- let elem_offset = valid_block.muli(elem_stride, index, location)?;
+ let is_empty = entry.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Eq,
+ array_capacity,
+ k0,
+ location,
+ ))?;
- let elem_ptr = valid_block.gep(
- context,
- location,
- ptr,
- &[GepIndex::Value(elem_offset)],
- IntegerType::new(context, 8).into(),
- )?;
+ let is_shared = entry.append_op_result(scf::r#if(
+ is_empty,
+ &[IntegerType::new(context, 1).into()],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let elem_size = valid_block.const_int(context, location, elem_layout.size(), 64)?;
+ let k0 = block.const_int(context, location, 0, 1)?;
- let target_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
- )?;
- let target_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context, target_ptr, elem_size, location,
- )?)?;
- assert_nonnull(
- context,
- valid_block,
- location,
- target_ptr,
- "realloc returned nullptr",
- )?;
+ block.append_operation(scf::r#yield(&[k0], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- // There's no need to clone it since we're moving it out of the array.
- valid_block.memcpy(context, location, elem_ptr, target_ptr, elem_size);
+ let is_shared = is_shared(context, entry, location, array_ptr, elem_layout)?;
- match metadata.get::<DropOverridesMeta>() {
- Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
- let array_end =
- valid_block.extui(array_end, IntegerType::new(context, 64).into(), location)?;
+ block.append_operation(scf::r#yield(&[is_shared], location));
+ region
+ },
+ location,
+ ))?;
- let array_start = valid_block.muli(array_start, elem_stride, location)?;
- let array_end = valid_block.muli(array_end, elem_stride, location)?;
+ let value = entry.append_op_result(scf::r#if(
+ is_shared,
+ &[self_ty],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- valid_block.append_operation(scf::r#for(
- array_start,
- array_end,
- elem_stride,
- {
- let region = Region::new();
- let block = region.append_block(Block::new(&[(
- IntegerType::new(context, 64).into(),
- location,
- )]));
+ let has_space = block.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ugt,
+ array_capacity,
+ array_len,
+ location,
+ ))?;
- let value_ptr = block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[block.arg(0)?],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
+ let op = block.append_operation(scf::r#if(
+ has_space,
+ &[len_ty, IntegerType::new(context, 64).into()],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let is_target_element = block.append_op_result(
- ods::llvm::icmp(
- context,
- IntegerType::new(context, 1).into(),
- value_ptr,
- elem_ptr,
- IntegerAttribute::new(IntegerType::new(context, 64).into(), 0)
- .into(),
- location,
- )
- .into(),
- )?;
- block.append_operation(scf::r#if(
- is_target_element,
- &[],
- {
- let region = Region::new();
- let block = region.append_block(Block::new(&[]));
+ let clone_size = block.append_op_result(arith::extui(
+ array_capacity,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let clone_size =
+ block.append_op_result(arith::muli(clone_size, elem_stride, location))?;
+
+ block.append_operation(scf::r#yield(&[array_capacity, clone_size], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let (realloc_capacity, realloc_size) =
+ compute_next_capacity(context, &block, location, elem_stride, array_end)?;
+
+ block.append_operation(scf::r#yield(
+ &[realloc_capacity, realloc_size],
+ location,
+ ));
+ region
+ },
+ location,
+ ));
+ let clone_capacity = op.result(0)?.into();
+ let clone_size = op.result(1)?.into();
- block.append_operation(scf::r#yield(&[], location));
- region
- },
- {
- let region = Region::new();
- let block = region.append_block(Block::new(&[]));
+ let clone_size_with_refcount = block.append_op_result(arith::addi(
+ clone_size,
+ block.const_int(context, location, calc_refcount_offset(elem_layout), 64)?,
+ location,
+ ))?;
- let value = block.load(context, location, value_ptr, elem_ty)?;
- drop_overrides_meta
- .invoke_override(context, &block, location, &info.ty, value)?;
+ let clone_ptr = block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let clone_ptr = block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ clone_ptr,
+ clone_size_with_refcount,
+ location,
+ )?)?;
+ block.store(context, location, clone_ptr, k1)?;
- block.append_operation(scf::r#yield(&[], location));
- region
- },
- location,
- ));
+ let clone_ptr = block.gep(
+ context,
+ location,
+ clone_ptr,
+ &[GepIndex::Const(calc_refcount_offset(elem_layout) as i32)],
+ IntegerType::new(context, 8).into(),
+ )?;
- block.append_operation(scf::r#yield(&[], location));
- region
- },
- location,
- ));
- }
- _ => {}
- }
- valid_block.append_operation(ReallocBindingsMeta::free(context, ptr, location)?);
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(&info.ty) => {
+ let k0 = block.const_int(context, location, 0, 64)?;
+ block.append_operation(scf::r#for(
+ k0,
+ array_size,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
- valid_block.append_operation(helper.br(0, &[range_check, target_ptr], location));
- }
+ let offset = block.argument(0)?.into();
+ let source_ptr = block.gep(
+ context,
+ location,
+ data_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let target_ptr = block.gep(
+ context,
+ location,
+ clone_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let value = block.load(context, location, source_ptr, elem_ty)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, &info.ty, value)?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, target_ptr, values.1)?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ }
+ _ => block.memcpy(context, location, array_ptr, clone_ptr, clone_size),
+ }
- metadata
- .get::<DropOverridesMeta>()
- .ok_or(Error::MissingMetadata)?
- .invoke_override(
- context,
- error_block,
- location,
- &info.param_signatures()[1].ty,
- value,
- )?;
- error_block.append_operation(helper.br(1, &[range_check], location));
+ let clone_value = block.append_op_result(llvm::zero(self_ty, location))?;
+ let clone_value = block.insert_values(
+ context,
+ location,
+ clone_value,
+ &[clone_ptr, k0, array_len, clone_capacity],
+ )?;
- Ok(())
-}
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
+ context,
+ &block,
+ location,
+ &info.signature.param_signatures[0].ty,
+ entry.argument(0)?.into(),
+ )?;
-/// Generate MLIR operations for the `array_pop_front` libfunc.
-pub fn build_pop_front<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
+ block.append_operation(scf::r#yield(&[clone_value], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ let has_tail_space = block.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ult,
+ array_end,
+ array_capacity,
+ location,
+ ))?;
+ let array_value = block.append_op_result(scf::r#if(
+ has_tail_space,
+ &[self_ty],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ block.append_operation(scf::r#yield(&[entry.argument(0)?.into()], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let has_head_space = block.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ugt,
+ array_start,
+ k0,
+ location,
+ ))?;
+ let array_value = block.append_op_result(scf::r#if(
+ has_head_space,
+ &[self_ty],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ block.append_operation(
+ ods::llvm::intr_memmove(
+ context,
+ array_ptr,
+ data_ptr,
+ array_size,
+ IntegerAttribute::new(IntegerType::new(context, 1).into(), 0),
+ location,
+ )
+ .into(),
+ );
+
+ let array_value = block.insert_value(
+ context,
+ location,
+ entry.argument(0)?.into(),
+ k0,
+ 1,
+ )?;
+ let array_value =
+ block.insert_value(context, location, array_value, array_len, 2)?;
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let offset_array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let array_ptr = block.append_op_result(arith::select(
+ is_empty,
+ array_ptr,
+ offset_array_ptr,
+ location,
+ ))?;
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
+ let (realloc_len, realloc_size) = compute_next_capacity(
+ context,
+ &block,
+ location,
+ elem_stride,
+ array_end,
+ )?;
+ let realloc_size_with_refcount =
+ block.append_op_result(arith::addi(
+ realloc_size,
+ block.const_int(
+ context,
+ location,
+ calc_refcount_offset(elem_layout),
+ 64,
+ )?,
+ location,
+ ))?;
+
+ let array_ptr =
+ block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ array_ptr,
+ realloc_size_with_refcount,
+ location,
+ )?)?;
+
+ let ref_count = block.load(context, location, array_ptr, len_ty)?;
+ let ref_count = block.append_op_result(arith::select(
+ is_empty, k1, ref_count, location,
+ ))?;
+ block.store(context, location, array_ptr, ref_count)?;
+
+ let array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(calc_refcount_offset(elem_layout) as i32)],
+ IntegerType::new(context, 8).into(),
+ )?;
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ let array_value = block.insert_value(
+ context,
+ location,
+ entry.argument(0)?.into(),
+ array_ptr,
+ 0,
+ )?;
+ let array_value = block.insert_value(
+ context,
+ location,
+ array_value,
+ realloc_len,
+ 3,
+ )?;
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ location,
+ ))?;
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ location,
+ ))?;
- let value = entry.arg(0)?;
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ location,
+ ))?;
- let array_start = entry.extract_value(context, location, value, len_ty, 1)?;
+ let array_ptr = entry.extract_value(context, location, value, ptr_ty, 0)?;
let array_end = entry.extract_value(context, location, value, len_ty, 2)?;
- let is_empty = entry.cmpi(context, CmpiPredicate::Eq, array_start, array_end, location)?;
-
- let valid_block = helper.append_block(Block::new(&[]));
- let empty_block = helper.append_block(Block::new(&[]));
- entry.append_operation(cf::cond_br(
+ let data_offset = entry.append_op_result(arith::extui(
+ array_end,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let data_offset = entry.append_op_result(arith::muli(data_offset, elem_stride, location))?;
+ let data_ptr = entry.gep(
context,
- is_empty,
- empty_block,
- valid_block,
- &[],
- &[],
location,
- ));
-
- {
- let ptr = valid_block.extract_value(context, location, value, ptr_ty, 0)?;
-
- let elem_size = valid_block.const_int(context, location, elem_layout.size(), 64)?;
- let elem_offset =
- valid_block.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let elem_offset = valid_block.muli(elem_offset, elem_size, location)?;
- let ptr = valid_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[elem_offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
-
- let target_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
- )?;
- let target_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context, target_ptr, elem_size, location,
- )?)?;
- assert_nonnull(
- context,
- valid_block,
- location,
- target_ptr,
- "realloc returned nullptr",
- )?;
-
- valid_block.memcpy(context, location, ptr, target_ptr, elem_size);
-
- let k1 = valid_block.const_int(context, location, 1, 32)?;
- let new_start = valid_block.addi(array_start, k1, location)?;
- let value = valid_block.insert_value(context, location, value, new_start, 1)?;
+ array_ptr,
+ &[GepIndex::Value(data_offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ entry.store(context, location, data_ptr, entry.argument(1)?.into())?;
- valid_block.append_operation(helper.br(0, &[value, target_ptr], location));
- }
+ let array_end = entry.append_op_result(arith::addi(array_end, k1, location))?;
+ let value = entry.insert_value(context, location, value, array_end, 2)?;
- empty_block.append_operation(helper.br(1, &[value], location));
+ entry.append_operation(helper.br(0, &[value], location));
Ok(())
}
-/// Generate MLIR operations for the `array_pop_front_consume` libfunc.
-pub fn build_pop_front_consume<'ctx, 'this>(
+#[derive(Clone, Copy)]
+enum PopInfo<'a> {
+ Single(&'a SignatureAndTypeConcreteLibfunc),
+ Multi(&'a ConcreteMultiPopLibfunc),
+}
+
+/// Generate MLIR operations for the `array_pop_*` libfuncs.
+///
+/// Template arguments:
+/// - Consume: Whether to consume or not the array on failure.
+/// - Reverse: False for front-popping, true for back-popping.
+///
+/// The `info` argument contains how many items to pop.
+fn build_pop<'ctx, 'this, const CONSUME: bool, const REVERSE: bool>(
context: &'ctx Context,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
location: Location<'ctx>,
helper: &LibfuncHelper<'ctx, 'this>,
metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
+ info: PopInfo,
) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
+ /*
+ * 1. Check if there's enough data to pop.
+ * 2. If there is not enough data, maybe consume and return.
+ * 3. Allocate output.
+ * 4. Clone or copy the popped data.
+ * - Clone if shared.
+ * - Copy if not shared.
+ */
+
+ metadata.get_or_insert_with(|| ReallocBindingsMeta::new(context, helper));
+
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ let (self_ty, elem_ty, array_value, extract_len, mut branch_values) = match info {
+ PopInfo::Single(info) => (
+ &info.signature.param_signatures[0].ty,
+ &info.ty,
+ entry.argument(0)?.into(),
+ 1,
+ Vec::new(),
+ ),
+ PopInfo::Multi(ConcreteMultiPopLibfunc {
+ popped_ty,
+ signature,
+ }) => {
+ let range_check = super::increment_builtin_counter(
+ context,
+ entry,
+ location,
+ entry.argument(0)?.into(),
+ )?;
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
+ let CoreTypeConcrete::Snapshot(InfoAndTypeConcreteType { ty, .. }) =
+ registry.get_type(&signature.param_signatures[1].ty)?
+ else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
+
+ let CoreTypeConcrete::Array(InfoAndTypeConcreteType { ty, .. }) =
+ registry.get_type(ty)?
+ else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
+
+ let CoreTypeConcrete::Struct(info) = registry.get_type(popped_ty)? else {
+ return Err(Error::SierraAssert(SierraAssertError::BadTypeInfo));
+ };
+ debug_assert!(info.members.iter().all(|member_ty| member_ty == ty));
+
+ (
+ &signature.param_signatures[1].ty,
+ ty,
+ entry.argument(1)?.into(),
+ info.members.len(),
+ vec![range_check],
+ )
+ }
+ };
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ registry.build_type(context, helper, registry, metadata, self_ty)?;
+ let extract_len_value = entry.const_int_from_type(context, location, extract_len, len_ty)?;
- let value = entry.arg(0)?;
+ let (elem_type, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, elem_ty)?;
- let array_start = entry.extract_value(context, location, value, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, value, len_ty, 2)?;
+ let array_start = entry.extract_value(context, location, array_value, len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, array_value, len_ty, 2)?;
- let is_empty = entry.cmpi(context, CmpiPredicate::Eq, array_start, array_end, location)?;
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
+ let has_enough_data = entry.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ule,
+ extract_len_value,
+ array_len,
+ location,
+ ))?;
let valid_block = helper.append_block(Block::new(&[]));
- let empty_block = helper.append_block(Block::new(&[]));
+ let error_block = helper.append_block(Block::new(&[]));
entry.append_operation(cf::cond_br(
context,
- is_empty,
- empty_block,
+ has_enough_data,
valid_block,
+ error_block,
&[],
&[],
location,
));
{
- let ptr = valid_block.extract_value(context, location, value, ptr_ty, 0)?;
+ // Clone branch_values so that it doesn't interfere with the other branch.
+ let mut branch_values = branch_values.clone();
- let elem_size = valid_block.const_int(context, location, elem_layout.size(), 64)?;
- let elem_offset =
- valid_block.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let elem_offset = valid_block.muli(elem_offset, elem_size, location)?;
- let ptr = valid_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[elem_offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
-
- let target_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
- )?;
- let target_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context, target_ptr, elem_size, location,
- )?)?;
- assert_nonnull(
+ let value_size = valid_block.const_int(
context,
- valid_block,
location,
- target_ptr,
- "realloc returned nullptr",
+ elem_layout.pad_to_align().size() * extract_len,
+ 64,
)?;
- valid_block.memcpy(context, location, ptr, target_ptr, elem_size);
+ let value_ptr = valid_block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let value_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
+ context, value_ptr, value_size, location,
+ )?)?;
- let k1 = valid_block.const_int(context, location, 1, 32)?;
- let new_start = valid_block.addi(array_start, k1, location)?;
- let value = valid_block.insert_value(context, location, value, new_start, 1)?;
+ let array_ptr = valid_block.extract_value(context, location, array_value, ptr_ty, 0)?;
+ let is_shared = is_shared(context, valid_block, location, array_ptr, elem_layout)?;
- valid_block.append_operation(helper.br(0, &[value, target_ptr], location));
- }
+ let data_ptr = {
+ let offset_elems = if REVERSE {
+ valid_block.append_op_result(arith::subi(array_end, extract_len_value, location))?
+ } else {
+ array_start
+ };
- metadata
- .get::<DropOverridesMeta>()
- .ok_or(Error::MissingMetadata)?
- .invoke_override(
- context,
- empty_block,
- location,
- &info.param_signatures()[0].ty,
- value,
- )?;
- empty_block.append_operation(helper.br(1, &[], location));
-
- Ok(())
-}
-
-/// Generate MLIR operations for the `array_snapshot_pop_front` libfunc.
-pub fn build_snapshot_pop_front<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- build_pop_front(context, registry, entry, location, helper, metadata, info)
-}
+ let offset = valid_block.append_op_result(arith::extui(
+ offset_elems,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let elem_stride =
+ valid_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
+ let offset =
+ valid_block.append_op_result(arith::muli(offset, elem_stride, location))?;
-/// Generate MLIR operations for the `array_snapshot_pop_back` libfunc.
-pub fn build_snapshot_pop_back<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
+ valid_block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?
+ };
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[0].ty,
- )?;
+ let new_array_ptr = valid_block.append_op_result(scf::r#if(
+ is_shared,
+ &[ptr_ty],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let k0 = block.const_int(context, location, 0, 64)?;
+ let k1 = block.const_int_from_type(context, location, 1, len_ty)?;
+
+ let elem_stride =
+ block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(elem_ty) => {
+ block.append_operation(scf::r#for(
+ k0,
+ value_size,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let offset = block.argument(0)?.into();
+ let source_ptr = block.gep(
+ context,
+ location,
+ data_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let target_ptr = block.gep(
+ context,
+ location,
+ value_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let value = block.load(context, location, source_ptr, elem_type)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, elem_ty, value)?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, target_ptr, values.1)?;
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ }
+ _ => block.memcpy(context, location, data_ptr, value_ptr, value_size),
+ }
- let ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
+ let array_ptr = {
+ let array_len_bytes =
+ block.append_op_result(arith::subi(array_len, k1, location))?;
+ let array_len_bytes = block.append_op_result(arith::extui(
+ array_len_bytes,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let array_len_bytes = block.append_op_result(arith::muli(
+ array_len_bytes,
+ elem_stride,
+ location,
+ ))?;
+ let array_len_bytes = block.append_op_result(arith::addi(
+ array_len_bytes,
+ block.const_int(
+ context,
+ location,
+ calc_refcount_offset(elem_layout),
+ 64,
+ )?,
+ location,
+ ))?;
+
+ let clone_ptr = block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let clone_ptr = block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ clone_ptr,
+ array_len_bytes,
+ location,
+ )?)?;
+ block.store(context, location, clone_ptr, k1)?;
+
+ let clone_ptr = block.gep(
+ context,
+ location,
+ clone_ptr,
+ &[GepIndex::Const(calc_refcount_offset(elem_layout) as i32)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let data_ptr = if REVERSE {
+ data_ptr
+ } else {
+ let offset = block.append_op_result(arith::extui(
+ extract_len_value,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let offset =
+ block.append_op_result(arith::muli(offset, elem_stride, location))?;
- let value = entry.arg(0)?;
+ block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?
+ };
+
+ let others_len = block.append_op_result(arith::subi(
+ array_len,
+ extract_len_value,
+ location,
+ ))?;
+ let others_len = block.append_op_result(arith::extui(
+ others_len,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let others_size =
+ block.append_op_result(arith::muli(others_len, elem_stride, location))?;
+
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) => {
+ block.append_operation(scf::r#for(
+ k0,
+ others_size,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let offset = block.argument(0)?.into();
+ let source_ptr = block.gep(
+ context,
+ location,
+ data_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let target_ptr = block.gep(
+ context,
+ location,
+ clone_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let value =
+ block.load(context, location, source_ptr, elem_type)?;
+ let values = dup_overrides_meta.invoke_override(
+ context, &block, location, elem_ty, value,
+ )?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, target_ptr, values.1)?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ }
+ _ => block.memcpy(context, location, data_ptr, clone_ptr, others_size),
+ }
- let array_start = entry.extract_value(context, location, value, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, value, len_ty, 2)?;
- let is_empty = entry.cmpi(context, CmpiPredicate::Eq, array_start, array_end, location)?;
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(context, &block, location, self_ty, array_value)?;
- let valid_block = helper.append_block(Block::new(&[]));
- let empty_block = helper.append_block(Block::new(&[]));
- entry.append_operation(cf::cond_br(
- context,
- is_empty,
- empty_block,
- valid_block,
- &[],
- &[],
- location,
- ));
+ clone_ptr
+ };
- {
- let k1 = valid_block.const_int(context, location, 1, 32)?;
- let new_end = valid_block.append_op_result(arith::subi(array_end, k1, location))?;
+ block.append_operation(scf::r#yield(&[array_ptr], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let ptr = valid_block.extract_value(context, location, value, ptr_ty, 0)?;
+ block.memcpy(context, location, data_ptr, value_ptr, value_size);
- let elem_size = valid_block.const_int(context, location, elem_layout.size(), 64)?;
- let elem_offset =
- valid_block.extui(new_end, IntegerType::new(context, 64).into(), location)?;
- let elem_offset = valid_block.muli(elem_offset, elem_size, location)?;
- let ptr = valid_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[elem_offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
+ block.append_operation(scf::r#yield(&[array_ptr], location));
+ region
+ },
location,
))?;
- let target_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
+ let array_value =
+ valid_block.insert_value(context, location, array_value, new_array_ptr, 0)?;
+
+ let has_realloc = valid_block.append_op_result(
+ ods::llvm::icmp(
+ context,
+ IntegerType::new(context, 1).into(),
+ array_ptr,
+ new_array_ptr,
+ IntegerAttribute::new(IntegerType::new(context, 64).into(), 1).into(),
+ location,
+ )
+ .into(),
)?;
- let target_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context, target_ptr, elem_size, location,
- )?)?;
- assert_nonnull(
- context,
- valid_block,
+ let array_value = valid_block.append_op_result(scf::r#if(
+ has_realloc,
+ &[array_value.r#type()],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let k0 = block.const_int_from_type(context, location, 0, len_ty)?;
+ let array_len =
+ block.append_op_result(arith::subi(array_len, extract_len_value, location))?;
+
+ let array_value = block.insert_value(context, location, array_value, k0, 1)?;
+ let array_value =
+ block.insert_value(context, location, array_value, array_len, 2)?;
+ let array_value =
+ block.insert_value(context, location, array_value, array_len, 3)?;
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let array_value = if REVERSE {
+ let array_end = block.append_op_result(arith::subi(
+ array_end,
+ extract_len_value,
+ location,
+ ))?;
+ block.insert_value(context, location, array_value, array_end, 2)?
+ } else {
+ let array_start = block.append_op_result(arith::addi(
+ array_start,
+ extract_len_value,
+ location,
+ ))?;
+ block.insert_value(context, location, array_value, array_start, 1)?
+ };
+
+ block.append_operation(scf::r#yield(&[array_value], location));
+ region
+ },
location,
- target_ptr,
- "realloc returned nullptr",
- )?;
+ ))?;
+
+ branch_values.push(array_value);
+ branch_values.push(value_ptr);
- valid_block.memcpy(context, location, ptr, target_ptr, elem_size);
+ valid_block.append_operation(helper.br(0, &branch_values, location));
+ }
- let value = valid_block.insert_value(context, location, value, new_end, 2)?;
+ {
+ if CONSUME {
+ let self_ty = match info {
+ PopInfo::Single(info) => &info.signature.param_signatures[0].ty,
+ PopInfo::Multi(info) => &info.signature.param_signatures[1].ty,
+ };
+
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(context, error_block, location, self_ty, array_value)?;
+ } else {
+ branch_values.push(array_value);
+ }
- valid_block.append_operation(helper.br(0, &[value, target_ptr], location));
+ error_block.append_operation(helper.br(1, &branch_values, location));
}
- empty_block.append_operation(helper.br(1, &[value], location));
Ok(())
}
-pub fn build_snapshot_multi_pop_front<'ctx, 'this>(
+/// Generate MLIR operations for the `array_get` libfunc.
+pub fn build_get<'ctx, 'this>(
context: &'ctx Context,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
location: Location<'ctx>,
helper: &LibfuncHelper<'ctx, 'this>,
metadata: &mut MetadataStorage,
- info: &ConcreteMultiPopLibfunc,
+ info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let range_check = entry.arg(0)?;
-
- // Get type information
+ let ptr_ty = llvm::r#type::pointer(context, 0);
+ let len_ty = IntegerType::new(context, 32).into();
- let array_ty = registry.build_type(
+ // Build the type so that the drop impl invocation works properly.
+ registry.build_type(
context,
helper,
registry,
metadata,
- &info.param_signatures()[1].ty,
+ &info.signature.param_signatures[1].ty,
)?;
- let popped_cty = registry.get_type(&info.popped_ty)?;
- let popped_size = popped_cty.layout(registry)?.size();
- let popped_size_value = entry.const_int(context, location, popped_size, 64)?;
-
- let popped_ctys = popped_cty
- .fields()
- .expect("popped type should be a tuple (ergo, has fields)");
- let popped_len = popped_ctys.len();
-
- let array_ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let array_start_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
- let array_end_ty = crate::ffi::get_struct_field_type_at(&array_ty, 2);
+ let range_check =
+ super::increment_builtin_counter(context, entry, location, entry.argument(0)?.into())?;
- // Get array information
+ let array_start =
+ entry.extract_value(context, location, entry.argument(1)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(1)?.into(), len_ty, 2)?;
- let array = entry.arg(1)?;
- let array_ptr = entry.extract_value(context, location, array, array_ptr_ty, 0)?;
- let array_start = entry.extract_value(context, location, array, array_start_ty, 1)?;
- let array_end = entry.extract_value(context, location, array, array_end_ty, 2)?;
-
- // Check if operation is valid:
- // if array.end - array.start < popped_len {
- // return
- // }
-
- let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let popped_len_value = entry.const_int(context, location, popped_len, 32)?;
- let is_valid = entry.cmpi(
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
+ let is_valid = entry.append_op_result(arith::cmpi(
context,
- CmpiPredicate::Uge,
+ CmpiPredicate::Ult,
+ entry.argument(2)?.into(),
array_len,
- popped_len_value,
location,
- )?;
+ ))?;
let valid_block = helper.append_block(Block::new(&[]));
- let invalid_block = helper.append_block(Block::new(&[]));
-
+ let error_block = helper.append_block(Block::new(&[]));
entry.append_operation(cf::cond_br(
context,
is_valid,
valid_block,
- invalid_block,
+ error_block,
&[],
&[],
location,
));
{
- // Get pointer to first element to pop
-
- let popped_ptr = {
- let single_popped_ty =
- registry.build_type(context, helper, registry, metadata, &popped_ctys[0])?;
-
- valid_block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- array_ptr,
- &[array_start],
- single_popped_ty,
- llvm::r#type::pointer(context, 0),
- location,
- ))?
- };
-
- // Allocate memory for return array
-
- let return_ptr = {
- let null_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
- )?;
- valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context,
- null_ptr,
- popped_size_value,
- location,
- )?)?
- };
-
- valid_block.memcpy(context, location, popped_ptr, return_ptr, popped_size_value);
-
- // Update array start (removing popped elements)
-
- let array = {
- let new_array_start = valid_block.addi(array_start, popped_len_value, location)?;
-
- valid_block.insert_value(context, location, array, new_array_start, 1)?
- };
-
- valid_block.append_operation(helper.br(0, &[range_check, array, return_ptr], location));
- }
-
- invalid_block.append_operation(helper.br(1, &[range_check, array], location));
-
- Ok(())
-}
-
-pub fn build_snapshot_multi_pop_back<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &ConcreteMultiPopLibfunc,
-) -> Result<()> {
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let range_check = entry.arg(0)?;
-
- // Get type information
-
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.param_signatures()[1].ty,
- )?;
-
- let popped_cty = registry.get_type(&info.popped_ty)?;
- let popped_size = popped_cty.layout(registry)?.size();
- let popped_size_value = entry.const_int(context, location, popped_size, 64)?;
+ let (elem_ty, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
+ let elem_stride =
+ valid_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let popped_ctys = popped_cty
- .fields()
- .expect("popped type should be a tuple (ergo, has fields)");
- let popped_len = popped_ctys.len();
+ let value_ptr = valid_block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let value_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ value_ptr,
+ elem_stride,
+ location,
+ )?)?;
- let array_ptr_ty = crate::ffi::get_struct_field_type_at(&array_ty, 0);
- let array_start_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
- let array_end_ty = crate::ffi::get_struct_field_type_at(&array_ty, 2);
+ let array_ptr =
+ valid_block.extract_value(context, location, entry.argument(1)?.into(), ptr_ty, 0)?;
+ let is_shared = is_shared(context, valid_block, location, array_ptr, elem_layout)?;
- // Get array information
+ let offset = valid_block.append_op_result(arith::addi(
+ array_start,
+ entry.argument(2)?.into(),
+ location,
+ ))?;
+ let offset = valid_block.append_op_result(arith::extui(
+ offset,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let offset = valid_block.append_op_result(arith::muli(offset, elem_stride, location))?;
- let array = entry.arg(1)?;
- let array_ptr = entry.extract_value(context, location, array, array_ptr_ty, 0)?;
- let array_start = entry.extract_value(context, location, array, array_start_ty, 1)?;
- let array_end = entry.extract_value(context, location, array, array_end_ty, 2)?;
+ let source_ptr = valid_block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
- // Check if operation is valid:
- // if array.end - array.start < popped_len {
- // return
- // }
+ valid_block.append_operation(scf::r#if(
+ is_shared,
+ &[],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(&info.ty) => {
+ let value = block.load(context, location, source_ptr, elem_ty)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, &info.ty, value)?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, value_ptr, values.1)?;
+ }
+ _ => block.memcpy(context, location, source_ptr, value_ptr, elem_stride),
+ }
- let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let popped_len_value = entry.const_int(context, location, popped_len, 32)?;
- let is_valid = entry.cmpi(
- context,
- CmpiPredicate::Uge,
- array_len,
- popped_len_value,
- location,
- )?;
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
+ context,
+ &block,
+ location,
+ &info.signature.param_signatures[1].ty,
+ entry.argument(1)?.into(),
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ block.memcpy(context, location, source_ptr, value_ptr, elem_stride);
+
+ match metadata.get::<DropOverridesMeta>() {
+ Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
+ let drop_loop = |o0, o1| {
+ block.append_operation(scf::r#for(
+ o0,
+ o1,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let value_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(block.argument(0)?.into())],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let value =
+ block.load(context, location, value_ptr, elem_ty)?;
+ drop_overrides_meta.invoke_override(
+ context, &block, location, &info.ty, value,
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
- let valid_block = helper.append_block(Block::new(&[]));
- let invalid_block = helper.append_block(Block::new(&[]));
+ Result::Ok(())
+ };
- entry.append_operation(cf::cond_br(
- context,
- is_valid,
- valid_block,
- invalid_block,
- &[],
- &[],
- location,
- ));
+ let o0 = block.append_op_result(arith::extui(
+ array_start,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::addi(
+ array_start,
+ entry.argument(2)?.into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::extui(
+ o1,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o0 = block.append_op_result(arith::muli(o0, elem_stride, location))?;
+ let o1 = block.append_op_result(arith::muli(o1, elem_stride, location))?;
+ drop_loop(o0, o1)?;
- {
- // Get pointer to first element to pop
+ let o0 = block.append_op_result(arith::addi(o1, elem_stride, location))?;
+ let o1 = block.append_op_result(arith::extui(
+ array_end,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::muli(o1, elem_stride, location))?;
+ drop_loop(o0, o1)?;
+ }
+ _ => {}
+ }
- let popped_ptr = {
- let single_popped_ty =
- registry.build_type(context, helper, registry, metadata, &popped_ctys[0])?;
+ let array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
+ IntegerType::new(context, 8).into(),
+ )?;
+ block.append_operation(ReallocBindingsMeta::free(context, array_ptr, location)?);
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
- let popped_start =
- valid_block.append_op_result(arith::subi(array_end, popped_len_value, location))?;
+ valid_block.append_operation(helper.br(0, &[range_check, value_ptr], location));
+ }
- valid_block.append_op_result(llvm::get_element_ptr_dynamic(
+ {
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
context,
- array_ptr,
- &[popped_start],
- single_popped_ty,
- llvm::r#type::pointer(context, 0),
+ error_block,
location,
- ))?
- };
-
- // Allocate memory for return array
-
- let return_ptr = {
- let null_ptr = valid_block.append_op_result(
- ods::llvm::mlir_zero(context, pointer(context, 0), location).into(),
+ &info.signature.param_signatures[1].ty,
+ entry.argument(1)?.into(),
)?;
- valid_block.append_op_result(ReallocBindingsMeta::realloc(
- context,
- null_ptr,
- popped_size_value,
- location,
- )?)?
- };
-
- valid_block.memcpy(context, location, popped_ptr, return_ptr, popped_size_value);
- // Update array end (removing popped elements)
-
- let array = {
- let new_array_end =
- valid_block.append_op_result(arith::subi(array_end, popped_len_value, location))?;
-
- valid_block.insert_value(context, location, array, new_array_end, 2)?
- };
-
- valid_block.append_operation(helper.br(0, &[range_check, array, return_ptr], location));
+ error_block.append_operation(helper.br(1, &[range_check], location));
}
- invalid_block.append_operation(helper.br(1, &[range_check, array], location));
-
Ok(())
}
@@ -3613,39 +4498,61 @@
metadata: &mut MetadataStorage,
info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- let range_check = super::increment_builtin_counter(context, entry, location, entry.arg(0)?)?;
+ // Signature:
+ // Params: RangeCheck, Snapshot<Array<felt252>>, u32, u32
+ // Branches:
+ // 0: RangeCheck, Snapshot<Array<felt252>>
+ // 1: RangeCheck
+ let ptr_ty = llvm::r#type::pointer(context, 0);
let len_ty = IntegerType::new(context, 32).into();
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_layout = elem_ty.layout(registry)?;
+ let self_ty = registry.build_type(
+ context,
+ helper,
+ registry,
+ metadata,
+ &info.signature.param_signatures[1].ty,
+ )?;
+
+ let range_check =
+ super::increment_builtin_counter(context, entry, location, entry.argument(0)?.into())?;
- let array_start = entry.extract_value(context, location, entry.arg(1)?, len_ty, 1)?;
- let array_end = entry.extract_value(context, location, entry.arg(1)?, len_ty, 2)?;
+ let k0 = entry.const_int_from_type(context, location, 0, len_ty)?;
+ let k1 = entry.const_int_from_type(context, location, 1, len_ty)?;
+
+ let array_start =
+ entry.extract_value(context, location, entry.argument(1)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(1)?.into(), len_ty, 2)?;
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let slice_start = entry.arg(2)?;
- let slice_len = entry.arg(3)?;
- let slice_end = entry.addi(slice_start, slice_len, location)?;
+ let slice_start = entry.argument(2)?.into();
+ let slice_len = entry.argument(3)?.into();
+ let slice_end = entry.append_op_result(arith::addi(slice_start, slice_len, location))?;
- let slice_start = entry.addi(array_start, slice_start, location)?;
- let slice_end = entry.addi(array_start, slice_end, location)?;
- let lhs_bound = entry.cmpi(
+ let slice_lhs_bound = entry.append_op_result(arith::cmpi(
context,
- CmpiPredicate::Uge,
+ CmpiPredicate::Ule,
slice_start,
- array_start,
+ array_len,
location,
- )?;
- let rhs_bound = entry.cmpi(context, CmpiPredicate::Ule, slice_end, array_end, location)?;
-
- let is_valid = entry.append_op_result(arith::andi(lhs_bound, rhs_bound, location))?;
+ ))?;
+ let slice_rhs_bound = entry.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ule,
+ slice_end,
+ array_len,
+ location,
+ ))?;
+ let slice_bounds =
+ entry.append_op_result(arith::andi(slice_lhs_bound, slice_rhs_bound, location))?;
- let slice_block = helper.append_block(Block::new(&[]));
+ let valid_block = helper.append_block(Block::new(&[]));
let error_block = helper.append_block(Block::new(&[]));
entry.append_operation(cf::cond_br(
context,
- is_valid,
- slice_block,
+ slice_bounds,
+ valid_block,
error_block,
&[],
&[],
@@ -3653,89 +4560,229 @@
));
{
- let elem_ty = elem_ty.build(context, helper, registry, metadata, &info.ty)?;
+ let (elem_ty, elem_layout) =
+ registry.build_type_with_layout(context, helper, registry, metadata, &info.ty)?;
+ let elem_stride =
+ valid_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let value = entry.arg(1)?;
- let value = slice_block.insert_value(context, location, value, slice_start, 1)?;
- let value = slice_block.insert_value(context, location, value, slice_end, 2)?;
+ let slice_size = valid_block.append_op_result(arith::extui(
+ slice_len,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let slice_size =
+ valid_block.append_op_result(arith::muli(elem_stride, slice_size, location))?;
+ let slice_size_with_offset = valid_block.append_op_result(arith::addi(
+ slice_size,
+ valid_block.const_int(context, location, calc_refcount_offset(elem_layout), 64)?,
+ location,
+ ))?;
- let elem_stride =
- slice_block.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let prepare = |value| {
- let value = slice_block.extui(value, IntegerType::new(context, 64).into(), location)?;
- slice_block.muli(value, elem_stride, location)
- };
+ let slice_ptr = valid_block.append_op_result(llvm::zero(ptr_ty, location))?;
+ let slice_ptr = valid_block.append_op_result(ReallocBindingsMeta::realloc(
+ context,
+ slice_ptr,
+ slice_size_with_offset,
+ location,
+ )?)?;
+ valid_block.store(context, location, slice_ptr, k1)?;
- let ptr = slice_block.extract_value(
+ let slice_ptr = valid_block.gep(
context,
location,
- entry.arg(1)?,
- llvm::r#type::pointer(context, 0),
- 0,
+ slice_ptr,
+ &[GepIndex::Const(calc_refcount_offset(elem_layout) as i32)],
+ IntegerType::new(context, 8).into(),
)?;
- let make_region = |drop_overrides_meta: &DropOverridesMeta| {
- let region = Region::new();
- let block = region.append_block(Block::new(&[(
- IntegerType::new(context, 64).into(),
- location,
- )]));
- let value_ptr = block.append_op_result(llvm::get_element_ptr_dynamic(
- context,
- ptr,
- &[block.arg(0)?],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
- location,
- ))?;
+ let array_ptr =
+ valid_block.extract_value(context, location, entry.argument(1)?.into(), ptr_ty, 0)?;
+ let is_shared = is_shared(context, valid_block, location, array_ptr, elem_layout)?;
- let value = block.load(context, location, value_ptr, elem_ty)?;
- drop_overrides_meta.invoke_override(context, &block, location, &info.ty, value)?;
+ let offset =
+ valid_block.append_op_result(arith::addi(array_start, slice_start, location))?;
+ let offset = valid_block.append_op_result(arith::extui(
+ offset,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let offset = valid_block.append_op_result(arith::muli(offset, elem_stride, location))?;
- block.append_operation(scf::r#yield(&[], location));
- Result::Ok(region)
- };
+ let source_ptr = valid_block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
- let array_start = prepare(array_start)?;
- let array_end = prepare(array_end)?;
- let slice_start = prepare(slice_start)?;
- let slice_end = prepare(slice_end)?;
-
- match metadata.get::<DropOverridesMeta>() {
- Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
- slice_block.append_operation(scf::r#for(
- array_start,
- slice_start,
- elem_stride,
- make_region(drop_overrides_meta)?,
- location,
- ));
- slice_block.append_operation(scf::r#for(
- slice_end,
- array_end,
- elem_stride,
- make_region(drop_overrides_meta)?,
- location,
- ));
- }
- _ => {}
- };
+ valid_block.append_operation(scf::r#if(
+ is_shared,
+ &[],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ match metadata.get::<DupOverridesMeta>() {
+ Some(dup_overrides_meta) if dup_overrides_meta.is_overriden(&info.ty) => {
+ let k0 = valid_block.const_int(context, location, 0, 64)?;
+ valid_block.append_operation(scf::r#for(
+ k0,
+ slice_size,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let offset = block.argument(0)?.into();
+ let source_ptr = block.gep(
+ context,
+ location,
+ source_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let target_ptr = block.gep(
+ context,
+ location,
+ slice_ptr,
+ &[GepIndex::Value(offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+
+ let value = block.load(context, location, source_ptr, elem_ty)?;
+ let values = dup_overrides_meta
+ .invoke_override(context, &block, location, &info.ty, value)?;
+ block.store(context, location, source_ptr, values.0)?;
+ block.store(context, location, target_ptr, values.1)?;
- slice_block.append_operation(helper.br(0, &[range_check, value], location));
- }
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ }
+ _ => block.memcpy(context, location, source_ptr, slice_ptr, slice_size),
+ }
- {
- registry.build_type(
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
+ context,
+ &block,
+ location,
+ &info.signature.param_signatures[1].ty,
+ entry.argument(1)?.into(),
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ block.memcpy(context, location, source_ptr, slice_ptr, slice_size);
+
+ match metadata.get::<DropOverridesMeta>() {
+ Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
+ let drop_loop = |o0, o1| {
+ block.append_operation(scf::r#for(
+ o0,
+ o1,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let value_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(block.argument(0)?.into())],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let value =
+ block.load(context, location, value_ptr, elem_ty)?;
+ drop_overrides_meta.invoke_override(
+ context, &block, location, &info.ty, value,
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+
+ Result::Ok(())
+ };
+
+ let o0 = block.append_op_result(arith::extui(
+ array_start,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::addi(
+ array_start,
+ slice_start,
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::extui(
+ o1,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o0 = block.append_op_result(arith::muli(o0, elem_stride, location))?;
+ let o1 = block.append_op_result(arith::muli(o1, elem_stride, location))?;
+ drop_loop(o0, o1)?;
+
+ let o0 = block.append_op_result(arith::addi(o1, slice_size, location))?;
+ let o1 = block.append_op_result(arith::extui(
+ array_end,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let o1 = block.append_op_result(arith::muli(o1, elem_stride, location))?;
+ drop_loop(o0, o1)?;
+ }
+ _ => {}
+ }
+
+ let array_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
+ IntegerType::new(context, 8).into(),
+ )?;
+ block.append_operation(ReallocBindingsMeta::free(context, array_ptr, location)?);
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+
+ let slice_value = valid_block.append_op_result(llvm::undef(self_ty, location))?;
+ let slice_value = valid_block.insert_values(
context,
- helper,
- registry,
- metadata,
- &info.signature.param_signatures[1].ty,
+ location,
+ slice_value,
+ &[slice_ptr, k0, slice_len, slice_len],
)?;
- // The metadata get will never fail because an array always has a drop implementation,
- // which at this point is always inserted thanks to the `build_type()` just above.
- metadata
+ valid_block.append_operation(helper.br(0, &[range_check, slice_value], location));
+ }
+
+ {
+ metadata
.get::<DropOverridesMeta>()
.ok_or(Error::MissingMetadata)?
.invoke_override(
@@ -3743,7 +4790,7 @@
error_block,
location,
&info.signature.param_signatures[1].ty,
- entry.arg(1)?,
+ entry.argument(1)?.into(),
)?;
error_block.append_operation(helper.br(1, &[range_check], location));
@@ -3752,309 +4799,137 @@
Ok(())
}
-/// Generate MLIR operations for the `span_from_tuple` libfunc.
-pub fn build_span_from_tuple<'ctx, 'this>(
+/// Generate MLIR operations for the `array_len` libfunc.
+pub fn build_len<'ctx, 'this>(
context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+ _registry: &ProgramRegistry<CoreType, CoreLibfunc>,
entry: &'this Block<'ctx>,
location: Location<'ctx>,
helper: &LibfuncHelper<'ctx, 'this>,
metadata: &mut MetadataStorage,
info: &SignatureAndTypeConcreteLibfunc,
) -> Result<()> {
- // tuple to array span (t,t,t) -> &[t,t,t]
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let struct_type_info = registry.get_type(&info.ty)?;
-
- let struct_ty = registry.build_type(context, helper, registry, metadata, &info.ty)?;
-
- let container: Value = {
- // load box
- entry.load(context, location, entry.arg(0)?, struct_ty)?
- };
- // TODO: Maybe reuse the pointer?
- entry.append_operation(ReallocBindingsMeta::free(context, entry.arg(0)?, location)?);
-
- let fields = struct_type_info.fields().expect("should have fields");
- let (field_ty, field_layout) =
- registry.build_type_with_layout(context, helper, registry, metadata, &fields[0])?;
- let field_stride = field_layout.pad_to_align().size();
-
- let array_ty = registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.branch_signatures()[0].vars[0].ty,
- )?;
- let len_ty = crate::ffi::get_struct_field_type_at(&array_ty, 1);
-
- let array_len_value = entry.const_int_from_type(context, location, fields.len(), len_ty)?;
-
- let array_container = entry.append_op_result(llvm::undef(array_ty, location))?;
-
- let k0 = entry.const_int_from_type(context, location, 0, len_ty)?;
-
- let array_container = entry.insert_value(context, location, array_container, k0, 1)?;
- let array_container =
- entry.insert_value(context, location, array_container, array_len_value, 2)?;
- let array_container =
- entry.insert_value(context, location, array_container, array_len_value, 3)?;
-
- let ptr = entry
- .append_op_result(ods::llvm::mlir_zero(context, pointer(context, 0), location).into())?;
-
- let field_size: Value = entry.const_int(context, location, field_stride, 64)?;
- let array_len_value_i64 = entry.extui(array_len_value, field_size.r#type(), location)?;
- let total_size = entry.muli(field_size, array_len_value_i64, location)?;
+ let len_ty = IntegerType::new(context, 32).into();
- let ptr = entry.append_op_result(ReallocBindingsMeta::realloc(
- context, ptr, total_size, location,
- )?)?;
+ let array_start =
+ entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 1)?;
+ let array_end = entry.extract_value(context, location, entry.argument(0)?.into(), len_ty, 2)?;
- for (i, _) in fields.iter().enumerate() {
- let value: Value = entry.extract_value(context, location, container, field_ty, i)?;
+ let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let target_ptr = entry.append_op_result(llvm::get_element_ptr(
+ metadata
+ .get::<DropOverridesMeta>()
+ .unwrap()
+ .invoke_override(
context,
- ptr,
- DenseI32ArrayAttribute::new(context, &[i as i32]),
- field_ty,
- pointer(context, 0),
+ entry,
location,
- ))?;
-
- entry.store(context, location, target_ptr, value)?;
- }
-
- let array_container = entry.insert_value(context, location, array_container, ptr, 0)?;
-
- entry.append_operation(helper.br(0, &[array_container], location));
+ &info.signature.param_signatures[0].ty,
+ entry.argument(0)?.into(),
+ )?;
+ entry.append_operation(helper.br(0, &[array_len], location));
Ok(())
}
-fn assert_nonnull<'ctx, 'this>(
+fn calc_refcount_offset(layout: Layout) -> usize {
+ get_integer_layout(32)
+ .align_to(layout.align())
+ .unwrap()
+ .pad_to_align()
+ .size()
+}
+
+fn is_shared<'ctx, 'this>(
context: &'ctx Context,
- entry: &'this Block<'ctx>,
+ block: &'this Block<'ctx>,
location: Location<'ctx>,
- ptr: Value<'ctx, 'this>,
- msg: &str,
-) -> Result<()> {
- let null_ptr =
- entry.append_op_result(ods::llvm::mlir_zero(context, ptr.r#type(), location).into())?;
-
- let ptr_is_not_null = entry.append_op_result(
- ods::llvm::icmp(
+ array_ptr: Value<'ctx, 'this>,
+ elem_layout: Layout,
+) -> Result<Value<'ctx, 'this>> {
+ let k0 = block.const_int(context, location, 0, 64)?;
+ let ptr_as_int = block.append_op_result(
+ ods::llvm::ptrtoint(
context,
- IntegerType::new(context, 1).into(),
- ptr,
- null_ptr,
- IntegerAttribute::new(IntegerType::new(context, 64).into(), 1).into(),
+ IntegerType::new(context, 64).into(),
+ array_ptr,
location,
)
.into(),
)?;
-
- entry.append_operation(cf::assert(context, ptr_is_not_null, msg, location));
- Ok(())
-}
-
-pub fn build_tuple_from_span<'ctx, 'this>(
- context: &'ctx Context,
- registry: &ProgramRegistry<CoreType, CoreLibfunc>,
- entry: &'this Block<'ctx>,
- location: Location<'ctx>,
- helper: &LibfuncHelper<'ctx, 'this>,
- metadata: &mut MetadataStorage,
- info: &SignatureAndTypeConcreteLibfunc,
-) -> Result<()> {
- // Tasks:
- // - Check if sizes match.
- // - If they do not match, jump to branch [1].
- // - If they do match:
- // - If start == 0 && capacity == len -> reuse the pointer
- // - Otherwise, realloc + memcpy + free.
-
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, helper));
- }
-
- let array_ty = registry.get_type(&info.signature.param_signatures[0].ty)?;
- let (elem_id, elem_ty) = match array_ty {
- CoreTypeConcrete::Array(info) => (&info.ty, registry.get_type(&info.ty)?),
- CoreTypeConcrete::Snapshot(info) => match registry.get_type(&info.ty)? {
- CoreTypeConcrete::Array(info) => (&info.ty, registry.get_type(&info.ty)?),
- _ => native_panic!(
- "matched an unexpected CoreTypeConcrete that is not a Array or Snapshot"
- ),
- },
- _ => {
- native_panic!("matched an unexpected CoreTypeConcrete that is not a Array or Snapshot")
- }
- };
- let elem_layout = elem_ty.layout(registry)?;
-
- let array_start = entry.extract_value(
- context,
- location,
- entry.arg(0)?,
- IntegerType::new(context, 32).into(),
- 1,
- )?;
- let array_end = entry.extract_value(
- context,
- location,
- entry.arg(0)?,
- IntegerType::new(context, 32).into(),
- 2,
- )?;
-
- let array_len = entry.append_op_result(arith::subi(array_end, array_start, location))?;
- let (tuple_len, tuple_len_val) = {
- let fields = registry
- .get_type(&info.ty)?
- .fields()
- .to_native_assert_error("missing field")?;
-
- native_assert!(
- fields.iter().all(|f| f.id == elem_id.id),
- "all the elements of the array must have the same type"
- );
-
- (
- entry.const_int(context, location, fields.len(), 32)?,
- fields.len(),
- )
- };
-
- let len_matches = entry.cmpi(context, CmpiPredicate::Eq, array_len, tuple_len, location)?;
-
- let block_ok = helper.append_block(Block::new(&[]));
- let block_err = helper.append_block(Block::new(&[]));
- entry.append_operation(cf::cond_br(
+ let ptr_is_null = block.append_op_result(arith::cmpi(
context,
- len_matches,
- block_ok,
- block_err,
- &[],
- &[],
+ CmpiPredicate::Eq,
+ ptr_as_int,
+ k0,
location,
- ));
-
- {
- let k0 = block_ok.const_int(context, location, 0, 32)?;
- let starts_at_zero =
- block_ok.cmpi(context, CmpiPredicate::Eq, array_start, k0, location)?;
-
- let array_cap = block_ok.extract_value(
- context,
- location,
- entry.arg(0)?,
- IntegerType::new(context, 32).into(),
- 3,
- )?;
- let capacity_matches =
- block_ok.cmpi(context, CmpiPredicate::Eq, array_cap, tuple_len, location)?;
+ ))?;
- let array_ptr = block_ok.extract_value(
- context,
- location,
- entry.arg(0)?,
- llvm::r#type::pointer(context, 0),
- 0,
- )?;
- let should_forward_pointer =
- block_ok.append_op_result(arith::andi(starts_at_zero, capacity_matches, location))?;
+ let is_shared = block.append_op_result(scf::r#if(
+ ptr_is_null,
+ &[IntegerType::new(context, 1).into()],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let block_clone = helper.append_block(Block::new(&[]));
- let block_forward = helper.append_block(Block::new(&[]));
- block_ok.append_operation(cf::cond_br(
- context,
- should_forward_pointer,
- block_forward,
- block_clone,
- &[],
- &[],
- location,
- ));
+ let k0 = block.const_int(context, location, 0, 1)?;
+ block.append_operation(scf::r#yield(&[k0], location));
+ region
+ },
{
- let elem_stride =
- block_clone.const_int(context, location, elem_layout.pad_to_align().size(), 64)?;
- let tuple_len =
- block_clone.extui(tuple_len, IntegerType::new(context, 64).into(), location)?;
- let tuple_len = block_clone.muli(tuple_len, elem_stride, location)?;
-
- let box_ptr = block_clone
- .append_op_result(llvm::zero(llvm::r#type::pointer(context, 0), location))?;
- let box_ptr = block_clone.append_op_result(ReallocBindingsMeta::realloc(
- context, box_ptr, tuple_len, location,
- )?)?;
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let elem_offset =
- block_clone.extui(array_start, IntegerType::new(context, 64).into(), location)?;
- let elem_offset = block_clone.muli(elem_offset, elem_stride, location)?;
- let elem_ptr = block_clone.append_op_result(llvm::get_element_ptr_dynamic(
+ let array_ptr = block.gep(
context,
+ location,
array_ptr,
- &[elem_offset],
+ &[GepIndex::Const(-(calc_refcount_offset(elem_layout) as i32))],
IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
+ )?;
+ let ref_count = block.load(
+ context,
location,
- ))?;
+ array_ptr,
+ IntegerType::new(context, 32).into(),
+ )?;
- block_clone.append_operation(
- ods::llvm::intr_memcpy_inline(
+ #[cfg(debug_assertions)]
+ {
+ let k0 = block.const_int(context, location, 0, 32)?;
+ let is_nonzero = block.append_op_result(arith::cmpi(
context,
- box_ptr,
- elem_ptr,
- IntegerAttribute::new(
- IntegerType::new(context, 64).into(),
- (tuple_len_val * elem_layout.pad_to_align().size()) as i64,
- ),
- IntegerAttribute::new(IntegerType::new(context, 1).into(), 0),
+ CmpiPredicate::Ne,
+ ref_count,
+ k0,
location,
- )
- .into(),
- );
-
- block_clone.append_operation(ReallocBindingsMeta::free(context, array_ptr, location)?);
- block_clone.append_operation(helper.br(0, &[box_ptr], location));
- }
+ ))?;
- block_forward.append_operation(helper.br(0, &[array_ptr], location));
- }
-
- {
- registry.build_type(
- context,
- helper,
- registry,
- metadata,
- &info.signature.param_signatures[0].ty,
- )?;
+ block.append_operation(cf::assert(
+ context,
+ is_nonzero,
+ "ref_count must not be zero",
+ location,
+ ));
+ }
- // The metadata get will never fail because an array always has a drop implementation,
- // which at this point is always inserted thanks to the `build_type()` just above.
- metadata
- .get::<DropOverridesMeta>()
- .ok_or(Error::MissingMetadata)?
- .invoke_override(
+ let k1 = block.const_int(context, location, 1, 32)?;
+ let is_shared = block.append_op_result(arith::cmpi(
context,
- block_err,
+ CmpiPredicate::Ne,
+ ref_count,
+ k1,
location,
- &info.signature.param_signatures[0].ty,
- entry.arg(0)?,
- )?;
+ ))?;
- block_err.append_operation(helper.br(1, &[], location));
- }
+ block.append_operation(scf::r#yield(&[is_shared], location));
+ region
+ },
+ location,
+ ))?;
- Ok(())
+ Ok(is_shared)
}
#[cfg(test)]
@@ -4365,7 +5240,6 @@
//data.append(5_u32);
*slice.get(0).unwrap().unbox()
}
-
);
let result = run_program(&program, "run_test", &[]).return_value;
diff --git a/src/cairo_native/metadata/debug_utils.rs.html b/src/cairo_native/metadata/debug_utils.rs.html
index ca4f3df8a..343e1c931 100644
--- a/src/cairo_native/metadata/debug_utils.rs.html
+++ b/src/cairo_native/metadata/debug_utils.rs.html
@@ -1563,7 +1563,7 @@
unsafe extern "C" fn dump_mem_impl(ptr: *const (), len: u64) {
println!("[DEBUG] Memory dump at {ptr:?}:");
for chunk in (0..len).step_by(8) {
- print!(" {ptr:?}:");
+ print!(" {:?}:", ptr.byte_add(chunk as usize));
for offset in chunk..chunk + 8 {
print!(" {:02x}", ptr.byte_add(offset as usize).cast::<u8>().read());
}
diff --git a/src/cairo_native/starknet.rs.html b/src/cairo_native/starknet.rs.html
index 4725ec488..b936c8a27 100644
--- a/src/cairo_native/starknet.rs.html
+++ b/src/cairo_native/starknet.rs.html
@@ -1703,6 +1703,33 @@
1703
1704
1705
+1706
+1707
+1708
+1709
+1710
+1711
+1712
+1713
+1714
+1715
+1716
+1717
+1718
+1719
+1720
+1721
+1722
+1723
+1724
+1725
+1726
+1727
+1728
+1729
+1730
+1731
+1732
//! Starknet related code for `cairo_native`
use serde::{Deserialize, Serialize};
@@ -2245,12 +2272,11 @@
// TODO: Move to the correct place or remove if unused.
pub(crate) mod handler {
use super::*;
- use crate::utils::{libc_free, libc_malloc};
+ use crate::utils::{get_integer_layout, libc_free, libc_malloc};
use std::{
alloc::Layout,
- ffi::c_void,
fmt::Debug,
- mem::{size_of, ManuallyDrop, MaybeUninit},
+ mem::{self, size_of, ManuallyDrop, MaybeUninit},
ptr::{null_mut, NonNull},
};
@@ -2614,7 +2640,17 @@
capacity: 0,
},
_ => {
- let ptr = libc_malloc(Layout::array::<E>(data.len()).unwrap().size()) as *mut E;
+ let refcount_offset = get_integer_layout(32)
+ .align_to(mem::align_of::<E>())
+ .unwrap()
+ .pad_to_align()
+ .size();
+ let ptr = libc_malloc(
+ Layout::array::<E>(data.len()).unwrap().size() + refcount_offset,
+ ) as *mut E;
+
+ ptr.cast::<u32>().write(1);
+ let ptr = ptr.byte_add(refcount_offset);
let len: u32 = data.len().try_into().unwrap();
for (i, val) in data.iter().enumerate() {
@@ -2631,6 +2667,24 @@
}
}
+ unsafe fn drop_mlir_array<E>(data: &ArrayAbi<E>) {
+ if data.ptr.is_null() {
+ return;
+ }
+
+ let refcount_offset = get_integer_layout(32)
+ .align_to(mem::align_of::<E>())
+ .unwrap()
+ .pad_to_align()
+ .size();
+
+ let ptr = data.ptr.byte_sub(refcount_offset);
+ match ptr.cast::<u32>().read() {
+ 1 => libc_free(ptr.cast()),
+ n => ptr.cast::<u32>().write(n - 1),
+ }
+ }
+
fn wrap_error<E>(e: &[Felt]) -> SyscallResultAbi<E> {
SyscallResultAbi {
err: ManuallyDrop::new(SyscallResultAbiErr {
@@ -2673,7 +2727,7 @@
let input_vec: Vec<_> = input.into();
unsafe {
- libc_free(input.ptr as *mut c_void);
+ Self::drop_mlir_array(input);
}
let result = ptr
@@ -2860,7 +2914,7 @@
let calldata_vec: Vec<_> = calldata.into();
unsafe {
- libc_free(calldata.ptr as *mut c_void);
+ Self::drop_mlir_array(calldata);
}
let result = ptr.deploy(
@@ -2920,7 +2974,7 @@
let calldata_vec: Vec<Felt> = calldata.into();
unsafe {
- libc_free(calldata.ptr as *mut c_void);
+ Self::drop_mlir_array(calldata);
}
let result = ptr.library_call(class_hash, function_selector, &calldata_vec, gas);
@@ -2954,7 +3008,7 @@
let calldata_vec: Vec<Felt> = calldata.into();
unsafe {
- libc_free(calldata.ptr as *mut c_void);
+ Self::drop_mlir_array(calldata);
}
let result = ptr.call_contract(address, entry_point_selector, &calldata_vec, gas);
@@ -3028,13 +3082,13 @@
let keys_vec: Vec<_> = keys.into();
unsafe {
- libc_free(keys.ptr as *mut c_void);
+ Self::drop_mlir_array(keys);
}
let data_vec: Vec<_> = data.into();
unsafe {
- libc_free(data.ptr as *mut c_void);
+ Self::drop_mlir_array(data);
}
let result = ptr.emit_event(&keys_vec, &data_vec, gas);
@@ -3061,7 +3115,7 @@
let payload_vec: Vec<_> = payload.into();
unsafe {
- libc_free(payload.ptr as *mut c_void);
+ Self::drop_mlir_array(payload);
}
let result = ptr.send_message_to_l1(to_address, &payload_vec, gas);
@@ -3096,7 +3150,7 @@
let result = ptr.keccak(input_vec, gas);
unsafe {
- libc_free(input.ptr as *mut c_void);
+ Self::drop_mlir_array(input);
}
*result_ptr = match result {
diff --git a/src/cairo_native/types.rs.html b/src/cairo_native/types.rs.html
index b080dc46b..87b16786e 100644
--- a/src/cairo_native/types.rs.html
+++ b/src/cairo_native/types.rs.html
@@ -1011,16 +1011,6 @@
1011
1012
1013
-1014
-1015
-1016
-1017
-1018
-1019
-1020
-1021
-1022
-1023
//! # Compiler type infrastructure
//!
//! Contains type generation stuff (aka. conversion from Sierra to MLIR types).
@@ -1157,9 +1147,6 @@
/// TODO: How is it used?
fn variants(&self) -> Option<&[ConcreteTypeId]>;
- // If the type is a struct, return the field types.
- fn fields(&self) -> Option<&[ConcreteTypeId]>;
-
#[allow(clippy::too_many_arguments)]
fn build_default<'ctx, 'this>(
&self,
@@ -1926,13 +1913,6 @@
}
}
- fn fields(&self) -> Option<&[ConcreteTypeId]> {
- match self {
- Self::Struct(info) => Some(&info.members),
- _ => None,
- }
- }
-
fn build_default<'ctx, 'this>(
&self,
context: &'ctx Context,
diff --git a/src/cairo_native/types/array.rs.html b/src/cairo_native/types/array.rs.html
index 9356c84f6..e8fcc3052 100644
--- a/src/cairo_native/types/array.rs.html
+++ b/src/cairo_native/types/array.rs.html
@@ -394,6 +394,39 @@
394
395
396
+397
+398
+399
+400
+401
+402
+403
+404
+405
+406
+407
+408
+409
+410
+411
+412
+413
+414
+415
+416
+417
+418
+419
+420
+421
+422
+423
+424
+425
+426
+427
+428
+429
//! # Array type
//!
//! An array type is a dynamically allocated list of items.
@@ -410,6 +443,11 @@
//! | 1 | `i32` | Array end offset[^2]. |
//! | 2 | `i32` | Allocated capacity[^2]. |
//!
+//! The pointer to the allocation (which is **not the data**) contains:
+//! 1. Reference counter.
+//! 2. Padding.
+//! 3. Array data. Its address is the pointer to the data stored in the type.
+//!
//! [^1]: When capacity is zero, this field is not guaranteed to be valid.
//! [^2]: Those numbers are number of items, **not bytes**.
@@ -420,7 +458,7 @@
drop_overrides::DropOverridesMeta, dup_overrides::DupOverridesMeta,
realloc_bindings::ReallocBindingsMeta, MetadataStorage,
},
- utils::{BlockExt, GepIndex, ProgramRegistryExt},
+ utils::{get_integer_layout, BlockExt, GepIndex, ProgramRegistryExt},
};
use cairo_lang_sierra::{
extensions::{
@@ -432,8 +470,8 @@
use melior::dialect::{arith::CmpiPredicate, func, scf};
use melior::ir::Region;
use melior::{
- dialect::{arith, cf, llvm, ods},
- ir::{attribute::IntegerAttribute, r#type::IntegerType, Block, Location, Module, Type},
+ dialect::{arith, llvm},
+ ir::{r#type::IntegerType, Block, Location, Module, Type},
Context,
};
@@ -486,7 +524,10 @@
))
}
-fn build_dup<'ctx>(
+/// This function clones the array shallowly. That is, it'll increment the reference counter but not
+/// actually clone anything. The deep clone implementation is provided in `src/libfuncs/array.rs` as
+/// part of some libfuncs's implementations.
+fn build_dup<'ctx>(
context: &'ctx Context,
module: &Module<'ctx>,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
@@ -494,167 +535,84 @@
info: &WithSelf<InfoAndTypeConcreteType>,
) -> Result<Region<'ctx>> {
let location = Location::unknown(context);
- if metadata.get::<ReallocBindingsMeta>().is_none() {
- metadata.insert(ReallocBindingsMeta::new(context, module));
- }
-
let value_ty = registry.build_type(context, module, registry, metadata, info.self_ty())?;
- let elem_ty = registry.get_type(&info.ty)?;
- let elem_stride = elem_ty.layout(registry)?.pad_to_align().size();
- let elem_ty = elem_ty.build(context, module, registry, metadata, &info.ty)?;
+
+ let elem_layout = registry.get_type(&info.ty)?.layout(registry)?;
+ let refcount_offset = get_integer_layout(32)
+ .align_to(elem_layout.align())
+ .unwrap()
+ .pad_to_align()
+ .size();
let region = Region::new();
let entry = region.append_block(Block::new(&[(value_ty, location)]));
- let src_value = entry.arg(0)?;
- let value_ptr = entry.extract_value(
- context,
- location,
- src_value,
- llvm::r#type::pointer(context, 0),
- 0,
- )?;
- let value_start = entry.extract_value(
- context,
- location,
- src_value,
- IntegerType::new(context, 32).into(),
- 1,
- )?;
- let value_end = entry.extract_value(
+ let array_cap = entry.extract_value(
context,
location,
- src_value,
+ entry.argument(0)?.into(),
IntegerType::new(context, 32).into(),
- 2,
+ 3,
)?;
-
- let value_len = entry.append_op_result(arith::subi(value_end, value_start, location))?;
-
let k0 = entry.const_int(context, location, 0, 32)?;
- let value_is_empty = entry.cmpi(context, CmpiPredicate::Eq, value_len, k0, location)?;
-
- let null_ptr =
- entry.append_op_result(llvm::zero(llvm::r#type::pointer(context, 0), location))?;
-
- let block_realloc = region.append_block(Block::new(&[]));
- let block_finish =
- region.append_block(Block::new(&[(llvm::r#type::pointer(context, 0), location)]));
- entry.append_operation(cf::cond_br(
+ let is_empty = entry.append_op_result(arith::cmpi(
context,
- value_is_empty,
- &block_finish,
- &block_realloc,
- &[null_ptr],
- &[],
+ CmpiPredicate::Eq,
+ array_cap,
+ k0,
location,
- ));
+ ))?;
- {
- let elem_stride = block_realloc.const_int(context, location, elem_stride, 64)?;
+ entry.append_operation(scf::r#if(
+ is_empty,
+ &[],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- let dst_value_len = {
- let value_len =
- block_realloc.extui(value_len, IntegerType::new(context, 64).into(), location)?;
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
- block_realloc.muli(value_len, elem_stride, location)?
- };
- let dst_value_ptr = {
- block_realloc.append_op_result(ReallocBindingsMeta::realloc(
+ let array_ptr = block.extract_value(
context,
- null_ptr,
- dst_value_len,
location,
- )?)?
- };
-
- let src_value_ptr = {
- let value_offset =
- block_realloc.extui(value_start, IntegerType::new(context, 64).into(), location)?;
+ entry.argument(0)?.into(),
+ llvm::r#type::pointer(context, 0),
+ 0,
+ )?;
- let src_value_offset = block_realloc.muli(value_offset, elem_stride, location)?;
- block_realloc.gep(
+ let refcount_ptr = block.gep(
context,
location,
- value_ptr,
- &[GepIndex::Value(src_value_offset)],
+ array_ptr,
+ &[GepIndex::Const(-(refcount_offset as i32))],
IntegerType::new(context, 8).into(),
- )?
- };
-
- match metadata.get::<DupOverridesMeta>() {
- Some(dup_override_meta) if dup_override_meta.is_overriden(&info.ty) => {
- let k0 = block_realloc.const_int(context, location, 0, 64)?;
- block_realloc.append_operation(scf::r#for(
- k0,
- dst_value_len,
- elem_stride,
- {
- let region = Region::new();
- let block = region.append_block(Block::new(&[(
- IntegerType::new(context, 64).into(),
- location,
- )]));
-
- let idx = block.arg(0)?;
-
- let src_value_ptr = block.gep(
- context,
- location,
- src_value_ptr,
- &[GepIndex::Value(idx)],
- IntegerType::new(context, 8).into(),
- )?;
- let dst_value_ptr = block.gep(
- context,
- location,
- dst_value_ptr,
- &[GepIndex::Value(idx)],
- IntegerType::new(context, 8).into(),
- )?;
-
- let value = block.load(context, location, src_value_ptr, elem_ty)?;
- let values = dup_override_meta
- .invoke_override(context, &block, location, &info.ty, value)?;
- block.store(context, location, src_value_ptr, values.0)?;
- block.store(context, location, dst_value_ptr, values.1)?;
-
- block.append_operation(scf::r#yield(&[], location));
- region
- },
- location,
- ));
- }
- _ => {
- block_realloc.append_operation(
- ods::llvm::intr_memcpy(
- context,
- dst_value_ptr,
- src_value_ptr,
- dst_value_len,
- IntegerAttribute::new(IntegerType::new(context, 1).into(), 0),
- location,
- )
- .into(),
- );
- }
- }
-
- block_realloc.append_operation(cf::br(&block_finish, &[dst_value_ptr], location));
- }
+ )?;
+ let ref_count = block.load(
+ context,
+ location,
+ refcount_ptr,
+ IntegerType::new(context, 32).into(),
+ )?;
- {
- let dst_value = block_finish.append_op_result(llvm::undef(value_ty, location))?;
- let dst_value = block_finish.insert_values(
- context,
- location,
- dst_value,
- &[block_finish.arg(0)?, k0, value_len, value_len],
- )?;
+ let k1 = block.const_int(context, location, 1, 32)?;
+ let ref_count = block.append_op_result(arith::addi(ref_count, k1, location))?;
+ block.store(context, location, refcount_ptr, ref_count)?;
- block_finish.append_operation(func::r#return(&[src_value, dst_value], location));
- }
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ entry.append_operation(func::r#return(
+ &[entry.argument(0)?.into(), entry.argument(0)?.into()],
+ location,
+ ));
Ok(region)
}
@@ -671,83 +629,191 @@
}
let value_ty = registry.build_type(context, module, registry, metadata, info.self_ty())?;
+
let elem_ty = registry.get_type(&info.ty)?;
let elem_stride = elem_ty.layout(registry)?.pad_to_align().size();
let elem_ty = elem_ty.build(context, module, registry, metadata, &info.ty)?;
+ let elem_layout = registry.get_type(&info.ty)?.layout(registry)?;
+ let refcount_offset = get_integer_layout(32)
+ .align_to(elem_layout.align())
+ .unwrap()
+ .pad_to_align()
+ .size();
let region = Region::new();
let entry = region.append_block(Block::new(&[(value_ty, location)]));
- let src_value = entry.arg(0)?;
- let value_ptr = entry.extract_value(
+ let array_ptr = entry.extract_value(
context,
location,
- src_value,
+ entry.argument(0)?.into(),
llvm::r#type::pointer(context, 0),
0,
)?;
- match metadata.get::<DropOverridesMeta>() {
- Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
- let value_start = entry.extract_value(
+ let array_cap = entry.extract_value(
+ context,
+ location,
+ entry.argument(0)?.into(),
+ IntegerType::new(context, 32).into(),
+ 3,
+ )?;
+ let k0 = entry.const_int(context, location, 0, 32)?;
+ let is_empty = entry.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Eq,
+ array_cap,
+ k0,
+ location,
+ ))?;
+
+ entry.append_operation(scf::r#if(
+ is_empty,
+ &[],
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ let refcount_ptr = block.gep(
context,
location,
- src_value,
- IntegerType::new(context, 32).into(),
- 1,
+ array_ptr,
+ &[GepIndex::Const(-(refcount_offset as i32))],
+ IntegerType::new(context, 8).into(),
)?;
- let value_end = entry.extract_value(
+ let ref_count = block.load(
context,
location,
- src_value,
+ refcount_ptr,
IntegerType::new(context, 32).into(),
- 2,
)?;
- let value_start =
- entry.extui(value_start, IntegerType::new(context, 64).into(), location)?;
- let value_end =
- entry.extui(value_end, IntegerType::new(context, 64).into(), location)?;
-
- let elem_stride = entry.const_int(context, location, elem_stride, 64)?;
- let offset_start = entry.muli(value_start, elem_stride, location)?;
- let offset_end = entry.muli(value_end, elem_stride, location)?;
+ let k1 = block.const_int(context, location, 1, 32)?;
+ let is_shared = block.append_op_result(arith::cmpi(
+ context,
+ CmpiPredicate::Ne,
+ ref_count,
+ k1,
+ location,
+ ))?;
- entry.append_operation(scf::r#for(
- offset_start,
- offset_end,
- elem_stride,
+ block.append_operation(scf::r#if(
+ is_shared,
+ &[],
{
let region = Region::new();
- let block = region.append_block(Block::new(&[(
- IntegerType::new(context, 64).into(),
- location,
- )]));
+ let block = region.append_block(Block::new(&[]));
+
+ let ref_count = block.append_op_result(arith::subi(ref_count, k1, location))?;
+ block.store(context, location, refcount_ptr, ref_count)?;
- let elem_offset = block.arg(0)?;
- let elem_ptr = block.append_op_result(llvm::get_element_ptr_dynamic(
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[]));
+
+ match metadata.get::<DropOverridesMeta>() {
+ Some(drop_overrides_meta) if drop_overrides_meta.is_overriden(&info.ty) => {
+ let value_start = block.extract_value(
+ context,
+ location,
+ entry.argument(0)?.into(),
+ IntegerType::new(context, 32).into(),
+ 1,
+ )?;
+ let value_end = block.extract_value(
+ context,
+ location,
+ entry.argument(0)?.into(),
+ IntegerType::new(context, 32).into(),
+ 2,
+ )?;
+
+ let value_start = block.append_op_result(arith::extui(
+ value_start,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+ let value_end = block.append_op_result(arith::extui(
+ value_end,
+ IntegerType::new(context, 64).into(),
+ location,
+ ))?;
+
+ let elem_stride =
+ block.const_int(context, location, elem_stride, 64)?;
+ let offset_start = block.append_op_result(arith::muli(
+ value_start,
+ elem_stride,
+ location,
+ ))?;
+ let offset_end = block.append_op_result(arith::muli(
+ value_end,
+ elem_stride,
+ location,
+ ))?;
+
+ block.append_operation(scf::r#for(
+ offset_start,
+ offset_end,
+ elem_stride,
+ {
+ let region = Region::new();
+ let block = region.append_block(Block::new(&[(
+ IntegerType::new(context, 64).into(),
+ location,
+ )]));
+
+ let elem_offset = block.argument(0)?.into();
+ let elem_ptr = block.gep(
+ context,
+ location,
+ array_ptr,
+ &[GepIndex::Value(elem_offset)],
+ IntegerType::new(context, 8).into(),
+ )?;
+ let elem_val =
+ block.load(context, location, elem_ptr, elem_ty)?;
+
+ drop_overrides_meta.invoke_override(
+ context, &block, location, &info.ty, elem_val,
+ )?;
+
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+ }
+ _ => {}
+ }
+
+ block.append_operation(ReallocBindingsMeta::free(
context,
- value_ptr,
- &[elem_offset],
- IntegerType::new(context, 8).into(),
- llvm::r#type::pointer(context, 0),
+ refcount_ptr,
location,
- ))?;
- let elem_val = block.load(context, location, elem_ptr, elem_ty)?;
-
- drop_overrides_meta
- .invoke_override(context, &block, location, &info.ty, elem_val)?;
-
+ )?);
block.append_operation(scf::r#yield(&[], location));
region
},
location,
));
- }
- _ => {}
- }
- entry.append_operation(ReallocBindingsMeta::free(context, value_ptr, location)?);
+ block.append_operation(scf::r#yield(&[], location));
+ region
+ },
+ location,
+ ));
+
entry.append_operation(func::r#return(&[], location));
Ok(region)
}
diff --git a/src/cairo_native/values.rs.html b/src/cairo_native/values.rs.html
index 7a638f64f..379686027 100644
--- a/src/cairo_native/values.rs.html
+++ b/src/cairo_native/values.rs.html
@@ -1713,6 +1713,81 @@
1713
1714
1715
+1716
+1717
+1718
+1719
+1720
+1721
+1722
+1723
+1724
+1725
+1726
+1727
+1728
+1729
+1730
+1731
+1732
+1733
+1734
+1735
+1736
+1737
+1738
+1739
+1740
+1741
+1742
+1743
+1744
+1745
+1746
+1747
+1748
+1749
+1750
+1751
+1752
+1753
+1754
+1755
+1756
+1757
+1758
+1759
+1760
+1761
+1762
+1763
+1764
+1765
+1766
+1767
+1768
+1769
+1770
+1771
+1772
+1773
+1774
+1775
+1776
+1777
+1778
+1779
+1780
+1781
+1782
+1783
+1784
+1785
+1786
+1787
+1788
+1789
+1790
//! # Params and return values de/serialization
//!
//! A Rusty interface to provide parameters to cairo-native entry point calls.
@@ -1956,16 +2031,29 @@
let elem_ty = registry.get_type(&info.ty)?;
let elem_layout = elem_ty.layout(registry)?.pad_to_align();
- let ptr: *mut () = match elem_layout.size() * data.len() {
+ let refcount_offset = get_integer_layout(32)
+ .align_to(elem_layout.align())
+ .unwrap()
+ .pad_to_align()
+ .size();
+ let ptr = match elem_layout.size() * data.len() {
0 => std::ptr::null_mut(),
- len => libc_malloc(len).cast(),
+ len => {
+ let ptr: *mut () = libc_malloc(len + refcount_offset).cast();
+
+ // Write reference count.
+ ptr.cast::<u32>().write(1);
+
+ ptr.byte_add(refcount_offset)
+ }
};
let len: u32 = data
.len()
.try_into()
.map_err(|_| Error::IntegerConversion)?;
- for (idx, elem) in data.iter().enumerate() {
+ // Write the data.
+ for (idx, elem) in data.iter().enumerate() {
let elem = elem.to_ptr(arena, registry, &info.ty)?;
std::ptr::copy_nonoverlapping(
@@ -2276,6 +2364,7 @@
ptr: NonNull<()>,
type_id: &ConcreteTypeId,
registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+ should_drop: bool,
) -> Result<Self, Error> {
let ty = registry.get_type(type_id)?;
@@ -2301,11 +2390,32 @@
.cast::<u32>()
.as_ref();
- // this pointer can be null if the array has a size of 0.
+ // This pointer can be null if the array is empty.
let init_data_ptr = *ptr.cast::<*mut ()>().as_ref();
let data_ptr =
init_data_ptr.byte_add(elem_stride * start_offset_value as usize);
+ let refcount_offset = get_integer_layout(32)
+ .align_to(elem_layout.align())
+ .unwrap()
+ .pad_to_align()
+ .size();
+ let should_drop = if !init_data_ptr.is_null()
+ && init_data_ptr.byte_sub(refcount_offset).cast::<u32>().read() == 1
+ {
+ should_drop
+ } else {
+ if !init_data_ptr.is_null() && should_drop {
+ *init_data_ptr
+ .byte_sub(refcount_offset)
+ .cast::<u32>()
+ .as_mut()
+ .unwrap() -= 1;
+ }
+
+ false
+ };
+
native_assert!(
end_offset_value >= start_offset_value,
"can't have an array with negative length"
@@ -2320,19 +2430,28 @@
"tried to make a non-null ptr out of a null one",
)?;
- array_value.push(Self::from_ptr(cur_elem_ptr, &info.ty, registry)?);
+ array_value.push(Self::from_ptr(
+ cur_elem_ptr,
+ &info.ty,
+ registry,
+ should_drop,
+ )?);
}
- if !init_data_ptr.is_null() {
- libc_free(init_data_ptr.cast());
+ if should_drop && !init_data_ptr.is_null() {
+ libc_free(init_data_ptr.byte_sub(refcount_offset).cast());
}
Self::Array(array_value)
}
CoreTypeConcrete::Box(info) => {
let inner = *ptr.cast::<NonNull<()>>().as_ptr();
- let value = Self::from_ptr(inner, &info.ty, registry)?;
- libc_free(inner.as_ptr().cast());
+ let value = Self::from_ptr(inner, &info.ty, registry, should_drop)?;
+
+ if should_drop {
+ libc_free(inner.as_ptr().cast());
+ }
+
value
}
CoreTypeConcrete::EcPoint(_) => {
@@ -2377,7 +2496,9 @@
CoreTypeConcrete::Sint32(_) => Self::Sint32(*ptr.cast::<i32>().as_ref()),
CoreTypeConcrete::Sint64(_) => Self::Sint64(*ptr.cast::<i64>().as_ref()),
CoreTypeConcrete::Sint128(_) => Self::Sint128(*ptr.cast::<i128>().as_ref()),
- CoreTypeConcrete::NonZero(info) => Self::from_ptr(ptr, &info.ty, registry)?,
+ CoreTypeConcrete::NonZero(info) => {
+ Self::from_ptr(ptr, &info.ty, registry, should_drop)?
+ }
CoreTypeConcrete::Nullable(info) => {
let inner_ptr = *ptr.cast::<*mut ()>().as_ptr();
if inner_ptr.is_null() {
@@ -2387,8 +2508,13 @@
NonNull::new_unchecked(inner_ptr).cast(),
&info.ty,
registry,
+ should_drop,
)?;
- libc_free(inner_ptr.cast());
+
+ if should_drop {
+ libc_free(inner_ptr.cast());
+ }
+
value
}
}
@@ -2430,7 +2556,12 @@
ptr.as_ptr().byte_add(tag_layout.extend(payload_layout)?.1),
)
.to_native_assert_error("tried to make a non-null ptr out of a null one")?;
- let payload = Self::from_ptr(payload_ptr, &info.variants[tag_value], registry)?;
+ let payload = Self::from_ptr(
+ payload_ptr,
+ &info.variants[tag_value],
+ registry,
+ should_drop,
+ )?;
Self::Enum {
tag: tag_value,
@@ -2458,6 +2589,7 @@
)?,
member_ty,
registry,
+ should_drop,
)?);
}
@@ -2468,19 +2600,20 @@
}
CoreTypeConcrete::Felt252Dict(info)
| CoreTypeConcrete::SquashedFelt252Dict(info) => {
- let FeltDict { inner, .. } = *Box::from_raw(
- ptr.cast::<NonNull<()>>()
- .as_ref()
- .cast::<FeltDict>()
- .as_ptr(),
- );
+ let inner = &ptr
+ .cast::<NonNull<()>>()
+ .as_ref()
+ .cast::<FeltDict>()
+ .as_ref()
+ .inner;
let mut output_map = HashMap::with_capacity(inner.len());
- for (mut key, val_ptr) in inner.into_iter() {
+ for (&key, &val_ptr) in inner.iter() {
if val_ptr.is_null() {
continue;
}
+ let mut key = key;
key[31] &= 0x0F; // Filter out first 4 bits (they're outside an i252).
let key = Felt::from_bytes_le(&key);
@@ -2494,9 +2627,22 @@
.cast(),
&info.ty,
registry,
+ should_drop,
)?,
);
- libc_free(val_ptr);
+
+ if should_drop {
+ libc_free(val_ptr);
+ }
+ }
+
+ if should_drop {
+ drop(Box::from_raw(
+ ptr.cast::<NonNull<()>>()
+ .as_ref()
+ .cast::<FeltDict>()
+ .as_ptr(),
+ ));
}
Self::Felt252Dict {
@@ -2546,8 +2692,10 @@
native_panic!("todo: implement Sha256StateHandle from_ptr")
}
},
- CoreTypeConcrete::Span(_) => native_panic!("todo: implement span from_ptr"),
- CoreTypeConcrete::Snapshot(info) => Self::from_ptr(ptr, &info.ty, registry)?,
+ CoreTypeConcrete::Span(_) => native_panic!("implement span from_ptr"),
+ CoreTypeConcrete::Snapshot(info) => {
+ Self::from_ptr(ptr, &info.ty, registry, should_drop)?
+ }
CoreTypeConcrete::Bytes31(_) => {
let data = *ptr.cast::<[u8; 31]>().as_ref();
Self::Bytes31(data)
@@ -2584,6 +2732,7 @@
)?,
&info.ty,
registry,
+ should_drop,
)?;
let y = Self::from_ptr(
@@ -2594,6 +2743,7 @@
.to_native_assert_error("tried to make a non-null ptr out of a null one")?,
&info.ty,
registry,
+ should_drop,
)?;
Self::IntRange {