diff --git a/tests/ast/functions-to-prune.ast b/tests/ast/functions-to-prune.ast index 9c95de767..b4a74866b 100644 --- a/tests/ast/functions-to-prune.ast +++ b/tests/ast/functions-to-prune.ast @@ -6,7 +6,7 @@ Block: Body: Block: FunctionDefinition: - Name: fun_ENTRY_POINT + Name: __main_meat Parameters: Return Variables: Body: diff --git a/tests/ast/functions-to-prune.ast.result b/tests/ast/functions-to-prune.ast.result index fd1c24766..41b153966 100644 --- a/tests/ast/functions-to-prune.ast.result +++ b/tests/ast/functions-to-prune.ast.result @@ -1,4 +1,4 @@ { function funD() { } - function fun_ENTRY_POINT() { funD() } + function __main_meat() { funD() } } \ No newline at end of file diff --git a/tests/yul/ERC20.cairo b/tests/yul/ERC20.cairo index 41b367d06..d4be63204 100644 --- a/tests/yul/ERC20.cairo +++ b/tests/yul/ERC20.cairo @@ -7,7 +7,6 @@ from evm.hashing import uint256_pedersen from evm.memory import uint256_mload, uint256_mstore from evm.uint256 import is_eq, is_gt, is_lt, is_zero, slt, u256_add, u256_shl, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -38,6 +37,39 @@ end func evm_storage(arg0_low, arg0_high) -> (res : Uint256): end +@constructor +func constructor{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): + alloc_locals + let (__fp__, _) = get_fp_and_pc() + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) + let exec_env : ExecutionEnvironment* = &exec_env_ + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + func update_byte_slice_shift_deployment(value : Uint256, toInsert : Uint256) -> (result : Uint256): alloc_locals let result : Uint256 = toInsert @@ -61,29 +93,18 @@ func constructor_WARP{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr return () end -@constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func __constructor_meat{ + memory_dict : DictAccess*, msize, pedersen_ptr : HashBuiltin*, range_check_ptr, + syscall_ptr : felt*}() -> (): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() - let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env : ExecutionEnvironment* = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - end - constructor_WARP() - return () + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 end + constructor_WARP() + return () end func abi_decode{range_check_ptr}(headStart : Uint256, dataEnd : Uint256) -> (): @@ -690,31 +711,19 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}() -> ( + ): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/ERC20_storage.cairo b/tests/yul/ERC20_storage.cairo index 22b16f763..659dd091e 100644 --- a/tests/yul/ERC20_storage.cairo +++ b/tests/yul/ERC20_storage.cairo @@ -7,7 +7,6 @@ from evm.hashing import uint256_pedersen from evm.memory import uint256_mload, uint256_mstore from evm.uint256 import is_eq, is_gt, is_lt, is_zero, slt, u256_add, u256_shl, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -38,6 +37,39 @@ end func evm_storage(arg0_low, arg0_high) -> (res : Uint256): end +@constructor +func constructor{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): + alloc_locals + let (__fp__, _) = get_fp_and_pc() + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) + let exec_env : ExecutionEnvironment* = &exec_env_ + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + func update_byte_slice_shift_0{range_check_ptr}(value : Uint256, toInsert : Uint256) -> ( result : Uint256): alloc_locals @@ -85,29 +117,18 @@ func constructor_WARP{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr return () end -@constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func __constructor_meat{ + memory_dict : DictAccess*, msize, pedersen_ptr : HashBuiltin*, range_check_ptr, + syscall_ptr : felt*}() -> (): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() - let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env : ExecutionEnvironment* = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - end - constructor_WARP() - return () + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 end + constructor_WARP() + return () end func abi_decode{range_check_ptr}(headStart : Uint256, dataEnd : Uint256) -> (): @@ -731,31 +752,19 @@ func __warp_if_1{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}() -> ( + ): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_1(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_1(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/address.cairo b/tests/yul/address.cairo index 96d1c3693..9cfbcb242 100644 --- a/tests/yul/address.cairo +++ b/tests/yul/address.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mstore from evm.uint256 import is_eq, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import address, warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -18,27 +17,46 @@ func __warp_constant_0() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -120,31 +138,18 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + syscall_ptr : felt*, termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/arrays.cairo b/tests/yul/arrays.cairo index 785f73c79..cc428610b 100644 --- a/tests/yul/arrays.cairo +++ b/tests/yul/arrays.cairo @@ -7,7 +7,6 @@ from evm.hashing import uint256_pedersen from evm.memory import uint256_mload, uint256_mstore from evm.uint256 import is_eq, is_lt, is_zero, slt, u256_add, u256_shl, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -35,27 +34,46 @@ func evm_storage(arg0_low, arg0_high) -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -283,31 +301,19 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}() -> ( + ): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/c2c.cairo b/tests/yul/c2c.cairo index 08e9779be..d7212d0bd 100644 --- a/tests/yul/c2c.cairo +++ b/tests/yul/c2c.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mload, uint256_mstore from evm.uint256 import is_eq, is_gt, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -26,27 +25,46 @@ func __warp_constant_10000000000000000000000000000000000000000() -> (res : Uint2 end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -500,31 +518,18 @@ func __warp_if_3{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + syscall_ptr : felt*, termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_3(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_3(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/calldatacopy.cairo b/tests/yul/calldatacopy.cairo index d22d61a5a..b74dc9fe7 100644 --- a/tests/yul/calldatacopy.cairo +++ b/tests/yul/calldatacopy.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mload, uint256_mstore from evm.uint256 import is_eq, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -18,27 +17,45 @@ func __warp_constant_0() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr}(calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -133,31 +150,18 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/calldataload.cairo b/tests/yul/calldataload.cairo index c6c55d5a8..d94db4a53 100644 --- a/tests/yul/calldataload.cairo +++ b/tests/yul/calldataload.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mstore from evm.uint256 import is_eq, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -22,27 +21,45 @@ func returndata_size{exec_env : ExecutionEnvironment*}() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr}(calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -136,31 +153,18 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/calldatasize.cairo b/tests/yul/calldatasize.cairo index 6a0526a19..b9ba4ade6 100644 --- a/tests/yul/calldatasize.cairo +++ b/tests/yul/calldatasize.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mstore from evm.uint256 import is_eq, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -18,27 +17,45 @@ func __warp_constant_0() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr}(calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -132,31 +149,18 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/constructors_dyn.cairo b/tests/yul/constructors_dyn.cairo index 7bef48fe2..abbd9bcea 100644 --- a/tests/yul/constructors_dyn.cairo +++ b/tests/yul/constructors_dyn.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mload, uint256_mstore from evm.uint256 import is_eq, is_gt, is_lt, is_zero, slt, u256_add, u256_shl, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -33,6 +32,42 @@ end func evm_storage(arg0_low, arg0_high) -> (res : Uint256): end +@constructor +func constructor{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (__fp__, _) = get_fp_and_pc() + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) + let exec_env : ExecutionEnvironment* = &exec_env_ + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with exec_env, memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): + alloc_locals + let (__fp__, _) = get_fp_and_pc() + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) + let exec_env : ExecutionEnvironment* = &exec_env_ + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + func finalize_allocation{memory_dict : DictAccess*, msize, range_check_ptr}( memPtr : Uint256, size : Uint256) -> (): alloc_locals @@ -148,31 +183,19 @@ func constructor_WARP{ return () end -@constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func __constructor_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}() -> (): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() - let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env : ExecutionEnvironment* = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - end - let (_1 : Uint256, _2 : Uint256, _3 : Uint256) = copy_arguments_for_constructor_object_WARP( - ) - constructor_WARP(_1, _2, _3) - return () + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 end + let (_1 : Uint256, _2 : Uint256, _3 : Uint256) = copy_arguments_for_constructor_object_WARP() + constructor_WARP(_1, _2, _3) + return () end func abi_decode_struct_Person_calldata{range_check_ptr}( @@ -512,31 +535,19 @@ func __warp_if_2{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}() -> ( + ): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_2(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_2(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/constructors_nonDyn.cairo b/tests/yul/constructors_nonDyn.cairo index 82b06a7ca..12447442c 100644 --- a/tests/yul/constructors_nonDyn.cairo +++ b/tests/yul/constructors_nonDyn.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mload, uint256_mstore from evm.uint256 import is_eq, is_lt, is_zero, slt, u256_add, u256_shl, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -33,6 +32,42 @@ end func evm_storage(arg0_low, arg0_high) -> (res : Uint256): end +@constructor +func constructor{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (__fp__, _) = get_fp_and_pc() + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) + let exec_env : ExecutionEnvironment* = &exec_env_ + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with exec_env, memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): + alloc_locals + let (__fp__, _) = get_fp_and_pc() + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) + let exec_env : ExecutionEnvironment* = &exec_env_ + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + func abi_decode_addresst_uint256t_uint256_deployment{ exec_env : ExecutionEnvironment*, range_check_ptr}( headStart : Uint256, dataEnd : Uint256) -> ( @@ -90,31 +125,19 @@ func constructor_WARP{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr return () end -@constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func __constructor_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}() -> (): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() - let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env : ExecutionEnvironment* = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - end - let (_1 : Uint256, _2 : Uint256, _3 : Uint256) = copy_arguments_for_constructor_object_WARP( - ) - constructor_WARP(_1, _2, _3) - return () + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 end + let (_1 : Uint256, _2 : Uint256, _3 : Uint256) = copy_arguments_for_constructor_object_WARP() + constructor_WARP(_1, _2, _3) + return () end func abi_decode{range_check_ptr}(headStart : Uint256, dataEnd : Uint256) -> (): @@ -439,31 +462,19 @@ func __warp_if_2{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}() -> ( + ): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_2(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_2(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/ctor-check.cairo b/tests/yul/ctor-check.cairo new file mode 100644 index 000000000..d712beed9 --- /dev/null +++ b/tests/yul/ctor-check.cairo @@ -0,0 +1,446 @@ +%lang starknet +%builtins pedersen range_check bitwise + +from evm.calls import calldatacopy, calldataload, calldatasize, caller, returndata_copy, warp_call +from evm.exec_env import ExecutionEnvironment +from evm.memory import uint256_mload, uint256_mstore +from evm.uint256 import is_eq, is_gt, is_lt, is_zero, slt, u256_add, u256_shl, u256_shr +from evm.yul_api import warp_return +from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin +from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new +from starkware.cairo.common.dict_access import DictAccess +from starkware.cairo.common.registers import get_fp_and_pc +from starkware.cairo.common.uint256 import Uint256, uint256_and, uint256_sub + +func sload{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}(key : Uint256) -> ( + value : Uint256): + let (value) = evm_storage.read(key.low, key.high) + return (value) +end + +func sstore{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + key : Uint256, value : Uint256): + evm_storage.write(key.low, key.high, value) + return () +end + +func __warp_constant_0() -> (res : Uint256): + return (Uint256(low=0, high=0)) +end + +func returndata_size{exec_env : ExecutionEnvironment*}() -> (res : Uint256): + return (Uint256(low=exec_env.returndata_size, high=0)) +end + +func __warp_constant_10000000000000000000000000000000000000000() -> (res : Uint256): + return (Uint256(low=131811359292784559562136384478721867776, high=29)) +end + +@storage_var +func evm_storage(arg0_low, arg0_high) -> (res : Uint256): +end + +@constructor +func constructor{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (__fp__, _) = get_fp_and_pc() + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) + let exec_env : ExecutionEnvironment* = &exec_env_ + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with exec_env, memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): + alloc_locals + let (__fp__, _) = get_fp_and_pc() + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) + let exec_env : ExecutionEnvironment* = &exec_env_ + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func abi_decode_contract_Lib{exec_env : ExecutionEnvironment*, range_check_ptr}( + headStart : Uint256, dataEnd : Uint256) -> (value0 : Uint256): + alloc_locals + let (__warp_subexpr_1 : Uint256) = uint256_sub(dataEnd, headStart) + let (__warp_subexpr_0 : Uint256) = slt(__warp_subexpr_1, Uint256(low=32, high=0)) + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + end + let (value0 : Uint256) = calldataload(headStart) + return (value0) +end + +func update_byte_slice_shift(value : Uint256, toInsert : Uint256) -> (result : Uint256): + alloc_locals + let result : Uint256 = toInsert + return (result) +end + +func update_storage_value_offsett_address_to_address{ + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + slot : Uint256, value : Uint256) -> (): + alloc_locals + let (__warp_subexpr_1 : Uint256) = sload(slot) + let (__warp_subexpr_0 : Uint256) = update_byte_slice_shift(__warp_subexpr_1, value) + sstore(key=slot, value=__warp_subexpr_0) + return () +end + +func constructor_WARP{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + var_lib_address : Uint256) -> (): + alloc_locals + let (__warp_subexpr_0 : Uint256) = caller() + update_storage_value_offsett_address_to_address(Uint256(low=0, high=0), __warp_subexpr_0) + update_storage_value_offsett_address_to_address(Uint256(low=1, high=0), var_lib_address) + return () +end + +func __constructor_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + end + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = abi_decode_contract_Lib( + Uint256(low=0, high=0), __warp_subexpr_2) + constructor_WARP(__warp_subexpr_1) + return () +end + +func abi_decode{range_check_ptr}(headStart : Uint256, dataEnd : Uint256) -> (): + alloc_locals + let (__warp_subexpr_1 : Uint256) = uint256_sub(dataEnd, headStart) + let (__warp_subexpr_0 : Uint256) = slt(__warp_subexpr_1, Uint256(low=0, high=0)) + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () + end +end + +func extract_from_storage_value_dynamict_address{range_check_ptr}( + slot_value : Uint256, offset : Uint256) -> (value : Uint256): + alloc_locals + let (__warp_subexpr_0 : Uint256) = u256_shl(Uint256(low=3, high=0), offset) + let (value : Uint256) = u256_shr(__warp_subexpr_0, slot_value) + return (value) +end + +func abi_encode_address{memory_dict : DictAccess*, msize, range_check_ptr}( + value : Uint256, pos : Uint256) -> (): + alloc_locals + uint256_mstore(offset=pos, value=value) + return () +end + +func abi_encode_tuple_address{memory_dict : DictAccess*, msize, range_check_ptr}( + headStart : Uint256, value0 : Uint256) -> (tail : Uint256): + alloc_locals + let (tail : Uint256) = u256_add(headStart, Uint256(low=32, high=0)) + abi_encode_address(value0, headStart) + return (tail) +end + +func convert_contract_Lib_to_address(value : Uint256) -> (converted : Uint256): + alloc_locals + let converted : Uint256 = value + return (converted) +end + +func copy_calldata_to_memory{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr}( + src : Uint256, dst : Uint256, length : Uint256) -> (): + alloc_locals + calldatacopy(dst, src, length) + let (__warp_subexpr_0 : Uint256) = u256_add(dst, length) + uint256_mstore(offset=__warp_subexpr_0, value=Uint256(low=0, high=0)) + return () +end + +func abi_encode_bytes_calldata{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr}( + start : Uint256, length : Uint256, pos : Uint256) -> (end__warp_mangled : Uint256): + alloc_locals + copy_calldata_to_memory(start, pos, length) + let (end__warp_mangled : Uint256) = u256_add(pos, length) + return (end__warp_mangled) +end + +func array_allocation_size_bytes{range_check_ptr}(length : Uint256) -> (size : Uint256): + alloc_locals + let (__warp_subexpr_0 : Uint256) = is_gt(length, Uint256(low=18446744073709551615, high=0)) + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + end + let (__warp_subexpr_2 : Uint256) = u256_add(length, Uint256(low=31, high=0)) + let (__warp_subexpr_1 : Uint256) = uint256_and( + __warp_subexpr_2, + Uint256(low=340282366920938463463374607431768211424, high=340282366920938463463374607431768211455)) + let (size : Uint256) = u256_add(__warp_subexpr_1, Uint256(low=32, high=0)) + return (size) +end + +func finalize_allocation{memory_dict : DictAccess*, msize, range_check_ptr}( + memPtr : Uint256, size : Uint256) -> (): + alloc_locals + let (__warp_subexpr_1 : Uint256) = u256_add(size, Uint256(low=31, high=0)) + let (__warp_subexpr_0 : Uint256) = uint256_and( + __warp_subexpr_1, + Uint256(low=340282366920938463463374607431768211424, high=340282366920938463463374607431768211455)) + let (newFreePtr : Uint256) = u256_add(memPtr, __warp_subexpr_0) + let (__warp_subexpr_4 : Uint256) = is_lt(newFreePtr, memPtr) + let (__warp_subexpr_3 : Uint256) = is_gt(newFreePtr, Uint256(low=18446744073709551615, high=0)) + let (__warp_subexpr_2 : Uint256) = uint256_sub(__warp_subexpr_3, __warp_subexpr_4) + if __warp_subexpr_2.low + __warp_subexpr_2.high != 0: + assert 0 = 1 + jmp rel 0 + end + uint256_mstore(offset=Uint256(low=64, high=0), value=newFreePtr) + return () +end + +func allocate_memory{memory_dict : DictAccess*, msize, range_check_ptr}(size : Uint256) -> ( + memPtr : Uint256): + alloc_locals + let (memPtr : Uint256) = uint256_mload(Uint256(low=64, high=0)) + finalize_allocation(memPtr, size) + return (memPtr) +end + +func allocate_memory_array_bytes{memory_dict : DictAccess*, msize, range_check_ptr}( + length : Uint256) -> (memPtr : Uint256): + alloc_locals + let (__warp_subexpr_0 : Uint256) = array_allocation_size_bytes(length) + let (memPtr : Uint256) = allocate_memory(__warp_subexpr_0) + uint256_mstore(offset=memPtr, value=length) + return (memPtr) +end + +func __warp_block_2{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr}() -> ( + data : Uint256): + alloc_locals + let (__warp_subexpr_0 : Uint256) = returndata_size() + let (data : Uint256) = allocate_memory_array_bytes(__warp_subexpr_0) + let (__warp_subexpr_2 : Uint256) = returndata_size() + let (__warp_subexpr_1 : Uint256) = u256_add(data, Uint256(low=32, high=0)) + returndata_copy(__warp_subexpr_1, Uint256(low=0, high=0), __warp_subexpr_2) + return (data) +end + +func __warp_if_0{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr}( + __warp_subexpr_0 : Uint256) -> (data : Uint256): + alloc_locals + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + let data : Uint256 = Uint256(low=96, high=0) + return (data) + else: + let (data : Uint256) = __warp_block_2() + return (data) + end +end + +func __warp_block_1{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr}( + match_var : Uint256) -> (data : Uint256): + alloc_locals + let (__warp_subexpr_0 : Uint256) = is_eq(match_var, Uint256(low=0, high=0)) + let (data : Uint256) = __warp_if_0(__warp_subexpr_0) + return (data) +end + +func __warp_block_0{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr}() -> ( + data : Uint256): + alloc_locals + let (match_var : Uint256) = returndata_size() + let (data : Uint256) = __warp_block_1(match_var) + return (data) +end + +func extract_returndata{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr}() -> ( + data : Uint256): + alloc_locals + let (data : Uint256) = __warp_block_0() + return (data) +end + +func fun{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}() -> (): + alloc_locals + let (__warp_subexpr_1 : Uint256) = sload(Uint256(low=1, high=0)) + let (__warp_subexpr_0 : Uint256) = convert_contract_Lib_to_address(__warp_subexpr_1) + let (expr : Uint256) = convert_contract_Lib_to_address(__warp_subexpr_0) + let (_1 : Uint256) = uint256_mload(Uint256(low=64, high=0)) + let (__warp_subexpr_6 : Uint256) = calldatasize() + let (__warp_subexpr_5 : Uint256) = abi_encode_bytes_calldata( + Uint256(low=0, high=0), __warp_subexpr_6, _1) + let (__warp_subexpr_4 : Uint256) = uint256_sub(__warp_subexpr_5, _1) + let (__warp_subexpr_3 : Uint256) = __warp_constant_10000000000000000000000000000000000000000() + let (__warp_subexpr_2 : Uint256) = warp_call( + __warp_subexpr_3, + expr, + Uint256(low=0, high=0), + _1, + __warp_subexpr_4, + Uint256(low=0, high=0), + Uint256(low=0, high=0)) + + let (__warp_subexpr_7 : Uint256) = extract_returndata() + + return () +end + +func __warp_block_5{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}() -> ( + ): + alloc_locals + let (__warp_subexpr_0 : Uint256) = calldatasize() + abi_decode(Uint256(low=4, high=0), __warp_subexpr_0) + let (__warp_subexpr_4 : Uint256) = sload(Uint256(low=0, high=0)) + let (__warp_subexpr_3 : Uint256) = extract_from_storage_value_dynamict_address( + __warp_subexpr_4, Uint256(low=0, high=0)) + let (__warp_subexpr_2 : Uint256) = abi_encode_tuple_address( + Uint256(low=128, high=0), __warp_subexpr_3) + let (__warp_subexpr_1 : Uint256) = u256_add( + __warp_subexpr_2, + Uint256(low=340282366920938463463374607431768211328, high=340282366920938463463374607431768211455)) + warp_return(Uint256(low=128, high=0), __warp_subexpr_1) + return () +end + +func __warp_block_7{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}() -> ( + ): + alloc_locals + let (__warp_subexpr_0 : Uint256) = calldatasize() + abi_decode(Uint256(low=4, high=0), __warp_subexpr_0) + let (__warp_subexpr_1 : Uint256) = sload(Uint256(low=1, high=0)) + let (ret__warp_mangled : Uint256) = extract_from_storage_value_dynamict_address( + __warp_subexpr_1, Uint256(low=0, high=0)) + let (memPos : Uint256) = uint256_mload(Uint256(low=64, high=0)) + let (__warp_subexpr_3 : Uint256) = abi_encode_tuple_address(memPos, ret__warp_mangled) + let (__warp_subexpr_2 : Uint256) = uint256_sub(__warp_subexpr_3, memPos) + warp_return(memPos, __warp_subexpr_2) + return () +end + +func __warp_if_3{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}( + __warp_subexpr_0 : Uint256) -> (): + alloc_locals + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + __warp_block_7() + return () + else: + return () + end +end + +func __warp_block_6{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}( + match_var : Uint256) -> (): + alloc_locals + let (__warp_subexpr_0 : Uint256) = is_eq(match_var, Uint256(low=2457866800, high=0)) + __warp_if_3(__warp_subexpr_0) + return () +end + +func __warp_if_2{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}( + __warp_subexpr_0 : Uint256, match_var : Uint256) -> (): + alloc_locals + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + __warp_block_5() + return () + else: + __warp_block_6(match_var) + return () + end +end + +func __warp_block_4{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}( + match_var : Uint256) -> (): + alloc_locals + let (__warp_subexpr_0 : Uint256) = is_eq(match_var, Uint256(low=2376452955, high=0)) + __warp_if_2(__warp_subexpr_0, match_var) + return () +end + +func __warp_block_3{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}() -> ( + ): + alloc_locals + let (__warp_subexpr_0 : Uint256) = calldataload(Uint256(low=0, high=0)) + let (match_var : Uint256) = u256_shr(Uint256(low=224, high=0), __warp_subexpr_0) + __warp_block_4(match_var) + return () +end + +func __warp_if_1{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}( + __warp_subexpr_0 : Uint256) -> (): + alloc_locals + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + __warp_block_3() + return () + else: + return () + end +end + +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}() -> ( + ): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_1(__warp_subexpr_0) + if termination_token == 1: + return () + end + fun() + warp_return(Uint256(low=0, high=0), Uint256(low=0, high=0)) + return () +end diff --git a/tests/yul/ctor-check.sol b/tests/yul/ctor-check.sol new file mode 100644 index 000000000..f65ef43f8 --- /dev/null +++ b/tests/yul/ctor-check.sol @@ -0,0 +1,23 @@ +pragma solidity ^0.8.3; + +contract Lib { + address public owner; + + function pwn() public { + owner = msg.sender; + } +} + +contract WARP { + address public owner; + Lib public lib; + + constructor(Lib _lib) { + owner = msg.sender; + lib = Lib(_lib); + } + + fallback() external payable { + address(lib).call(msg.data); + } +} \ No newline at end of file diff --git a/tests/yul/for-loop-with-break.cairo b/tests/yul/for-loop-with-break.cairo index bb2ea27fa..6a8a4aa98 100644 --- a/tests/yul/for-loop-with-break.cairo +++ b/tests/yul/for-loop-with-break.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mload, uint256_mstore from evm.uint256 import is_eq, is_gt, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -18,27 +17,45 @@ func __warp_constant_0() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr}(calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -183,31 +200,18 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/for-loop-with-continue.cairo b/tests/yul/for-loop-with-continue.cairo index 97dddcbe2..e686ac607 100644 --- a/tests/yul/for-loop-with-continue.cairo +++ b/tests/yul/for-loop-with-continue.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mload, uint256_mstore from evm.uint256 import is_eq, is_gt, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -18,27 +17,45 @@ func __warp_constant_0() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr}(calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -179,31 +196,18 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/for-loop-with-nested-return.cairo b/tests/yul/for-loop-with-nested-return.cairo index d4e0cc5f1..dd43612d3 100644 --- a/tests/yul/for-loop-with-nested-return.cairo +++ b/tests/yul/for-loop-with-nested-return.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mload, uint256_mstore from evm.uint256 import is_eq, is_gt, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -18,27 +17,45 @@ func __warp_constant_0() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr}(calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -197,31 +214,18 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/function-with-nested-return.cairo b/tests/yul/function-with-nested-return.cairo index cb88d72fd..e6e826915 100644 --- a/tests/yul/function-with-nested-return.cairo +++ b/tests/yul/function-with-nested-return.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mstore from evm.uint256 import is_eq, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -18,27 +17,45 @@ func __warp_constant_0() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr}(calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -136,31 +153,18 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/if-flattening.cairo b/tests/yul/if-flattening.cairo index 69a162db6..526715f25 100644 --- a/tests/yul/if-flattening.cairo +++ b/tests/yul/if-flattening.cairo @@ -7,7 +7,6 @@ from evm.hashing import uint256_pedersen from evm.memory import uint256_mload, uint256_mstore from evm.uint256 import is_eq, is_lt, is_zero, slt, u256_add, u256_shl, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -39,27 +38,46 @@ func evm_storage(arg0_low, arg0_high) -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -338,31 +356,19 @@ func __warp_if_1{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}() -> ( + ): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_1(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_1(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/payable-function.cairo b/tests/yul/payable-function.cairo index 6303322b7..5f9b48c59 100644 --- a/tests/yul/payable-function.cairo +++ b/tests/yul/payable-function.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mstore from evm.uint256 import is_eq, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -18,27 +17,45 @@ func __warp_constant_0() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr}(calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -172,31 +189,18 @@ func __warp_if_1{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_1(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_1(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/pure-function.cairo b/tests/yul/pure-function.cairo index ece485c39..710fb8b06 100644 --- a/tests/yul/pure-function.cairo +++ b/tests/yul/pure-function.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mstore from evm.uint256 import is_eq, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -18,27 +17,45 @@ func __warp_constant_0() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr}(calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -172,31 +189,18 @@ func __warp_if_1{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_1(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_1(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/return-var-capturing.cairo b/tests/yul/return-var-capturing.cairo index c814c41b3..6b71b5be5 100644 --- a/tests/yul/return-var-capturing.cairo +++ b/tests/yul/return-var-capturing.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mload, uint256_mstore from evm.uint256 import is_eq, is_gt, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -18,27 +17,45 @@ func __warp_constant_0() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr}(calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -171,31 +188,18 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/returndatasize.cairo b/tests/yul/returndatasize.cairo index c565aceba..21fc92e1c 100644 --- a/tests/yul/returndatasize.cairo +++ b/tests/yul/returndatasize.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mstore from evm.uint256 import is_eq, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -22,27 +21,45 @@ func returndata_size{exec_env : ExecutionEnvironment*}() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr}(calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -135,31 +152,18 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/short_string.cairo b/tests/yul/short_string.cairo index b43041198..939ec079e 100644 --- a/tests/yul/short_string.cairo +++ b/tests/yul/short_string.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mload, uint256_mstore, uint256_mstore8 from evm.uint256 import is_eq, is_gt, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -18,27 +17,45 @@ func __warp_constant_0() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr}(calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -358,31 +375,18 @@ func __warp_if_1{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_1(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_1(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/simple-storage-var.cairo b/tests/yul/simple-storage-var.cairo index 3e3ebfdeb..4a1820666 100644 --- a/tests/yul/simple-storage-var.cairo +++ b/tests/yul/simple-storage-var.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mload, uint256_mstore from evm.uint256 import is_eq, is_gt, is_lt, is_zero, slt, u256_add, u256_shl, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -34,27 +33,46 @@ func evm_storage(arg0_low, arg0_high) -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -244,31 +262,19 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}() -> ( + ): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/sstore-sload.cairo b/tests/yul/sstore-sload.cairo index 04dfa19a4..a8df21f7d 100644 --- a/tests/yul/sstore-sload.cairo +++ b/tests/yul/sstore-sload.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mstore from evm.uint256 import is_eq, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -34,27 +33,46 @@ func evm_storage(arg0_low, arg0_high) -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*}( + calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -148,31 +166,19 @@ func __warp_if_0{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, + pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, termination_token}() -> ( + ): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_0(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_0(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/tests/yul/view-function.cairo b/tests/yul/view-function.cairo index 9d56d90ff..b145996c8 100644 --- a/tests/yul/view-function.cairo +++ b/tests/yul/view-function.cairo @@ -6,7 +6,6 @@ from evm.exec_env import ExecutionEnvironment from evm.memory import uint256_mstore from evm.uint256 import is_eq, is_lt, is_zero, slt, u256_add, u256_shr from evm.yul_api import warp_return -from starkware.cairo.common.alloc import alloc from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin from starkware.cairo.common.default_dict import default_dict_finalize, default_dict_new from starkware.cairo.common.dict_access import DictAccess @@ -18,27 +17,45 @@ func __warp_constant_0() -> (res : Uint256): end @constructor -func constructor{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*): +func constructor{range_check_ptr}(calldata_size, calldata_len, calldata : felt*): + alloc_locals + let (memory_dict) = default_dict_new(0) + let memory_dict_start = memory_dict + let msize = 0 + with memory_dict, msize: + __constructor_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return () +end + +@external +func __main{range_check_ptr}(calldata_size, calldata_len, calldata : felt*) -> ( + returndata_size, returndata_len, returndata : felt*): alloc_locals - let termination_token = 0 - let (returndata_ptr : felt*) = alloc() let (__fp__, _) = get_fp_and_pc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) + local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=cast(0, felt*), to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*)) let exec_env : ExecutionEnvironment* = &exec_env_ let (memory_dict) = default_dict_new(0) let memory_dict_start = memory_dict let msize = 0 - with memory_dict, msize, exec_env, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_0 : Uint256) = __warp_constant_0() - if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: - assert 0 = 1 - jmp rel 0 - else: - return () - end + let termination_token = 0 + with exec_env, memory_dict, msize, termination_token: + __main_meat() + end + default_dict_finalize(memory_dict_start, memory_dict, 0) + return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) +end + +func __constructor_meat{memory_dict : DictAccess*, msize, range_check_ptr}() -> (): + alloc_locals + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_0 : Uint256) = __warp_constant_0() + if __warp_subexpr_0.low + __warp_subexpr_0.high != 0: + assert 0 = 1 + jmp rel 0 + else: + return () end end @@ -172,31 +189,18 @@ func __warp_if_1{ end end -@external -func fun_ENTRY_POINT{ - pedersen_ptr : HashBuiltin*, range_check_ptr, syscall_ptr : felt*, - bitwise_ptr : BitwiseBuiltin*}(calldata_size, calldata_len, calldata : felt*) -> ( - returndata_size : felt, returndata_len : felt, returndata : felt*): +func __main_meat{ + exec_env : ExecutionEnvironment*, memory_dict : DictAccess*, msize, range_check_ptr, + termination_token}() -> (): alloc_locals - let termination_token = 0 - let (__fp__, _) = get_fp_and_pc() - let (returndata_ptr : felt*) = alloc() - local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata, returndata_size=0, returndata_len=0, returndata=returndata_ptr, to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr) - let exec_env = &exec_env_ - let (memory_dict) = default_dict_new(0) - let memory_dict_start = memory_dict - let msize = 0 - with exec_env, msize, memory_dict, termination_token: - uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) - let (__warp_subexpr_2 : Uint256) = calldatasize() - let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) - let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) - __warp_if_1(__warp_subexpr_0) - if termination_token == 1: - default_dict_finalize(memory_dict_start, memory_dict, 0) - return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata) - end - assert 0 = 1 - jmp rel 0 + uint256_mstore(offset=Uint256(low=64, high=0), value=Uint256(low=128, high=0)) + let (__warp_subexpr_2 : Uint256) = calldatasize() + let (__warp_subexpr_1 : Uint256) = is_lt(__warp_subexpr_2, Uint256(low=4, high=0)) + let (__warp_subexpr_0 : Uint256) = is_zero(__warp_subexpr_1) + __warp_if_1(__warp_subexpr_0) + if termination_token == 1: + return () end + assert 0 = 1 + jmp rel 0 end diff --git a/warp/cairo-src/evm/calls.cairo b/warp/cairo-src/evm/calls.cairo index 2299d1b71..99f54deae 100644 --- a/warp/cairo-src/evm/calls.cairo +++ b/warp/cairo-src/evm/calls.cairo @@ -54,7 +54,7 @@ end @contract_interface namespace GenericCallInterface: - func fun_ENTRY_POINT(calldata_size : felt, calldata_len : felt, calldata : felt*) -> ( + func __main(calldata_size : felt, calldata_len : felt, calldata : felt*) -> ( returndata_size : felt, returndata_len : felt, returndata : felt*): end end @@ -79,7 +79,7 @@ func warp_call{ memory_dict=memory_dict, range_check_ptr=range_check_ptr}(in.low, insize.low) let (calldata_len) = calculate_data_len(insize.low) let (address_felt : felt) = uint256_to_address_felt(address) - let (returndata_size, returndata_len, returndata) = GenericCallInterface.fun_ENTRY_POINT( + let (returndata_size, returndata_len, returndata) = GenericCallInterface.__main( address_felt, insize.low, calldata_len, mem) array_copy_to_memory(returndata_size, returndata, 0, out.low, outsize.low) local exec_env_ : ExecutionEnvironment = ExecutionEnvironment( diff --git a/warp/cli/commands.py b/warp/cli/commands.py index 009c736aa..79cbe687d 100644 --- a/warp/cli/commands.py +++ b/warp/cli/commands.py @@ -45,7 +45,7 @@ def starknet_invoke( f"starknet invoke " f"--address {address} " f"--abi {abi} " - f"--function fun_ENTRY_POINT " + f"--function __main " f"--inputs {inputs} " f"--network {network} " ).read() diff --git a/warp/yul/FunctionPruner.py b/warp/yul/FunctionPruner.py index 1c3b4289a..49120327e 100644 --- a/warp/yul/FunctionPruner.py +++ b/warp/yul/FunctionPruner.py @@ -17,7 +17,7 @@ def map(self, node: ast.Node, *args, **kwargs) -> ast.Node: self.callgraph = build_callgraph(node) for function in self.callgraph: - if function.name in ("fun_ENTRY_POINT", "constructor"): + if function.name in ("__main_meat", "__constructor_meat"): self._dfs(function) return self.visit(node, *args, **kwargs) @@ -43,7 +43,7 @@ def _is_unused_function(self, node): return ( isinstance(node, ast.FunctionDefinition) and node.name not in self.visited_functions - and node.name != "constructor" + and node.name != "__constructor_meat" and "setter" not in node.name and "getter" not in node.name ) diff --git a/warp/yul/ToCairoVisitor.py b/warp/yul/ToCairoVisitor.py index 8abd29355..aa97eb937 100644 --- a/warp/yul/ToCairoVisitor.py +++ b/warp/yul/ToCairoVisitor.py @@ -1,6 +1,5 @@ from __future__ import annotations -import re from collections import defaultdict from contextlib import contextmanager from typing import Callable, Optional @@ -9,7 +8,13 @@ from yul.AstVisitor import AstVisitor from yul.BuiltinHandler import BuiltinHandler from yul.FunctionGenerator import CairoFunctions -from yul.implicits import IMPLICITS_SET, print_implicit +from yul.implicits import ( + IMPLICITS_SET, + MANUAL_IMPLICITS, + finalize_manual_implicit, + initialize_manual_implicit, + print_implicit, +) from yul.Imports import format_imports, merge_imports from yul.NameGenerator import NameGenerator from yul.storage_access import ( @@ -35,7 +40,6 @@ "HashBuiltin", "BitwiseBuiltin", }, - "starkware.cairo.common.alloc": {"alloc"}, "evm.exec_env": {"ExecutionEnvironment"}, } @@ -77,6 +81,8 @@ def translate(self, node: ast.Node) -> str: *self.cairo_functions.get_definitions(), "", *storage_var_decls, + self._make_constructor(), + self._make_main(), main_part, ] ) @@ -135,12 +141,11 @@ def visit_function_call(self, node: ast.FunctionCall) -> str: if self.next_stmt_is_leave: return result if "termination_token" in self.last_used_implicits: - assert ( - "exec_env" in self.last_used_implicits - ), "Termination requires writing to returndata" + n_returns = len(self.last_function.return_variables) + dummy_returns = ", ".join("Uint256(0, 0)" for _ in range(n_returns)) return ( result - + f"\nif termination_token == 1:\n{self._get_termination_actions()}\nend" + + f"\nif termination_token == 1:\nreturn ({dummy_returns})\nend" ) return result @@ -183,58 +188,6 @@ def visit_function_definition(self, node: ast.FunctionDefinition): body_repr = self._try_make_storage_accessor_body(node) if not body_repr: body_repr = self.print(node.body) - if node.name == "constructor": - return ( - f"@constructor\n" - f"func constructor{{pedersen_ptr : HashBuiltin*, range_check_ptr," - f"syscall_ptr : felt* , bitwise_ptr : BitwiseBuiltin*}}(calldata_size," - f"calldata_len, calldata : felt*):\n" - f"alloc_locals\n" - f"let termination_token = 0\n" - f"let (returndata_ptr: felt*) = alloc()\n" - f"let (__fp__, _) = get_fp_and_pc()\n" - f"local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(" - f"calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata," - f"returndata_size=0, returndata_len=0, returndata=returndata_ptr," - f"to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr)\n" - f"let exec_env : ExecutionEnvironment* = &exec_env_\n" - f"let (memory_dict) = default_dict_new(0)\n" - f"let memory_dict_start = memory_dict\n" - f"let msize = 0\n" - f"with memory_dict, msize, exec_env, termination_token:\n" - f"{body_repr}\n" - f"end\n" - f"end\n" - ) - if node.name == "fun_ENTRY_POINT": - # The leave gets replaced with the wrong return type in this case - # we need to replace it with our return - body_repr = re.sub("return \(\)$", "", body_repr) - returns_repr = ( - "returndata_size: felt, returndata_len: felt, returndata: felt*" - ) - return ( - f"@external\n" - f"func {node.name}{{pedersen_ptr : HashBuiltin*, range_check_ptr," - f"syscall_ptr : felt* , bitwise_ptr : BitwiseBuiltin*}}(calldata_size," - f"calldata_len, calldata : felt*) -> ({returns_repr}):\n" - f"alloc_locals\n" - f"let termination_token = 0\n" - f"let (__fp__, _) = get_fp_and_pc()\n" - f"let (returndata_ptr: felt*) = alloc()\n" - f"local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(" - f"calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata," - f"returndata_size=0, returndata_len=0, returndata=returndata_ptr," - f"to_returndata_size=0, to_returndata_len=0, to_returndata=returndata_ptr)\n" - f"let exec_env = &exec_env_\n" - f"let (memory_dict) = default_dict_new(0)\n" - f"let memory_dict_start = memory_dict\n" - f"let msize = 0\n" - f"with exec_env, msize, memory_dict, termination_token:\n" - f" {body_repr}\n" - f"end\n" - f"end\n" - ) implicits = sorted(self.function_to_implicits.setdefault(node.name, set())) implicits_decl = "" @@ -337,18 +290,59 @@ def _get_implicits(self, fn_name: str) -> tuple[str, ...]: sorted(self.function_to_implicits.setdefault(fn_name, IMPLICITS_SET)) ) - def _get_termination_actions(self): - if self.last_function.name == "fun_ENTRY_POINT": - return ( - "default_dict_finalize(memory_dict_start, memory_dict, 0)\n" - "return (exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata)\n" - ) - elif self.last_function.name.startswith("fun_warp_constructor"): - return ( - "default_dict_finalize(memory_dict_start, memory_dict, 0)\n" - "return ()\n" - ) + def _make_constructor(self): + ctor_implicits = self.function_to_implicits.get("__constructor_meat") + assert ctor_implicits, "The '__constructor_meat' function is not generated" + manual_implicits = sorted(ctor_implicits & MANUAL_IMPLICITS) + builtin_implicits = sorted(ctor_implicits - MANUAL_IMPLICITS) + + builtins_str = "{" + ", ".join(map(print_implicit, builtin_implicits)) + "}" + manuals_str = ", ".join(manual_implicits) + manuals_init = "".join(map(initialize_manual_implicit, manual_implicits)) + manuals_fin = "".join(map(finalize_manual_implicit, manual_implicits)) + if not manual_implicits: + meat = "__constructor_meat()" else: - n_returns = len(self.last_function.return_variables) - dummy_returns = ", ".join("Uint256(0, 0)" for _ in range(n_returns)) - return f"return ({dummy_returns})" + meat = f"with {manuals_str}:\n__constructor_meat()\nend" + + return ( + f"@constructor\n" + f"func constructor{builtins_str}(calldata_size, calldata_len, calldata : felt*):\n" + f"alloc_locals\n" + f"{manuals_init}" + f"{meat}\n" + f"{manuals_fin}" + f"return ()\n" + f"end\n" + ) + + def _make_main(self): + main_implicits = self.function_to_implicits.get("__main_meat") + assert main_implicits, "The '__main_meat' function is not generated" + manual_implicits = sorted(main_implicits & MANUAL_IMPLICITS) + builtin_implicits = sorted(main_implicits - MANUAL_IMPLICITS) + + builtins_str = "{" + ", ".join(map(print_implicit, builtin_implicits)) + "}" + manuals_str = ", ".join(manual_implicits) + manuals_init = "".join(map(initialize_manual_implicit, manual_implicits)) + manuals_fin = "".join(map(finalize_manual_implicit, manual_implicits)) + if not manual_implicits: + meat = "__main_meat()" + else: + meat = f"with {manuals_str}:\n__main_meat()\nend" + if "exec_env" in manual_implicits: + returns = "(exec_env.to_returndata_size, exec_env.to_returndata_len, exec_env.to_returndata)" + else: + returns = "(0, 0, cast(0, felt*))" + + return ( + f"@external\n" + f"func __main{builtins_str}(calldata_size, calldata_len, calldata : felt*)" + f"-> (returndata_size, returndata_len, returndata: felt*):\n" + f"alloc_locals\n" + f"{manuals_init}" + f"{meat}\n" + f"{manuals_fin}" + f"return {returns}\n" + f"end\n" + ) diff --git a/warp/yul/implicits.py b/warp/yul/implicits.py index 51b8dc974..59900e2e3 100644 --- a/warp/yul/implicits.py +++ b/warp/yul/implicits.py @@ -11,6 +11,10 @@ IMPLICITS_SET = set(IMPLICITS.keys()) +# Implicits that we create manually, they are not built into Cairo +MANUAL_IMPLICITS = {"memory_dict", "msize", "exec_env", "termination_token"} +assert MANUAL_IMPLICITS.issubset(IMPLICITS_SET) + def print_implicit(name): type_ = IMPLICITS.get(name, None) @@ -22,3 +26,34 @@ def print_implicit(name): def copy_implicit(name): return f"local {print_implicit(name)} = {name}" + + +def initialize_manual_implicit(name): + assert name in MANUAL_IMPLICITS + if name == "memory_dict": + return ( + f"let (memory_dict) = default_dict_new(0)\n" + f"let memory_dict_start = memory_dict\n" + ) + elif name == "msize": + return "let msize = 0\n" + elif name == "exec_env": + return ( + f"let (__fp__, _) = get_fp_and_pc()\n" + f"local exec_env_ : ExecutionEnvironment = ExecutionEnvironment(" + f"calldata_size=calldata_size, calldata_len=calldata_len, calldata=calldata," + f"returndata_size=0, returndata_len=0, returndata=cast(0, felt*)," + f"to_returndata_size=0, to_returndata_len=0, to_returndata=cast(0, felt*))\n" + f"let exec_env : ExecutionEnvironment* = &exec_env_\n" + ) + elif name == "termination_token": + return "let termination_token = 0\n" + assert False, f"Unhandled manual implicit: '{name}'" + + +def finalize_manual_implicit(name): + assert name in MANUAL_IMPLICITS + if name == "memory_dict": + return "default_dict_finalize(memory_dict_start, memory_dict, 0)\n" + else: + return "" diff --git a/warp/yul/parse_object.py b/warp/yul/parse_object.py index a84944649..d63bb8a2a 100644 --- a/warp/yul/parse_object.py +++ b/warp/yul/parse_object.py @@ -18,17 +18,16 @@ def parse_to_normalized_ast(codes) -> ast.Node: def combine_deployment_and_runtime( deployment_code: ast.Block, runtime_code: ast.Block ) -> ast.Block: - ctor_block, deployment_functions = extract_top_level_code(deployment_code) - entry_point_block, runtime_functions = extract_top_level_code(runtime_code) + main_block, runtime_functions = extract_top_level_code(runtime_code) ctor = ast.FunctionDefinition( - name="constructor", parameters=[], return_variables=[], body=ctor_block + name="__constructor_meat", parameters=[], return_variables=[], body=ctor_block ) - entry_point = ast.FunctionDefinition( - name="fun_ENTRY_POINT", + main_ = ast.FunctionDefinition( + name="__main_meat", parameters=[], return_variables=[], - body=entry_point_block, + body=main_block, ) deployment_names = { @@ -42,7 +41,7 @@ def combine_deployment_and_runtime( renamed_deployment_functions = renamer.visit_list(deployment_functions) renamed_ctor = renamer.visit(ctor) return ast.Block( - (renamed_ctor, *renamed_deployment_functions, entry_point, *runtime_functions) + (renamed_ctor, *renamed_deployment_functions, main_, *runtime_functions) ) diff --git a/warp/yul/starknet_utils.py b/warp/yul/starknet_utils.py index 5633bbb5c..0cf05c8c0 100644 --- a/warp/yul/starknet_utils.py +++ b/warp/yul/starknet_utils.py @@ -13,7 +13,7 @@ async def invoke_method( cairo_calldata = get_cairo_calldata(evm_calldata) return await starknet.invoke_raw( contract_address=address, - selector="fun_ENTRY_POINT", + selector="__main", calldata=cairo_calldata, caller_address=0, )