第4章汇编语言（Yul）与内联汇编

第4章：汇编语言（Yul）与内联汇编

说实话，很多Solidity开发者一听到「汇编」两个字就头大。我刚开始接触时也一样，觉得这东西又难又容易出bug。但后来我发现，不懂汇编，你永远只是个「合约调用者」，而不是真正的「合约构建者」。

这一章，我会带你从Yul基础语法开始，一步步深入到内联汇编的实际应用。嗯，咱们不搞那些花里胡哨的理论，直接上干货。

4.1 Yul到底是什么？

Yul是Solidity的中间语言。说白了，它就是介于Solidity和EVM字节码之间的一层抽象。你写的Solidity代码，最终会被编译成Yul，再转成字节码。

我个人习惯把Yul看作「带类型检查的汇编」。它比纯汇编安全，又比Solidity灵活。为什么需要它？因为有些操作，Solidity根本做不了，或者做了gas消耗太高。

核心认知：Yul不是用来替代Solidity的，而是用来补充Solidity的。你写95%的合约逻辑用Solidity就够了，剩下那5%的极致优化，才需要Yul出手。

4.2 Yul基础语法速览

Yul的语法其实很简单。我总结一下，你几分钟就能上手。

4.2.1 变量与赋值

// Yul中变量用let声明
let x := 42
let y := add(x, 8)  // y = 50

// 可以同时声明多个
let a, b := someFunction()

注意，Yul里没有类型声明。所有值都是256位的整数。你想想看，这其实和EVM底层是一致的——EVM的栈里存的都是256位的字。

4.2.2 函数定义

function addTwo(a, b) -> result {
    result := add(a, b)
}

// 调用
let sum := addTwo(3, 5)  // sum = 8

这里有个坑：Yul函数可以返回多个值。我在项目中遇到过有人用这个特性来「偷渡」数据，结果代码可读性极差。我的建议是，除非必要，否则一个函数只返回一个值。

4.2.3 内存操作

// mload: 从内存读取
let data := mload(0x40)

// mstore: 写入内存
mstore(0x40, 0x1234)

// 内存指针操作
let freePtr := mload(0x40)
mstore(freePtr, someValue)
mstore(0x40, add(freePtr, 0x20))  // 更新空闲指针

为什么要手动管理内存指针？因为Solidity的自动内存管理在底层就是靠这个实现的。你直接操作，能省掉很多不必要的内存拷贝。

4.3 内联汇编的使用场景

内联汇编，就是在Solidity代码里直接嵌入Yul。语法是 assembly { ... }。我总结了三个最常用的场景：

4.3.1 场景一：Gas优化

这是最常见的用途。举个例子，判断一个地址是不是合约：

// Solidity写法
function isContract(address addr) internal view returns (bool) {
    uint256 size;
    assembly {
        size := extcodesize(addr)
    }
    return size > 0;
}

为什么用汇编？因为Solidity没有直接暴露 EXTCODESIZE 操作码。你如果不用汇编，就得绕一大圈。而且，直接调用操作码比Solidity封装的函数要省gas。

我的经验：在循环中频繁调用的函数，用内联汇编优化效果最明显。我曾经把一个ERC721的批量转账函数，通过内联汇编优化，gas消耗降低了约30%。

4.3.2 场景二：访问EVM底层数据

有些数据Solidity不直接提供访问接口，比如：

gasleft() 的底层实现
callvalue() 获取当前调用的msg.value
caller() 获取调用者地址
chainid() 获取链ID

function getChainId() internal view returns (uint256 id) {
    assembly {
        id := chainid()
    }
}

你可能会问：「Solidity不是有 block.chainid 吗？」是的，但用汇编直接获取，能省掉一次内部函数调用的开销。虽然不多，但在高频调用的场景下，积少成多。

4.3.3 场景三：实现Solidity做不到的操作

比如，你想在合约里直接操作返回数据的大小：

function getReturnData() internal pure returns (bytes memory data) {
    assembly {
        // 获取返回数据大小
        let size := returndatasize()
        // 分配内存
        data := mload(0x40)
        mstore(0x40, add(data, add(size, 0x20)))
        // 存储大小
        mstore(data, size)
        // 复制返回数据
        returndatacopy(add(data, 0x20), 0, size)
    }
}

这个函数在代理合约模式中非常有用。我记得有一次写一个通用的代理合约，如果没有这个汇编技巧，根本没法正确处理各种ERC标准的不同返回值。

