[Ethereum] Understanding parameters of the STATICCALL opcode in Solidity inline assembly

assemblyevmsolidity

I am new to inline assembly. I have tried understanding different opcodes, and understood quite a bit, but still not be able to correlate them in context to STATICCALL opcode. Kindly help me understand what's happening here in this piece of code

function getUint(address addr, bytes memory data) internal view returns (uint result) {
    result = 0;

    assembly {
        let status := staticcall(16000, addr, add(data, 32), mload(data), 0, 0)

        // Success!
        if eq(status, 1) {
            if eq(returndatasize(), 32) {
                returndatacopy(0, 0, 32)
                result := mload(0)
            }
        }
    }
}

As far as I have understood from solidity assembly documentation,

STATICCALL: identical to call(g, a, 0, in, insize, out, outsize) but does not have v value and do not allow state modifications

How do the parameters in the above code represent in, insize, out and outsize?

Best Answer

From the call you have

staticcall(16000, addr, add(data, 32), mload(data), 0, 0)

16000 is gas
addr target address
add(data, 32) input
mload(data) input size
0 output
0 output size

For bytes the first 32 bytes are the size and it follow the raw data. mload(data) read 32 bytes pointed by data (it returns the length of data). add(data, 32) it moves the pointer to the raw data skipping the size field.

Related Solutions

[Ethereum] understanding mload assembly function

mload(0xAB) Loads the word (32byte) located at the memory address 0xAB. e.g mload(0x60) loads the word located at 0x60 memory address.

let's code to understand more :

 function f ()  
    {

        assembly {
            let freemem_pointer := mload(0x40)
            mstore(add(freemem_pointer,0x00),"36e5236fcd4c61044949678014f0d085")
            mstore(add(freemem_pointer,0x20),"36e5236fcd4c61044949678014f0d086")
            let arr1:= mload(freemem_pointer) //read first string 
            mstore(add(freemem_pointer,0x40),arr1)


        }
    }

this results in the flowing memory state :

This previous code stores tow strings (two memory words 32bytes each) in the free memory space. The destinations memory addresses are obtained by adding an offset of 0bytes for the first and of 0x20 for the second to the free memory pointer address(located in the memory address 0x40).
in the EVM The 6 first words in the memory are reserved and the 0x40-0x50 memory words are allocated to the free memory pointer.

Details : mload and mstore are defined in details in the yellow paper :

[a...b) signifies the bytes of memory starting at position a up to (excluding) position b. however b] means b included

[Ethereum] Understanding solidity inline assembly code

Within the assembly code, _data is the memory address of the start of the array data.

However, the first memory word (32 bytes = 0x20 bytes) is reserved for the length of the array, so we need to step over this. Thus, _data[0] is at memory address _data + 0x20. In the code, this looks like add(_data, 0x20).

The array elements follow consecutively, numbered from 0, each occupying one 32 byte (0x20 byte) word. Thus, element [N] is offset N * 0x20 from the start of the array data that we found above. In the code this offset is mul(i, 0x20).

Putting it all together, _data[i] is found at (_data + 0x20) + (i * 0x20), which is the expression (add(add(_data, 0x20), mul(i, 0x20))).

The net effect of the loop is to add up all the array elements into o_sum. It is likely done in assembly to avoid the overhead of array bounds checking that Solidity always inserts.

Best Answer

Related Solutions

[Ethereum] understanding mload assembly function

[Ethereum] Understanding solidity inline assembly code

Related Topic