This information is requested a System Contract called .
On how the System Contract is called, see .
LLVM IR
is common for Yul and EVMLA representations.
The request to the System Contract is done via the runtime function.
ORIGIN
System Contract
LLVM IR
CALLER
LLVM IR
CALLVALUE
LLVM IR
CALLDATALOAD
Calldata is accessed with a generic memory access instruction, but the memory chunk itself is a reference to the calling contract's heap. A fat pointer to the parent contract is passed via ABI using registers.
LLVM IR
@ptr_calldata = private unnamed_addr global ptr addrspace(3) null ; global variable declaration
...
store ptr addrspace(3) %0, ptr @ptr_calldata, align 32 ; saving the pointer from `r1` to the global variable
...
%calldata_pointer = load ptr addrspace(3), ptr @ptr_calldata, align 32 ; loading the pointer from the global variable to `calldata_pointer`
%calldata_value = load i256, ptr addrspace(3) %calldata_pointer, align 32 ; loading the value from the calldata pointer
EraVM Assembly
ptr.add r1, r0, stack[@ptr_calldata] ; saving the pointer from `r1` to the global variable
...
ptr.add stack[@ptr_calldata], r0, r1 ; loading the pointer from the global variable to `r1`
ld r1, r1 ; loading the value to `r1`
CALLDATASIZE
The size value can be extracted with bitwise operations as illustrated below.
LLVM IR
@calldatasize = private unnamed_addr global i256 0 ; global variable declaration
...
%abi_pointer_value = ptrtoint ptr addrspace(3) %0 to i256 ; converting the pointer to an integer
%abi_pointer_value_shifted = lshr i256 %abi_pointer_value, 96 ; shifting the integer right 96 bits
%abi_length_value = and i256 %abi_pointer_value_shifted, 4294967295 ; keeping the lowest 32 bits of the integer
store i256 %abi_length_value, ptr @calldatasize, align 32 ; saving the value to the global variable
EraVM Assembly
ptr.add r1, r0, stack[@ptr_calldata] ; saving the pointer from `r1` to the global variable
shr.s 96, r1, r1 ; shifting the integer right 96 bits
and @CPI0_0[0], r1, stack[@calldatasize] ; keeping the lowest 32 bits of the integer, saving the value to the global variable
...
CPI0_0:
.cell 4294967295
CALLDATACOPY
LLVM IR
; loading the pointer from the global variable to `calldata_pointer`
%calldata_pointer = load ptr addrspace(3), ptr @ptr_calldata, align 32
; shifting the pointer by 122 bytes
%calldata_source_pointer = getelementptr i8, ptr addrspace(3) %calldata_pointer, i256 122
; copying 64 bytes from calldata at offset 122 to the heap at offset 128
call void @llvm.memcpy.p1.p3.i256(ptr addrspace(1) align 1 inttoptr (i256 128 to ptr addrspace(1)), ptr addrspace(3) align 1 %calldata_source_pointer, i256 64, i1 false)
EraVM Assembly
.BB0_3:
shl.s 5, r2, r3 ; shifting the offset by 32
ptr.add r1, r3, r4 ; adding the offset to the calldata pointer
ld r4, r4 ; reading the calldata value
add 128, r3, r3 ; adding the offset to the heap pointer
st.1 r3, r4 ; writing the calldata value to the heap
add 1, r2, r2 ; incrementing the offset
sub.s! 2, r2, r3 ; checking the bounds
jump.lt @.BB0_3 ; loop continuation branching
CODECOPY
CODESIZE
GASPRICE
System Contract
LLVM IR
EXTCODESIZE
System Contract
LLVM IR
EXTCODECOPY
Not supported. Triggers a compile-time error.
RETURNDATASIZE
Return data size is read from the fat pointer returned from the child contract.
The size value can be extracted with bitwise operations as illustrated below.
near_call r0, @__farcall, @DEFAULT_UNWIND ; calling a child contract
shr.s 96, r1, r1 ; shifting the pointer value right 96 bits
and @CPI0_1[0], r1, r1 ; keeping the lowest 32 bits of the pointer value
...
CPI0_1:
.cell 4294967295
RETURNDATACOPY
Unlike on EVM, on EraVM it is a simple loop over memory operations on 256-bit values.
LLVM IR
; loading the pointer from the global variable to `return_data_pointer`
%return_data_pointer = load ptr addrspace(3), ptr @ptr_return_data, align 32
; shifting the pointer by 122 bytes
%return_data_source_pointer = getelementptr i8, ptr addrspace(3) %return_data_pointer, i256 122
; copying 64 bytes from return data at offset 122 to the heap at offset 128
call void @llvm.memcpy.p1.p3.i256(ptr addrspace(1) align 1 inttoptr (i256 128 to ptr addrspace(1)), ptr addrspace(3) align 1 %return_data_source_pointer, i256 64, i1 false)
EraVM Assembly
.BB0_3:
shl.s 5, r2, r3 ; shifting the offset by 32
ptr.add r1, r3, r4 ; adding the offset to the return data pointer
ld r4, r4 ; reading the return data value
add 128, r3, r3 ; adding the offset to the heap pointer
st.1 r3, r4 ; writing the return data value to the heap
add 1, r2, r2 ; incrementing the offset
sub.s! 2, r2, r3 ; checking the bounds
jump.lt @.BB0_3 ; loop continuation branching
EXTCODEHASH
System Contract
LLVM IR
Original instruction.
This information is requested a System Contract called .
On how the System Contract is called, see .
is common for Yul and EVMLA representations.
The request to the System Contract is done via the runtime function.
Original instruction.
This value is fetched with a native .
is common for Yul and EVMLA representations.
Original instruction.
This value is fetched with a native .
is common for Yul and EVMLA representations.
Original instruction.
Then, the pointer accessible from anywhere in the contract.
is common for Yul and EVMLA representations.
Original instruction.
Calldata size is stored in the fat pointer passed from the parent contract (see ).
is common for Yul and EVMLA representations.
Original instruction.
Unlike on EVM, on EraVM it is a simple loop over ).
is common for Yul and EVMLA representations.
Original instruction.
See .
.
Original instruction.
See .
.
Original instruction.
This information is requested a System Contract called .
On how the System Contract is called, see .
is common for Yul and EVMLA representations.
The request to the System Contract is done via the runtime function.
Original instruction.
This information is requested a System Contract called .
On how the System Contract is called, see .
is common for Yul and EVMLA representations.
The request to the System Contract is done via the runtime function.
Original instruction.
Original instruction.
is common for Yul and EVMLA representations.
Original instruction.
is common for Yul and EVMLA representations.
Original instruction.
This information is requested a System Contract called .
On how the System Contract is called, see .
is common for Yul and EVMLA representations.
The request to the System Contract is done via the runtime function.
