Solidity 中的内联汇编（Inline Assembly）如何使用？有哪些注意事项？

Solidity 内联汇编允许开发者在合约中直接编写 Yul（EVM 汇编）代码，绕过编译器的高级抽象，获得对 EVM 的细粒度控制。它主要用于 Gas 优化、底层操作和实现 Solidity 本身无法完成的功能，但也带来了安全隐患——编译器的溢出检查、类型安全等保护机制在汇编块内全部失效。

什么时候需要内联汇编？

三个典型场景：

1. Gas 敏感路径：循环内的频繁操作、批量存储读写，汇编可减少冗余操作码
2. Solidity 语法盲区：读取 calldata 的特定偏移、访问预编译合约、手动控制内存布局
3. 库函数封装：如 ECDSA 签名解析、高效的字符串拼接，用汇编实现再供外部调用

原则：能不用就不用，必须用时要充分测试和审计。

基础语法

使用 assembly { ... } 块嵌入 Yul 代码，:= 是赋值操作符：

solidity
contract AssemblyBasic {
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        uint256 result;
        assembly {
            result := add(a, b)
        }
        return result;
    }

    function getCaller() public view returns (address) {
        address caller;
        assembly {
            caller := caller()  // 读取 msg.sender
        }
        return caller;
    }
}

注意：不同的 assembly 块之间不共享命名空间，Yul 变量无法跨块访问。

变量访问与存储位置

汇编可以读写 Solidity 变量，但必须区分 storage 和 memory：

solidity
contract VariableAccess {
    uint256 public storedValue;  // storage 变量

    function safeAccess(uint256 newValue) public {
        assembly {
            // .slot 返回 storage slot 编号
            sstore(storedValue.slot, newValue)
            // .offset 用于结构体成员偏移
        }
    }
}

关键点：

• Storage 变量用 .slot 获取槽位号，用 sload / sstore 读写
• Memory 变量直接访问值，但需要知道内存偏移才能操作原始字节
• 对于小于 256 位的类型，不能假设高位是干净的——必须手动掩码

内存操作

EVM 内存是线性字节数组，0x40 位置存放空闲内存指针：

solidity
contract MemoryOps {
    function memoryDemo() public pure returns (bytes32) {
        bytes32 result;
        assembly {
            mstore(0x00, 0x1234567890abcdef)  // 写 32 字节到 0x00
            result := mload(0x00)               // 从 0x00 读 32 字节
            mstore8(0x20, 0xff)                 // 写单字节
        }
        return result;
    }

    function freeMemPtr() public pure returns (uint256) {
        uint256 ptr;
        assembly {
            ptr := mload(0x40)  // 读取空闲内存指针
        }
        return ptr;
    }
}

内存布局规则：

• 0x00-0x3f：暂存空间（64 字节，可短期使用）
• 0x40-0x5f：空闲内存指针
• 0x60 起：Solidity 可用内存起始

存储操作与 Mapping 计算

Storage 读写是 Gas 大户（SSTORE 22100 / SLOAD 2100），但有时汇编能减少中间步骤：

solidity
contract StorageOps {
    uint256 public value;
    mapping(address => uint256) public balances;

    function mappingAccess(address user) public {
        assembly {
            // mapping[key] 的 slot = keccak256(key || slot)
            mstore(0x00, user)           // key 放入暂存区
            mstore(0x20, balances.slot)  // slot 放入暂存区
            let mappingSlot := keccak256(0x00, 0x40)

            let balance := sload(mappingSlot)
            sstore(mappingSlot, add(balance, 100))
        }
    }
}

这就是为什么汇编块内常用 mstore(0x00, ...) ——利用暂存空间拼接 keccak256 输入，无需分配新内存。

外部调用：call 与 delegatecall

汇编的 call 和 delegatecall 比 Solidity 语法更底层，需要手动管理内存和返回值：

solidity
contract ExternalCalls {
    function safeCall(address target, bytes memory data)
        public returns (bytes memory)
    {
        bytes memory result;
        assembly {
            let dataLen := mload(data)
            let dataPtr := add(data, 0x20)
            result := mload(0x40)

            let success := call(
                gas(),       // 剩余 gas
                target,      // 目标地址
                0,           // 发送的 ETH
                dataPtr,     // 输入数据指针
                dataLen,     // 输入数据长度
                result,      // 返回数据指针
                0x40         // 返回数据最大长度
            )

            if iszero(success) {
                revert(0, 0)
            }
            mstore(0x40, add(result, 0x60))  // 更新空闲指针
        }
        return result;
    }
}

call vs delegatecall：call 在目标上下文执行（独立的 storage），delegatecall 在调用者上下文执行（共享 storage），是代理合约模式的基础。

控制流：switch 与 for

