How does this assembly function work?

Question

From the Docs, how does this operation create a new "memory end"?

mstore(0x40, add(o_code, and(add(add(size, 0x20), 0x1f), not(0x1f)))

Context:

library GetCode {
function at(address _addr) public view returns (bytes memory o_code) {
    assembly {
        // retrieve the size of the code, this needs assembly
        let size := extcodesize(_addr)
        // allocate output byte array - this could also be done without assembly
        // by using o_code = new bytes(size)
        o_code := mload(0x40)
        // new "memory end" including padding
        **mstore(0x40, add(o_code, and(add(add(size, 0x20), 0x1f), not(0x1f))))**

I can follow the operators and parse the hexadecimal, however I'm never sure if I should be performing these on underlying values or the memory address values themselves (eg. 0x20 + 0x40 = 0x60).

Answer 1

It explained a little later in the same documentation:

Solidity manages memory in a very simple way: There is a “free memory pointer” at position 0x40 in memory. If you want to allocate memory, just use the memory starting from where this pointer points at and update it accordingly.

An array always use the first slot to store its length and it always aligned to 32 bytes (one slot).

In pseudo code it does something like this:

• Read free memory pointer

  array_memory = memory[0x40]
  

• Calculate array size in memory, add an extra 32 bytes for the array length and round it to 32 bytes. The mathematical formula is trunc((code_size + 32 + 32 - 1) / 32) * 32. And optimized to EVM assembly it is

  array_size = (code_size + 0x20 + 0x1f) & ~0x1f
  

• Update free memory pointer

  memory[0x40] += array_size