How are bytes and bytes32 different in inline-assembly?

Question

function mloadTest1() public pure returns(bytes memory) {
  bytes memory a;

  assembly {
      a :=mload(0x40)
  }

  return a; // 0x20
}

function mloadTest2() public pure returns(bytes32) {
    bytes32 a;
    assembly {
        a := mload(0x40)
    }
    return a; // 0x80
}

mload(x) is a Yul code that reads 32 bytes from offset x in memory. And Solidity defaults to free memory points from 0x00 to 0x60, with 0x80 stored at 0x40.

I ran the code in two cases. I thought bytes memory a would return 0x80 (free memory point), but it returns 0x20. bytes32 a returns 0x80 as normal.

Answer 1

They are different types, and behave differently.

• bytes is a dynamic array of bytes, allocated in memory or storage.
• bytes32 is a fixed array of 32 bytes, allocated in the stack, it could be memory or storage in an array or struct

Answer 2

First, You have small typos of function name as both of function name as mloadTest1. If you call both functions in the same transaction, the second function will override the memory contents set by the first one.

About your questions of bytes memory a, in this function, bytes memory a; declares a dynamic byte array, but it doesn't initialize its length. The line a := mload(0x40) reads 32 bytes from the memory location 0x40 and assigns it to the dynamic byte array a. The value at memory location 0x40 is whatever was previously stored there.

In more details:

Solidity, by default, allocates free memory from 0x00 to 0x60. The value at memory location 0x40 is initially set to 0x20 when your contract starts executing.

When you read 32 bytes starting from 0x40 (mload(0x40)), you are effectively reading the 32 bytes from 0x40 to 0x5F. This includes the value 0x20.

So, a ends up being a dynamic byte array with a length of 0x20. The value 0x20 comes from the initial state of the memory location 0x40.