fmp illustration

Introduction Link to heading

In the Ethereum Virtual Machine (EVM), memory management is a crucial aspect of efficient smart contract execution. One key component of this system is the Free Memory Pointer (FMP), which determines where new dynamic allocations should be stored in memory. Understanding the FMP is essential for optimizing storage and gas usage in Solidity smart contracts.

What is the Free Memory Pointer (FMP)? Link to heading

The Free Memory Pointer (FMP) is a special memory slot that holds the next available memory address. It ensures that new allocations do not overwrite existing data, allowing Solidity’s dynamic structures (such as arrays, mappings, and structs) to expand safely.

  • The FMP is stored at memory address.
  • It points to the next available, unallocated memory slot.
  • It gets updated whenever memory is allocated dynamically.

How the FMP Works Link to heading

1. Initial State of the FMP Link to heading

At the beginning of contract execution, the FMP is set to 0x80 , as the first 256 bytes (0x00 to 0x7F) are reserved for the EVM memory layout (including scratch space and the FMP itself).

2. Allocating Memory Link to heading

When Solidity requires dynamic memory allocation (e.g., for arrays or structs), it:

  1. Reads the FMP - mload(0x40) - to get the current free memory address.
  2. Writes data to that address.
  3. Updates the FMP - mstore(0x40, new_address) - to point beyond the allocated space.

3. Example: Expanding a Dynamic Array Link to heading

When pushing a new element to a dynamically allocated array, Solidity:

  • Reads the current FMP to find where to store the new element.
  • Writes the element in memory.
  • Moves the FMP forward to reserve space for future allocations.

Code Example Link to heading

Here’s a simple Solidity with some Assembly lines example demonstrating the FMP in action:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract MemoryExample {
    function getFMP() external pure returns (uint256 fmp) {
        assembly {
            fmp := mload(0x40) // Load current Free Memory Pointer
        }
    }
    
    function allocateMemory() external pure returns (uint256 newFMP) {
        assembly {
            let fmp := mload(0x40) // Get current FMP
            mstore(fmp, 42)        // Store a value at FMP
            mstore(0x40, add(fmp, 32)) // Move FMP forward by 32 bytes
            newFMP := mload(0x40) // Return updated FMP
        }
    }
}

Why is the FMP Important? Link to heading

  • Prevents memory overwrites: Ensures new allocations do not corrupt existing data.
  • Facilitates dynamic data structures: Used when expanding arrays or struct instances.
  • Optimizes gas efficiency: Proper memory management reduces unnecessary gas costs.

 

Conclusion Link to heading

The Free Memory Pointer (FMP) is a critical component in Solidity’s memory management. By tracking available memory space, it enables safe and efficient dynamic allocations. Understanding how to manipulate the FMP in inline assembly can lead to better contract optimization and lower gas costs.

 

🚀 Getting to know the FMP better gives you deeper control over smart contract memory handling, making your Solidity code more efficient and gas-optimized!