内联汇编 #

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

contract VariableAccess {
    uint256 public value = 100;
    
    function getValue() public view returns (uint256) {
        uint256 result;
        
        assembly {
            result := sload(0)  // 读取slot 0
        }
        
        return result;
    }
    
    function setValue(uint256 newValue) public {
        assembly {
            sstore(0, newValue)  // 写入slot 0
        }
    }
}

contract ArithmeticOps {
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        assembly {
            let result := add(a, b)
            mstore(0, result)
            return(0, 32)
        }
    }
    
    function sub(uint256 a, uint256 b) public pure returns (uint256) {
        assembly {
            let result := sub(a, b)
            mstore(0, result)
            return(0, 32)
        }
    }
    
    function mul(uint256 a, uint256 b) public pure returns (uint256) {
        assembly {
            let result := mul(a, b)
            mstore(0, result)
            return(0, 32)
        }
    }
    
    function div(uint256 a, uint256 b) public pure returns (uint256) {
        assembly {
            let result := div(a, b)
            mstore(0, result)
            return(0, 32)
        }
    }
}

contract ComparisonOps {
    function eq(uint256 a, uint256 b) public pure returns (bool) {
        assembly {
            let result := eq(a, b)
            mstore(0, result)
            return(0, 32)
        }
    }
    
    function lt(uint256 a, uint256 b) public pure returns (bool) {
        assembly {
            let result := lt(a, b)
            mstore(0, result)
            return(0, 32)
        }
    }
    
    function gt(uint256 a, uint256 b) public pure returns (bool) {
        assembly {
            let result := gt(a, b)
            mstore(0, result)
            return(0, 32)
        }
    }
}

contract MemoryOps {
    function mstoreDemo(uint256 value) public pure returns (bytes32) {
        assembly {
            mstore(0x80, value)  // 在内存位置0x80存储值
            return(0x80, 32)
        }
    }
    
    function mloadDemo() public pure returns (uint256) {
        assembly {
            let value := mload(0x40)  // 读取空闲内存指针
            mstore(0, value)
            return(0, 32)
        }
    }
}

contract StorageOps {
    uint256 private value1;
    uint256 private value2;
    
    function readSlot(uint256 slot) public view returns (uint256) {
        assembly {
            let result := sload(slot)
            mstore(0, result)
            return(0, 32)
        }
    }
    
    function writeSlot(uint256 slot, uint256 value) public {
        assembly {
            sstore(slot, value)
        }
    }
}

contract AssemblyIf {
    function max(uint256 a, uint256 b) public pure returns (uint256) {
        assembly {
            switch gt(a, b)
            case 1 {
                mstore(0, a)
            }
            default {
                mstore(0, b)
            }
            return(0, 32)
        }
    }
    
    function min(uint256 a, uint256 b) public pure returns (uint256) {
        assembly {
            switch lt(a, b)
            case 1 {
                mstore(0, a)
            }
            default {
                mstore(0, b)
            }
            return(0, 32)
        }
    }
}

contract AssemblyLoop {
    function sum(uint256 n) public pure returns (uint256) {
        assembly {
            let total := 0
            let i := 1
            
            for {} lt(i, add(n, 1)) { i := add(i, 1) } {
                total := add(total, i)
            }
            
            mstore(0, total)
            return(0, 32)
        }
    }
}

contract EfficientCopy {
    function copyBytes(
        bytes memory source,
        bytes memory destination
    ) public pure {
        assembly {
            let length := mload(source)
            
            // 复制长度
            mstore(destination, length)
            
            // 复制数据
            let src := add(source, 32)
            let dst := add(destination, 32)
            
            for { let i := 0 } lt(i, length) { i := add(i, 32) } {
                mstore(add(dst, i), mload(add(src, i)))
            }
        }
    }
}

contract SignatureRecover {
    function recoverSigner(
        bytes32 hash,
        bytes memory signature
    ) public pure returns (address) {
        assembly {
            let r := mload(add(signature, 0x20))
            let s := mload(add(signature, 0x40))
            let v := byte(0, mload(add(signature, 0x60)))
            
            // 调整v值
            if lt(v, 27) { v := add(v, 27) }
            
            // 恢复地址
            let addr := ecrecover(hash, v, r, s)
            mstore(0, addr)
            return(0, 32)
        }
    }
}

contract ProxyAssembly {
    address public implementation;
    
    constructor(address _implementation) {
        implementation = _implementation;
    }
    
    fallback() external payable {
        address impl = implementation;
        
        assembly {
            calldatacopy(0, 0, calldatasize())
            
            let result := delegatecall(
                gas(),
                impl,
                0,
                calldatasize(),
                0,
                0
            )
            
            returndatacopy(0, 0, returndatasize())
            
            switch result
            case 0 {
                revert(0, returndatasize())
            }
            default {
                return(0, returndatasize())
            }
        }
    }
}

contract SafeAssembly {
    function safeAdd(uint256 a, uint256 b) public pure returns (uint256) {
        assembly {
            let result := add(a, b)
            
            // 检查溢出
            if lt(result, a) {
                revert(0, 0)
            }
            
            mstore(0, result)
            return(0, 32)
        }
    }
}

contract MemorySafety {
    function safeAllocate(uint256 size) public pure returns (bytes memory) {
        assembly {
            // 获取空闲内存指针
            let freePtr := mload(0x40)
            
            // 分配内存
            mstore(0x40, add(freePtr, add(size, 32)))
            
            // 存储长度
            mstore(freePtr, size)
            
            return(freePtr, add(size, 32))
        }
    }
}