Yul 的控制流比 Solidity 更原始：

solidity
contract ControlFlow {
    function findMax(uint256[] memory arr) public pure returns (uint256) {
        require(arr.length > 0, "Empty array");
        uint256 max;
        assembly {
            let len := mload(arr)
            let dataPtr := add(arr, 0x20)
            max := mload(dataPtr)

            for { let i := 1 } lt(i, len) { i := add(i, 1) } {
                let elem := mload(add(dataPtr, mul(i, 0x20)))
                if gt(elem, max) { max := elem }
            }
        }
        return max;
    }

    function conditional(uint256 x) public pure returns (uint256) {
        uint256 result;
        assembly {
            switch gt(x, 10)
            case 1 { result := mul(x, 2) }
            default { result := add(x, 5) }
        }
        return result;
    }
}

注意 Yul 的 for 循环三段式（init / condition / post），没有 break，靠条件控制退出。

Gas 优化实战：字符串拼接

对比 Solidity 和汇编两种实现的 Gas 差异：

solidity
contract StringConcat {
    // Solidity 方式：abi.encodePacked 内部有额外开销
    function concatSolidity(string memory a, string memory b)
        public pure returns (string memory)
    {
        return string(abi.encodePacked(a, b));
    }

    // 汇编方式：手动复制，省去编码中间步骤
    function concatAssembly(string memory a, string memory b)
        public pure returns (string memory result)
    {
        assembly {
            let aLen := mload(a)
            let bLen := mload(b)
            let totalLen := add(aLen, bLen)

            result := mload(0x40)
            mstore(result, totalLen)

            // 复制 a
            let aPtr := add(a, 0x20)
            let resultPtr := add(result, 0x20)
            for { let i := 0 } lt(i, aLen) { i := add(i, 0x20) } {
                mstore(add(resultPtr, i), mload(add(aPtr, i)))
            }

            // 复制 b
            let bPtr := add(b, 0x20)
            let bResultPtr := add(resultPtr, aLen)
            for { let i := 0 } lt(i, bLen) { i := add(i, 0x20) } {
                mstore(add(bResultPtr, i), mload(add(bPtr, i)))
            }

            mstore(0x40, add(add(resultPtr, totalLen), 0x20))
        }
    }
}

高效数组删除

Swap-and-pop 模式的汇编实现，避免移动大量元素：

solidity
contract ArrayOps {
    function removeElement(uint256[] storage arr, uint256 index) internal {
        require(index < arr.length, "Invalid index");
        assembly {
            let lenSlot := arr.slot
            let len := sload(lenSlot)

            // 不是最后一个元素时，用末尾元素覆盖
            if lt(add(index, 1), len) {
                let lastIndex := sub(len, 1)
                let baseSlot := keccak256(lenSlot, 0x20)
                let indexSlot := add(baseSlot, index)
                let lastSlot := add(baseSlot, lastIndex)
                sstore(indexSlot, sload(lastSlot))
            }

            sstore(lenSlot, sub(len, 1))
        }
    }
}

安全红线

汇编代码绕过了 Solidity 的全部安全机制，以下操作极其危险：

危险操作：

• sstore(slot, value) 写入任意 slot —— 可能覆盖其他变量
• mstore(0x1000000, 1) 写入远超分配范围的内存 —— 可能破坏内存结构
• call(gas(), target, 0, 0, 0, 0, 0) 不检查返回值 —— 静默失败

安全准则：

1. 验证所有输入参数的范围
2. 始终检查 call / delegatecall 的返回值
3. 不对小于 256 位类型的高位做假设，使用掩码清理
4. 将汇编操作封装在 library 中，限制暴露面
5. 汇编代码必须经过专业审计，不能只靠测试

solidity
library SafeAssemblyLib {
    function safeSStore(bytes32 slot, uint256 value) internal {
        // 仅允许写入预定义 slot
        require(slot == keccak256("allowed_slot"), "Invalid slot");
        assembly { sstore(slot, value) }
    }
}

面试高频追问

Q：内联汇编能直接访问哪些 Solidity 变量？ 局部变量（memory/stack）和 storage 变量（通过 .slot / .offset）均可访问，但不能访问 calldata 中未拷贝到 memory 的引用类型。

Q：Yul 和 EVM 汇编是什么关系？ Yul 是中间语言，编译器先将 Solidity 编译为 Yul，再由 Yul 编译器生成 EVM 字节码。内联汇编里写的代码就是 Yul 代码，经过同一套编译管线。

Q：为什么 OpenZeppelin 的 Proxy 用了汇编？ 因为 delegatecall 的返回值在 Solidity 层面难以完整获取（特别是返回数据长度未知时），必须用汇编的 returndatacopy 才能正确处理。