[pallet-revive] EVM backend: implement various missing opcodes

prdoc/pr_9385.prdoc

@@ -0,0 +1,16 @@
+title: Rve/revm instructions bitwise WIP
+doc:
+- audience: Runtime Dev
+  description: |
+   Extend EVM support for pallet_revive with the follow instructions:
+   - arithmetic
+   - bitwise
+   - control
+   - host
+   - memory
+   - stack
+crates:
+- name: pallet-revive-fixtures
+  bump: minor
+- name: pallet-revive
+  bump: major

substrate/frame/revive/fixtures/build.rs

@@ -217,7 +217,7 @@ fn compile_with_standard_json(
 		"sources": {},
 		"settings": {
 			"optimizer": {
-				"enabled": true,
+				"enabled": false,
 				"runs": 200
 			},
 			"outputSelection":
@@ -344,12 +344,19 @@ fn compile_solidity_contracts(
 		return Ok(());
 	}
 
+	let evm_only = vec!["HostEvmOnly"];
+	let solidity_entries_pvm: Vec<_> = solidity_entries
+		.iter()
+		.cloned()
+		.filter(|entry| !evm_only.contains(&entry.path.file_stem().unwrap().to_str().unwrap()))
+		.collect();
+
 	// Compile with solc for EVM bytecode
 	let json = compile_with_standard_json("solc", contracts_dir, &solidity_entries)?;
 	extract_and_write_bytecode(&json, out_dir, ".sol.bin")?;
 
 	// Compile with resolc for PVM bytecode
-	let json = compile_with_standard_json("resolc", contracts_dir, &solidity_entries)?;
+	let json = compile_with_standard_json("resolc", contracts_dir, &solidity_entries_pvm)?;
 	extract_and_write_bytecode(&json, out_dir, ".resolc.polkavm")?;
 
 	Ok(())

substrate/frame/revive/fixtures/contracts/Arithmetic.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Arithmetic {
+    function testArithmetic() public {
+        // ADD tests
+        require(20 + 22 == 42, "ADD basic");
+
+        // SUB tests
+        require(42 - 20 == 22, "SUB basic");
+
+        // MUL tests
+        require(20 * 22 == 440, "MUL basic");
+
+        // DIV tests
+        require(100 / 5 == 20, "DIV basic");
+
+        // SDIV tests
+        require(int(-100) / 5 == -20, "SDIV neg/pos");
+        require(int(100) / -5 == -20, "SDIV pos/neg");
+        require(int(-100) / -5 == 20, "SDIV neg/neg");
+
+        // REM/MOD tests
+        require(100 % 7 == 2, "REM basic");
+
+        // SMOD tests
+        require(int(-100) % 7 == -2, "SMOD neg dividend");
+        require(int(100) % -7 == 2, "SMOD neg divisor");
+
+        // ADDMOD tests
+        require((10 + 15) % 7 == 4, "ADDMOD basic");
+
+        // MULMOD tests
+        require((10 * 15) % 7 == 3, "MULMOD basic");
+
+        // EXP tests
+        require(2 ** 3 == 8, "EXP basic");
+        require(10 ** 0 == 1, "EXP zero exponent");
+        require(0 ** 5 == 0, "EXP zero base");
+
+        // SIGNEXTEND tests
+        uint result1;
+        assembly {
+            result1 := signextend(0, 0xff)
+        }
+        require(result1 == type(uint256).max, "SIGNEXTEND negative byte");
+        uint result2;
+        assembly {
+            result2 := signextend(0, 0x7f)
+        }
+        require(result2 == 0x7f, "SIGNEXTEND positive byte");
+    }
+}

substrate/frame/revive/fixtures/contracts/Bitwise.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract Bitwise {
+    function testBitwise() public pure {
+        require(5 < 10, "LT basic");
+        require(type(uint256).max - 1 < type(uint256).max, "LT max");
+
+        require(10 > 5, "GT basic");
+        require(type(uint256).max > type(uint256).max - 1, "GT max");
+
+        require(5 != 10, "NEQ basic");
+        require(10 == 10, "EQ basic");
+        require(type(uint256).max == type(uint256).max, "EQ max");
+
+        require(int(-5) < int(10), "SLT basic");
+        require(type(int256).min < 0, "SLT min");
+
+        require(int(5) > int(-10), "SGT basic");
+        require(0 > type(int256).min, "SGT min");
+
+        require((5 & 3) == 1, "AND basic");
+        require((5 | 3) == 7, "OR basic");
+        require((5 ^ 3) == 6, "XOR basic");
+        require(~uint(0) == type(uint256).max, "NOT basic");
+
+        require((1 << 3) == 8, "SHL basic");
+        require((8 >> 3) == 1, "SHR basic");
+    }
+}

substrate/frame/revive/fixtures/contracts/Host.sol

@@ -1,116 +1,59 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
+pragma solidity ^0.8.24;
 
 contract Host {
     function balance(address account) public view returns (uint256) {
         return account.balance;
     }
 
-    function extcodesize(address account) public view returns (uint256) {
+    function extcodesizeOp(address account) public view returns (uint256) {
         uint256 size;
         assembly {
             size := extcodesize(account)
         }
         return size;
     }
 
-    function extcodecopy(
-        address /* account */,
-        uint256 /* destOffset */,
-        uint256 /* offset */,
-        uint256 size
-    ) public pure returns (bytes memory) {
-        bytes memory code = new bytes(size);
-        return code;
-    }
-
-    function extcodehash(address account) public view returns (bytes32) {
+    function extcodehashOp(address account) public view returns (bytes32) {
         bytes32 hash;
         assembly {
             hash := extcodehash(account)
         }
         return hash;
     }
 
-    function blockhash(uint256 blockNumber) public view returns (bytes32) {
-        return blockhash(blockNumber);
-    }
-
-    function sload(uint256 slot) public view returns (uint256) {
-        uint256 value;
-        assembly {
-            value := sload(slot)
-        }
-        return value;
-    }
-
-    function sstore(uint256 slot, uint256 value) public returns (uint256) {
+    function blockhashOp(uint256 blockNumber) public view returns (bytes32) {
+        bytes32 hash;
         assembly {
-            sstore(slot, value)
+            hash := blockhash(blockNumber)
         }
-        return value;
+        return hash;
     }
 
-    function tload(uint256 slot) public view returns (uint256) {
+    function sloadOp(uint256 slot) public view returns (uint256) {
         uint256 value;
         assembly {
-            value := tload(slot)
-        }
-        return value;
-    }
-
-    function tstore(uint256 slot, uint256 value) public returns (uint256) {
-        assembly {
-            tstore(slot, value)
+            value := sload(slot)
         }
         return value;
     }
 
-    function log0(bytes32 data) public {
-        assembly {
-            log0(data, 0x20)
-        }
-    }
-
-    function log1(bytes32 data, bytes32 topic1) public {
-        assembly {
-            log1(data, 0x20, topic1)
-        }
-    }
-
-    function log2(bytes32 data, bytes32 topic1, bytes32 topic2) public {
+    function sstoreOp(uint256 slot, uint256 value) public {
         assembly {
-            log2(data, 0x20, topic1, topic2)
-        }
-    }
-
-    function log3(
-        bytes32 data,
-        bytes32 topic1,
-        bytes32 topic2,
-        bytes32 topic3
-    ) public {
-        assembly {
-            log3(data, 0x20, topic1, topic2, topic3)
+            sstore(slot, value)
         }
     }
 
-    function log4(
-        bytes32 data,
-        bytes32 topic1,
-        bytes32 topic2,
-        bytes32 topic3,
-        bytes32 topic4
-    ) public {
+    function logOps() public {
         assembly {
-            log4(data, 0x20, topic1, topic2, topic3, topic4)
+            log0(0x01, 0x20)
+            log1(0x02, 0x20, 0x11)
+            log2(0x03, 0x20, 0x22, 0x33)
+            log3(0x04, 0x20, 0x44, 0x55, 0x66)
+            log4(0x05, 0x20, 0x77, 0x88, 0x99, 0xaa)
         }
     }
 
-    function selfdestruct(address payable recipient) public {
-        selfdestruct(recipient);
-    }
-
     function selfbalance() public view returns (uint256) {
         return address(this).balance;
     }

substrate/frame/revive/fixtures/contracts/HostEvmOnly.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract HostEvmOnly {
+    function selfdestructOp(address payable recipient) public {
+        assembly {
+            selfdestruct(recipient)
+        }
+    }
+    function extcodecopyOp(
+        address account,
+        uint256 offset,
+        uint256 size
+    ) public view returns (bytes memory code) {
+        code = new bytes(size);
+        assembly {
+            extcodecopy(account, add(code, 32), offset, size)
+        }
+    }
+}
+
+contract HostEvmOnlyFactory {
+    function createAndSelfdestruct(address payable recipient) public returns (address newContract) {
+        // Deploy a new instance of HostEvmOnly
+        HostEvmOnly newInstance = new HostEvmOnly();
+        newContract = address(newInstance);
+
+        // Call selfdestruct on the newly created contract
+        newInstance.selfdestructOp(recipient);
+
+        return newContract;
+    }
+}

substrate/frame/revive/fixtures/contracts/HostTransientMemory.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+contract HostTransientMemory {
+    function transientMemoryTest(
+        uint256 slot,
+        uint256 a
+    ) public returns (uint256) {
+        uint256 value;
+        assembly {
+            tstore(slot, a)
+        }
+        value = 1;
+        assembly {
+            value := tload(slot)
+        }
+        return value - a;
+    }
+}