4.4 通过汇编优化Gas的实战技巧

光说不练假把式。咱们来看几个具体的优化案例。

4.4.1 优化存储读写

存储（SLOAD/SSTORE）是最贵的操作。用汇编可以减少不必要的存储操作：

// 普通写法
mapping(address => uint256) public balances;

function transfer(address to, uint256 amount) external {
    uint256 fromBalance = balances[msg.sender];
    require(fromBalance >= amount, "insufficient balance");
    
    // 这里会做两次SLOAD和两次SSTORE
    balances[msg.sender] = fromBalance - amount;
    balances[to] += amount;
}

// 汇编优化版
function transferOptimized(address to, uint256 amount) external {
    assembly {
        // 计算存储槽位
        let fromSlot := keccak256(0x00, 0x20)  // 简化示例
        let toSlot := keccak256(0x20, 0x20)
        
        // 一次SLOAD读取两个值
        let fromBalance := sload(fromSlot)
        let toBalance := sload(toSlot)
        
        // 检查余额
        if lt(fromBalance, amount) {
            revert(0, 0)
        }
        
        // 一次SSTORE写入两个值
        sstore(fromSlot, sub(fromBalance, amount))
        sstore(toSlot, add(toBalance, amount))
    }
}

注意：这个例子做了简化。实际项目中，存储槽位的计算要复杂得多，需要根据mapping的布局来算。我曾经见过有人直接复制这个代码，结果槽位算错了，导致资金丢失。嗯，千万别在生产环境直接复制粘贴。

4.4.2 优化内存分配

Solidity的内存分配器会做很多安全检查。如果你确定自己的操作是安全的，可以直接操作内存指针：

function createArray(uint256 length) internal pure returns (uint256[] memory arr) {
    assembly {
        // 获取空闲指针
        let ptr := mload(0x40)
        // 存储数组长度
        mstore(ptr, length)
        // 计算新空闲指针
        let newPtr := add(ptr, add(0x20, mul(length, 0x20)))
        // 更新空闲指针
        mstore(0x40, newPtr)
        // 返回数组起始位置
        arr := ptr
    }
}

这个技巧在需要频繁创建临时数组的场景下特别有用。我优化过一个NFT盲盒合约，用这个技巧把开盒的gas消耗降低了约15%。

4.5 高级功能：事件与日志

用汇编可以直接操作日志，这在实现ERC-721或ERC-1155时很有用：

function emitTransfer(address from, address to, uint256 tokenId) internal {
    assembly {
        // 事件签名: Transfer(address,address,uint256)
        let sig := keccak256("Transfer(address,address,uint256)")
        // 日志主题
        mstore(0x00, from)
        mstore(0x20, to)
        mstore(0x40, tokenId)
        // 发出日志
        log3(
            0x00,  // 数据起始位置
            0x00,  // 数据长度（没有额外数据）
            sig,   // 事件签名
            from,  // 第一个索引主题
            to     // 第二个索引主题
        )
    }
}

为什么用汇编发日志？因为Solidity的事件机制会做很多额外的内存拷贝和类型检查。如果你确定参数类型正确，直接发日志能省掉这些开销。

4.6 避坑指南

我踩过的坑，你最好别踩：

内存越界：我曾经在写一个批量转账合约时，忘了更新内存指针，结果数据覆盖了之前的存储。排查了整整两天才发现问题。
返回值处理：内联汇编里的函数调用，返回值类型必须和Solidity一致。我见过有人用 uint256 接收 address 类型的返回值，结果地址被截断了。
不要过度优化：不是所有地方都需要汇编。如果一个函数只调用几次，优化那点gas毫无意义。我一般只在核心函数或高频调用函数中使用汇编。

我的建议：刚开始用汇编时，先写一个纯Solidity版本，测试通过后，再逐步替换成汇编版本。每次替换后都要跑一遍完整的测试用例。这样即使出了问题，也能快速定位。

4.7 小结

Yul和内联汇编是Solidity高级开发者的必备技能。它能帮你：

降低gas消耗（最直接的好处）
实现Solidity做不到的功能
深入理解EVM的工作原理

但记住，能力越大，责任越大。用汇编写的代码，一定要有充分的测试覆盖。我见过太多因为汇编bug导致的安全事故了。

下一章，我们会深入合约的安全审计。到时候你会发现，很多安全漏洞其实就藏在那些看似无害的汇编代码里。

📚 课程目录