CALLDATALOAD (0x35)

This page is a placeholder. All examples on this page are currently AI-generated and are not correct. This documentation will be completed in the future with accurate, tested examples.

Overview

Opcode: 0x35 Introduced: Frontier (EVM genesis) CALLDATALOAD reads 32 bytes from the call data (input data passed to the contract) starting at a specified offset. Bytes beyond call data bounds are zero-padded.

Specification

Stack Input:

offset (uint256)

Stack Output:

data (bytes32 as uint256)

Gas Cost: 3 (GasFastestStep) Operation:

offset = stack.pop()
data = calldata[offset:offset+32]  // zero-padded if out of bounds
stack.push(data)

Behavior

CALLDATALOAD loads exactly 32 bytes from call data, reading from the specified byte offset. If the offset extends beyond call data, the remaining bytes are padded with zeros. Key characteristics:

Always returns 32 bytes (256 bits)
Zero-pads when offset + 32 > calldata.length
Big-endian byte order
Does not revert on out-of-bounds access

Examples

Basic Usage

import { calldataload } from '@tevm/voltaire/evm/context';
import { createFrame } from '@tevm/voltaire/evm/Frame';

// Load from calldata
const calldata = new Uint8Array([
  0x12, 0x34, 0x56, 0x78, // First 4 bytes
  ...new Array(28).fill(0xAB) // Next 28 bytes
]);

const frame = createFrame({
  calldata,
  stack: [0n] // offset = 0
});

const err = calldataload(frame);

// Result: 0x12345678AB...AB (32 bytes)

Function Arguments

contract Example {
    function process(uint256 x, uint256 y) public pure returns (uint256) {
        // Calldata layout:
        // 0x00-0x03: function selector (4 bytes)
        // 0x04-0x23: first argument (x)
        // 0x24-0x43: second argument (y)

        uint256 firstArg;
        uint256 secondArg;

        assembly {
            firstArg := calldataload(4)   // Skip selector
            secondArg := calldataload(36) // 4 + 32
        }

        return firstArg + secondArg;
    }
}

Zero Padding

// Calldata shorter than 32 bytes
const shortCalldata = new Uint8Array([0xFF, 0xEE]);

const frame = createFrame({
  calldata: shortCalldata,
  stack: [0n]
});

calldataload(frame);

// Result: 0xFFEE000000000000000000000000000000000000000000000000000000000000

Gas Cost

Cost: 3 gas (GasFastestStep) CALLDATALOAD shares the same cost tier with:

ADD, SUB (0x01, 0x03): 3 gas
NOT, ISZERO (0x19, 0x15): 3 gas
Comparison operations: 3 gas

Comparison:

CALLDATALOAD (read 32 bytes): 3 gas
CALLDATACOPY (copy N bytes): 3 + memory + copy cost
MLOAD (read from memory): 3 gas

Common Usage

Function Selector Extraction

function getSelector() public pure returns (bytes4) {
    bytes4 selector;
    assembly {
        // First 4 bytes contain function selector
        let data := calldataload(0)
        selector := shr(224, data) // Shift right 224 bits (32-4)*8
    }
    return selector;
}

Manual ABI Decoding

function decodeUint256(uint256 offset) public pure returns (uint256 value) {
    assembly {
        value := calldataload(offset)
    }
}

