When writing assembly to which memory address should I start writing

assemblyevmsolidity

when should you start writing to memory address mstore(0x40, x) and when to mstore(0x80, x)?

Some contracts that I've seen, for example this one https://github.com/Rari-Capital/solmate/blob/main/src/utils/SafeTransferLib.sol

They use the 0x40 memory address, but others use the 0x80.

What is the difference, and which one should I use?

Thanks a lot hope the question is clear.

Best Answer

If you are asking the question, you probably should write at the address returned by mload(0x40), you can read more about the solidity memory layout in the documentation.

This is what the code that you linked is doing :

// Get a pointer to some free memory.
let freeMemoryPointer := mload(0x40)

// Write the abi-encoded calldata into memory, beginning with the function selector.
mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000)

Writing directly to 0x80 or any other fixed address is a possible optimization (because don't pay additional gas for an mload(0x40) instruction) if you either :

Know that this is the current value at memory[0x40] (0x80 is the initial value stored at 0x40)
Don't care about overwriting allocating memory / respecting solidity memory model. (proxy do this for instance by writing an arbitrary amount of data starting at address 0x00)

In any case, if you intend to return / use the any allocated memory space, make sure to mark that memory as allocated by incrementing the free memory pointer :

// Allocate 32 bytes of memory by :
// taking the value of the free memory pointer : mload(0x40)
// incrementing it by 0x20 (32) : add(mload(0x40), 0x20)
// writing the resulting value to 0x40 : mstore(0x40, ...)
mstore(0x40, add(mload(0x40), 0x20))

I hope this answers your question.

Related Solutions

Inline assembly-updating the free memory pointer

It is the developer's responsibility.

By using (inline) assembly, you can take full control, obviously, that also means full responsibility.

Take this line from the documentation :

It is your responsibility to make sure that the assembly actually satisfies the memory model.

What if you don’t update the free memory pointer in assembly

What will happen? Will it overwrite my data?

Yes, if the code following adheres to solidity's memory model AND uses memory, it will start writing at the address returned by mload(0x40) and overwrite your data.

  function example() public pure returns (bytes32, string memory) {
        bytes32 myValue;

        assembly {
            // mload(0x40) is 0x80 initially
            mstore(mload(0x40), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
        }

        string memory myString = "hello";

        assembly {
            myValue := mload(0x80)
        }

        // myValue : 0x0000000000000000000000000000000000000000000000000000000000000005
        // myString : 'hello'
        return (myValue, myString);
    }

Here, myValue becomes 0x05 because the 32 bytes at 0x80 are now used by myString to store the length field. hello is 5 ASCII characters long, so its length is 5 bytes.

If you want to ensure that the memory space is secure (i.e., no side effects) then you must allocate the memory by incrementing the free memory pointer. Using memory above the free memory pointer but not allocating it is perfectly fine as long as you are treating that memory space as a scratch space. You can read more about it in the documentation.

I hope this answers your question.

Best Answer

Related Solutions

Inline assembly-updating the free memory pointer

What if you don’t update the free memory pointer in assembly

Related Topic