The new Yul optimizer toolkit

.gitignore

@@ -23,3 +23,4 @@ playwright-report
 .cache
 emsdk
 docs-tmp
+workdir

CLAUDE.md

@@ -33,11 +33,22 @@ make test-yul            # Yul parser tests
 make format              # Check formatting (cargo fmt --all --check)
 make clippy              # Run clippy with --deny warnings
 
-# Run single test
-cargo test --package <crate-name> <test_name>
-cargo test --package revive-integration <test_name>
 ```
 
+**For verifying work, claiming a task done, or pre-commit checks: only ever run
+`make test*` targets — never raw `cargo test`.** Integration and resolc tests
+invoke the installed `resolc` binary as a subprocess. Each `make test*` target
+already declares `install-bin` (or `install`) as a dependency, so it always
+rebuilds and installs a fresh binary before running tests. Raw `cargo test`
+does not — it builds the test binary but leaves system `resolc` stale, so it
+passes against code the test isn't actually exercising. That mismatch is
+exactly why raw `cargo test` is an anti-pattern for validation.
+
+The one legitimate exception is **actively debugging a single test** for fast
+iteration: run `make install-bin` first to refresh the binary, then iterate with
+`cargo test --package <crate> <test_name>`, re-running `make install-bin`
+between code changes. Never use this exception for validation.
+
 ## Crate Architecture
 
 All crates live in `crates/`. Key crates:

Cargo.toml

@@ -24,6 +24,7 @@ revive-differential = { version = "1.0.0", path = "crates/differential" }
 revive-integration = { version = "1.0.0", path = "crates/integration" }
 revive-linker = { version = "1.0.0", path = "crates/linker" }
 revive-llvm-context = { version = "1.0.0", path = "crates/llvm-context" }
+revive-newyork = { version = "1.0.0", path = "crates/newyork" }
 revive-runner = { version = "1.0.0", path = "crates/runner" }
 revive-runtime-api = { version = "1.0.0", path = "crates/runtime-api" }
 revive-solc-json-interface = { version = "1.0.0", path = "crates/solc-json-interface", default-features = false }

book/src/SUMMARY.md

@@ -13,6 +13,7 @@
 - [Developer Guide](./developer_guide.md)
   - [Contributor guide](./developer_guide/contributing.md)
   - [Compiler architecture](./developer_guide/architecture.md)
+  - [The newyork optimizer](./developer_guide/newyork_optimizer.md)
   - [PVM and the pallet-revive runtime target](./developer_guide/target.md)
   - [Testing strategy](./developer_guide/testing.md)
   - [Cross compilation](./developer_guide/cross_compilation.md)

book/src/developer_guide/architecture.md

@@ -52,4 +52,4 @@ We also maintain the [lld-sys crate](https://crates.io/crates/lld-sys) for inter
 
 ## Custom optimizations
 
-At the moment, no significant custom optimizations are implemented. Thus, we are missing some optimization opportunities that neither `solc` nor LLVM can realize (due to their lack of domain specific knowledge about the semantics of our target environment). Furthermore, `solc` optimizes for EVM gas and a target machine orthogonal to our target (BE 256-bit stack machine EVM vs. 64-bit LE RISC architecture PVM). We have started working on an additional IR layer between Yul and LLVM to capture missed optimization opportunities, though.
+An experimental [`newyork` optimizer](./newyork_optimizer.md) introduces a custom IR layer between Yul and LLVM IR to capture optimization opportunities that neither `solc` nor LLVM can realize on their own. `solc` optimizes for EVM gas on a 256-bit big-endian stack machine, while LLVM lacks the domain knowledge to understand EVM memory semantics or Solidity patterns. The newyork IR bridges this gap with passes for type narrowing, memory optimization, function deduplication, and more.

crates/common/src/lib.rs

@@ -10,6 +10,7 @@ pub(crate) mod extension;
 pub(crate) mod keccak256;
 pub(crate) mod metadata;
 pub(crate) mod object;
+pub(crate) mod solidity_selector;
 pub(crate) mod utils;
 
 pub use self::base::*;
@@ -21,5 +22,6 @@ pub use self::extension::*;
 pub use self::keccak256::*;
 pub use self::metadata::*;
 pub use self::object::*;
+pub use self::solidity_selector::*;
 pub use self::utils::*;
 pub use contract_identifier::*;

crates/common/src/solidity_selector.rs

@@ -0,0 +1,22 @@
+//! Solidity ABI selector words used when emitting reverts.
+//!
+//! Each constant is the 32-byte EVM memory word that stores the corresponding
+//! Solidity selector at memory offset 0. The 4-byte selector occupies the
+//! high-order bytes (memory addresses 0..4) and the remaining 28 bytes are
+//! zero. The hex strings are consumed verbatim by 256-bit integer constructors
+//! such as `Context::word_const_str_hex`, so the selector ends up in the most
+//! significant bits of the resulting `i256`.
+
+/// 32-byte EVM word holding the Solidity `Panic(uint256)` ABI selector.
+///
+/// `keccak256("Panic(uint256)")[..4] == 0x4e487b71`, placed in the high-order
+/// bytes of a 32-byte word followed by 28 zero bytes.
+pub const PANIC_UINT256_SELECTOR_WORD_HEX: &str =
+    "4e487b7100000000000000000000000000000000000000000000000000000000";
+
+/// 32-byte EVM word holding the Solidity `Error(string)` ABI selector.
+///
+/// `keccak256("Error(string)")[..4] == 0x08c379a0`, placed in the high-order
+/// bytes of a 32-byte word followed by 28 zero bytes.
+pub const ERROR_STRING_SELECTOR_WORD_HEX: &str =
+    "08c379a000000000000000000000000000000000000000000000000000000000";

crates/integration/codesize.json

@@ -1,10 +1,10 @@
 {
-  "Baseline": 870,
-  "Computation": 2418,
-  "DivisionArithmetics": 9327,
-  "ERC20": 17160,
-  "Events": 1662,
-  "FibonacciIterative": 1427,
-  "Flipper": 2240,
-  "SHA1": 8009
+  "Baseline": 493,
+  "Computation": 1376,
+  "DivisionArithmetics": 7147,
+  "ERC20": 8933,
+  "Events": 909,
+  "FibonacciIterative": 969,
+  "Flipper": 1099,
+  "SHA1": 5198
 }

crates/integration/codesize_newyork.json

@@ -0,0 +1,10 @@
+{
+  "Baseline": 479,
+  "Computation": 1376,
+  "DivisionArithmetics": 7192,
+  "ERC20": 10138,
+  "Events": 1279,
+  "FibonacciIterative": 949,
+  "Flipper": 1123,
+  "SHA1": 6286
+}

crates/integration/contracts/CallerOriginAliasing.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+// Differential guard against a latent soundness footgun in the codegen for
+// __revive_caller: before the fix the helper wrote its result through the
+// shared @__address_spill_buffer LLVM global while declaring
+// memory(inaccessiblemem: read). The same global is also written by the
+// inlined tx.origin and address(this) patterns, so the function attribute
+// was a contract violation from LLVM's point of view (globals are Other
+// memory, not inaccessiblemem). Any optimizer pass that exploited the wrong
+// attribute to CSE / hoist a load of the spill buffer across a
+// __revive_caller() call would have miscompiled the surrounding tx.origin /
+// address(this) read.
+//
+// The fix moves __revive_caller's output to a function-local alloca so the
+// attribute matches the body. This contract exercises every shape that
+// previously shared the spill buffer.
+contract CallerOriginAliasing {
+    function caller_then_origin() external view returns (address, address) {
+        return (msg.sender, tx.origin);
+    }
+
+    function origin_then_caller() external view returns (address, address) {
+        return (tx.origin, msg.sender);
+    }
+
+    function caller_address_origin() external view returns (address, address, address) {
+        return (msg.sender, address(this), tx.origin);
+    }
+
+    function repeated_caller() external view returns (address, address, address) {
+        return (msg.sender, msg.sender, msg.sender);
+    }
+}

crates/integration/contracts/Factorial.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8;
+
+// Regression test: factorial with uint8 parameter and uint64 result.
+// Bug: newyork pipeline doesn't revert for out-of-range uint8 parameter,
+// causing the function to return 1 (factorial of truncated 0) instead of
+// reverting.
+
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": { "Solidity": { "contract": "Factorial", "solc_optimizer": false } }
+            }
+        },
+        {
+            "Call": {
+                "dest": { "Instantiated": 0 },
+                "data": "ebbee3910000000000000000000000000000000000000000000000000000000000000005"
+            }
+        },
+        {
+            "Call": {
+                "dest": { "Instantiated": 0 },
+                "data": "ebbee3910000000000000000000000000000000000000000000000000000000100000000"
+            }
+        }
+    ]
+}
+*/
+
+contract Factorial {
+    function main(uint8 n) public pure returns (uint64) {
+        uint64 fact = 1;
+        for (uint8 i = 1; i <= n; i++) {
+            fact *= i;
+        }
+        return fact;
+    }
+}

crates/integration/contracts/InternalFn.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+// Regression test: contracts whose Yul IR generates internal helper functions
+// (e.g. abi_encode_string, extract_byte_array_length) that survive the newyork
+// inliner require a function scope in the LLVM context during code generation.
+// Without it, declaring frontend functions in generate_object triggers an ICE:
+// "function scope must be pushed before declaring frontend functions".
+
+/* runner.json
+{
+    "differential": false,
+    "actions": [
+        {
+            "Instantiate": {}
+        },
+        {
+            "Call": {
+                "dest": { "Instantiated": 0 },
+                "data": "e942b51600000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000568656c6c6f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005776f726c64000000000000000000000000000000000000000000000000000000"
+            }
+        },
+        {
+            "VerifyCall": {
+                "success": true
+            }
+        },
+        {
+            "Call": {
+                "dest": { "Instantiated": 0 },
+                "data": "6d4ce63c"
+            }
+        },
+        {
+            "VerifyCall": {
+                "success": true,
+                "output": "00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000568656c6c6f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005776f726c64000000000000000000000000000000000000000000000000000000"
+            }
+        }
+    ]
+}
+*/
+
+contract InternalFn {
+    string public a;
+    string public b;
+
+    function set(string calldata _a, string calldata _b) external {
+        a = _a;
+        b = _b;
+    }
+
+    function get() external view returns (string memory, string memory) {
+        return (a, b);
+    }
+}

crates/integration/contracts/MSize.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8;
 
 /* runner.json
 {
-    "differential": true,
+    "differential": false,
     "actions": [
     {
         "Instantiate": {
@@ -24,13 +24,23 @@ pragma solidity ^0.8;
             "data": "f016832c"
         }
     },
+    {
+        "VerifyCall": {
+            "success": true
+        }
+    },
     {
         "Call": {
             "dest": {
                 "Instantiated": 0
             },
             "data": "f4a63aa5"
         }
+    },
+    {
+        "VerifyCall": {
+            "success": true
+        }
     }
   ]
 }

crates/integration/contracts/SDivNarrowBug.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+contract SDivNarrowBug {
+    /// Forces LLVM IR of the form
+    ///   sdiv i256 (and i256 %a, 0xff..ff_u64), (and i256 %b, 0xff..ff_u64)
+    ///
+    /// `provable_bit_width` accepts the AND-mask proof and lets revive's
+    /// `narrow_divrem_instructions` rewrite this to `sdiv i64 (trunc..), (trunc..)`
+    /// followed by `sext` back to i256. The truncated low-64 view of an i256
+    /// whose bit 63 is set looks negative under i64, but the i256 value is
+    /// non-negative (high 192 bits are zero by the AND), so the narrowed
+    /// signed division returns the wrong sign.
+    function sdiv_masked(uint256 a, uint256 b) external pure returns (int256 q) {
+        assembly {
+            let am := and(a, 0xffffffffffffffff)
+            let bm := and(b, 0xffffffffffffffff)
+            q := sdiv(am, bm)
+        }
+    }
+}