function decodeAddress(uint256 offset) public pure returns (address addr) {
    assembly {
        let data := calldataload(offset)
        addr := and(data, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
    }
}

Dynamic Array Length

function getArrayLength(uint256 arrayOffset) public pure returns (uint256 length) {
    assembly {
        // Array length is stored at arrayOffset
        length := calldataload(arrayOffset)
    }
}

Calldata Validation

function validateCalldata() public pure returns (bool) {
    assembly {
        // Check if calldata is at least 36 bytes (selector + 1 uint256)
        if lt(calldatasize(), 36) {
            revert(0, 0)
        }

        // Load and validate first parameter
        let param := calldataload(4)
        if gt(param, 1000) {
            revert(0, 0)
        }
    }
    return true;
}

Security

Out-of-Bounds Reading

// Safe: automatically zero-padded
function readAtOffset(uint256 offset) public pure returns (uint256) {
    uint256 value;
    assembly {
        value := calldataload(offset)
        // If offset >= calldatasize(), returns 0
    }
    return value;
}

Function Selector Validation

function onlyCorrectSelector() public pure {
    assembly {
        let selector := shr(224, calldataload(0))
        // Verify expected selector
        if iszero(eq(selector, 0x12345678)) {
            revert(0, 0)
        }
    }
}

Calldata Bounds Check

function safeRead(uint256 offset) public pure returns (uint256) {
    require(offset + 32 <= msg.data.length, "Out of bounds");

    uint256 value;
    assembly {
        value := calldataload(offset)
    }
    return value;
}

Implementation

TypeScript

import { consumeGas } from "../Frame/consumeGas.js";
import { popStack } from "../Frame/popStack.js";
import { pushStack } from "../Frame/pushStack.js";

/**
 * CALLDATALOAD opcode (0x35) - Load 32 bytes from calldata
 *
 * Stack: [offset] => [data]
 * Gas: 3 (GasFastestStep)
 */
export function calldataload(frame: FrameType): EvmError | null {
  const gasErr = consumeGas(frame, 3n);
  if (gasErr) return gasErr;

  const offsetResult = popStack(frame);
  if (offsetResult.error) return offsetResult.error;
  const offset = offsetResult.value;

  if (offset > 0xffffffffn) {
    // Offset beyond reasonable range, return zero
    const pushErr = pushStack(frame, 0n);
    if (pushErr) return pushErr;
  } else {
    const off = Number(offset);
    let result = 0n;

    // Load 32 bytes (zero-padded if out of bounds)
    for (let i = 0; i < 32; i++) {
      const idx = off + i;
      const byte = idx < frame.calldata.length ? frame.calldata[idx] : 0;
      result = (result << 8n) | BigInt(byte);
    }

    const pushErr = pushStack(frame, result);
    if (pushErr) return pushErr;
  }

  frame.pc += 1;
  return null;
}

Edge Cases

Offset Beyond Calldata

const frame = createFrame({
  calldata: new Uint8Array([0xFF]),
  stack: [100n] // Offset beyond calldata
});

calldataload(frame);
console.log(frame.stack[0]); // 0n (all zeros)

Partial Overlap

// 4 bytes calldata, offset = 1
const frame = createFrame({
  calldata: new Uint8Array([0xAA, 0xBB, 0xCC, 0xDD]),
  stack: [1n]
});

calldataload(frame);
// Result: 0xBBCCDD00...00 (3 bytes data, 29 bytes padding)

Zero Offset Empty Calldata

const frame = createFrame({
  calldata: Bytes(),
  stack: [0n]
});

calldataload(frame);
console.log(frame.stack[0]); // 0n

Maximum Offset

const frame = createFrame({
  calldata: new Uint8Array(100),
  stack: [(1n << 256n) - 1n] // Max u256
});

calldataload(frame);
console.log(frame.stack[0]); // 0n (out of bounds)

References

Yellow Paper - Section 9.1 (Machine State)
EVM Codes - CALLDATALOAD
Solidity Docs - ABI Encoding
EIP-211 - Related return data opcodes

​Overview

​Specification

​Behavior

​Examples

​Basic Usage

​Function Arguments

​Zero Padding

​Gas Cost

​Common Usage

​Function Selector Extraction

​Manual ABI Decoding

​Dynamic Array Length

​Calldata Validation

​Security

​Out-of-Bounds Reading

​Function Selector Validation

​Calldata Bounds Check

​Implementation

​Edge Cases

​Offset Beyond Calldata

​Partial Overlap

​Zero Offset Empty Calldata

​Maximum Offset

​References

Overview

Specification

Behavior

Examples

Basic Usage

Function Arguments

Zero Padding

Gas Cost

Common Usage

Function Selector Extraction

Manual ABI Decoding

Dynamic Array Length

Calldata Validation

Security

Out-of-Bounds Reading

Function Selector Validation

Calldata Bounds Check

Implementation

Edge Cases

Offset Beyond Calldata

Partial Overlap

Zero Offset Empty Calldata

Maximum Offset

References