init

.gitignore

@@ -1,14 +0,0 @@
-/target
-*.dot
-.vscode/
-.DS_Store
-/*.sol
-/*.yul
-/*.ll
-/*.s
-/llvm-project
-/llvm18.0
-node_modules
-artifacts
-tmp
-package-lock.json

Cargo.toml

@@ -1,51 +0,0 @@
-[workspace]
-resolver = "2"
-members = ["crates/*"]
-
-[workspace.dependencies]
-hex = "0.4"
-petgraph = "0.6"
-cc = "1.0"
-libc = "0.2"
-tempfile = "3.8"
-anyhow = "1.0"
-semver = { version = "1.0", features = [ "serde" ] }
-itertools = "0.12"
-serde = { version = "1.0", features = [ "derive" ] }
-serde_json = { version = "1.0", features = [ "arbitrary_precision" ] }
-regex = "1.10"
-once_cell = "1.19"
-num = "0.4"
-sha1 = "0.10"
-sha2 = "0.10"
-sha3 = "0.10"
-md5 = "0.7"
-colored = "2.1"
-thiserror = "1.0"
-which = "5.0"
-path-slash = "0.2"
-rayon = "1.8"
-structopt = { version = "0.3", default-features = false }
-rand = "0.8"
-polkavm-common = { branch = "master_byteswap", git = "https://github.com/xermicus/polkavm.git" } 
-polkavm-linker = { branch = "master_byteswap", git = "https://github.com/xermicus/polkavm.git" } 
-polkavm = { branch = "master_byteswap", git = "https://github.com/xermicus/polkavm.git" } 
-alloy-primitives = "0.6"
-alloy-sol-types = "0.6"
-env_logger = { version = "0.10.0", default-features = false }
-serde_stacker = "0.1"
-criterion = { version = "0.5", features = ["html_reports"] }
-
-# Benchmarking against EVM
-primitive-types = { version = "0.12", features = ["codec"] }
-evm-interpreter = { git = "https://github.com/xermicus/evm.git", branch = "separate-compilation" }
-
-[workspace.dependencies.inkwell]
-git = "https://github.com/TheDan64/inkwell.git"
-commit = "d916c66"
-default-features = false
-features = ["serde", "llvm18-0", "no-libffi-linking", "target-riscv"]
-
-[profile.benchmark]
-inherits = "release"
-lto = true

LICENSE-APACHE

@@ -1,191 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        https://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   Copyright (c) 2019 Matter Labs
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       https://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

LICENSE-MIT

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2019 Matter Labs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

Makefile

@@ -1,49 +0,0 @@
-.PHONY: install test test-solidity test-cli test-integration clean
-
-install: install-bin install-npm
-
-install-bin:
-	cargo install --path crates/solidity
-
-install-npm:
-	npm install && npm fund
-
-test: install test-integration test-cli test-solidity
-
-test-integration: install-bin
-	cargo test --package revive-integration
-
-test-solidity: install
-	cargo test --package revive-solidity
-
-test-cli: install
-	npm run test:cli
-
-bench-prepare: install-bin
-	cargo criterion --bench prepare --features bench-evm,bench-pvm --message-format=json \
-	| criterion-table > crates/benchmarks/PREPARE.md
-
-bench-execute: install-bin
-	cargo criterion --bench execute --features bench-evm,bench-pvm --message-format=json \
-	| criterion-table > crates/benchmarks/EXECUTE.md
-
-bench-extensive: install-bin
-	cargo criterion --all --all-features --message-format=json \
-	| criterion-table > crates/benchmarks/BENCHMARKS.md
-
-bench-quick: install-bin
-	cargo criterion --all --features bench-evm
-
-bench: install-bin
-	cargo criterion --all --features bench-evm,bench-pvm --message-format=json \
-	| criterion-table > crates/benchmarks/BENCHMARKS.md
-
-clippy:
-	cargo clippy --all-features --workspace --tests --benches
-
-clean:
-	cargo clean ; \
-	rm -rf node_modules ; \
-	rm -rf crates/solidity/src/tests/cli-tests/artifacts ; \
-	cargo uninstall revive-solidity ; \
-	rm -f package-lock.json

README.md

@@ -1,38 +0,0 @@
-# revive
-
-YUL and EVM bytecode recompiler to LLVM, targetting RISC-V on PolkaVM.
-
-Code bases of [frontend](https://github.com/matter-labs/era-compiler-solidity) and [code generator](https://github.com/matter-labs/era-compiler-llvm-context) are forked and adapted from ZKSync `zksolc`.
-
-# Status
-
-Currently, primary goal of this codebase is to allow for benchmarks comparing performance against ink! and solang artifacts as well as EVM interpreters.
-
-# TODO
-
-The project is in a very early PoC phase. Don't yet expect the produced code to be working nor to be correct for anything more than a basic flipper contract at the current stage.
-
-- [ ] Efficient implementations of byte swaps, memset, memmove, mulmod and the like
-- [ ] Use `drink` for integration tests once we have 64bit support in PolkaVM
-- [x] Use PolkaVM allocator for heap space
-- [ ] Exercice `schlau` and possibly `smart-bench` benchmark cases
-- [x] Tests currently rely on the binary being in $PATH, which is very annoying and requires `cargo install` all the times
-- [ ] Define how to do deployments
-- [ ] Calling conventions for calling other contracts
-- [ ] Runtime environment isn't fully figured out; implement all EVM builtins
-- [ ] Iron out many leftovers from the ZKVM target
-    - [ ] Use of exceptions
-    - [ ] Change long calls (contract calls)
-    - [ ] Check all alignments, attributes etc. if they still make sense with our target
-    - [x] Custom extensions related to zk VM
-    - [ ] `Active Pointer`: Redundant to calldata forwarding in pallet contracts. [Mainly used here](https://github.com/matter-labs/era-contracts/blob/4aa7006153ad571643342dff22c16eaf4a70fdc1/system-contracts/contracts/libraries/EfficientCall.sol) however we could offer a similar optimization.
-    - []
-- [ ] Add a lot more test cases
-- [ ] Debug information
-- [ ] Look for and implement further optimizations
-- [ ] Differential testing against EVM
-- [x] Switch to LLVM 18 which has `RV{32,64}E` targets upstream
-- [ ] Minimize scope of "stdlib"
-- [ ] Document differences from EVM
-- [ ] Audit for bugs and correctness
-- [ ] Rebranding

build-llvm.sh

@@ -1,70 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-INSTALL_DIR="${PWD}/llvm18.0"
-mkdir -p $INSTALL_DIR
-
-
-# Clone LLVM 18 (any revision after commit bd32aaa is supposed to work)
-if [ ! -d "llvm-project" ]; then
-  git clone --depth 1 --branch release/18.x https://github.com/llvm/llvm-project.git
-fi
-
-
-# Build LLVM, clang
-cd llvm-project
-
-mkdir -p build
-cd build
-cmake -G Ninja -DLLVM_ENABLE_ASSERTIONS=On \
-  -DLLVM_ENABLE_TERMINFO=Off \
-  -DLLVM_ENABLE_LIBXML2=Off \
-  -DLLVM_ENABLE_ZLIB=Off \
-  -DLLVM_ENABLE_PROJECTS='clang;lld' \
-  -DLLVM_TARGETS_TO_BUILD='RISCV' \
-  -DLLVM_ENABLE_ZSTD=Off \
-  -DCMAKE_BUILD_TYPE=MinSizeRel \
-  -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR \
-	../llvm
-
-ninja
-ninja install
-
-
-# Build compiler builtins
-cd ../compiler-rt
-mkdir -p build
-cd build
-
-CFLAGS="--target=riscv64 -march=rv64em -mabi=lp64e -nostdlib -nodefaultlibs -mcpu=generic-rv64"
-cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR \
-  -DCOMPILER_RT_BUILD_BUILTINS=ON \
-  -DCOMPILER_RT_BUILD_LIBFUZZER=OFF \
-  -DCOMPILER_RT_BUILD_MEMPROF=OFF \
-  -DCOMPILER_RT_BUILD_PROFILE=OFF \
-  -DCOMPILER_RT_BUILD_SANITIZERS=OFF \
-  -DCOMPILER_RT_BUILD_XRAY=OFF \
-  -DCMAKE_C_COMPILER=$INSTALL_DIR/bin/clang \
-  -DCMAKE_C_COMPILER_TARGET="riscv64" \
-  -DCMAKE_ASM_COMPILER_TARGET="riscv64" \
-  -DCMAKE_AR=$INSTALL_DIR/bin/llvm-ar \
-  -DCMAKE_NM=$INSTALL_DIR/bin/llvm-nm \
-  -DCMAKE_RANLIB=$INSTALL_DIR/bin/llvm-ranlib \
-  -DCOMPILER_RT_BAREMETAL_BUILD=ON \
-  -DLLVM_CONFIG_PATH=$INSTALL_DIR/bin/llvm-config \
-  -DCMAKE_C_FLAGS="$CFLAGS" \
-  -DCMAKE_ASM_FLAGS="$CFLAGS" \
-  -DCOMPILER_RT_TEST_COMPILER=$INSTALL_DIR/bin/clang \
-  -DCMAKE_CXX_FLAGS="$CFLAGS" \
-  -DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON \
-  -DCMAKE_SYSTEM_NAME=Linux \
-  ..
-
-ninja
-ninja install
-
-
-echo ""
-echo "success"
-echo "add this directory to your PATH: ${INSTALL_DIR}/bin/"

crates/benchmarks/BENCHMARKS.md

@@ -1,125 +0,0 @@
-# Benchmarks
-
-## Table of Contents
-
-- [Benchmark Results](#benchmark-results)
-    - [Baseline](#baseline)
-    - [OddProduct](#oddproduct)
-    - [TriangleNumber](#trianglenumber)
-    - [FibonacciRecursive](#fibonaccirecursive)
-    - [FibonacciIterative](#fibonacciiterative)
-    - [FibonacciBinet](#fibonaccibinet)
-    - [SHA1](#sha1)
-    - [PrepareBaseline](#preparebaseline)
-    - [PrepareOddProduct](#prepareoddproduct)
-    - [PrepareTriangleNumber](#preparetrianglenumber)
-    - [PrepareFibonacciRecursive](#preparefibonaccirecursive)
-    - [PrepareFibonacciIterative](#preparefibonacciiterative)
-    - [PrepareFibonacciBinet](#preparefibonaccibinet)
-    - [PrepareSHA1](#preparesha1)
-
-## Benchmark Results
-
-### Baseline
-
-|         | `EVM`                     | `PVMInterpreter`                 | `PVM`                             |
-|:--------|:--------------------------|:---------------------------------|:--------------------------------- |
-| **`0`** | `855.27 ns` (✅ **1.00x**) | `729.35 ns` (✅ **1.17x faster**) | `23.19 us` (❌ *27.12x slower*)    |
-
-### OddProduct
-
-|                 | `EVM`                   | `PVMInterpreter`               | `PVM`                             |
-|:----------------|:------------------------|:-------------------------------|:--------------------------------- |
-| **`2000000`**   | `1.51 s` (✅ **1.00x**)  | `1.11 s` (✅ **1.35x faster**)  | `16.91 ms` (🚀 **89.26x faster**)  |
-| **`4000000`**   | `3.12 s` (✅ **1.00x**)  | `2.09 s` (✅ **1.49x faster**)  | `32.48 ms` (🚀 **96.10x faster**)  |
-| **`8000000`**   | `6.22 s` (✅ **1.00x**)  | `4.26 s` (✅ **1.46x faster**)  | `65.36 ms` (🚀 **95.23x faster**)  |
-| **`120000000`** | `90.60 s` (✅ **1.00x**) | `59.54 s` (✅ **1.52x faster**) | `1.02 s` (🚀 **89.00x faster**)    |
-
-### TriangleNumber
-
-|                 | `EVM`                   | `PVMInterpreter`               | `PVM`                             |
-|:----------------|:------------------------|:-------------------------------|:--------------------------------- |
-| **`3000000`**   | `1.45 s` (✅ **1.00x**)  | `1.01 s` (✅ **1.43x faster**)  | `20.83 ms` (🚀 **69.67x faster**)  |
-| **`6000000`**   | `2.92 s` (✅ **1.00x**)  | `2.08 s` (✅ **1.41x faster**)  | `41.97 ms` (🚀 **69.61x faster**)  |
-| **`12000000`**  | `5.88 s` (✅ **1.00x**)  | `4.05 s` (✅ **1.45x faster**)  | `83.03 ms` (🚀 **70.82x faster**)  |
-| **`180000000`** | `89.53 s` (✅ **1.00x**) | `59.08 s` (✅ **1.52x faster**) | `1.24 s` (🚀 **72.49x faster**)    |
-
-### FibonacciRecursive
-
-|          | `EVM`                     | `PVMInterpreter`                 | `PVM`                              |
-|:---------|:--------------------------|:---------------------------------|:---------------------------------- |
-| **`26`** | `200.07 ms` (✅ **1.00x**) | `478.04 ms` (❌ *2.39x slower*)   | `6.93 ms` (🚀 **28.88x faster**)    |
-| **`30`** | `1.37 s` (✅ **1.00x**)    | `3.36 s` (❌ *2.45x slower*)      | `45.17 ms` (🚀 **30.30x faster**)   |
-| **`34`** | `9.83 s` (✅ **1.00x**)    | `22.55 s` (❌ *2.29x slower*)     | `306.43 ms` (🚀 **32.08x faster**)  |
-| **`38`** | `66.98 s` (✅ **1.00x**)   | `150.55 s` (❌ *2.25x slower*)    | `2.22 s` (🚀 **30.21x faster**)     |
-
-### FibonacciIterative
-
-|                 | `EVM`                     | `PVMInterpreter`                 | `PVM`                             |
-|:----------------|:--------------------------|:---------------------------------|:--------------------------------- |
-| **`256`**       | `88.32 us` (✅ **1.00x**)  | `294.08 us` (❌ *3.33x slower*)   | `42.46 us` (🚀 **2.08x faster**)   |
-| **`100000`**    | `32.88 ms` (✅ **1.00x**)  | `121.70 ms` (❌ *3.70x slower*)   | `1.73 ms` (🚀 **18.97x faster**)   |
-| **`1000000`**   | `320.59 ms` (✅ **1.00x**) | `1.25 s` (❌ *3.89x slower*)      | `15.60 ms` (🚀 **20.55x faster**)  |
-| **`100000000`** | `33.09 s` (✅ **1.00x**)   | `125.08 s` (❌ *3.78x slower*)    | `1.49 s` (🚀 **22.18x faster**)    |
-
-### FibonacciBinet
-
-|           | `EVM`                    | `PVMInterpreter`                 | `PVM`                            |
-|:----------|:-------------------------|:---------------------------------|:-------------------------------- |
-| **`64`**  | `20.15 us` (✅ **1.00x**) | `129.45 us` (❌ *6.42x slower*)   | `39.56 us` (❌ *1.96x slower*)    |
-| **`128`** | `22.97 us` (✅ **1.00x**) | `150.62 us` (❌ *6.56x slower*)   | `40.13 us` (❌ *1.75x slower*)    |
-| **`256`** | `26.20 us` (✅ **1.00x**) | `165.38 us` (❌ *6.31x slower*)   | `39.70 us` (❌ *1.52x slower*)    |
-
-### SHA1
-
-|           | `EVM`                     | `PVMInterpreter`                 | `PVM`                             |
-|:----------|:--------------------------|:---------------------------------|:--------------------------------- |
-| **`1`**   | `216.56 us` (✅ **1.00x**) | `328.90 us` (❌ *1.52x slower*)   | `43.54 us` (🚀 **4.97x faster**)   |
-| **`64`**  | `442.13 us` (✅ **1.00x**) | `553.22 us` (❌ *1.25x slower*)   | `45.73 us` (🚀 **9.67x faster**)   |
-| **`512`** | `1.90 ms` (✅ **1.00x**)   | `2.27 ms` (❌ *1.19x slower*)     | `78.40 us` (🚀 **24.21x faster**)  |
-
-### PrepareBaseline
-
-|         | `Evm`                     | `PVMInterpreterCompile`          | `PVMInterpreterInstantiate`          | `PVMCompile`                      | `PVMInstantiate`                   |
-|:--------|:--------------------------|:---------------------------------|:-------------------------------------|:----------------------------------|:---------------------------------- |
-| **`0`** | `177.34 ns` (✅ **1.00x**) | `10.83 us` (❌ *61.07x slower*)   | `1.33 us` (❌ *7.49x slower*)         | `33.43 us` (❌ *188.48x slower*)   | `69.26 us` (❌ *390.56x slower*)    |
-
-### PrepareOddProduct
-
-|         | `Evm`                     | `PVMInterpreterCompile`          | `PVMInterpreterInstantiate`          | `PVMCompile`                     | `PVMInstantiate`                   |
-|:--------|:--------------------------|:---------------------------------|:-------------------------------------|:---------------------------------|:---------------------------------- |
-| **`0`** | `486.78 ns` (✅ **1.00x**) | `11.43 us` (❌ *23.49x slower*)   | `1.35 us` (❌ *2.78x slower*)         | `33.95 us` (❌ *69.75x slower*)   | `68.19 us` (❌ *140.07x slower*)    |
-
-### PrepareTriangleNumber
-
-|         | `Evm`                     | `PVMInterpreterCompile`          | `PVMInterpreterInstantiate`          | `PVMCompile`                      | `PVMInstantiate`                   |
-|:--------|:--------------------------|:---------------------------------|:-------------------------------------|:----------------------------------|:---------------------------------- |
-| **`0`** | `489.04 ns` (✅ **1.00x**) | `23.99 us` (❌ *49.06x slower*)   | `1.33 us` (❌ *2.72x slower*)         | `61.40 us` (❌ *125.56x slower*)   | `73.01 us` (❌ *149.29x slower*)    |
-
-### PrepareFibonacciRecursive
-
-|         | `Evm`                     | `PVMInterpreterCompile`          | `PVMInterpreterInstantiate`          | `PVMCompile`                      | `PVMInstantiate`                   |
-|:--------|:--------------------------|:---------------------------------|:-------------------------------------|:----------------------------------|:---------------------------------- |
-| **`0`** | `411.19 ns` (✅ **1.00x**) | `22.32 us` (❌ *54.27x slower*)   | `1.43 us` (❌ *3.49x slower*)         | `54.52 us` (❌ *132.59x slower*)   | `68.99 us` (❌ *167.77x slower*)    |
-
-### PrepareFibonacciIterative
-
-|         | `Evm`                     | `PVMInterpreterCompile`          | `PVMInterpreterInstantiate`          | `PVMCompile`                      | `PVMInstantiate`                   |
-|:--------|:--------------------------|:---------------------------------|:-------------------------------------|:----------------------------------|:---------------------------------- |
-| **`0`** | `313.74 ns` (✅ **1.00x**) | `19.15 us` (❌ *61.04x slower*)   | `1.39 us` (❌ *4.44x slower*)         | `48.30 us` (❌ *153.95x slower*)   | `69.20 us` (❌ *220.57x slower*)    |
-
-### PrepareFibonacciBinet
-
-|         | `Evm`                     | `PVMInterpreterCompile`          | `PVMInterpreterInstantiate`          | `PVMCompile`                      | `PVMInstantiate`                  |
-|:--------|:--------------------------|:---------------------------------|:-------------------------------------|:----------------------------------|:--------------------------------- |
-| **`0`** | `700.40 ns` (✅ **1.00x**) | `41.78 us` (❌ *59.65x slower*)   | `1.40 us` (❌ *2.00x slower*)         | `92.23 us` (❌ *131.69x slower*)   | `68.52 us` (❌ *97.83x slower*)    |
-
-### PrepareSHA1
-
-|         | `Evm`                   | `PVMInterpreterCompile`           | `PVMInterpreterInstantiate`          | `PVMCompile`                       | `PVMInstantiate`                  |
-|:--------|:------------------------|:----------------------------------|:-------------------------------------|:-----------------------------------|:--------------------------------- |
-| **`0`** | `1.77 us` (✅ **1.00x**) | `124.24 us` (❌ *70.39x slower*)   | `1.33 us` (✅ **1.33x faster**)       | `242.14 us` (❌ *137.19x slower*)   | `69.28 us` (❌ *39.25x slower*)    |
-
----
-Made with [criterion-table](https://github.com/nu11ptr/criterion-table)
-

crates/benchmarks/Cargo.toml

@@ -1,32 +0,0 @@
-[package]
-name = "revive-benchmarks"
-version = "0.1.0"
-edition = "2021"
-authors = [
-    "Cyrill Leutwiler <cyrill@parity.io>",
-]
-
-[features]
-default = ["bench-pvm-interpreter"]
-bench-pvm-interpreter = []
-bench-pvm = []
-bench-evm = ["revive-differential"]
-bench-extensive = []
-
-[dependencies]
-hex = { workspace = true }
-polkavm = { workspace = true }
-revive-integration = { path = "../integration" }
-revive-differential = { path = "../differential", optional = true }
-alloy-primitives = { workspace = true }
-
-[dev-dependencies]
-criterion = { workspace = true }
-
-[[bench]]
-name = "execute"
-harness = false
-
-[[bench]]
-name = "prepare"
-harness = false

crates/benchmarks/benches/execute.rs

@@ -1,185 +0,0 @@
-#[cfg(feature = "bench-extensive")]
-use std::time::Duration;
-
-use criterion::{
-    criterion_group, criterion_main, measurement::Measurement, BenchmarkGroup, BenchmarkId,
-    Criterion,
-};
-#[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-use polkavm::BackendKind;
-
-use revive_benchmarks::prepare_pvm;
-use revive_integration::cases::Contract;
-
-fn bench<P, L, I, M>(mut group: BenchmarkGroup<'_, M>, parameters: &[P], labels: &[L], contract: I)
-where
-    P: Clone,
-    L: std::fmt::Display,
-    I: Fn(P) -> Contract,
-    M: Measurement,
-{
-    assert_eq!(parameters.len(), labels.len());
-
-    for (p, l) in parameters.iter().zip(labels.iter()) {
-        #[cfg(feature = "bench-evm")]
-        {
-            let contract = contract(p.clone());
-            let vm = revive_differential::prepare(contract.evm_runtime, contract.calldata);
-            group.bench_with_input(BenchmarkId::new("EVM", l), p, move |b, _| {
-                b.iter(|| {
-                    revive_differential::execute(vm.clone());
-                });
-            });
-        }
-
-        #[cfg(feature = "bench-pvm-interpreter")]
-        {
-            let contract = contract(p.clone());
-            let (state, mut instance, export) = prepare_pvm(
-                &contract.pvm_runtime,
-                &contract.calldata,
-                BackendKind::Interpreter,
-            );
-            group.bench_with_input(BenchmarkId::new("PVMInterpreter", l), p, |b, _| {
-                b.iter(|| {
-                    revive_integration::mock_runtime::call(state.clone(), &mut instance, export);
-                });
-            });
-        }
-
-        #[cfg(feature = "bench-pvm")]
-        {
-            let contract = contract(p.clone());
-            let (state, mut instance, export) = prepare_pvm(
-                &contract.pvm_runtime,
-                &contract.calldata,
-                BackendKind::Compiler,
-            );
-            group.bench_with_input(BenchmarkId::new("PVM", l), p, |b, _| {
-                b.iter(|| {
-                    revive_integration::mock_runtime::call(state.clone(), &mut instance, export);
-                });
-            });
-        }
-    }
-
-    group.finish();
-}
-
-#[cfg(feature = "bench-extensive")]
-fn group_extensive<'error, M>(
-    c: &'error mut Criterion<M>,
-    group_name: &str,
-) -> BenchmarkGroup<'error, M>
-where
-    M: Measurement,
-{
-    let mut group = c.benchmark_group(group_name);
-    group
-        .sample_size(10)
-        .measurement_time(Duration::from_secs(60));
-    group
-}
-
-fn bench_baseline(c: &mut Criterion) {
-    let parameters = &[0u8];
-
-    bench(
-        c.benchmark_group("Baseline"),
-        parameters,
-        parameters,
-        |_| Contract::baseline(),
-    );
-}
-
-fn bench_odd_product(c: &mut Criterion) {
-    #[cfg(feature = "bench-extensive")]
-    let group = group_extensive(c, "OddProduct");
-    #[cfg(not(feature = "bench-extensive"))]
-    let group = c.benchmark_group("OddProduct");
-
-    #[cfg(feature = "bench-extensive")]
-    let parameters = &[2_000_000i32, 4_000_000, 8_000_000, 120_000_000];
-    #[cfg(not(feature = "bench-extensive"))]
-    let parameters = &[10_000, 100_000];
-
-    bench(group, parameters, parameters, Contract::odd_product);
-}
-
-fn bench_triangle_number(c: &mut Criterion) {
-    #[cfg(feature = "bench-extensive")]
-    let group = group_extensive(c, "TriangleNumber");
-    #[cfg(not(feature = "bench-extensive"))]
-    let group = c.benchmark_group("TriangleNumber");
-
-    #[cfg(feature = "bench-extensive")]
-    let parameters = &[3_000_000i64, 6_000_000, 12_000_000, 180_000_000];
-    #[cfg(not(feature = "bench-extensive"))]
-    let parameters = &[10_000, 100_000];
-
-    bench(group, parameters, parameters, Contract::triangle_number);
-}
-
-fn bench_fibonacci_recurisve(c: &mut Criterion) {
-    #[cfg(not(feature = "bench-extensive"))]
-    let group = c.benchmark_group("FibonacciRecursive");
-    #[cfg(feature = "bench-extensive")]
-    let group = group_extensive(c, "FibonacciRecursive");
-
-    #[cfg(feature = "bench-extensive")]
-    let parameters = &[26, 30, 34, 38];
-    #[cfg(not(feature = "bench-extensive"))]
-    let parameters = &[12, 16, 20];
-
-    bench(group, parameters, parameters, Contract::fib_recursive);
-}
-
-fn bench_fibonacci_iterative(c: &mut Criterion) {
-    #[cfg(not(feature = "bench-extensive"))]
-    let group = c.benchmark_group("FibonacciIterative");
-    #[cfg(feature = "bench-extensive")]
-    let group = group_extensive(c, "FibonacciIterative");
-
-    #[cfg(feature = "bench-extensive")]
-    let parameters = &[256, 100000, 1000000, 100000000];
-    #[cfg(not(feature = "bench-extensive"))]
-    let parameters = &[64, 128, 256];
-
-    bench(group, parameters, parameters, Contract::fib_iterative);
-}
-
-fn bench_fibonacci_binet(c: &mut Criterion) {
-    let parameters = &[64, 128, 256];
-
-    bench(
-        c.benchmark_group("FibonacciBinet"),
-        parameters,
-        parameters,
-        Contract::fib_binet,
-    );
-}
-
-fn bench_sha1(c: &mut Criterion) {
-    let parameters = &[vec![0xff], vec![0xff; 64], vec![0xff; 512]];
-    let labels = parameters.iter().map(|p| p.len()).collect::<Vec<_>>();
-
-    bench(
-        c.benchmark_group("SHA1"),
-        parameters,
-        &labels,
-        Contract::sha1,
-    );
-}
-
-criterion_group!(
-    name = execute;
-    config = Criterion::default();
-    targets = bench_baseline,
-    bench_odd_product,
-    bench_triangle_number,
-    bench_fibonacci_recurisve,
-    bench_fibonacci_iterative,
-    bench_fibonacci_binet,
-    bench_sha1
-);
-criterion_main!(execute);

crates/benchmarks/benches/prepare.rs

@@ -1,172 +0,0 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use polkavm::BackendKind;
-
-use revive_benchmarks::instantiate_engine;
-use revive_integration::cases::Contract;
-
-fn bench(
-    c: &mut Criterion,
-    group_name: &str,
-    #[cfg(feature = "bench-evm")] evm_runtime: Vec<u8>,
-    #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))] pvm_runtime: Vec<u8>,
-) {
-    let mut group = c.benchmark_group(group_name);
-    let code_size = 0;
-
-    #[cfg(feature = "bench-evm")]
-    group.bench_with_input(
-        BenchmarkId::new("Evm", code_size),
-        &evm_runtime,
-        |b, code| b.iter(|| revive_differential::prepare(code.clone(), Vec::new())),
-    );
-
-    #[cfg(feature = "bench-pvm-interpreter")]
-    {
-        let engine = instantiate_engine(BackendKind::Interpreter);
-        group.bench_with_input(
-            BenchmarkId::new("PVMInterpreterCompile", code_size),
-            &(&pvm_runtime, engine),
-            |b, (code, engine)| {
-                b.iter(|| {
-                    revive_integration::mock_runtime::recompile_code(code, engine);
-                });
-            },
-        );
-    }
-
-    #[cfg(feature = "bench-pvm-interpreter")]
-    {
-        let engine = instantiate_engine(BackendKind::Interpreter);
-        let module = revive_integration::mock_runtime::recompile_code(&pvm_runtime, &engine);
-        group.bench_with_input(
-            BenchmarkId::new("PVMInterpreterInstantiate", code_size),
-            &(module, engine),
-            |b, (module, engine)| {
-                b.iter(|| {
-                    revive_integration::mock_runtime::instantiate_module(module, engine);
-                });
-            },
-        );
-    }
-
-    #[cfg(feature = "bench-pvm")]
-    {
-        let engine = instantiate_engine(BackendKind::Compiler);
-        group.bench_with_input(
-            BenchmarkId::new("PVMCompile", code_size),
-            &(&pvm_runtime, engine),
-            |b, (code, engine)| {
-                b.iter(|| {
-                    revive_integration::mock_runtime::recompile_code(code, engine);
-                });
-            },
-        );
-    }
-
-    #[cfg(feature = "bench-pvm")]
-    {
-        let engine = instantiate_engine(BackendKind::Compiler);
-        let module = revive_integration::mock_runtime::recompile_code(&pvm_runtime, &engine);
-        group.bench_with_input(
-            BenchmarkId::new("PVMInstantiate", code_size),
-            &(module, engine),
-            |b, (module, engine)| {
-                b.iter(|| {
-                    revive_integration::mock_runtime::instantiate_module(module, engine);
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-fn bench_baseline(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareBaseline",
-        #[cfg(feature = "bench-evm")]
-        Contract::baseline().evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::baseline().pvm_runtime,
-    );
-}
-
-fn bench_odd_product(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareOddProduct",
-        #[cfg(feature = "bench-evm")]
-        Contract::odd_product(0).evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::baseline().pvm_runtime,
-    );
-}
-
-fn bench_triangle_number(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareTriangleNumber",
-        #[cfg(feature = "bench-evm")]
-        Contract::triangle_number(0).evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::triangle_number(0).pvm_runtime,
-    );
-}
-
-fn bench_fibonacci_recursive(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareFibonacciRecursive",
-        #[cfg(feature = "bench-evm")]
-        Contract::fib_recursive(0).evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::fib_recursive(0).pvm_runtime,
-    );
-}
-
-fn bench_fibonacci_iterative(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareFibonacciIterative",
-        #[cfg(feature = "bench-evm")]
-        Contract::fib_iterative(0).evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::fib_iterative(0).pvm_runtime,
-    );
-}
-
-fn bench_fibonacci_binet(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareFibonacciBinet",
-        #[cfg(feature = "bench-evm")]
-        Contract::fib_binet(0).evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::fib_binet(0).pvm_runtime,
-    );
-}
-
-fn bench_sha1(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareSHA1",
-        #[cfg(feature = "bench-evm")]
-        Contract::sha1(Default::default()).evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::sha1(Default::default()).pvm_runtime,
-    );
-}
-
-criterion_group!(
-    name = prepare;
-    config = Criterion::default();
-    targets = bench_baseline,
-    bench_odd_product,
-    bench_triangle_number,
-    bench_fibonacci_recursive,
-    bench_fibonacci_iterative,
-    bench_fibonacci_binet,
-    bench_sha1
-);
-criterion_main!(prepare);

crates/benchmarks/src/lib.rs

@@ -1,24 +0,0 @@
-use polkavm::{BackendKind, Config, Engine, ExportIndex, Instance, SandboxKind};
-use revive_integration::mock_runtime;
-use revive_integration::mock_runtime::State;
-
-pub fn prepare_pvm(
-    code: &[u8],
-    input: &[u8],
-    backend: BackendKind,
-) -> (State, Instance<State>, ExportIndex) {
-    let mut config = Config::new();
-    config.set_backend(Some(backend));
-    config.set_sandbox(Some(SandboxKind::Linux));
-
-    let (instance, export_index) = mock_runtime::prepare(code, Some(config));
-
-    (State::new(input.to_vec()), instance, export_index)
-}
-
-pub fn instantiate_engine(backend: BackendKind) -> Engine {
-    let mut config = Config::new();
-    config.set_backend(Some(backend));
-    config.set_sandbox(Some(SandboxKind::Linux));
-    mock_runtime::setup(Some(config))
-}

crates/builtins/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "revive-builtins"
-version = "0.1.0"
-edition = "2021"
-build = "build.rs"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]

crates/builtins/build.rs

@@ -1,31 +0,0 @@
-use std::{env, fs, io::Read, path::Path, process::Command};
-
-fn main() {
-    let lib = "libclang_rt.builtins-riscv64.a";
-    let mut llvm_lib_dir = String::new();
-
-    Command::new("llvm-config")
-        .args(["--libdir"])
-        .output()
-        .expect("llvm-config should be able to provide LD path")
-        .stdout
-        .as_slice()
-        .read_to_string(&mut llvm_lib_dir)
-        .expect("llvm-config output should be utf8");
-
-    let lib_path = std::path::PathBuf::from(llvm_lib_dir.trim())
-        .join("linux")
-        .join(lib);
-    let archive = fs::read(lib_path).expect("clang builtins for riscv64 not found");
-
-    let out_dir = env::var_os("OUT_DIR").expect("has OUT_DIR");
-    let archive_path = Path::new(&out_dir).join(lib);
-    let len = archive.len();
-    std::fs::write(archive_path, &archive).expect("can write to OUT_DIR");
-
-    let src_path = Path::new(&out_dir).join("compiler_rt.rs");
-    let src = format!("pub static COMPILER_RT: &[u8; {len}] = include_bytes!(\"{lib}\");");
-    fs::write(src_path, src).expect("can write to OUT_DIR");
-
-    println!("cargo:rerun-if-changed=build.rs");
-}

crates/builtins/src/lib.rs

@@ -1 +0,0 @@
-include!(concat!(env!("OUT_DIR"), "/compiler_rt.rs"));

crates/common/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,39 +0,0 @@
----
-name: Bug report
-about: Use this template for reporting issues
-title: ''
-labels: bug
-assignees: ''
----
-
-### 🐛 Bug Report
-
-#### 📝 Description
-
-Provide a clear and concise description of the bug.
-
-#### 🔄 Reproduction Steps
-
-Steps to reproduce the behaviour
-
-#### 🤔 Expected Behavior
-
-Describe what you expected to happen.
-
-#### 😯 Current Behavior
-
-Describe what actually happened.
-
-#### 🖥️ Environment
-
-Any relevant environment details.
-
-#### 📋 Additional Context
-
-Add any other context about the problem here. If applicable, add screenshots to help explain.
-
-#### 📎 Log Output
-
-```
-Paste any relevant log output here.
-```

crates/common/.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,21 +0,0 @@
----
-name: Feature request
-about: Use this template for requesting features
-title: ''
-labels: feat
-assignees: ''
----
-
-### 🌟 Feature Request
-
-#### 📝 Description
-
-Provide a clear and concise description of the feature you'd like to see.
-
-#### 🤔 Rationale
-
-Explain why this feature is important and how it benefits the project.
-
-#### 📋 Additional Context
-
-Add any other context or information about the feature request here.

crates/common/.github/pull_request_template.md

@@ -1,20 +0,0 @@
-# What ❔
-
-<!-- What are the changes this PR brings about? -->
-<!-- Example: This PR adds a PR template to the repo. -->
-<!-- (For bigger PRs adding more context is appreciated) -->
-
-## Why ❔
-
-<!-- Why are these changes done? What goal do they contribute to? What are the principles behind them? -->
-<!-- Example: PR templates ensure PR reviewers, observers, and future iterators are in context about the evolution of repos. -->
-
-## Checklist
-
-<!-- Check your PR fulfills the following items. -->
-<!-- For draft PRs check the boxes as you complete them. -->
-
-- [ ] PR title corresponds to the body of PR.
-- [ ] Tests for the changes have been added / updated.
-- [ ] Documentation comments have been added / updated.
-- [ ] Code has been formatted via `cargo fmt` and checked with `cargo clippy`.

crates/common/.github/workflows/cargo-license.yaml

@@ -1,9 +0,0 @@
-name: Cargo license check
-on: pull_request
-
-jobs:
-  cargo-deny:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    - uses: EmbarkStudios/cargo-deny-action@v1

crates/common/.github/workflows/ci.yaml

@@ -1,23 +0,0 @@
-name: "Rust CI"
-on:
-  pull_request:
-
-jobs:
-  build:
-    name: cargo build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-      - run: cargo build --verbose
-
-  formatting:
-    name: cargo fmt
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          components: rustfmt
-      - name: Rustfmt Check
-        uses: actions-rust-lang/rustfmt@v1

crates/common/.github/workflows/secrets_scanner.yaml

@@ -1,17 +0,0 @@
-name: Leaked Secrets Scan
-on: [pull_request]
-jobs:
-  TruffleHog:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@ac593985615ec2ede58e132d2e21d2b1cbd6127c # v3
-        with:
-          fetch-depth: 0
-      - name: TruffleHog OSS
-        uses: trufflesecurity/trufflehog@0c66d30c1f4075cee1aada2e1ab46dabb1b0071a
-        with:
-          path: ./
-          base: ${{ github.event.repository.default_branch }}
-          head: HEAD
-          extra_args: --debug --only-verified

crates/common/.gitignore

@@ -1,14 +0,0 @@
-# Generated by Cargo
-# will have compiled files and executables
-/target/
-
-# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
-# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
-Cargo.lock
-
-# These are backup files generated by rustfmt
-**/*.rs.bk
-
-# IDE
-/.idea/
-/.vscode/

crates/common/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "revive-common"
-version = "0.1.0"
-authors = [
-    "Cyrill Leutwiler <cyrill@parity.io>",
-    "Oleksandr Zarudnyi <a.zarudnyy@matterlabs.dev>",
-]
-license = "MIT OR Apache-2.0"
-edition = "2021"
-description = "Shared constants of the revive compiler"
-
-[lib]
-doctest = false
-
-[dependencies]
-anyhow = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true, features = [ "arbitrary_precision", "unbounded_depth" ] }
-serde_stacker = { workspace = true }

crates/common/README.md

@@ -1,35 +0,0 @@
-# zkSync Era: Compiler Common
-
-[![Logo](eraLogo.svg)](https://zksync.io/)
-
-zkSync Era is a layer 2 rollup that uses zero-knowledge proofs to scale Ethereum without compromising on security
-or decentralization. As it's EVM-compatible (with Solidity/Vyper), 99% of Ethereum projects can redeploy without
-needing to refactor or re-audit any code. zkSync Era also uses an LLVM-based compiler that will eventually enable
-developers to write smart contracts in popular languages such as C++ and Rust.
-
-This repository contains the common compiler constants.
-
-## License
-
-This library is distributed under the terms of either
-
-- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or <http://www.apache.org/licenses/LICENSE-2.0>)
-- MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)
-
-at your option.
-
-## Official Links
-
-- [Website](https://zksync.io/)
-- [GitHub](https://github.com/matter-labs)
-- [Twitter](https://twitter.com/zksync)
-- [Twitter for Devs](https://twitter.com/zkSyncDevs)
-- [Discord](https://join.zksync.dev/)
-
-## Disclaimer
-
-zkSync Era has been through extensive testing and audits, and although it is live, it is still in alpha state and
-will undergo further audits and bug bounty programs. We would love to hear our community's thoughts and suggestions
-about it!
-It's important to note that forking it now could potentially lead to missing important
-security updates, critical features, and performance improvements.

crates/common/src/base.rs

@@ -1,15 +0,0 @@
-//!
-//! The number base constants.
-//!
-
-/// The binary number base.
-pub const BASE_BINARY: u32 = 2;
-
-/// The octal number base.
-pub const BASE_OCTAL: u32 = 8;
-
-/// The decimal number base.
-pub const BASE_DECIMAL: u32 = 10;
-
-/// The hexadecimal number base.
-pub const BASE_HEXADECIMAL: u32 = 16;

crates/common/src/bit_length.rs

@@ -1,25 +0,0 @@
-//!
-//! The common sizes in bits.
-//!
-
-/// The `bool` type bit-length.
-pub const BIT_LENGTH_BOOLEAN: usize = 1;
-
-/// The `u8` type or byte bit-length.
-pub const BIT_LENGTH_BYTE: usize = 8;
-
-/// The x86 word type (usually `u32`) bit-length.
-pub const BIT_LENGTH_X32: usize = crate::byte_length::BYTE_LENGTH_X32 * BIT_LENGTH_BYTE;
-
-/// The x86_64 word type (usually `u64`) bit-length.
-pub const BIT_LENGTH_X64: usize = crate::byte_length::BYTE_LENGTH_X64 * BIT_LENGTH_BYTE;
-
-/// The ETH address (usually `u160`) bit-length.
-pub const BIT_LENGTH_ETH_ADDRESS: usize =
-    crate::byte_length::BYTE_LENGTH_ETH_ADDRESS * BIT_LENGTH_BYTE;
-
-/// The field (usually `u256` or `i256`) bit-length.
-pub const BIT_LENGTH_FIELD: usize = crate::byte_length::BYTE_LENGTH_FIELD * BIT_LENGTH_BYTE;
-
-/// Bit length of the runtime value type.
-pub const BIT_LENGTH_VALUE: usize = crate::byte_length::BYTE_LENGTH_VALUE * BIT_LENGTH_BYTE;

crates/common/src/byte_length.rs

@@ -1,24 +0,0 @@
-//!
-//! The common sizes in bytes.
-//!
-
-/// The byte-length.
-pub const BYTE_LENGTH_BYTE: usize = 1;
-
-/// The x86 word byte-length.
-pub const BYTE_LENGTH_X32: usize = 4;
-
-/// Native stack alignment size in bytes
-pub const BYTE_LENGTH_STACK_ALIGN: usize = BYTE_LENGTH_X64;
-
-/// The x86_64 word byte-length.
-pub const BYTE_LENGTH_X64: usize = 8;
-
-/// The ETH address byte-length.
-pub const BYTE_LENGTH_ETH_ADDRESS: usize = 20;
-
-/// The field byte-length.
-pub const BYTE_LENGTH_FIELD: usize = 32;
-
-/// Byte length of the runtime value type.
-pub const BYTE_LENGTH_VALUE: usize = 16;

crates/common/src/eravm/address.rs

@@ -1,117 +0,0 @@
-//!
-//! The EraVM address constants.
-//!
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_TO_L1: u16 = 0xFFFF;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_PRECOMPILE: u16 = 0xFFFD;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_META: u16 = 0xFFFC;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_MIMIC_CALL: u16 = 0xFFFB;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_SYSTEM_MIMIC_CALL: u16 = 0xFFFA;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_MIMIC_CALL_BYREF: u16 = 0xFFF9;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_SYSTEM_MIMIC_CALL_BYREF: u16 = 0xFFF8;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_RAW_FAR_CALL: u16 = 0xFFF7;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_RAW_FAR_CALL_BYREF: u16 = 0xFFF6;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_SYSTEM_CALL: u16 = 0xFFF5;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_SYSTEM_CALL_BYREF: u16 = 0xFFF4;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_SET_CONTEXT_VALUE_CALL: u16 = 0xFFF3;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_SET_PUBDATA_PRICE: u16 = 0xFFF2;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_INCREMENT_TX_COUNTER: u16 = 0xFFF1;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_GET_GLOBAL_PTR_CALLDATA: u16 = 0xFFF0;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_GET_GLOBAL_CALL_FLAGS: u16 = 0xFFEF;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_GET_GLOBAL_PTR_RETURN_DATA: u16 = 0xFFEE;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_EVENT_INITIALIZE: u16 = 0xFFED;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_EVENT_WRITE: u16 = 0xFFEC;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_ACTIVE_PTR_LOAD_CALLDATA: u16 = 0xFFEB;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_ACTIVE_PTR_LOAD_RETURN_DATA: u16 = 0xFFEA;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_ACTIVE_PTR_ADD: u16 = 0xFFE9;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_ACTIVE_PTR_SHRINK: u16 = 0xFFE8;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_ACTIVE_PTR_PACK: u16 = 0xFFE7;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_MULTIPLICATION_HIGH_REGISTER: u16 = 0xFFE6;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_GET_GLOBAL_EXTRA_ABI_DATA: u16 = 0xFFE5;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_ACTIVE_PTR_DATA_LOAD: u16 = 0xFFE4;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_ACTIVE_PTR_DATA_COPY: u16 = 0xFFE3;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_ACTIVE_PTR_DATA_SIZE: u16 = 0xFFE2;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_CONST_ARRAY_DECLARE: u16 = 0xFFE1;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_CONST_ARRAY_SET: u16 = 0xFFE0;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_CONST_ARRAY_FINALIZE: u16 = 0xFFDF;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_CONST_ARRAY_GET: u16 = 0xFFDE;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_DECOMMIT: u16 = 0xFFDD;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_ACTIVE_PTR_LOAD_DECOMMIT: u16 = 0xFFDC;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_RETURN_FORWARD: u16 = 0xFFDB;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_REVERT_FORWARD: u16 = 0xFFDA;
-
-/// The corresponding simulation predefined address.
-pub const ERAVM_ADDRESS_ACTIVE_PTR_SWAP: u16 = 0xFFD9;

crates/common/src/eravm/mod.rs

@@ -1,5 +0,0 @@
-//!
-//! The EraVM constants.
-//!
-
-pub mod address;

crates/common/src/evm_version.rs

@@ -1,91 +0,0 @@
-//!
-//! The EVM version.
-//!
-
-use serde::Deserialize;
-use serde::Serialize;
-
-///
-/// The EVM version.
-///
-#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[serde(rename_all = "camelCase")]
-pub enum EVMVersion {
-    /// The corresponding EVM version.
-    #[serde(rename = "homestead")]
-    Homestead,
-    /// The corresponding EVM version.
-    #[serde(rename = "tangerineWhistle")]
-    TangerineWhistle,
-    /// The corresponding EVM version.
-    #[serde(rename = "spuriousDragon")]
-    SpuriousDragon,
-    /// The corresponding EVM version.
-    #[serde(rename = "byzantium")]
-    Byzantium,
-    /// The corresponding EVM version.
-    #[serde(rename = "constantinople")]
-    Constantinople,
-    /// The corresponding EVM version.
-    #[serde(rename = "petersburg")]
-    Petersburg,
-    /// The corresponding EVM version.
-    #[serde(rename = "istanbul")]
-    Istanbul,
-    /// The corresponding EVM version.
-    #[serde(rename = "berlin")]
-    Berlin,
-    /// The corresponding EVM version.
-    #[serde(rename = "london")]
-    London,
-    /// The corresponding EVM version.
-    #[serde(rename = "paris")]
-    Paris,
-    /// The corresponding EVM version.
-    #[serde(rename = "shanghai")]
-    Shanghai,
-    /// The corresponding EVM version.
-    #[serde(rename = "cancun")]
-    Cancun,
-}
-
-impl TryFrom<&str> for EVMVersion {
-    type Error = anyhow::Error;
-
-    fn try_from(value: &str) -> Result<Self, Self::Error> {
-        Ok(match value {
-            "homestead" => Self::Homestead,
-            "tangerineWhistle" => Self::TangerineWhistle,
-            "spuriousDragon" => Self::SpuriousDragon,
-            "byzantium" => Self::Byzantium,
-            "constantinople" => Self::Constantinople,
-            "petersburg" => Self::Petersburg,
-            "istanbul" => Self::Istanbul,
-            "berlin" => Self::Berlin,
-            "london" => Self::London,
-            "paris" => Self::Paris,
-            "shanghai" => Self::Shanghai,
-            "cancun" => Self::Cancun,
-            _ => anyhow::bail!("Invalid EVM version: {}", value),
-        })
-    }
-}
-
-impl std::fmt::Display for EVMVersion {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Homestead => write!(f, "homestead"),
-            Self::TangerineWhistle => write!(f, "tangerineWhistle"),
-            Self::SpuriousDragon => write!(f, "spuriousDragon"),
-            Self::Byzantium => write!(f, "byzantium"),
-            Self::Constantinople => write!(f, "constantinople"),
-            Self::Petersburg => write!(f, "petersburg"),
-            Self::Istanbul => write!(f, "istanbul"),
-            Self::Berlin => write!(f, "berlin"),
-            Self::London => write!(f, "london"),
-            Self::Paris => write!(f, "paris"),
-            Self::Shanghai => write!(f, "shanghai"),
-            Self::Cancun => write!(f, "cancun"),
-        }
-    }
-}

crates/common/src/exit_code.rs

@@ -1,9 +0,0 @@
-//!
-//! The exit code constants.
-//!
-
-/// The common application success exit code.
-pub const EXIT_CODE_SUCCESS: i32 = 0;
-
-/// The common application failure exit code.
-pub const EXIT_CODE_FAILURE: i32 = 1;

crates/common/src/extension.rs

@@ -1,48 +0,0 @@
-//!
-//! The file extensions.
-//!
-
-/// The manifest file extension.
-pub static EXTENSION_MANIFEST: &str = "toml";
-
-/// The JSON data file extension.
-pub static EXTENSION_JSON: &str = "json";
-
-/// The ABI file extension.
-pub static EXTENSION_ABI: &str = "abi";
-
-/// The Yul IR file extension.
-pub static EXTENSION_YUL: &str = "yul";
-
-/// The EVM legacy assembly IR file extension.
-pub static EXTENSION_EVMLA: &str = "evmla";
-
-/// The Ethereal IR file extension.
-pub static EXTENSION_ETHIR: &str = "ethir";
-
-/// The EVM file extension.
-pub static EXTENSION_EVM: &str = "evm";
-
-/// The EVM bytecode file extension.
-pub static EXTENSION_EVM_BINARY: &str = "bin";
-
-/// The Solidity file extension.
-pub static EXTENSION_SOLIDITY: &str = "sol";
-
-/// The LLL IR file extension.
-pub static EXTENSION_LLL: &str = "lll";
-
-/// The Vyper file extension.
-pub static EXTENSION_VYPER: &str = "vy";
-
-/// The LLVM source code file extension.
-pub static EXTENSION_LLVM_SOURCE: &str = "ll";
-
-/// The LLVM bitcode file extension.
-pub static EXTENSION_LLVM_BINARY: &str = "bc";
-
-/// The EraVM assembly file extension.
-pub static EXTENSION_ERAVM_ASSEMBLY: &str = "zasm";
-
-/// The EraVM bytecode file extension.
-pub static EXTENSION_ERAVM_BINARY: &str = "zbin";

crates/common/src/lib.rs

@@ -1,21 +0,0 @@
-//!
-//! The compiler common library.
-//!
-
-pub(crate) mod base;
-pub(crate) mod bit_length;
-pub(crate) mod byte_length;
-pub(crate) mod eravm;
-pub(crate) mod evm_version;
-pub(crate) mod exit_code;
-pub(crate) mod extension;
-pub(crate) mod utils;
-
-pub use self::base::*;
-pub use self::bit_length::*;
-pub use self::byte_length::*;
-pub use self::eravm::address::*;
-pub use self::evm_version::EVMVersion;
-pub use self::exit_code::*;
-pub use self::extension::*;
-pub use self::utils::*;

crates/common/src/utils.rs

@@ -1,35 +0,0 @@
-//!
-//! The compiler common utils.
-//!
-
-///
-/// Deserializes a `serde_json` object from slice with the recursion limit disabled.
-///
-/// Must be used for all JSON I/O to avoid crashes due to the aforementioned limit.
-///
-pub fn deserialize_from_slice<O>(input: &[u8]) -> anyhow::Result<O>
-where
-    O: serde::de::DeserializeOwned,
-{
-    let mut deserializer = serde_json::Deserializer::from_slice(input);
-    deserializer.disable_recursion_limit();
-    let deserializer = serde_stacker::Deserializer::new(&mut deserializer);
-    let result = O::deserialize(deserializer)?;
-    Ok(result)
-}
-
-///
-/// Deserializes a `serde_json` object from string with the recursion limit disabled.
-///
-/// Must be used for all JSON I/O to avoid crashes due to the aforementioned limit.
-///
-pub fn deserialize_from_str<O>(input: &str) -> anyhow::Result<O>
-where
-    O: serde::de::DeserializeOwned,
-{
-    let mut deserializer = serde_json::Deserializer::from_str(input);
-    deserializer.disable_recursion_limit();
-    let deserializer = serde_stacker::Deserializer::new(&mut deserializer);
-    let result = O::deserialize(deserializer)?;
-    Ok(result)
-}

crates/differential/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "revive-differential"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-evm-interpreter = { workspace = true }
-primitive-types = { workspace = true }

crates/differential/src/lib.rs

@@ -1,154 +0,0 @@
-use evm_interpreter::{
-    interpreter::{EtableInterpreter, RunInterpreter},
-    trap::CallCreateTrap,
-    Context, Etable, ExitError, Log, Machine, RuntimeBackend, RuntimeBaseBackend,
-    RuntimeEnvironment, RuntimeState, TransactionContext, Valids,
-};
-use primitive_types::{H160, H256, U256};
-
-static RUNTIME_ETABLE: Etable<RuntimeState, UnimplementedHandler, CallCreateTrap> =
-    Etable::runtime();
-
-pub struct UnimplementedHandler;
-
-impl RuntimeEnvironment for UnimplementedHandler {
-    fn block_hash(&self, _number: U256) -> H256 {
-        unimplemented!()
-    }
-    fn block_number(&self) -> U256 {
-        unimplemented!()
-    }
-    fn block_coinbase(&self) -> H160 {
-        unimplemented!()
-    }
-    fn block_timestamp(&self) -> U256 {
-        unimplemented!()
-    }
-    fn block_difficulty(&self) -> U256 {
-        unimplemented!()
-    }
-    fn block_randomness(&self) -> Option<H256> {
-        unimplemented!()
-    }
-    fn block_gas_limit(&self) -> U256 {
-        unimplemented!()
-    }
-    fn block_base_fee_per_gas(&self) -> U256 {
-        unimplemented!()
-    }
-    fn chain_id(&self) -> U256 {
-        unimplemented!()
-    }
-}
-
-impl RuntimeBaseBackend for UnimplementedHandler {
-    fn balance(&self, _address: H160) -> U256 {
-        unimplemented!()
-    }
-    fn code_size(&self, _address: H160) -> U256 {
-        unimplemented!()
-    }
-    fn code_hash(&self, _address: H160) -> H256 {
-        unimplemented!()
-    }
-    fn code(&self, _address: H160) -> Vec<u8> {
-        unimplemented!()
-    }
-    fn storage(&self, _address: H160, _index: H256) -> H256 {
-        unimplemented!()
-    }
-
-    fn exists(&self, _address: H160) -> bool {
-        unimplemented!()
-    }
-
-    fn nonce(&self, _address: H160) -> U256 {
-        unimplemented!()
-    }
-}
-
-impl RuntimeBackend for UnimplementedHandler {
-    fn original_storage(&self, _address: H160, _index: H256) -> H256 {
-        unimplemented!()
-    }
-
-    fn deleted(&self, _address: H160) -> bool {
-        unimplemented!()
-    }
-    fn is_cold(&self, _address: H160, _index: Option<H256>) -> bool {
-        unimplemented!()
-    }
-
-    fn mark_hot(&mut self, _address: H160, _index: Option<H256>) {
-        unimplemented!()
-    }
-
-    fn set_storage(&mut self, _address: H160, _index: H256, _value: H256) -> Result<(), ExitError> {
-        unimplemented!()
-    }
-    fn log(&mut self, _log: Log) -> Result<(), ExitError> {
-        unimplemented!()
-    }
-    fn mark_delete(&mut self, _address: H160) {
-        unimplemented!()
-    }
-
-    fn reset_storage(&mut self, _address: H160) {
-        unimplemented!()
-    }
-
-    fn set_code(&mut self, _address: H160, _code: Vec<u8>) -> Result<(), ExitError> {
-        unimplemented!()
-    }
-    fn reset_balance(&mut self, _address: H160) {
-        unimplemented!()
-    }
-
-    fn deposit(&mut self, _address: H160, _value: U256) {
-        unimplemented!()
-    }
-    fn withdrawal(&mut self, _address: H160, _value: U256) -> Result<(), ExitError> {
-        unimplemented!()
-    }
-
-    fn inc_nonce(&mut self, _address: H160) -> Result<(), ExitError> {
-        unimplemented!()
-    }
-}
-
-#[derive(Clone)]
-pub struct PreparedEvm {
-    pub valids: Valids,
-    pub vm: Machine<RuntimeState>,
-}
-
-pub fn prepare(code: Vec<u8>, data: Vec<u8>) -> PreparedEvm {
-    let state = RuntimeState {
-        context: Context {
-            address: H160::default(),
-            caller: H160::default(),
-            apparent_value: U256::default(),
-        },
-        transaction_context: TransactionContext {
-            gas_price: U256::default(),
-            origin: H160::default(),
-        }
-        .into(),
-        retbuf: Vec::new(),
-    };
-
-    PreparedEvm {
-        valids: Valids::new(&code[..]),
-        vm: evm_interpreter::Machine::new(code.into(), data.to_vec().into(), 1024, 0xFFFF, state),
-    }
-}
-
-pub fn execute(pre: PreparedEvm) -> Vec<u8> {
-    let mut vm = EtableInterpreter::new_valid(pre.vm, &RUNTIME_ETABLE, pre.valids);
-    vm.run(&mut UnimplementedHandler {})
-        .exit()
-        .unwrap()
-        .unwrap();
-
-    vm.retval.clone()
-}

crates/extensions/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "revive-extensions"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-inkwell = { workspace = true, features = ["target-riscv", "no-libffi-linking", "llvm18-0"] }

crates/extensions/bswap.ll

@@ -1,15 +0,0 @@
-; target datalayout = "e-m:e-p:32:32-i64:64-n32-S128"
-; target triple = "riscv32-unknown-unknown-elf"
-target datalayout = "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128"
-target triple = "riscv64-unknown-unknown-elf"
-
-define dso_local noundef i256 @__bswap(i256 noundef %0) local_unnamed_addr #0 {
-  %2 = tail call i256 @llvm.bswap.i256(i256 %0)
-  ret i256 %2
-}
-
-; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
-declare i256 @llvm.bswap.i256(i256) #1
-
-attributes #0 = { alwaysinline mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
-attributes #1 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }

crates/extensions/build.rs

@@ -1,40 +0,0 @@
-use std::{env, fs, path::Path, process::Command};
-
-fn compile(source_path: &str, output_path: &str) {
-    let output = Command::new("llc")
-        .args([
-            "-O3",
-            "-filetype=asm",
-            "-mattr=+zbb,+e",
-            source_path,
-            "-o",
-            output_path,
-        ])
-        .output()
-        .expect("should be able to invoke llc");
-
-    assert!(
-        output.status.success(),
-        "failed to compile {}: {:?}",
-        source_path,
-        output
-    );
-}
-
-fn main() {
-    let in_file = "bswap.ll";
-    let out_file = "bswap.s";
-    let out_dir = env::var_os("OUT_DIR").expect("env should have $OUT_DIR");
-    let out_path = Path::new(&out_dir).join(out_file);
-    compile(
-        in_file,
-        out_path.to_str().expect("$OUT_DIR should be UTF-8"),
-    );
-
-    let src_path = Path::new(&out_dir).join("bswap.rs");
-    let src = format!("pub static ASSEMBLY: &str = include_str!(\"{out_file}\");");
-    fs::write(src_path, src).expect("should be able to write in $OUT_DIR");
-
-    println!("cargo:rerun-if-changed=build.rs");
-    println!("cargo:rerun-if-changed=bswap.ll");
-}

crates/extensions/src/lib.rs

@@ -1,40 +0,0 @@
-//! Custom RISC-V extension in PolkaVM that are partially supported.
-//! We use inline assembly to emit partially supported instructions.
-
-use inkwell::{context::Context, module::Module, support::LLVMString};
-
-include!(concat!(env!("OUT_DIR"), "/bswap.rs"));
-
-/// Returns a LLVM module containing a `__bswap` function, which
-/// - Takes a `i256` value argument
-/// - Byte swaps it using `rev8` from the `zbb` extension
-/// - Returns the `i256` value
-///
-/// Returns `Error` if the module fails to validate, which should never happen.
-pub fn module<'context>(
-    context: &'context Context,
-    module_name: &str,
-) -> Result<Module<'context>, LLVMString> {
-    let module = context.create_module(module_name);
-
-    module.set_inline_assembly(ASSEMBLY);
-    module.verify()?;
-
-    Ok(module)
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn assembly_contains_rev8_instruction() {
-        assert!(crate::ASSEMBLY.contains("rev8"));
-    }
-
-    #[test]
-    fn module_is_valid() {
-        inkwell::targets::Target::initialize_riscv(&Default::default());
-        let context = inkwell::context::Context::create();
-
-        assert!(crate::module(&context, "polkavm_bswap").is_ok());
-    }
-}

crates/integration/Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-name = "revive-integration"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-polkavm = { workspace = true }
-alloy-primitives = { workspace = true }
-alloy-sol-types = { workspace = true }
-hex = { workspace = true }
-env_logger = { workspace = true }
-
-revive-solidity = { path = "../solidity" }
-revive-differential = { path = "../differential" }
-era-compiler-llvm-context = { path = "../llvm-context" }
-
-[dev-dependencies]
-sha1 = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }

crates/integration/codesize.json

@@ -1,7 +0,0 @@
-{
-  "Flipper": 3958,
-  "Baseline": 3551,
-  "Computation": 5912,
-  "Fibonacci": 4909,
-  "ERC20": 1966
-}

crates/integration/contracts/Baseline.sol

@@ -1,7 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.24;
-
-contract Baseline {
-    function baseline() public payable {}
-}

crates/integration/contracts/Computation.sol

@@ -1,23 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.24;
-
-contract Computation {
-    function triangle_number(int64 n) public pure returns (int64 sum) {
-        unchecked {
-            for (int64 x = 1; x <= n; x++) {
-                sum += x;
-            }
-        }
-    }
-
-    function odd_product(int32 n) public pure returns (int64) {
-        unchecked {
-            int64 prod = 1;
-            for (int32 x = 1; x <= n; x++) {
-                prod *= 2 * int64(x) - 1;
-            }
-            return prod;
-        }
-    }
-}

crates/integration/contracts/ERC20.sol

@@ -1,74 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.20;
-
-// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.0.0/contracts/token/ERC20/IERC20.sol
-interface IERC20 {
-    function totalSupply() external view returns (uint);
-
-    function balanceOf(address account) external view returns (uint);
-
-    function transfer(address recipient, uint amount) external returns (bool);
-
-    function allowance(
-        address owner,
-        address spender
-    ) external view returns (uint);
-
-    function approve(address spender, uint amount) external returns (bool);
-
-    function transferFrom(
-        address sender,
-        address recipient,
-        uint amount
-    ) external returns (bool);
-
-    event Transfer(address indexed from, address indexed to, uint value);
-    event Approval(address indexed owner, address indexed spender, uint value);
-}
-
-contract ERC20 is IERC20 {
-    uint public totalSupply;
-    mapping(address => uint) public balanceOf;
-    mapping(address => mapping(address => uint)) public allowance;
-    string public name = "Solidity by Example";
-    string public symbol = "SOLBYEX";
-    uint8 public decimals = 18;
-
-    function transfer(address recipient, uint amount) external returns (bool) {
-        balanceOf[msg.sender] -= amount;
-        balanceOf[recipient] += amount;
-        emit Transfer(msg.sender, recipient, amount);
-        return true;
-    }
-
-    function approve(address spender, uint amount) external returns (bool) {
-        allowance[msg.sender][spender] = amount;
-        emit Approval(msg.sender, spender, amount);
-        return true;
-    }
-
-    function transferFrom(
-        address sender,
-        address recipient,
-        uint amount
-    ) external returns (bool) {
-        allowance[sender][msg.sender] -= amount;
-        balanceOf[sender] -= amount;
-        balanceOf[recipient] += amount;
-        emit Transfer(sender, recipient, amount);
-        return true;
-    }
-
-    function mint(uint amount) external {
-        balanceOf[msg.sender] += amount;
-        totalSupply += amount;
-        emit Transfer(address(0), msg.sender, amount);
-    }
-
-    function burn(uint amount) external {
-        balanceOf[msg.sender] -= amount;
-        totalSupply -= amount;
-        emit Transfer(msg.sender, address(0), amount);
-    }
-}

crates/integration/contracts/Fibonacci.sol

@@ -1,67 +0,0 @@
-// SPDX-License-Identifier: UNLICENSED
-
-pragma solidity ^0.8.24;
-
-// https://medium.com/coinmonks/fibonacci-in-solidity-8477d907e22a
-
-contract FibonacciRecursive {
-    function f(uint n) internal pure returns (uint) {
-        if (n <= 1) {
-            return n;
-        } else {
-            return f(n - 1) + f(n - 2);
-        }
-    }
-
-    function fib3(uint n) public pure returns (uint) {
-        return f(n);
-    }
-}
-
-contract FibonacciIterative {
-    function fib3(uint n) external pure returns (uint b) {
-        if (n == 0) {
-            return 0;
-        }
-        uint a = 1;
-        b = 1;
-        for (uint i = 2; i < n; i++) {
-            unchecked {
-                uint c = a + b;
-                a = b;
-                b = c;
-            }
-        }
-        return b;
-    }
-}
-
-contract FibonacciBinet {
-    function fib3(uint n) external pure returns (uint a) {
-        if (n == 0) {
-            return 0;
-        }
-        uint h = n / 2;
-        uint mask = 1;
-        // find highest set bit in n
-        while (mask <= h) {
-            mask <<= 1;
-        }
-        mask >>= 1;
-        a = 1;
-        uint b = 1;
-        uint c;
-        while (mask > 0) {
-            c = a * a + b * b;
-            if (n & mask > 0) {
-                b = b * (b + 2 * a);
-                a = c;
-            } else {
-                a = a * (2 * b - a);
-                b = c;
-            }
-            mask >>= 1;
-        }
-        return a;
-    }
-}

crates/integration/contracts/MSize.sol

@@ -1,20 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.24;
-
-contract MSize {
-    uint[] public data;
-
-    function mSize() public pure returns (uint size) {
-        assembly {
-            size := msize()
-        }
-    }
-
-    function mStore100() public pure returns (uint size) {
-        assembly {
-            mstore(100, msize())
-            size := msize()
-        }
-    }
-}

crates/integration/contracts/SHA1.sol

@@ -1,240 +0,0 @@
-// SPDX-License-Identifier: BSD-2-Clause
-pragma solidity ^0.8.4;
-
-contract SHA1 {
-    function sha1(bytes memory data) public pure returns (bytes20 ret) {
-        assembly {
-            // Get a safe scratch location
-            let scratch := mload(0x40)
-
-            // Get the data length, and point data at the first byte
-            let len := mload(data)
-            data := add(data, 32)
-
-            // Find the length after padding
-            let totallen := add(and(add(len, 1), 0xFFFFFFFFFFFFFFC0), 64)
-            switch lt(sub(totallen, len), 9)
-            case 1 {
-                totallen := add(totallen, 64)
-            }
-
-            let h := 0x6745230100EFCDAB890098BADCFE001032547600C3D2E1F0
-
-            function readword(ptr, off, count) -> result {
-                result := 0
-                if lt(off, count) {
-                    result := mload(add(ptr, off))
-                    count := sub(count, off)
-                    if lt(count, 32) {
-                        let mask := not(sub(exp(256, sub(32, count)), 1))
-                        result := and(result, mask)
-                    }
-                }
-            }
-
-            for {
-                let i := 0
-            } lt(i, totallen) {
-                i := add(i, 64)
-            } {
-                mstore(scratch, readword(data, i, len))
-                mstore(add(scratch, 32), readword(data, add(i, 32), len))
-
-                // If we loaded the last byte, store the terminator byte
-                switch lt(sub(len, i), 64)
-                case 1 {
-                    mstore8(add(scratch, sub(len, i)), 0x80)
-                }
-
-                // If this is the last block, store the length
-                switch eq(i, sub(totallen, 64))
-                case 1 {
-                    mstore(
-                        add(scratch, 32),
-                        or(mload(add(scratch, 32)), mul(len, 8))
-                    )
-                }
-
-                // Expand the 16 32-bit words into 80
-                for {
-                    let j := 64
-                } lt(j, 128) {
-                    j := add(j, 12)
-                } {
-                    let temp := xor(
-                        xor(
-                            mload(add(scratch, sub(j, 12))),
-                            mload(add(scratch, sub(j, 32)))
-                        ),
-                        xor(
-                            mload(add(scratch, sub(j, 56))),
-                            mload(add(scratch, sub(j, 64)))
-                        )
-                    )
-                    temp := or(
-                        and(
-                            mul(temp, 2),
-                            0xFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFE
-                        ),
-                        and(
-                            div(temp, 0x80000000),
-                            0x0000000100000001000000010000000100000001000000010000000100000001
-                        )
-                    )
-                    mstore(add(scratch, j), temp)
-                }
-                for {
-                    let j := 128
-                } lt(j, 320) {
-                    j := add(j, 24)
-                } {
-                    let temp := xor(
-                        xor(
-                            mload(add(scratch, sub(j, 24))),
-                            mload(add(scratch, sub(j, 64)))
-                        ),
-                        xor(
-                            mload(add(scratch, sub(j, 112))),
-                            mload(add(scratch, sub(j, 128)))
-                        )
-                    )
-                    temp := or(
-                        and(
-                            mul(temp, 4),
-                            0xFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFC
-                        ),
-                        and(
-                            div(temp, 0x40000000),
-                            0x0000000300000003000000030000000300000003000000030000000300000003
-                        )
-                    )
-                    mstore(add(scratch, j), temp)
-                }
-
-                let x := h
-                let f := 0
-                let k := 0
-                for {
-                    let j := 0
-                } lt(j, 80) {
-                    j := add(j, 1)
-                } {
-                    switch div(j, 20)
-                    case 0 {
-                        // f = d xor (b and (c xor d))
-                        f := xor(
-                            div(x, 0x100000000000000000000),
-                            div(x, 0x10000000000)
-                        )
-                        f := and(div(x, 0x1000000000000000000000000000000), f)
-                        f := xor(div(x, 0x10000000000), f)
-                        k := 0x5A827999
-                    }
-                    case 1 {
-                        // f = b xor c xor d
-                        f := xor(
-                            div(x, 0x1000000000000000000000000000000),
-                            div(x, 0x100000000000000000000)
-                        )
-                        f := xor(div(x, 0x10000000000), f)
-                        k := 0x6ED9EBA1
-                    }
-                    case 2 {
-                        // f = (b and c) or (d and (b or c))
-                        f := or(
-                            div(x, 0x1000000000000000000000000000000),
-                            div(x, 0x100000000000000000000)
-                        )
-                        f := and(div(x, 0x10000000000), f)
-                        f := or(
-                            and(
-                                div(x, 0x1000000000000000000000000000000),
-                                div(x, 0x100000000000000000000)
-                            ),
-                            f
-                        )
-                        k := 0x8F1BBCDC
-                    }
-                    case 3 {
-                        // f = b xor c xor d
-                        f := xor(
-                            div(x, 0x1000000000000000000000000000000),
-                            div(x, 0x100000000000000000000)
-                        )
-                        f := xor(div(x, 0x10000000000), f)
-                        k := 0xCA62C1D6
-                    }
-                    // temp = (a leftrotate 5) + f + e + k + w[i]
-                    let temp := and(
-                        div(
-                            x,
-                            0x80000000000000000000000000000000000000000000000
-                        ),
-                        0x1F
-                    )
-                    temp := or(
-                        and(
-                            div(x, 0x800000000000000000000000000000000000000),
-                            0xFFFFFFE0
-                        ),
-                        temp
-                    )
-                    temp := add(f, temp)
-                    temp := add(and(x, 0xFFFFFFFF), temp)
-                    temp := add(k, temp)
-                    temp := add(
-                        div(
-                            mload(add(scratch, mul(j, 4))),
-                            0x100000000000000000000000000000000000000000000000000000000
-                        ),
-                        temp
-                    )
-                    x := or(
-                        div(x, 0x10000000000),
-                        mul(temp, 0x10000000000000000000000000000000000000000)
-                    )
-                    x := or(
-                        and(
-                            x,
-                            0xFFFFFFFF00FFFFFFFF000000000000FFFFFFFF00FFFFFFFF
-                        ),
-                        mul(
-                            or(
-                                and(div(x, 0x4000000000000), 0xC0000000),
-                                and(div(x, 0x400000000000000000000), 0x3FFFFFFF)
-                            ),
-                            0x100000000000000000000
-                        )
-                    )
-                }
-
-                h := and(
-                    add(h, x),
-                    0xFFFFFFFF00FFFFFFFF00FFFFFFFF00FFFFFFFF00FFFFFFFF
-                )
-            }
-            ret := mul(
-                or(
-                    or(
-                        or(
-                            or(
-                                and(
-                                    div(h, 0x100000000),
-                                    0xFFFFFFFF00000000000000000000000000000000
-                                ),
-                                and(
-                                    div(h, 0x1000000),
-                                    0xFFFFFFFF000000000000000000000000
-                                )
-                            ),
-                            and(div(h, 0x10000), 0xFFFFFFFF0000000000000000)
-                        ),
-                        and(div(h, 0x100), 0xFFFFFFFF00000000)
-                    ),
-                    and(h, 0xFFFFFFFF)
-                ),
-                0x1000000000000000000000000
-            )
-        }
-    }
-}

crates/integration/contracts/Value.sol

@@ -1,9 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.24;
-
-contract Value {
-    function value() public payable returns (uint ret) {
-        ret = msg.value;
-    }
-}

crates/integration/contracts/flipper.sol

@@ -1,10 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.24;
-
-contract Flipper {
-    bool coin;
-
-    function flip() public {
-        coin = !coin;
-    }
-}

crates/integration/contracts/mStore8.sol

@@ -1,12 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.24;
-
-contract MStore8 {
-    function mStore8(uint value) public pure returns (uint256 word) {
-        assembly {
-            mstore8(0x80, value)
-            word := mload(0x80)
-        }
-    }
-}

crates/integration/src/cases.rs

@@ -1,220 +0,0 @@
-use alloy_primitives::U256;
-use alloy_sol_types::{sol, SolCall};
-
-#[derive(Clone)]
-pub struct Contract {
-    pub evm_runtime: Vec<u8>,
-    pub pvm_runtime: Vec<u8>,
-    pub calldata: Vec<u8>,
-}
-
-sol!(contract Baseline { function baseline() public payable; });
-
-sol!(contract Flipper { function flip() public; });
-
-sol!(contract Computation {
-    function odd_product(int32 n) public pure returns (int64);
-    function triangle_number(int64 n) public pure returns (int64 sum);
-});
-
-sol!(
-    contract FibonacciRecursive {
-        function fib3(uint n) public pure returns (uint);
-    }
-);
-
-sol!(
-    contract FibonacciIterative {
-        function fib3(uint n) external pure returns (uint b);
-    }
-);
-
-sol!(
-    contract FibonacciBinet {
-        function fib3(uint n) external pure returns (uint a);
-    }
-);
-
-sol!(
-    contract SHA1 {
-        function sha1(bytes memory data) public pure returns (bytes20 ret);
-    }
-);
-
-sol!(
-    interface IERC20 {
-        function totalSupply() external view returns (uint);
-
-        function balanceOf(address account) external view returns (uint);
-
-        function transfer(address recipient, uint amount) external returns (bool);
-
-        function allowance(
-            address owner,
-            address spender
-        ) external view returns (uint);
-
-        function approve(address spender, uint amount) external returns (bool);
-
-        function transferFrom(
-            address sender,
-            address recipient,
-            uint amount
-        ) external returns (bool);
-
-        event Transfer(address indexed from, address indexed to, uint value);
-        event Approval(address indexed owner, address indexed spender, uint value);
-    }
-);
-
-impl Contract {
-    pub fn baseline() -> Self {
-        let code = include_str!("../contracts/Baseline.sol");
-        let name = "Baseline";
-
-        Self {
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: Baseline::baselineCall::new(()).abi_encode(),
-        }
-    }
-
-    pub fn odd_product(n: i32) -> Self {
-        let code = include_str!("../contracts/Computation.sol");
-        let name = "Computation";
-
-        Self {
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: Computation::odd_productCall::new((n,)).abi_encode(),
-        }
-    }
-
-    pub fn triangle_number(n: i64) -> Self {
-        let code = include_str!("../contracts/Computation.sol");
-        let name = "Computation";
-
-        Self {
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: Computation::triangle_numberCall::new((n,)).abi_encode(),
-        }
-    }
-
-    pub fn fib_recursive(n: u32) -> Self {
-        let code = include_str!("../contracts/Fibonacci.sol");
-        let name = "FibonacciRecursive";
-
-        Self {
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: FibonacciRecursive::fib3Call::new((U256::from(n),)).abi_encode(),
-        }
-    }
-
-    pub fn fib_iterative(n: u32) -> Self {
-        let code = include_str!("../contracts/Fibonacci.sol");
-        let name = "FibonacciIterative";
-
-        Self {
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: FibonacciIterative::fib3Call::new((U256::from(n),)).abi_encode(),
-        }
-    }
-
-    pub fn fib_binet(n: u32) -> Self {
-        let code = include_str!("../contracts/Fibonacci.sol");
-        let name = "FibonacciBinet";
-
-        Self {
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: FibonacciBinet::fib3Call::new((U256::from(n),)).abi_encode(),
-        }
-    }
-
-    pub fn sha1(pre: Vec<u8>) -> Self {
-        let code = include_str!("../contracts/SHA1.sol");
-        let name = "SHA1";
-
-        Self {
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: SHA1::sha1Call::new((pre,)).abi_encode(),
-        }
-    }
-
-    pub fn flipper() -> Self {
-        let code = include_str!("../contracts/flipper.sol");
-        let name = "Flipper";
-
-        Self {
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: Flipper::flipCall::new(()).abi_encode(),
-        }
-    }
-
-    pub fn erc20() -> Self {
-        let code = include_str!("../contracts/ERC20.sol");
-        let name = "ERC20";
-
-        Self {
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: IERC20::totalSupplyCall::new(()).abi_encode(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use serde::{de::Deserialize, Serialize};
-    use std::{collections::HashMap, fs::File};
-
-    use super::Contract;
-
-    #[test]
-    fn codesize() {
-        let path = "codesize.json";
-
-        let existing = File::open(path)
-            .map(|file| {
-                HashMap::<String, usize>::deserialize(&mut serde_json::Deserializer::from_reader(
-                    file,
-                ))
-                .expect("should be able to deserialze codesize data")
-            })
-            .ok();
-
-        let sizes = HashMap::from([
-            ("Baseline", Contract::baseline().pvm_runtime.len()),
-            ("Flipper", Contract::flipper().pvm_runtime.len()),
-            ("Computation", Contract::odd_product(0).pvm_runtime.len()),
-            ("Fibonacci", Contract::fib_iterative(0).pvm_runtime.len()),
-            ("ERC20", Contract::erc20().pvm_runtime.len()),
-        ]);
-
-        for (name, bytes) in sizes.iter() {
-            let change = existing
-                .as_ref()
-                .and_then(|map| map.get(*name))
-                .map(|old| {
-                    let new = *bytes as f32;
-                    let old = *old as f32;
-                    let p = (new - old) / new * 100.0;
-                    format!("({p}% change from {old} bytes)")
-                })
-                .unwrap_or_default();
-
-            println!("{name}: {bytes} bytes {change}");
-        }
-
-        sizes
-            .serialize(&mut serde_json::Serializer::pretty(
-                File::create(path).unwrap(),
-            ))
-            .unwrap_or_else(|err| panic!("can not write codesize data to '{}': {}", path, err));
-    }
-}

crates/integration/src/lib.rs

@@ -1,85 +0,0 @@
-use cases::Contract;
-use mock_runtime::State;
-
-pub mod cases;
-pub mod mock_runtime;
-
-#[cfg(test)]
-mod tests;
-
-/// Compile the blob of `contract_name` found in given `source_code`.
-/// The `solc` optimizer will be enabled
-pub fn compile_blob(contract_name: &str, source_code: &str) -> Vec<u8> {
-    compile_blob_with_options(
-        contract_name,
-        source_code,
-        true,
-        revive_solidity::SolcPipeline::Yul,
-    )
-}
-
-/// Compile the EVM bin-runtime of `contract_name` found in given `source_code`.
-/// The `solc` optimizer will be enabled
-pub fn compile_evm_bin_runtime(contract_name: &str, source_code: &str) -> Vec<u8> {
-    let file_name = "contract.sol";
-
-    let contracts = revive_solidity::test_utils::build_solidity_with_options_evm(
-        [(file_name.into(), source_code.into())].into(),
-        Default::default(),
-        None,
-        revive_solidity::SolcPipeline::Yul,
-        true,
-    )
-    .expect("source should compile");
-    let bin_runtime = &contracts
-        .get(contract_name)
-        .unwrap_or_else(|| panic!("contract '{}' didn't produce bin-runtime", contract_name))
-        .object;
-
-    hex::decode(bin_runtime).expect("bin-runtime shold be hex encoded")
-}
-
-/// Compile the blob of `contract_name` found in given `source_code`.
-pub fn compile_blob_with_options(
-    contract_name: &str,
-    source_code: &str,
-    solc_optimizer_enabled: bool,
-    pipeline: revive_solidity::SolcPipeline,
-) -> Vec<u8> {
-    let file_name = "contract.sol";
-
-    let contracts = revive_solidity::test_utils::build_solidity_with_options(
-        [(file_name.into(), source_code.into())].into(),
-        Default::default(),
-        None,
-        pipeline,
-        era_compiler_llvm_context::OptimizerSettings::cycles(),
-        solc_optimizer_enabled,
-    )
-    .expect("source should compile")
-    .contracts
-    .expect("source should contain at least one contract");
-
-    let bytecode = contracts[file_name][contract_name]
-        .evm
-        .as_ref()
-        .expect("source should produce EVM output")
-        .assembly_text
-        .as_ref()
-        .expect("source should produce assembly text");
-
-    hex::decode(bytecode).expect("hex encoding should always be valid")
-}
-
-pub fn assert_success(contract: Contract, differential: bool) -> State {
-    let (mut instance, export) = mock_runtime::prepare(&contract.pvm_runtime, None);
-    let state = mock_runtime::call(State::new(contract.calldata.clone()), &mut instance, export);
-    assert_eq!(state.output.flags, 0);
-
-    if differential {
-        let evm = revive_differential::prepare(contract.evm_runtime, contract.calldata);
-        assert_eq!(state.output.data.clone(), revive_differential::execute(evm));
-    }
-
-    state
-}

crates/integration/src/mock_runtime.rs

@@ -1,256 +0,0 @@
-//! Mock environment used for integration tests.
-//! TODO: Switch to drink! once RISCV is ready in polkadot-sdk
-use std::collections::HashMap;
-
-use alloy_primitives::{Keccak256, U256};
-use polkavm::{
-    Caller, Config, Engine, ExportIndex, GasMeteringKind, Instance, Linker, Module, ModuleConfig,
-    ProgramBlob, Trap,
-};
-
-#[derive(Default, Clone, Debug)]
-pub struct State {
-    pub input: Vec<u8>,
-    pub output: CallOutput,
-    pub value: u128,
-    pub storage: HashMap<U256, U256>,
-}
-
-#[derive(Clone, Debug)]
-pub struct CallOutput {
-    pub flags: u32,
-    pub data: Vec<u8>,
-}
-
-impl Default for CallOutput {
-    fn default() -> Self {
-        Self {
-            flags: u32::MAX,
-            data: Vec::new(),
-        }
-    }
-}
-
-impl State {
-    pub fn new(input: Vec<u8>) -> Self {
-        Self {
-            input,
-            ..Default::default()
-        }
-    }
-
-    pub fn reset_output(&mut self) {
-        self.output = Default::default();
-    }
-
-    pub fn assert_storage_key(&self, at: U256, expect: U256) {
-        assert_eq!(self.storage[&at], expect);
-    }
-}
-
-fn link_host_functions(engine: &Engine) -> Linker<State> {
-    let mut linker = Linker::new(engine);
-
-    linker
-        .func_wrap(
-            "input",
-            |caller: Caller<State>, out_ptr: u32, out_len_ptr: u32| -> Result<(), Trap> {
-                let (mut caller, state) = caller.split();
-
-                assert!(state.input.len() <= caller.read_u32(out_len_ptr).unwrap() as usize);
-
-                caller.write_memory(out_ptr, &state.input)?;
-                caller.write_memory(out_len_ptr, &(state.input.len() as u32).to_le_bytes())?;
-
-                Ok(())
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            "seal_return",
-            |caller: Caller<State>, flags: u32, data_ptr: u32, data_len: u32| -> Result<(), Trap> {
-                let (caller, state) = caller.split();
-
-                state.output.flags = flags;
-                state.output.data = caller.read_memory_into_vec(data_ptr, data_len)?;
-
-                Err(Default::default())
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            "value_transferred",
-            |caller: Caller<State>, out_ptr: u32, out_len_ptr: u32| -> Result<(), Trap> {
-                let (mut caller, state) = caller.split();
-
-                let value = state.value.to_le_bytes();
-
-                caller.write_memory(out_ptr, &value)?;
-                caller.write_memory(out_len_ptr, &(value.len() as u32).to_le_bytes())?;
-
-                Ok(())
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            "debug_message",
-            |caller: Caller<State>, str_ptr: u32, str_len: u32| -> Result<u32, Trap> {
-                let (caller, _) = caller.split();
-
-                let data = caller.read_memory_into_vec(str_ptr, str_len)?;
-                print!("debug_message: {}", String::from_utf8(data).unwrap());
-
-                Ok(0)
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            "set_storage",
-            |caller: Caller<State>,
-             key_ptr: u32,
-             key_len: u32,
-             value_ptr: u32,
-             value_len: u32|
-             -> Result<u32, Trap> {
-                let (caller, state) = caller.split();
-
-                assert_eq!(key_len, 32, "storage key must be 32 bytes");
-                assert_eq!(value_len, 32, "storage value must be 32 bytes");
-
-                let key = caller.read_memory_into_vec(key_ptr, key_len)?;
-                let value = caller.read_memory_into_vec(value_ptr, value_len)?;
-
-                state.storage.insert(
-                    U256::from_be_bytes::<32>(key.try_into().unwrap()),
-                    U256::from_be_bytes::<32>(value.try_into().unwrap()),
-                );
-
-                Ok(0)
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            "get_storage",
-            |caller: Caller<State>,
-             key_ptr: u32,
-             key_len: u32,
-             out_ptr: u32,
-             out_len_ptr: u32|
-             -> Result<u32, Trap> {
-                let (mut caller, state) = caller.split();
-
-                let key = caller.read_memory_into_vec(key_ptr, key_len)?;
-                let out_len = caller.read_u32(out_len_ptr)?;
-                assert!(out_len >= 32);
-
-                let value = state
-                    .storage
-                    .get(&U256::from_be_bytes::<32>(key.try_into().unwrap()))
-                    .map(U256::to_be_bytes::<32>)
-                    .unwrap_or_default();
-
-                caller.write_memory(out_ptr, &value[..])?;
-                caller.write_memory(out_len_ptr, &32u32.to_le_bytes())?;
-
-                Ok(0)
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            "hash_keccak_256",
-            |caller: Caller<State>,
-             input_ptr: u32,
-             input_len: u32,
-             out_ptr: u32|
-             -> Result<(), Trap> {
-                let (mut caller, _) = caller.split();
-
-                let pre = caller.read_memory_into_vec(input_ptr, input_len)?;
-
-                let mut hasher = Keccak256::new();
-                hasher.update(&pre);
-                caller.write_memory(out_ptr, &hasher.finalize()[..])?;
-
-                Ok(())
-            },
-        )
-        .unwrap();
-
-    linker
-}
-
-pub fn setup(config: Option<Config>) -> Engine {
-    Engine::new(&config.unwrap_or_default()).unwrap()
-}
-
-pub fn recompile_code(code: &[u8], engine: &Engine) -> Module {
-    let mut module_config = ModuleConfig::new();
-    module_config.set_gas_metering(Some(GasMeteringKind::Sync));
-
-    Module::new(engine, &module_config, code).unwrap()
-}
-
-pub fn instantiate_module(module: &Module, engine: &Engine) -> (Instance<State>, ExportIndex) {
-    let export = module.lookup_export("call").unwrap();
-    let func = link_host_functions(engine).instantiate_pre(module).unwrap();
-    let instance = func.instantiate().unwrap();
-
-    (instance, export)
-}
-
-pub fn prepare(code: &[u8], config: Option<Config>) -> (Instance<State>, ExportIndex) {
-    let blob = ProgramBlob::parse(code).unwrap();
-
-    let engine = Engine::new(&config.unwrap_or_default()).unwrap();
-
-    let mut module_config = ModuleConfig::new();
-    module_config.set_gas_metering(Some(GasMeteringKind::Sync));
-
-    let module = Module::from_blob(&engine, &module_config, &blob).unwrap();
-    let export = module.lookup_export("call").unwrap();
-    let func = link_host_functions(&engine)
-        .instantiate_pre(&module)
-        .unwrap();
-    let instance = func.instantiate().unwrap();
-
-    (instance, export)
-}
-
-pub fn call(mut state: State, on: &mut Instance<State>, export: ExportIndex) -> State {
-    state.reset_output();
-
-    let mut state_args = polkavm::StateArgs::default();
-    state_args.set_gas(polkavm::Gas::MAX);
-
-    let call_args = polkavm::CallArgs::new(&mut state, export);
-
-    init_logs();
-
-    match on.call(state_args, call_args) {
-        Err(polkavm::ExecutionError::Trap(_)) => state,
-        Err(other) => panic!("unexpected error: {other}"),
-        Ok(_) => panic!("unexpected return"),
-    }
-}
-
-fn init_logs() {
-    if std::env::var("RUST_LOG").is_ok() {
-        #[cfg(test)]
-        let test = true;
-        #[cfg(not(test))]
-        let test = false;
-        let _ = env_logger::builder().is_test(test).try_init();
-    }
-}

crates/integration/src/tests.rs

@@ -1,266 +0,0 @@
-use alloy_primitives::{FixedBytes, Keccak256, I256, U256};
-use alloy_sol_types::{sol, SolCall};
-use sha1::Digest;
-
-use crate::{
-    assert_success,
-    cases::Contract,
-    mock_runtime::{self, State},
-};
-
-#[test]
-fn fibonacci() {
-    let parameter = 6;
-
-    for contract in [
-        Contract::fib_recursive(parameter),
-        Contract::fib_iterative(parameter),
-        Contract::fib_binet(parameter),
-    ] {
-        let state = assert_success(contract, true);
-        let received = U256::from_be_bytes::<32>(state.output.data.try_into().unwrap());
-        let expected = U256::from(8);
-        assert_eq!(received, expected);
-    }
-}
-
-#[test]
-fn flipper() {
-    let contract = Contract::flipper();
-    let (mut instance, export) = mock_runtime::prepare(&contract.pvm_runtime, None);
-
-    let state = crate::mock_runtime::call(State::new(contract.calldata), &mut instance, export);
-    assert_eq!(state.output.flags, 0);
-    assert_eq!(state.storage[&U256::ZERO], U256::try_from(1).unwrap());
-
-    let state = crate::mock_runtime::call(state, &mut instance, export);
-    assert_eq!(state.output.flags, 0);
-    assert_eq!(state.storage[&U256::ZERO], U256::ZERO);
-}
-
-#[test]
-fn hash_keccak_256() {
-    sol!(
-        #[derive(Debug, PartialEq, Eq)]
-        contract TestSha3 {
-            function test(string memory _pre) external payable returns (bytes32);
-        }
-    );
-    let source = r#"contract TestSha3 {
-            function test(string memory _pre) external payable returns (bytes32 hash) {
-                hash = keccak256(bytes(_pre));
-            }
-        }"#;
-    let code = crate::compile_blob("TestSha3", source);
-
-    let param = "hello";
-    let input = TestSha3::testCall::new((param.to_string(),)).abi_encode();
-
-    let state = State::new(input);
-    let (mut instance, export) = mock_runtime::prepare(&code, None);
-    let state = crate::mock_runtime::call(state, &mut instance, export);
-
-    assert_eq!(state.output.flags, 0);
-
-    let mut hasher = Keccak256::new();
-    hasher.update(param);
-    let expected = hasher.finalize();
-    let received = FixedBytes::<32>::from_slice(&state.output.data);
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn erc20() {
-    let _ = crate::compile_blob("ERC20", include_str!("../contracts/ERC20.sol"));
-}
-
-#[test]
-fn triangle_number() {
-    let state = assert_success(Contract::triangle_number(13), true);
-    let received = U256::from_be_bytes::<32>(state.output.data.try_into().unwrap());
-    let expected = U256::try_from(91).unwrap();
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn odd_product() {
-    let state = assert_success(Contract::odd_product(5), true);
-    let received = I256::from_be_bytes::<32>(state.output.data.try_into().unwrap());
-    let expected = I256::try_from(945i64).unwrap();
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn msize_plain() {
-    sol!(
-        #[derive(Debug, PartialEq, Eq)]
-        contract MSize {
-            function mSize() public pure returns (uint);
-        }
-    );
-    let code = crate::compile_blob_with_options(
-        "MSize",
-        include_str!("../contracts/MSize.sol"),
-        false,
-        revive_solidity::SolcPipeline::EVMLA,
-    );
-    let (mut instance, export) = mock_runtime::prepare(&code, None);
-
-    let input = MSize::mSizeCall::new(()).abi_encode();
-    let state = crate::mock_runtime::call(State::new(input), &mut instance, export);
-
-    assert_eq!(state.output.flags, 0);
-
-    // Solidity always stores the "free memory pointer" (32 byte int) at offset 64.
-    let expected = U256::try_from(64 + 32).unwrap();
-    let received = U256::from_be_bytes::<32>(state.output.data.try_into().unwrap());
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn transferred_value() {
-    sol!(
-        contract Value {
-            function value() public payable returns (uint);
-        }
-    );
-    let code = crate::compile_blob("Value", include_str!("../contracts/Value.sol"));
-    let mut state = State::new(Value::valueCall::SELECTOR.to_vec());
-    state.value = 0x1;
-
-    let (mut instance, export) = mock_runtime::prepare(&code, None);
-    let state = crate::mock_runtime::call(state, &mut instance, export);
-
-    assert_eq!(state.output.flags, 0);
-
-    let expected = I256::try_from(state.value).unwrap();
-    let received = I256::from_be_bytes::<32>(state.output.data.try_into().unwrap());
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn msize_non_word_sized_access() {
-    sol!(
-        #[derive(Debug, PartialEq, Eq)]
-        contract MSize {
-            function mStore100() public pure returns (uint);
-        }
-    );
-    let code = crate::compile_blob_with_options(
-        "MSize",
-        include_str!("../contracts/MSize.sol"),
-        false,
-        revive_solidity::SolcPipeline::Yul,
-    );
-    let (mut instance, export) = mock_runtime::prepare(&code, None);
-
-    let input = MSize::mStore100Call::new(()).abi_encode();
-    let state = crate::mock_runtime::call(State::new(input), &mut instance, export);
-
-    assert_eq!(state.output.flags, 0);
-
-    // https://docs.zksync.io/build/developer-reference/differences-with-ethereum.html#mstore-mload
-    // "Unlike EVM, where the memory growth is in words, on zkEVM the memory growth is counted in bytes."
-    // "For example, if you write mstore(100, 0) the msize on zkEVM will be 132, but on the EVM it will be 160."
-    let expected = U256::try_from(132).unwrap();
-    let received = U256::from_be_bytes::<32>(state.output.data.try_into().unwrap());
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn mstore8() {
-    sol!(
-        #[derive(Debug, PartialEq, Eq)]
-        contract MStore8 {
-            function mStore8(uint value) public pure returns (uint256 word);
-        }
-    );
-    let code = crate::compile_blob("MStore8", include_str!("../contracts/mStore8.sol"));
-    let (mut instance, export) = mock_runtime::prepare(&code, None);
-
-    let mut assert = |parameter, expected| {
-        let input = MStore8::mStore8Call::new((parameter,)).abi_encode();
-        let state = crate::mock_runtime::call(State::new(input), &mut instance, export);
-
-        assert_eq!(state.output.flags, 0);
-
-        let received = U256::from_be_bytes::<32>(state.output.data.try_into().unwrap());
-        assert_eq!(received, expected);
-    };
-
-    for (parameter, expected) in [
-        (U256::MIN, U256::MIN),
-        (
-            U256::from(1),
-            U256::from_str_radix(
-                "452312848583266388373324160190187140051835877600158453279131187530910662656",
-                10,
-            )
-            .unwrap(),
-        ),
-        (
-            U256::from(2),
-            U256::from_str_radix(
-                "904625697166532776746648320380374280103671755200316906558262375061821325312",
-                10,
-            )
-            .unwrap(),
-        ),
-        (
-            U256::from(255),
-            U256::from_str_radix(
-                "115339776388732929035197660848497720713218148788040405586178452820382218977280",
-                10,
-            )
-            .unwrap(),
-        ),
-        (U256::from(256), U256::from(0)),
-        (
-            U256::from(257),
-            U256::from_str_radix(
-                "452312848583266388373324160190187140051835877600158453279131187530910662656",
-                10,
-            )
-            .unwrap(),
-        ),
-        (
-            U256::from(258),
-            U256::from_str_radix(
-                "904625697166532776746648320380374280103671755200316906558262375061821325312",
-                10,
-            )
-            .unwrap(),
-        ),
-        (
-            U256::from(123456789),
-            U256::from_str_radix(
-                "9498569820248594155839807363993929941088553429603327518861754938149123915776",
-                10,
-            )
-            .unwrap(),
-        ),
-        (
-            U256::MAX,
-            U256::from_str_radix(
-                "115339776388732929035197660848497720713218148788040405586178452820382218977280",
-                10,
-            )
-            .unwrap(),
-        ),
-    ] {
-        assert(parameter, expected);
-    }
-}
-
-#[test]
-fn sha1() {
-    let pre = vec![0xffu8; 512];
-    let mut hasher = sha1::Sha1::new();
-    hasher.update(&pre);
-    let hash = hasher.finalize();
-
-    let state = assert_success(Contract::sha1(pre), true);
-    let expected = FixedBytes::<20>::from_slice(&hash[..]);
-    let received = FixedBytes::<20>::from_slice(&state.output.data[..20]);
-    assert_eq!(received, expected);
-}

crates/linker/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "revive-linker"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-inkwell = { workspace = true }
-tempfile = { workspace = true }
-polkavm-linker = { workspace = true }
-polkavm-common = { workspace = true }
-libc = { workspace = true }
-anyhow = { workspace = true }
-
-revive-builtins = { path = "../builtins" }
-lld-sys = { path = "../lld-sys" }

crates/linker/src/lib.rs

@@ -1,78 +0,0 @@
-use std::{env, ffi::CString, fs};
-
-use lld_sys::LLDELFLink;
-use revive_builtins::COMPILER_RT;
-
-const LINKER_SCRIPT: &str = r#"
-SECTIONS {
-    .text : { KEEP(*(.text.polkavm_export)) *(.text .text.*) }
-}"#;
-
-fn invoke_lld(cmd_args: &[&str]) -> bool {
-    let c_strings = cmd_args
-        .iter()
-        .map(|arg| CString::new(*arg).expect("ld.lld args should not contain null bytes"))
-        .collect::<Vec<_>>();
-
-    let args: Vec<*const libc::c_char> = c_strings.iter().map(|arg| arg.as_ptr()).collect();
-
-    unsafe { LLDELFLink(args.as_ptr(), args.len()) == 0 }
-}
-
-fn polkavm_linker<T: AsRef<[u8]>>(code: T) -> anyhow::Result<Vec<u8>> {
-    let mut config = polkavm_linker::Config::default();
-    config.set_strip(true);
-
-    polkavm_linker::program_from_elf(config, code.as_ref())
-        .map(|blob| blob.as_bytes().to_vec())
-        .map_err(|reason| anyhow::anyhow!("polkavm linker failed: {}", reason))
-}
-
-pub fn link<T: AsRef<[u8]>>(input: T) -> anyhow::Result<Vec<u8>> {
-    let dir = tempfile::tempdir().expect("failed to create temp directory for linking");
-    let output_path = dir.path().join("out.so");
-    let object_path = dir.path().join("out.o");
-    let linker_script_path = dir.path().join("linker.ld");
-    let compiler_rt_path = dir.path().join("libclang_rt.builtins-riscv64.a");
-
-    fs::write(&object_path, input).map_err(|msg| anyhow::anyhow!("{msg} {object_path:?}"))?;
-
-    if env::var("PVM_LINKER_DUMP_OBJ").is_ok() {
-        fs::copy(&object_path, "/tmp/out.o")?;
-    }
-
-    fs::write(&linker_script_path, LINKER_SCRIPT)
-        .map_err(|msg| anyhow::anyhow!("{msg} {linker_script_path:?}"))?;
-
-    fs::write(&compiler_rt_path, COMPILER_RT)
-        .map_err(|msg| anyhow::anyhow!("{msg} {compiler_rt_path:?}"))?;
-
-    let ld_args = [
-        "ld.lld",
-        "--lto=full",
-        "--error-limit=0",
-        "--relocatable",
-        "--emit-relocs",
-        "--no-relax",
-        "--gc-sections",
-        "--library-path",
-        dir.path().to_str().expect("should be utf8"),
-        "--library",
-        "clang_rt.builtins-riscv64",
-        linker_script_path.to_str().expect("should be utf8"),
-        object_path.to_str().expect("should be utf8"),
-        "-o",
-        output_path.to_str().expect("should be utf8"),
-    ];
-
-    if invoke_lld(&ld_args) {
-        return Err(anyhow::anyhow!("ld.lld failed"));
-    }
-
-    if env::var("PVM_LINKER_DUMP_SO").is_ok() {
-        fs::copy(&output_path, "/tmp/out.so")?;
-    };
-
-    let blob = fs::read(&output_path)?;
-    polkavm_linker(blob)
-}

crates/lld-sys/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "lld-sys"
-version = "0.1.0"
-edition = "2021"
-build = "build.rs"
-
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-libc = { workspace = true }
-
-[build-dependencies]
-cc = { workspace = true }

crates/lld-sys/build.rs

@@ -1,45 +0,0 @@
-fn llvm_config(arg: &str) -> String {
-    let output = std::process::Command::new("llvm-config")
-        .args([arg])
-        .output()
-        .unwrap_or_else(|_| panic!("`llvm-config {arg}` failed"));
-
-    String::from_utf8(output.stdout)
-        .unwrap_or_else(|_| panic!("output of `llvm-config {arg}` should be utf8"))
-}
-
-fn set_rustc_link_flags() {
-    println!("cargo:rustc-link-search=native={}", llvm_config("--libdir"));
-
-    for lib in [
-        "lldELF",
-        "lldCommon",
-        "lldMachO",
-        "LLVMSupport",
-        "LLVMLinker",
-        "LLVMCore",
-        "LLVMLTO",
-        "LLVMTargetParser",
-        "LLVMBinaryFormat",
-        "LLVMDemangle",
-    ] {
-        println!("cargo:rustc-link-lib=static={lib}");
-    }
-
-    #[cfg(target_os = "linux")]
-    println!("cargo:rustc-link-lib=dylib=stdc++");
-}
-
-fn main() {
-    llvm_config("--cxxflags")
-        .split_whitespace()
-        .fold(&mut cc::Build::new(), |builder, flag| builder.flag(flag))
-        .flag("-Wno-unused-parameter")
-        .cpp(true)
-        .file("src/linker.cpp")
-        .compile("liblinker.a");
-
-    set_rustc_link_flags();
-
-    println!("cargo:rerun-if-changed=build.rs");
-}

crates/lld-sys/src/lib.rs

@@ -1,3 +0,0 @@
-extern "C" {
-    pub fn LLDELFLink(args: *const *const libc::c_char, size: libc::size_t) -> libc::c_int;
-}

crates/lld-sys/src/linker.cpp

@@ -1,22 +0,0 @@
-#include "lld/Common/Driver.h"
-#include "lld/Common/CommonLinkerContext.h"
-#include "llvm/Support/CrashRecoveryContext.h"
-
-LLD_HAS_DRIVER(elf);
-
-extern "C" bool LLDELFLink(const char *argv[], size_t length)
-{
-    bool canRunAgain;
-
-    {
-        llvm::ArrayRef<const char *> args(argv, length);
-        llvm::CrashRecoveryContext crc;
-        if (!crc.RunSafely([&]()
-                           { canRunAgain = lld::elf::link(args, llvm::outs(), llvm::errs(), false, false); }))
-            return false;
-    }
-
-    llvm::CrashRecoveryContext crc;
-    return canRunAgain && crc.RunSafely([&]()
-                                        { lld::CommonLinkerContext::destroy(); });
-}

crates/llvm-context/Cargo.toml

@@ -1,38 +0,0 @@
-[package]
-name = "era-compiler-llvm-context"
-version = "1.4.1"
-authors = [
-    "Oleksandr Zarudnyi <a.zarudnyy@matterlabs.dev>",
-    "Cyrill Leutwiler <cyrill@parity.io>",
-]
-license = "MIT OR Apache-2.0"
-edition = "2021"
-description = "Shared front end code of the EraVM compilers"
-
-[lib]
-doctest = false
-
-[features]
-riscv-zbb = []
-
-[dependencies]
-anyhow = { workspace = true }
-semver = { workspace = true }
-itertools = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-regex = { workspace = true }
-once_cell = { workspace = true }
-num = { workspace = true }
-hex = { workspace = true }
-sha2 = { workspace = true }
-sha3 = { workspace = true }
-md5 = { workspace = true }
-inkwell = { workspace = true }
-
-zkevm_opcode_defs = { git = "https://github.com/matter-labs/era-zkevm_opcode_defs", branch = "v1.4.1" }
-revive-common = { path = "../common" }
-
-pallet-contracts-pvm-llapi = { path = "../pallet-contracts-pvm-llapi" }
-revive-linker = { path = "../linker" }
-revive-builtins = { path = "../builtins" }
-revive-stdlib = { path = "../stdlib" }

crates/llvm-context/src/debug_config/ir_type.rs

@@ -1,40 +0,0 @@
-//!
-//! The debug IR type.
-//!
-
-///
-/// The debug IR type.
-///
-#[allow(non_camel_case_types)]
-#[allow(clippy::upper_case_acronyms)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum IRType {
-    /// Whether to dump the Yul code.
-    Yul,
-    /// Whether to dump the EVM legacy assembly code.
-    EVMLA,
-    /// Whether to dump the Ethereal IR code.
-    EthIR,
-    /// Whether to dump the Vyper LLL IR code.
-    LLL,
-    /// Whether to dump the LLVM IR code.
-    LLVM,
-    /// Whether to dump the assembly code.
-    Assembly,
-}
-
-impl IRType {
-    ///
-    /// Returns the file extension for the specified IR.
-    ///
-    pub fn file_extension(&self) -> &'static str {
-        match self {
-            Self::Yul => revive_common::EXTENSION_YUL,
-            Self::EthIR => revive_common::EXTENSION_ETHIR,
-            Self::EVMLA => revive_common::EXTENSION_EVMLA,
-            Self::LLL => revive_common::EXTENSION_LLL,
-            Self::LLVM => revive_common::EXTENSION_LLVM_SOURCE,
-            Self::Assembly => revive_common::EXTENSION_ERAVM_ASSEMBLY,
-        }
-    }
-}

crates/llvm-context/src/debug_config/mod.rs

@@ -1,140 +0,0 @@
-//!
-//! The debug configuration.
-//!
-
-pub mod ir_type;
-
-use std::path::PathBuf;
-
-use serde::Deserialize;
-use serde::Serialize;
-
-use self::ir_type::IRType;
-
-///
-/// The debug configuration.
-///
-#[derive(Debug, Default, Serialize, Deserialize, Clone)]
-pub struct DebugConfig {
-    /// The directory to dump the IRs to.
-    pub output_directory: PathBuf,
-}
-
-impl DebugConfig {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(output_directory: PathBuf) -> Self {
-        Self { output_directory }
-    }
-
-    ///
-    /// Dumps the Yul IR.
-    ///
-    pub fn dump_yul(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, None, IRType::Yul);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, code)?;
-
-        Ok(())
-    }
-
-    ///
-    /// Dumps the EVM legacy assembly IR.
-    ///
-    pub fn dump_evmla(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, None, IRType::EVMLA);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, code)?;
-
-        Ok(())
-    }
-
-    ///
-    /// Dumps the Ethereal IR.
-    ///
-    pub fn dump_ethir(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, None, IRType::EthIR);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, code)?;
-
-        Ok(())
-    }
-
-    ///
-    /// Dumps the LLL IR.
-    ///
-    pub fn dump_lll(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, None, IRType::LLL);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, code)?;
-
-        Ok(())
-    }
-
-    ///
-    /// Dumps the unoptimized LLVM IR.
-    ///
-    pub fn dump_llvm_ir_unoptimized(
-        &self,
-        contract_path: &str,
-        module: &inkwell::module::Module,
-    ) -> anyhow::Result<()> {
-        let llvm_code = module.print_to_string().to_string();
-
-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, Some("unoptimized"), IRType::LLVM);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, llvm_code)?;
-
-        Ok(())
-    }
-
-    ///
-    /// Dumps the optimized LLVM IR.
-    ///
-    pub fn dump_llvm_ir_optimized(
-        &self,
-        contract_path: &str,
-        module: &inkwell::module::Module,
-    ) -> anyhow::Result<()> {
-        let llvm_code = module.print_to_string().to_string();
-
-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, Some("optimized"), IRType::LLVM);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, llvm_code)?;
-
-        Ok(())
-    }
-
-    ///
-    /// Dumps the assembly.
-    ///
-    pub fn dump_assembly(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, None, IRType::Assembly);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, code)?;
-
-        Ok(())
-    }
-
-    ///
-    /// Creates a full file name, given the contract full path, suffix, and extension.
-    ///
-    fn full_file_name(contract_path: &str, suffix: Option<&str>, ir_type: IRType) -> String {
-        let mut full_file_name = contract_path.replace('/', "_").replace(':', ".");
-        if let Some(suffix) = suffix {
-            full_file_name.push('.');
-            full_file_name.push_str(suffix);
-        }
-        full_file_name.push('.');
-        full_file_name.push_str(ir_type.file_extension());
-        full_file_name
-    }
-}

crates/llvm-context/src/eravm/const.rs

@@ -1,75 +0,0 @@
-//!
-//! The LLVM context constants.
-//!
-
-/// The LLVM framework version.
-pub const LLVM_VERSION: semver::Version = semver::Version::new(18, 1, 4);
-
-/// The EraVM version.
-pub const ZKEVM_VERSION: semver::Version = semver::Version::new(1, 3, 2);
-
-/// The register width sized type
-pub static XLEN: usize = revive_common::BIT_LENGTH_X32;
-
-/// The heap memory pointer pointer global variable name.
-pub static GLOBAL_HEAP_MEMORY_POINTER: &str = "memory_pointer";
-
-/// The calldata pointer global variable name.
-pub static GLOBAL_CALLDATA_POINTER: &str = "ptr_calldata";
-
-/// The calldata size global variable name.
-pub static GLOBAL_CALLDATA_SIZE: &str = "calldatasize";
-
-/// The return data pointer global variable name.
-pub static GLOBAL_RETURN_DATA_POINTER: &str = "ptr_return_data";
-
-/// The return data size pointer global variable name.
-pub static GLOBAL_RETURN_DATA_SIZE: &str = "returndatasize";
-
-/// The call flags global variable name.
-pub static GLOBAL_CALL_FLAGS: &str = "call_flags";
-
-/// The extra ABI data global variable name.
-pub static GLOBAL_EXTRA_ABI_DATA: &str = "extra_abi_data";
-
-/// The active pointer global variable name.
-pub static GLOBAL_ACTIVE_POINTER: &str = "ptr_active";
-
-/// The constant array global variable name prefix.
-pub static GLOBAL_CONST_ARRAY_PREFIX: &str = "const_array_";
-
-/// The global verbatim getter identifier prefix.
-pub static GLOBAL_VERBATIM_GETTER_PREFIX: &str = "get_global::";
-
-/// The external call data offset in the auxiliary heap.
-pub const HEAP_AUX_OFFSET_EXTERNAL_CALL: u64 = 0;
-
-/// The constructor return data offset in the auxiliary heap.
-pub const HEAP_AUX_OFFSET_CONSTRUCTOR_RETURN_DATA: u64 =
-    8 * (revive_common::BYTE_LENGTH_FIELD as u64);
-
-/// The number of the extra ABI data arguments.
-pub const EXTRA_ABI_DATA_SIZE: usize = 0;
-
-/// The `create` method deployer signature.
-pub static DEPLOYER_SIGNATURE_CREATE: &str = "create(bytes32,bytes32,bytes)";
-
-/// The `create2` method deployer signature.
-pub static DEPLOYER_SIGNATURE_CREATE2: &str = "create2(bytes32,bytes32,bytes)";
-
-/// The absence of system call bit.
-pub const NO_SYSTEM_CALL_BIT: bool = false;
-
-/// The system call bit.
-pub const SYSTEM_CALL_BIT: bool = true;
-
-///
-/// The deployer call header size that consists of:
-/// - selector (4 bytes)
-/// - salt (32 bytes)
-/// - bytecode hash (32 bytes)
-/// - constructor arguments offset (32 bytes)
-/// - constructor arguments length (32 bytes)
-///
-pub const DEPLOYER_CALL_HEADER_SIZE: usize =
-    revive_common::BYTE_LENGTH_X32 + (revive_common::BYTE_LENGTH_FIELD * 4);

crates/llvm-context/src/eravm/context/address_space.rs

@@ -1,39 +0,0 @@
-//!
-//! The address space aliases.
-//!
-
-///
-/// The address space aliases.
-///
-#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum AddressSpace {
-    /// The stack memory.
-    #[default]
-    Stack,
-    /// The heap memory.
-    Heap,
-    /// The auxiliary heap memory.
-    HeapAuxiliary,
-    /// The generic memory page.
-    Generic,
-    /// The code area.
-    Code,
-    /// The storage.
-    Storage,
-    /// The transient storage.
-    TransientStorage,
-}
-
-impl From<AddressSpace> for inkwell::AddressSpace {
-    fn from(value: AddressSpace) -> Self {
-        match value {
-            AddressSpace::Stack => Self::from(0),
-            AddressSpace::Heap => Self::from(1),
-            AddressSpace::HeapAuxiliary => Self::from(2),
-            AddressSpace::Generic => Self::from(3),
-            AddressSpace::Code => Self::from(4),
-            AddressSpace::Storage => Self::from(5),
-            AddressSpace::TransientStorage => Self::from(6),
-        }
-    }
-}

crates/llvm-context/src/eravm/context/argument.rs

@@ -1,76 +0,0 @@
-//!
-//! The LLVM argument with metadata.
-//!
-
-///
-/// The LLVM argument with metadata.
-///
-#[derive(Debug, Clone)]
-pub struct Argument<'ctx> {
-    /// The actual LLVM operand.
-    pub value: inkwell::values::BasicValueEnum<'ctx>,
-    /// The original AST value. Used mostly for string literals.
-    pub original: Option<String>,
-    /// The preserved constant value, if available.
-    pub constant: Option<num::BigUint>,
-}
-
-impl<'ctx> Argument<'ctx> {
-    /// The calldata offset argument index.
-    pub const ARGUMENT_INDEX_CALLDATA_OFFSET: usize = 0;
-
-    /// The calldata length argument index.
-    pub const ARGUMENT_INDEX_CALLDATA_LENGTH: usize = 1;
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(value: inkwell::values::BasicValueEnum<'ctx>) -> Self {
-        Self {
-            value,
-            original: None,
-            constant: None,
-        }
-    }
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new_with_original(
-        value: inkwell::values::BasicValueEnum<'ctx>,
-        original: String,
-    ) -> Self {
-        Self {
-            value,
-            original: Some(original),
-            constant: None,
-        }
-    }
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new_with_constant(
-        value: inkwell::values::BasicValueEnum<'ctx>,
-        constant: num::BigUint,
-    ) -> Self {
-        Self {
-            value,
-            original: None,
-            constant: Some(constant),
-        }
-    }
-
-    ///
-    /// Returns the inner LLVM value.
-    ///
-    pub fn to_llvm(&self) -> inkwell::values::BasicValueEnum<'ctx> {
-        self.value
-    }
-}
-
-impl<'ctx> From<inkwell::values::BasicValueEnum<'ctx>> for Argument<'ctx> {
-    fn from(value: inkwell::values::BasicValueEnum<'ctx>) -> Self {
-        Self::new(value)
-    }
-}

crates/llvm-context/src/eravm/context/attribute.rs

@@ -1,132 +0,0 @@
-//! The LLVM attribute.
-
-use serde::Deserialize;
-use serde::Serialize;
-
-/// The LLVM attribute.
-///
-/// In order to check the real order in a new major version of LLVM, find the `Attributes.inc` file
-/// inside of the LLVM build directory. This order is actually generated during the building.
-///
-/// FIXME: Generate this in build.rs?
-#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Attribute {
-    Unused = 0,
-    AllocAlign = 1,
-    AllocatedPointer = 2,
-    AlwaysInline = 3,
-    Builtin = 4,
-    Cold = 5,
-    Convergent = 6,
-    CoroDestroyOnlyWhenComplete = 7,
-    DeadOnUnwind = 8,
-    DisableSanitizerInstrumentation = 9,
-    FnRetThunkExtern = 10,
-    Hot = 11,
-    ImmArg = 12,
-    InReg = 13,
-    InlineHint = 14,
-    JumpTable = 15,
-    MinSize = 16,
-    MustProgress = 17,
-    Naked = 18,
-    Nest = 19,
-    NoAlias = 20,
-    NoBuiltin = 21,
-    NoCallback = 22,
-    NoCapture = 23,
-    NoCfCheck = 24,
-    NoDuplicate = 25,
-    NoFree = 26,
-    NoImplicitFloat = 27,
-    NoInline = 28,
-    NoMerge = 29,
-    NoProfile = 30,
-    NoRecurse = 31,
-    NoRedZone = 32,
-    NoReturn = 33,
-    NoSanitizeBounds = 34,
-    NoSanitizeCoverage = 35,
-    NoSync = 36,
-    NoUndef = 37,
-    NoUnwind = 38,
-    NonLazyBind = 39,
-    NonNull = 40,
-    NullPointerIsValid = 41,
-    OptForFuzzing = 42,
-    OptimizeForDebugging = 43,
-    OptimizeForSize = 44,
-    OptimizeNone = 45,
-    PresplitCoroutine = 46,
-    ReadNone = 47,
-    ReadOnly = 48,
-    Returned = 49,
-    ReturnsTwice = 50,
-    SExt = 51,
-    SafeStack = 52,
-    SanitizeAddress = 53,
-    SanitizeHWAddress = 54,
-    SanitizeMemTag = 55,
-    SanitizeMemory = 56,
-    SanitizeThread = 57,
-    ShadowCallStack = 58,
-    SkipProfile = 59,
-    Speculatable = 60,
-    SpeculativeLoadHardening = 61,
-    StackProtect = 62,
-    StackProtectReq = 63,
-    StackProtectStrong = 64,
-    StrictFP = 65,
-    SwiftAsync = 66,
-    SwiftError = 67,
-    SwiftSelf = 68,
-    WillReturn = 69,
-    Writable = 70,
-    WriteOnly = 71,
-    ZExt = 72,
-    //LastEnumAttr = 72,
-    // FirstTypeAttr = 73,
-    ByRef = 73,
-    ByVal = 74,
-    ElementType = 75,
-    InAlloca = 76,
-    Preallocated = 77,
-    StructRet = 78,
-    // LastTypeAttr = 78,
-    // FirstIntAttr = 79,
-    Alignment = 79,
-    AllocKind = 80,
-    AllocSize = 81,
-    Dereferenceable = 82,
-    DereferenceableOrNull = 83,
-    Memory = 84,
-    NoFPClass = 85,
-    StackAlignment = 86,
-    UWTable = 87,
-    VScaleRange = 88,
-    // LastIntAttr = 88,
-}
-
-impl TryFrom<&str> for Attribute {
-    type Error = String;
-
-    fn try_from(value: &str) -> Result<Self, Self::Error> {
-        match value {
-            "AlwaysInline" => Ok(Attribute::AlwaysInline),
-            "Cold" => Ok(Attribute::Cold),
-            "Hot" => Ok(Attribute::Hot),
-            "MinSize" => Ok(Attribute::MinSize),
-            "OptimizeForSize" => Ok(Attribute::OptimizeForSize),
-            "NoInline" => Ok(Attribute::NoInline),
-            "WillReturn" => Ok(Attribute::WillReturn),
-            "WriteOnly" => Ok(Attribute::WriteOnly),
-            "ReadNone" => Ok(Attribute::ReadNone),
-            "ReadOnly" => Ok(Attribute::ReadOnly),
-            "NoReturn" => Ok(Attribute::NoReturn),
-            // FIXME: Not in Attributes.inc
-            //"InaccessibleMemOnly" => Ok(Attribute::InaccessibleMemOnly),
-            "MustProgress" => Ok(Attribute::MustProgress),
-            _ => Err(value.to_owned()),
-        }
-    }
-}

crates/llvm-context/src/eravm/context/build.rs

@@ -1,45 +0,0 @@
-//!
-//! The LLVM module build.
-//!
-
-use std::collections::BTreeMap;
-
-use serde::Deserialize;
-use serde::Serialize;
-
-///
-/// The LLVM module build.
-///
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Build {
-    /// The EraVM text assembly.
-    pub assembly_text: String,
-    /// The metadata hash.
-    pub metadata_hash: Option<[u8; revive_common::BYTE_LENGTH_FIELD]>,
-    /// The EraVM binary bytecode.
-    pub bytecode: Vec<u8>,
-    /// The EraVM bytecode hash.
-    pub bytecode_hash: String,
-    /// The hash-to-full-path mapping of the contract factory dependencies.
-    pub factory_dependencies: BTreeMap<String, String>,
-}
-
-impl Build {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(
-        assembly_text: String,
-        metadata_hash: Option<[u8; revive_common::BYTE_LENGTH_FIELD]>,
-        bytecode: Vec<u8>,
-        bytecode_hash: String,
-    ) -> Self {
-        Self {
-            assembly_text,
-            metadata_hash,
-            bytecode,
-            bytecode_hash,
-            factory_dependencies: BTreeMap::new(),
-        }
-    }
-}

crates/llvm-context/src/eravm/context/code_type.rs

@@ -1,26 +0,0 @@
-//!
-//! The contract code types.
-//!
-
-///
-/// The contract code types (deploy and runtime).
-///
-/// They do not represent any entities in the final bytecode, but this separation is always present
-/// in the IRs used for translation to the EVM bytecode.
-///
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum CodeType {
-    /// The deploy code.
-    Deploy,
-    /// The runtime code.
-    Runtime,
-}
-
-impl std::fmt::Display for CodeType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Deploy => write!(f, "deploy"),
-            Self::Runtime => write!(f, "runtime"),
-        }
-    }
-}

crates/llvm-context/src/eravm/context/debug_info.rs

@@ -1,109 +0,0 @@
-//!
-//! The LLVM debug information.
-//!
-
-use inkwell::debug_info::AsDIScope;
-use num::Zero;
-
-///
-/// The LLVM debug information.
-///
-pub struct DebugInfo<'ctx> {
-    /// The compile unit.
-    compile_unit: inkwell::debug_info::DICompileUnit<'ctx>,
-    /// The debug info builder.
-    builder: inkwell::debug_info::DebugInfoBuilder<'ctx>,
-}
-
-impl<'ctx> DebugInfo<'ctx> {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(module: &inkwell::module::Module<'ctx>) -> Self {
-        let (builder, compile_unit) = module.create_debug_info_builder(
-            true,
-            inkwell::debug_info::DWARFSourceLanguage::C,
-            module.get_name().to_string_lossy().as_ref(),
-            "",
-            "",
-            false,
-            "",
-            0,
-            "",
-            inkwell::debug_info::DWARFEmissionKind::Full,
-            0,
-            false,
-            false,
-            "",
-            "",
-        );
-
-        Self {
-            compile_unit,
-            builder,
-        }
-    }
-
-    ///
-    /// Creates a function info.
-    ///
-    pub fn create_function(
-        &self,
-        name: &str,
-    ) -> anyhow::Result<inkwell::debug_info::DISubprogram<'ctx>> {
-        let subroutine_type = self.builder.create_subroutine_type(
-            self.compile_unit.get_file(),
-            Some(self.create_type(era_compiler_common::BIT_LENGTH_FIELD)?),
-            &[],
-            inkwell::debug_info::DIFlags::zero(),
-        );
-
-        let function = self.builder.create_function(
-            self.compile_unit.get_file().as_debug_info_scope(),
-            name,
-            None,
-            self.compile_unit.get_file(),
-            42,
-            subroutine_type,
-            true,
-            false,
-            1,
-            inkwell::debug_info::DIFlags::zero(),
-            false,
-        );
-
-        self.builder.create_lexical_block(
-            function.as_debug_info_scope(),
-            self.compile_unit.get_file(),
-            1,
-            1,
-        );
-
-        Ok(function)
-    }
-
-    ///
-    /// Creates a primitive type info.
-    ///
-    pub fn create_type(
-        &self,
-        bit_length: usize,
-    ) -> anyhow::Result<inkwell::debug_info::DIType<'ctx>> {
-        self.builder
-            .create_basic_type(
-                "U256",
-                bit_length as u64,
-                0,
-                inkwell::debug_info::DIFlags::zero(),
-            )
-            .map(|basic_type| basic_type.as_type())
-            .map_err(|error| anyhow::anyhow!("Debug info error: {}", error))
-    }
-
-    ///
-    /// Finalizes the builder.
-    ///
-    pub fn finalize(&self) {
-        self.builder.finalize();
-    }
-}

crates/llvm-context/src/eravm/context/evmla_data.rs

@@ -1,34 +0,0 @@
-//!
-//! The LLVM IR generator EVM legacy assembly data.
-//!
-
-use crate::eravm::context::argument::Argument;
-
-///
-/// The LLVM IR generator EVM legacy assembly data.
-///
-/// Describes some data that is only relevant to the EVM legacy assembly.
-///
-#[derive(Debug, Clone)]
-pub struct EVMLAData<'ctx> {
-    /// The Solidity compiler version.
-    /// Some instruction behave differenly depending on the version.
-    pub version: semver::Version,
-    /// The static stack allocated for the current function.
-    pub stack: Vec<Argument<'ctx>>,
-}
-
-impl<'ctx> EVMLAData<'ctx> {
-    /// The default stack size.
-    pub const DEFAULT_STACK_SIZE: usize = 64;
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(version: semver::Version) -> Self {
-        Self {
-            version,
-            stack: Vec::with_capacity(Self::DEFAULT_STACK_SIZE),
-        }
-    }
-}

crates/llvm-context/src/eravm/context/function/block/evmla_data/key.rs

@@ -1,41 +0,0 @@
-//!
-//! The LLVM IR generator function block key.
-//!
-
-use crate::eravm::context::code_type::CodeType;
-
-///
-/// The LLVM IR generator function block key.
-///
-/// Is only relevant to the EVM legacy assembly.
-///
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Key {
-    /// The block code type.
-    pub code_type: CodeType,
-    /// The block tag.
-    pub tag: num::BigUint,
-}
-
-impl Key {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(code_type: CodeType, tag: num::BigUint) -> Self {
-        Self { code_type, tag }
-    }
-}
-
-impl std::fmt::Display for Key {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}_{}",
-            match self.code_type {
-                CodeType::Deploy => "dt",
-                CodeType::Runtime => "rt",
-            },
-            self.tag
-        )
-    }
-}

crates/llvm-context/src/eravm/context/function/block/evmla_data/mod.rs

@@ -1,25 +0,0 @@
-//!
-//! The LLVM function block EVM legacy assembly data.
-//!
-
-pub mod key;
-
-///
-/// The LLVM function block EVM legacy assembly data.
-///
-/// Describes some data that is only relevant to the EVM legacy assembly.
-///
-#[derive(Debug, Clone)]
-pub struct EVMLAData {
-    /// The initial hashes of the allowed stack states.
-    pub stack_hashes: Vec<md5::Digest>,
-}
-
-impl EVMLAData {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(stack_hashes: Vec<md5::Digest>) -> Self {
-        Self { stack_hashes }
-    }
-}

crates/llvm-context/src/eravm/context/function/block/mod.rs

@@ -1,68 +0,0 @@
-//!
-//! The LLVM IR generator function block.
-//!
-
-pub mod evmla_data;
-
-use self::evmla_data::EVMLAData;
-
-///
-/// The LLVM IR generator function block.
-///
-#[derive(Debug, Clone)]
-pub struct Block<'ctx> {
-    /// The inner block.
-    inner: inkwell::basic_block::BasicBlock<'ctx>,
-    /// The EVM legacy assembly compiler data.
-    evmla_data: Option<EVMLAData>,
-}
-
-impl<'ctx> Block<'ctx> {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(inner: inkwell::basic_block::BasicBlock<'ctx>) -> Self {
-        Self {
-            inner,
-            evmla_data: None,
-        }
-    }
-
-    ///
-    /// Sets the EVM legacy assembly data.
-    ///
-    pub fn set_evmla_data(&mut self, data: EVMLAData) {
-        self.evmla_data = Some(data);
-    }
-
-    ///
-    /// The LLVM object reference.
-    ///
-    pub fn inner(&self) -> inkwell::basic_block::BasicBlock<'ctx> {
-        self.inner
-    }
-
-    ///
-    /// Returns the EVM data reference.
-    ///
-    /// # Panics
-    /// If the EVM data has not been initialized.
-    ///
-    pub fn evm(&self) -> &EVMLAData {
-        self.evmla_data
-            .as_ref()
-            .expect("The EVM data must have been initialized")
-    }
-
-    ///
-    /// Returns the EVM data mutable reference.
-    ///
-    /// # Panics
-    /// If the EVM data has not been initialized.
-    ///
-    pub fn evm_mut(&mut self) -> &mut EVMLAData {
-        self.evmla_data
-            .as_mut()
-            .expect("The EVM data must have been initialized")
-    }
-}

crates/llvm-context/src/eravm/context/function/declaration.rs

@@ -1,26 +0,0 @@
-//!
-//! The LLVM function declaration.
-//!
-
-///
-/// The LLVM function declaration.
-///
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Declaration<'ctx> {
-    /// The function type.
-    pub r#type: inkwell::types::FunctionType<'ctx>,
-    /// The function value.
-    pub value: inkwell::values::FunctionValue<'ctx>,
-}
-
-impl<'ctx> Declaration<'ctx> {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(
-        r#type: inkwell::types::FunctionType<'ctx>,
-        value: inkwell::values::FunctionValue<'ctx>,
-    ) -> Self {
-        Self { r#type, value }
-    }
-}

crates/llvm-context/src/eravm/context/function/evmla_data.rs

@@ -1,86 +0,0 @@
-//!
-//! The LLVM function EVM legacy assembly data.
-//!
-
-use std::collections::BTreeMap;
-
-use crate::eravm::context::function::block::evmla_data::key::Key as BlockKey;
-use crate::eravm::context::function::block::Block;
-
-///
-/// The LLVM function EVM legacy assembly data.
-///
-/// Describes some data that is only relevant to the EVM legacy assembly.
-///
-#[derive(Debug)]
-pub struct EVMLAData<'ctx> {
-    /// The ordinary blocks with numeric tags.
-    /// Is only used by the Solidity EVM compiler.
-    pub blocks: BTreeMap<BlockKey, Vec<Block<'ctx>>>,
-    /// The function stack size.
-    pub stack_size: usize,
-}
-
-impl<'ctx> EVMLAData<'ctx> {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(stack_size: usize) -> Self {
-        Self {
-            blocks: BTreeMap::new(),
-            stack_size,
-        }
-    }
-
-    ///
-    /// Inserts a function block.
-    ///
-    pub fn insert_block(&mut self, key: BlockKey, block: Block<'ctx>) {
-        if let Some(blocks) = self.blocks.get_mut(&key) {
-            blocks.push(block);
-        } else {
-            self.blocks.insert(key, vec![block]);
-        }
-    }
-
-    ///
-    /// Returns the block with the specified tag and initial stack pattern.
-    ///
-    /// If there is only one block, it is returned unconditionally.
-    ///
-    pub fn find_block(
-        &self,
-        key: &BlockKey,
-        stack_hash: &md5::Digest,
-    ) -> anyhow::Result<Block<'ctx>> {
-        if self
-            .blocks
-            .get(key)
-            .ok_or_else(|| anyhow::anyhow!("Undeclared function block {}", key))?
-            .len()
-            == 1
-        {
-            return self
-                .blocks
-                .get(key)
-                .ok_or_else(|| anyhow::anyhow!("Undeclared function block {}", key))?
-                .first()
-                .cloned()
-                .ok_or_else(|| anyhow::anyhow!("Undeclared function block {}", key));
-        }
-
-        self.blocks
-            .get(key)
-            .ok_or_else(|| anyhow::anyhow!("Undeclared function block {}", key))?
-            .iter()
-            .find(|block| {
-                block
-                    .evm()
-                    .stack_hashes
-                    .iter()
-                    .any(|hash| hash == stack_hash)
-            })
-            .cloned()
-            .ok_or_else(|| anyhow::anyhow!("Undeclared function block {}", key))
-    }
-}

crates/llvm-context/src/eravm/context/function/intrinsics.rs

@@ -1,149 +0,0 @@
-//!
-//! The LLVM intrinsic functions.
-//!
-
-use inkwell::types::BasicType;
-
-use crate::eravm::context::address_space::AddressSpace;
-use crate::eravm::context::function::declaration::Declaration as FunctionDeclaration;
-
-///
-/// The LLVM intrinsic functions, implemented in the LLVM back-end.
-///
-/// Most of them are translated directly into bytecode instructions.
-///
-#[derive(Debug)]
-pub struct Intrinsics<'ctx> {
-    /// The trap.
-    pub trap: FunctionDeclaration<'ctx>,
-    /// The memory copy within the heap.
-    pub memory_copy: FunctionDeclaration<'ctx>,
-    /// The memory copy from a generic page.
-    pub memory_copy_from_generic: FunctionDeclaration<'ctx>,
-    /// Performs endianness swaps on i256 values
-    pub byte_swap: FunctionDeclaration<'ctx>,
-}
-
-impl<'ctx> Intrinsics<'ctx> {
-    /// The corresponding intrinsic function name.
-    pub const FUNCTION_TRAP: &'static str = "llvm.trap";
-
-    /// The corresponding intrinsic function name.
-    pub const FUNCTION_MEMORY_COPY: &'static str = "llvm.memcpy.p1.p1.i256";
-
-    /// The corresponding intrinsic function name.
-    pub const FUNCTION_MEMORY_COPY_FROM_GENERIC: &'static str = "llvm.memcpy.p3.p1.i256";
-
-    /// The corresponding intrinsic function name.
-    pub const FUNCTION_BYTE_SWAP: &'static str = "llvm.bswap.i256";
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(
-        llvm: &'ctx inkwell::context::Context,
-        module: &inkwell::module::Module<'ctx>,
-    ) -> Self {
-        let void_type = llvm.void_type();
-        let bool_type = llvm.bool_type();
-        let field_type = llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32);
-        let _stack_field_pointer_type = llvm.ptr_type(AddressSpace::Stack.into());
-        let heap_field_pointer_type = llvm.ptr_type(AddressSpace::Heap.into());
-        let generic_byte_pointer_type = llvm.ptr_type(AddressSpace::Generic.into());
-
-        let trap = Self::declare(
-            llvm,
-            module,
-            Self::FUNCTION_TRAP,
-            void_type.fn_type(&[], false),
-        );
-        let memory_copy = Self::declare(
-            llvm,
-            module,
-            Self::FUNCTION_MEMORY_COPY,
-            void_type.fn_type(
-                &[
-                    heap_field_pointer_type.as_basic_type_enum().into(),
-                    heap_field_pointer_type.as_basic_type_enum().into(),
-                    field_type.as_basic_type_enum().into(),
-                    bool_type.as_basic_type_enum().into(),
-                ],
-                false,
-            ),
-        );
-        let memory_copy_from_generic = Self::declare(
-            llvm,
-            module,
-            Self::FUNCTION_MEMORY_COPY_FROM_GENERIC,
-            void_type.fn_type(
-                &[
-                    heap_field_pointer_type.as_basic_type_enum().into(),
-                    generic_byte_pointer_type.as_basic_type_enum().into(),
-                    field_type.as_basic_type_enum().into(),
-                    bool_type.as_basic_type_enum().into(),
-                ],
-                false,
-            ),
-        );
-        let byte_swap = Self::declare(
-            llvm,
-            module,
-            Self::FUNCTION_BYTE_SWAP,
-            field_type.fn_type(&[field_type.as_basic_type_enum().into()], false),
-        );
-
-        Self {
-            trap,
-            memory_copy,
-            memory_copy_from_generic,
-            byte_swap,
-        }
-    }
-
-    ///
-    /// Finds the specified LLVM intrinsic function in the target and returns its declaration.
-    ///
-    pub fn declare(
-        llvm: &'ctx inkwell::context::Context,
-        module: &inkwell::module::Module<'ctx>,
-        name: &str,
-        r#type: inkwell::types::FunctionType<'ctx>,
-    ) -> FunctionDeclaration<'ctx> {
-        let intrinsic = inkwell::intrinsics::Intrinsic::find(name)
-            .unwrap_or_else(|| panic!("Intrinsic function `{name}` does not exist"));
-        let argument_types = Self::argument_types(llvm, name);
-        let value = intrinsic
-            .get_declaration(module, argument_types.as_slice())
-            .unwrap_or_else(|| panic!("Intrinsic function `{name}` declaration error"));
-        FunctionDeclaration::new(r#type, value)
-    }
-
-    ///
-    /// Returns the LLVM types for selecting via the signature.
-    ///
-    pub fn argument_types(
-        llvm: &'ctx inkwell::context::Context,
-        name: &str,
-    ) -> Vec<inkwell::types::BasicTypeEnum<'ctx>> {
-        let field_type = llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32);
-
-        match name {
-            name if name == Self::FUNCTION_MEMORY_COPY => vec![
-                llvm.ptr_type(AddressSpace::Heap.into())
-                    .as_basic_type_enum(),
-                llvm.ptr_type(AddressSpace::Heap.into())
-                    .as_basic_type_enum(),
-                field_type.as_basic_type_enum(),
-            ],
-            name if name == Self::FUNCTION_MEMORY_COPY_FROM_GENERIC => vec![
-                llvm.ptr_type(AddressSpace::Heap.into())
-                    .as_basic_type_enum(),
-                llvm.ptr_type(AddressSpace::Generic.into())
-                    .as_basic_type_enum(),
-                field_type.as_basic_type_enum(),
-            ],
-            name if name == Self::FUNCTION_BYTE_SWAP => vec![field_type.as_basic_type_enum()],
-            _ => vec![],
-        }
-    }
-}

crates/llvm-context/src/eravm/context/function/llvm_runtime.rs

@@ -1,667 +0,0 @@
-//!
-//! The LLVM runtime functions.
-//!
-
-use inkwell::types::BasicType;
-
-use crate::eravm::context::address_space::AddressSpace;
-use crate::eravm::context::function::declaration::Declaration as FunctionDeclaration;
-use crate::eravm::context::function::Function;
-use crate::optimizer::Optimizer;
-
-///
-/// The runtime functions, implemented on the LLVM side.
-///
-/// The functions are automatically linked to the LLVM implementations if the signatures match.
-///
-#[derive(Debug)]
-pub struct LLVMRuntime<'ctx> {
-    /// The LLVM personality function, used for exception handling.
-    pub personality: FunctionDeclaration<'ctx>,
-    /// The LLVM exception throwing function.
-    pub cxa_throw: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub div: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub sdiv: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub r#mod: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub smod: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub shl: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub shr: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub sar: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub byte: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub add_mod: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub mul_mod: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub exp: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub sign_extend: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub sha3: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub system_request: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    //pub far_call: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub far_call_byref: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub static_call: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub static_call_byref: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub delegate_call: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub delegate_call_byref: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub mimic_call: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub mimic_call_byref: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub r#return: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub revert: FunctionDeclaration<'ctx>,
-}
-
-impl<'ctx> LLVMRuntime<'ctx> {
-    /// The LLVM personality function name.
-    pub const FUNCTION_PERSONALITY: &'static str = "__personality";
-
-    /// The LLVM exception throwing function name.
-    pub const FUNCTION_CXA_THROW: &'static str = "__cxa_throw";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_DIV: &'static str = "__div";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_SDIV: &'static str = "__sdiv";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_MOD: &'static str = "__mod";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_SMOD: &'static str = "__smod";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_SHL: &'static str = "__shl";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_SHR: &'static str = "__shr";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_SAR: &'static str = "__sar";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_BYTE: &'static str = "__byte";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_ADDMOD: &'static str = "__addmod";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_MULMOD: &'static str = "__mulmod";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_EXP: &'static str = "__exp";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_SIGNEXTEND: &'static str = "__signextend";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_SHA3: &'static str = "__sha3";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_SYSTEM_REQUEST: &'static str = "__system_request";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_FARCALL: &'static str = "__farcall";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_STATICCALL: &'static str = "__staticcall";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_DELEGATECALL: &'static str = "__delegatecall";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_MIMICCALL: &'static str = "__mimiccall";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_FARCALL_BYREF: &'static str = "__farcall_byref";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_STATICCALL_BYREF: &'static str = "__staticcall_byref";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_DELEGATECALL_BYREF: &'static str = "__delegatecall_byref";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_MIMICCALL_BYREF: &'static str = "__mimiccall_byref";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_RETURN: &'static str = "__return";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_REVERT: &'static str = "__revert";
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(
-        llvm: &'ctx inkwell::context::Context,
-        module: &inkwell::module::Module<'ctx>,
-        optimizer: &Optimizer,
-    ) -> Self {
-        let personality = Self::declare(
-            module,
-            Self::FUNCTION_PERSONALITY,
-            llvm.i32_type().fn_type(&[], false),
-            None,
-        );
-
-        let cxa_throw = Self::declare(
-            module,
-            Self::FUNCTION_CXA_THROW,
-            llvm.void_type().fn_type(
-                vec![
-                    llvm.ptr_type(AddressSpace::Stack.into())
-                        .as_basic_type_enum()
-                        .into();
-                    3
-                ]
-                .as_slice(),
-                false,
-            ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_cxa_throw_attributes(llvm, cxa_throw);
-
-        let div = Self::declare(
-            module,
-            Self::FUNCTION_DIV,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                            .as_basic_type_enum()
-                            .into();
-                        2
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, div, optimizer);
-        Function::set_pure_function_attributes(llvm, div);
-
-        let r#mod = Self::declare(
-            module,
-            Self::FUNCTION_MOD,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                            .as_basic_type_enum()
-                            .into();
-                        2
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, r#mod, optimizer);
-        Function::set_pure_function_attributes(llvm, r#mod);
-
-        let sdiv = Self::declare(
-            module,
-            Self::FUNCTION_SDIV,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                            .as_basic_type_enum()
-                            .into();
-                        2
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, sdiv, optimizer);
-        Function::set_pure_function_attributes(llvm, sdiv);
-
-        let smod = Self::declare(
-            module,
-            Self::FUNCTION_SMOD,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                            .as_basic_type_enum()
-                            .into();
-                        2
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, smod, optimizer);
-        Function::set_pure_function_attributes(llvm, smod);
-
-        let shl = Self::declare(
-            module,
-            Self::FUNCTION_SHL,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                            .as_basic_type_enum()
-                            .into();
-                        2
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, shl, optimizer);
-        Function::set_pure_function_attributes(llvm, shl);
-
-        let shr = Self::declare(
-            module,
-            Self::FUNCTION_SHR,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                            .as_basic_type_enum()
-                            .into();
-                        2
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, shr, optimizer);
-        Function::set_pure_function_attributes(llvm, shr);
-
-        let sar = Self::declare(
-            module,
-            Self::FUNCTION_SAR,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                            .as_basic_type_enum()
-                            .into();
-                        2
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, sar, optimizer);
-        Function::set_pure_function_attributes(llvm, sar);
-
-        let byte = Self::declare(
-            module,
-            Self::FUNCTION_BYTE,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                            .as_basic_type_enum()
-                            .into();
-                        2
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, byte, optimizer);
-        Function::set_pure_function_attributes(llvm, byte);
-
-        let add_mod =
-            Self::define(module, Self::FUNCTION_ADDMOD).expect("should be declared in stdlib");
-        Function::set_default_attributes(llvm, add_mod, optimizer);
-        Function::set_pure_function_attributes(llvm, add_mod);
-
-        let mul_mod =
-            Self::define(module, Self::FUNCTION_MULMOD).expect("should be declared in stdlib");
-        Function::set_default_attributes(llvm, mul_mod, optimizer);
-        Function::set_pure_function_attributes(llvm, mul_mod);
-
-        let exp = Self::define(module, Self::FUNCTION_EXP).expect("should be declared in stdlib");
-        Function::set_default_attributes(llvm, exp, optimizer);
-        Function::set_pure_function_attributes(llvm, exp);
-
-        let sign_extend =
-            Self::define(module, Self::FUNCTION_SIGNEXTEND).expect("should be declared in stdlib");
-        Function::set_default_attributes(llvm, sign_extend, optimizer);
-        Function::set_pure_function_attributes(llvm, sign_extend);
-
-        let sha3 = Self::declare(
-            module,
-            Self::FUNCTION_SHA3,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                .fn_type(
-                    vec![
-                        llvm.ptr_type(AddressSpace::Heap.into())
-                            .as_basic_type_enum()
-                            .into(),
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                            .as_basic_type_enum()
-                            .into(),
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_BOOLEAN as u32)
-                            .as_basic_type_enum()
-                            .into(),
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, sha3, optimizer);
-        Function::set_attributes(
-            llvm,
-            sha3,
-            //vec![Attribute::ArgMemOnly, Attribute::ReadOnly],
-            vec![],
-            false,
-        );
-
-        let system_request = Self::declare(
-            module,
-            Self::FUNCTION_SYSTEM_REQUEST,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                            .as_basic_type_enum()
-                            .into(),
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                            .as_basic_type_enum()
-                            .into(),
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                            .as_basic_type_enum()
-                            .into(),
-                        llvm.ptr_type(AddressSpace::Stack.into())
-                            .as_basic_type_enum()
-                            .into(),
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, system_request, optimizer);
-        Function::set_attributes(
-            llvm,
-            system_request,
-            //vec![Attribute::ArgMemOnly, Attribute::ReadOnly],
-            vec![],
-            false,
-        );
-
-        let external_call_arguments: Vec<inkwell::types::BasicMetadataTypeEnum> = vec![
-                llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                    .as_basic_type_enum()
-                    .into();
-                crate::eravm::context::function::runtime::entry::Entry::MANDATORY_ARGUMENTS_COUNT
-                    + crate::eravm::EXTRA_ABI_DATA_SIZE
-            ];
-        let mut mimic_call_arguments = external_call_arguments.clone();
-        mimic_call_arguments.push(
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                .as_basic_type_enum()
-                .into(),
-        );
-
-        let mut external_call_arguments_by_ref: Vec<inkwell::types::BasicMetadataTypeEnum> = vec![
-            llvm.ptr_type(AddressSpace::Generic.into())
-                .as_basic_type_enum()
-                .into(),
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                .as_basic_type_enum()
-                .into(),
-        ];
-        external_call_arguments_by_ref.extend::<Vec<inkwell::types::BasicMetadataTypeEnum>>(vec![
-            llvm.custom_width_int_type(
-                revive_common::BIT_LENGTH_FIELD as u32
-            )
-            .as_basic_type_enum()
-            .into();
-            crate::eravm::EXTRA_ABI_DATA_SIZE
-        ]);
-        let mut mimic_call_arguments_by_ref = external_call_arguments_by_ref.clone();
-        mimic_call_arguments_by_ref.push(
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                .as_basic_type_enum()
-                .into(),
-        );
-
-        let external_call_result_type = llvm
-            .struct_type(
-                &[
-                    llvm.ptr_type(AddressSpace::Generic.into())
-                        .as_basic_type_enum(),
-                    llvm.bool_type().as_basic_type_enum(),
-                ],
-                false,
-            )
-            .as_basic_type_enum();
-
-        //let far_call = Self::declare(
-        //    module,
-        //    Self::FUNCTION_FARCALL,
-        //    external_call_result_type.fn_type(external_call_arguments.as_slice(), false),
-        //    Some(inkwell::module::Linkage::External),
-        //);
-        //Function::set_default_attributes(llvm, far_call, optimizer);
-        let static_call = Self::declare(
-            module,
-            Self::FUNCTION_STATICCALL,
-            external_call_result_type.fn_type(external_call_arguments.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, static_call, optimizer);
-        let delegate_call = Self::declare(
-            module,
-            Self::FUNCTION_DELEGATECALL,
-            external_call_result_type.fn_type(external_call_arguments.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, delegate_call, optimizer);
-        let mimic_call = Self::declare(
-            module,
-            Self::FUNCTION_MIMICCALL,
-            external_call_result_type.fn_type(mimic_call_arguments.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, mimic_call, optimizer);
-
-        let far_call_byref = Self::declare(
-            module,
-            Self::FUNCTION_FARCALL_BYREF,
-            external_call_result_type.fn_type(external_call_arguments_by_ref.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, far_call_byref, optimizer);
-        let static_call_byref = Self::declare(
-            module,
-            Self::FUNCTION_STATICCALL_BYREF,
-            external_call_result_type.fn_type(external_call_arguments_by_ref.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, static_call_byref, optimizer);
-        let delegate_call_byref = Self::declare(
-            module,
-            Self::FUNCTION_DELEGATECALL_BYREF,
-            external_call_result_type.fn_type(external_call_arguments_by_ref.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, delegate_call_byref, optimizer);
-        let mimic_call_byref = Self::declare(
-            module,
-            Self::FUNCTION_MIMICCALL_BYREF,
-            external_call_result_type.fn_type(mimic_call_arguments_by_ref.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, mimic_call_byref, optimizer);
-
-        let r#return = Self::declare(
-            module,
-            Self::FUNCTION_RETURN,
-            llvm.void_type().fn_type(
-                vec![
-                    llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                        .as_basic_type_enum()
-                        .into();
-                    3
-                ]
-                .as_slice(),
-                false,
-            ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, r#return, optimizer);
-        let revert = Self::declare(
-            module,
-            Self::FUNCTION_REVERT,
-            llvm.void_type().fn_type(
-                vec![
-                    llvm.custom_width_int_type(revive_common::BIT_LENGTH_FIELD as u32)
-                        .as_basic_type_enum()
-                        .into();
-                    3
-                ]
-                .as_slice(),
-                false,
-            ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, revert, optimizer);
-
-        Self {
-            personality,
-            cxa_throw,
-
-            div,
-            sdiv,
-            r#mod,
-            smod,
-
-            shl,
-            shr,
-            sar,
-            byte,
-
-            add_mod,
-            mul_mod,
-            exp,
-            sign_extend,
-
-            sha3,
-
-            system_request,
-
-            //far_call,
-            static_call,
-            delegate_call,
-            mimic_call,
-
-            far_call_byref,
-            static_call_byref,
-            delegate_call_byref,
-            mimic_call_byref,
-
-            r#return,
-            revert,
-        }
-    }
-
-    ///
-    /// Declares an LLVM runtime function in the `module`,
-    ///
-    pub fn declare(
-        module: &inkwell::module::Module<'ctx>,
-        name: &str,
-        r#type: inkwell::types::FunctionType<'ctx>,
-        linkage: Option<inkwell::module::Linkage>,
-    ) -> FunctionDeclaration<'ctx> {
-        let value = module.add_function(name, r#type, linkage);
-        FunctionDeclaration::new(r#type, value)
-    }
-
-    /// Create the function definition from an existing symbol.
-    pub fn define(
-        module: &inkwell::module::Module<'ctx>,
-        name: &str,
-    ) -> Option<FunctionDeclaration<'ctx>> {
-        let value = module.get_function(name)?;
-        value.set_linkage(inkwell::module::Linkage::External);
-        FunctionDeclaration::new(value.get_type(), value).into()
-    }
-
-    ///
-    /// Modifies the external call function with `is_byref` and `is_system` modifiers.
-    ///
-    pub fn modify(
-        &self,
-        function: FunctionDeclaration<'ctx>,
-        is_byref: bool,
-    ) -> anyhow::Result<FunctionDeclaration<'ctx>> {
-        let modified = if
-        /*function == self.far_call {
-            match is_byref {
-                false => self.far_call,
-                true => self.far_call_byref,
-            }
-        } else if */
-        function == self.static_call {
-            match is_byref {
-                false => self.static_call,
-                true => self.static_call_byref,
-            }
-        } else if function == self.delegate_call {
-            match is_byref {
-                false => self.delegate_call,
-                true => self.delegate_call_byref,
-            }
-        } else if function == self.mimic_call {
-            match is_byref {
-                false => self.mimic_call,
-                true => self.mimic_call_byref,
-            }
-        } else {
-            anyhow::bail!(
-                "Cannot modify an external call function `{}`",
-                function.value.get_name().to_string_lossy()
-            );
-        };
-
-        Ok(modified)
-    }
-}

crates/llvm-context/src/eravm/context/function/mod.rs

@@ -1,450 +0,0 @@
-//!
-//! The LLVM IR generator function.
-//!
-
-pub mod block;
-pub mod declaration;
-pub mod evmla_data;
-pub mod intrinsics;
-pub mod llvm_runtime;
-pub mod r#return;
-pub mod runtime;
-pub mod vyper_data;
-pub mod yul_data;
-
-use std::collections::HashMap;
-
-use crate::eravm::context::attribute::Attribute;
-use crate::eravm::context::pointer::Pointer;
-use crate::optimizer::settings::size_level::SizeLevel;
-use crate::optimizer::Optimizer;
-
-use self::declaration::Declaration;
-use self::evmla_data::EVMLAData;
-use self::r#return::Return;
-use self::runtime::Runtime;
-use self::vyper_data::VyperData;
-use self::yul_data::YulData;
-
-///
-/// The LLVM IR generator function.
-///
-#[derive(Debug)]
-pub struct Function<'ctx> {
-    /// The high-level source code name.
-    name: String,
-    /// The LLVM function declaration.
-    declaration: Declaration<'ctx>,
-    /// The stack representation.
-    stack: HashMap<String, Pointer<'ctx>>,
-    /// The return value entity.
-    r#return: Return<'ctx>,
-
-    /// The entry block. Each LLVM IR functions must have an entry block.
-    entry_block: inkwell::basic_block::BasicBlock<'ctx>,
-    /// The return/leave block. LLVM IR functions may have multiple returning blocks, but it is
-    /// more reasonable to have a single returning block and other high-level language returns
-    /// jumping to it. This way it is easier to implement some additional checks and clean-ups
-    /// before the returning.
-    return_block: inkwell::basic_block::BasicBlock<'ctx>,
-
-    /// The Yul compiler data.
-    yul_data: Option<YulData>,
-    /// The EVM legacy assembly compiler data.
-    evmla_data: Option<EVMLAData<'ctx>>,
-    /// The Vyper data.
-    vyper_data: Option<VyperData>,
-}
-
-impl<'ctx> Function<'ctx> {
-    /// The near call ABI function prefix.
-    pub const ZKSYNC_NEAR_CALL_ABI_PREFIX: &'static str = "ZKSYNC_NEAR_CALL";
-
-    /// The near call ABI exception handler name.
-    pub const ZKSYNC_NEAR_CALL_ABI_EXCEPTION_HANDLER: &'static str = "ZKSYNC_CATCH_NEAR_CALL";
-
-    /// The stack hashmap default capacity.
-    const STACK_HASHMAP_INITIAL_CAPACITY: usize = 64;
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(
-        name: String,
-        declaration: Declaration<'ctx>,
-        r#return: Return<'ctx>,
-
-        entry_block: inkwell::basic_block::BasicBlock<'ctx>,
-        return_block: inkwell::basic_block::BasicBlock<'ctx>,
-    ) -> Self {
-        Self {
-            name,
-            declaration,
-            stack: HashMap::with_capacity(Self::STACK_HASHMAP_INITIAL_CAPACITY),
-            r#return,
-
-            entry_block,
-            return_block,
-
-            yul_data: None,
-            evmla_data: None,
-            vyper_data: None,
-        }
-    }
-
-    ///
-    /// Returns the function name reference.
-    ///
-    pub fn name(&self) -> &str {
-        self.name.as_str()
-    }
-
-    ///
-    /// Checks whether the function is defined outside of the front-end.
-    ///
-    pub fn is_name_external(name: &str) -> bool {
-        name.starts_with("llvm.")
-            || (name.starts_with("__")
-                && name != Runtime::FUNCTION_ENTRY
-                && name != Runtime::FUNCTION_DEPLOY_CODE
-                && name != Runtime::FUNCTION_RUNTIME_CODE)
-    }
-
-    ///
-    /// Checks whether the function is related to the near call ABI.
-    ///
-    pub fn is_near_call_abi(name: &str) -> bool {
-        name.starts_with(Self::ZKSYNC_NEAR_CALL_ABI_PREFIX)
-            || name == Self::ZKSYNC_NEAR_CALL_ABI_EXCEPTION_HANDLER
-    }
-
-    ///
-    /// Returns the LLVM function declaration.
-    ///
-    pub fn declaration(&self) -> Declaration<'ctx> {
-        self.declaration
-    }
-
-    ///
-    /// Returns the N-th parameter of the function.
-    ///
-    pub fn get_nth_param(&self, index: usize) -> inkwell::values::BasicValueEnum<'ctx> {
-        self.declaration()
-            .value
-            .get_nth_param(index as u32)
-            .expect("Always exists")
-    }
-
-    ///
-    /// Sets the memory writer function attributes.
-    ///
-    pub fn set_attributes(
-        llvm: &'ctx inkwell::context::Context,
-        declaration: Declaration<'ctx>,
-        attributes: Vec<Attribute>,
-        force: bool,
-    ) {
-        for attribute_kind in attributes.into_iter() {
-            match attribute_kind {
-                attribute_kind @ Attribute::AlwaysInline if force => {
-                    let is_optimize_none_set = declaration
-                        .value
-                        .get_enum_attribute(
-                            inkwell::attributes::AttributeLoc::Function,
-                            Attribute::OptimizeNone as u32,
-                        )
-                        .is_some();
-                    if !is_optimize_none_set {
-                        declaration.value.remove_enum_attribute(
-                            inkwell::attributes::AttributeLoc::Function,
-                            Attribute::NoInline as u32,
-                        );
-                        declaration.value.add_attribute(
-                            inkwell::attributes::AttributeLoc::Function,
-                            llvm.create_enum_attribute(attribute_kind as u32, 0),
-                        );
-                    }
-                }
-                attribute_kind @ Attribute::NoInline if force => {
-                    declaration.value.remove_enum_attribute(
-                        inkwell::attributes::AttributeLoc::Function,
-                        Attribute::AlwaysInline as u32,
-                    );
-                    declaration.value.add_attribute(
-                        inkwell::attributes::AttributeLoc::Function,
-                        llvm.create_enum_attribute(attribute_kind as u32, 0),
-                    );
-                }
-                attribute_kind => declaration.value.add_attribute(
-                    inkwell::attributes::AttributeLoc::Function,
-                    llvm.create_enum_attribute(attribute_kind as u32, 0),
-                ),
-            }
-        }
-    }
-
-    /// Remove specified attributes existing on the given declaration.
-    pub fn remove_attributes(declaration: Declaration, attributes: &[Attribute]) {
-        for attribute in attributes.iter().filter(|attribute| {
-            declaration
-                .value
-                .get_enum_attribute(
-                    inkwell::attributes::AttributeLoc::Function,
-                    **attribute as u32,
-                )
-                .is_some()
-        }) {
-            declaration.value.remove_enum_attribute(
-                inkwell::attributes::AttributeLoc::Function,
-                *attribute as u32,
-            );
-        }
-    }
-
-    ///
-    /// Sets the default attributes.
-    ///
-    /// The attributes only affect the LLVM optimizations.
-    ///
-    pub fn set_default_attributes(
-        llvm: &'ctx inkwell::context::Context,
-        declaration: Declaration<'ctx>,
-        optimizer: &Optimizer,
-    ) {
-        if optimizer.settings().level_middle_end == inkwell::OptimizationLevel::None {
-            Self::remove_attributes(
-                declaration,
-                &[Attribute::OptimizeForSize, Attribute::AlwaysInline],
-            );
-            Self::set_attributes(
-                llvm,
-                declaration,
-                vec![Attribute::OptimizeNone, Attribute::NoInline],
-                false,
-            );
-        } else if optimizer.settings().level_middle_end_size == SizeLevel::Z {
-            Self::set_attributes(
-                llvm,
-                declaration,
-                vec![Attribute::OptimizeForSize, Attribute::MinSize],
-                false,
-            );
-        }
-
-        Self::set_attributes(llvm, declaration, vec![Attribute::NoFree], false);
-    }
-
-    ///
-    /// Sets the front-end runtime attributes.
-    ///
-    pub fn set_frontend_runtime_attributes(
-        llvm: &'ctx inkwell::context::Context,
-        declaration: Declaration<'ctx>,
-        optimizer: &Optimizer,
-    ) {
-        if optimizer.settings().level_middle_end_size == SizeLevel::Z {
-            Self::set_attributes(llvm, declaration, vec![Attribute::NoInline], false);
-        }
-    }
-
-    ///
-    /// Sets the exception handler attributes.
-    ///
-    pub fn set_exception_handler_attributes(
-        llvm: &'ctx inkwell::context::Context,
-        declaration: Declaration<'ctx>,
-    ) {
-        Self::set_attributes(llvm, declaration, vec![Attribute::NoInline], false);
-    }
-
-    ///
-    /// Sets the CXA-throw attributes.
-    ///
-    pub fn set_cxa_throw_attributes(
-        llvm: &'ctx inkwell::context::Context,
-        declaration: Declaration<'ctx>,
-    ) {
-        Self::set_attributes(llvm, declaration, vec![Attribute::NoProfile], false);
-    }
-
-    ///
-    /// Sets the pure function attributes.
-    ///
-    pub fn set_pure_function_attributes(
-        llvm: &'ctx inkwell::context::Context,
-        declaration: Declaration<'ctx>,
-    ) {
-        Self::set_attributes(
-            llvm,
-            declaration,
-            vec![
-                Attribute::MustProgress,
-                Attribute::NoUnwind,
-                // FIXME: LLVM complains about ReadNone being not valid for fns
-                // Attribute::ReadNone,
-                Attribute::WillReturn,
-            ],
-            false,
-        );
-    }
-
-    ///
-    /// Saves the pointer to a stack variable, returning the pointer to the shadowed variable,
-    /// if it exists.
-    ///
-    pub fn insert_stack_pointer(
-        &mut self,
-        name: String,
-        pointer: Pointer<'ctx>,
-    ) -> Option<Pointer<'ctx>> {
-        self.stack.insert(name, pointer)
-    }
-
-    ///
-    /// Gets the pointer to a stack variable.
-    ///
-    pub fn get_stack_pointer(&self, name: &str) -> Option<Pointer<'ctx>> {
-        self.stack.get(name).copied()
-    }
-
-    ///
-    /// Removes the pointer to a stack variable.
-    ///
-    pub fn remove_stack_pointer(&mut self, name: &str) {
-        self.stack.remove(name);
-    }
-
-    ///
-    /// Returns the return entity representation.
-    ///
-    pub fn r#return(&self) -> Return<'ctx> {
-        self.r#return
-    }
-
-    ///
-    /// Returns the pointer to the function return value.
-    ///
-    /// # Panics
-    /// If the pointer has not been set yet.
-    ///
-    pub fn return_pointer(&self) -> Option<Pointer<'ctx>> {
-        self.r#return.return_pointer()
-    }
-
-    ///
-    /// Returns the return data size in bytes, based on the default stack alignment.
-    ///
-    /// # Panics
-    /// If the pointer has not been set yet.
-    ///
-    pub fn return_data_size(&self) -> usize {
-        self.r#return.return_data_size()
-    }
-
-    ///
-    /// Returns the function entry block.
-    ///
-    pub fn entry_block(&self) -> inkwell::basic_block::BasicBlock<'ctx> {
-        self.entry_block
-    }
-
-    ///
-    /// Returns the function return block.
-    ///
-    pub fn return_block(&self) -> inkwell::basic_block::BasicBlock<'ctx> {
-        self.return_block
-    }
-
-    ///
-    /// Sets the EVM legacy assembly data.
-    ///
-    pub fn set_evmla_data(&mut self, data: EVMLAData<'ctx>) {
-        self.evmla_data = Some(data);
-    }
-
-    ///
-    /// Returns the EVM legacy assembly data reference.
-    ///
-    /// # Panics
-    /// If the EVM data has not been initialized.
-    ///
-    pub fn evmla(&self) -> &EVMLAData<'ctx> {
-        self.evmla_data
-            .as_ref()
-            .expect("The EVM data must have been initialized")
-    }
-
-    ///
-    /// Returns the EVM legacy assembly data mutable reference.
-    ///
-    /// # Panics
-    /// If the EVM data has not been initialized.
-    ///
-    pub fn evmla_mut(&mut self) -> &mut EVMLAData<'ctx> {
-        self.evmla_data
-            .as_mut()
-            .expect("The EVM data must have been initialized")
-    }
-
-    ///
-    /// Sets the Vyper data.
-    ///
-    pub fn set_vyper_data(&mut self, data: VyperData) {
-        self.vyper_data = Some(data);
-    }
-
-    ///
-    /// Returns the Vyper data reference.
-    ///
-    /// # Panics
-    /// If the Vyper data has not been initialized.
-    ///
-    pub fn vyper(&self) -> &VyperData {
-        self.vyper_data
-            .as_ref()
-            .expect("The Vyper data must have been initialized")
-    }
-
-    ///
-    /// Returns the Vyper data mutable reference.
-    ///
-    /// # Panics
-    /// If the Vyper data has not been initialized.
-    ///
-    pub fn vyper_mut(&mut self) -> &mut VyperData {
-        self.vyper_data
-            .as_mut()
-            .expect("The Vyper data must have been initialized")
-    }
-
-    ///
-    /// Sets the Yul data.
-    ///
-    pub fn set_yul_data(&mut self, data: YulData) {
-        self.yul_data = Some(data);
-    }
-
-    ///
-    /// Returns the Yul data reference.
-    ///
-    /// # Panics
-    /// If the Yul data has not been initialized.
-    ///
-    pub fn yul(&self) -> &YulData {
-        self.yul_data
-            .as_ref()
-            .expect("The Yul data must have been initialized")
-    }
-
-    ///
-    /// Returns the Yul data mutable reference.
-    ///
-    /// # Panics
-    /// If the Yul data has not been initialized.
-    ///
-    pub fn yul_mut(&mut self) -> &mut YulData {
-        self.yul_data
-            .as_mut()
-            .expect("The Yul data must have been initialized")
-    }
-}

crates/llvm-context/src/eravm/context/function/return.rs

@@ -1,73 +0,0 @@
-//!
-//! The LLVM IR generator function return entity.
-//!
-
-use crate::eravm::context::pointer::Pointer;
-
-///
-/// The LLVM IR generator function return entity.
-///
-#[derive(Debug, Clone, Copy)]
-pub enum Return<'ctx> {
-    /// The function does not return a value.
-    None,
-    /// The function returns a primitive value.
-    Primitive {
-        /// The primitive value pointer allocated at the function entry.
-        pointer: Pointer<'ctx>,
-    },
-    /// The function returns a compound value.
-    /// In this case, the return pointer is allocated on the stack by the callee.
-    Compound {
-        /// The structure pointer allocated at the function entry.
-        pointer: Pointer<'ctx>,
-        /// The function return type size.
-        size: usize,
-    },
-}
-
-impl<'ctx> Return<'ctx> {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn none() -> Self {
-        Self::None
-    }
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn primitive(pointer: Pointer<'ctx>) -> Self {
-        Self::Primitive { pointer }
-    }
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn compound(pointer: Pointer<'ctx>, size: usize) -> Self {
-        Self::Compound { pointer, size }
-    }
-
-    ///
-    /// Returns the pointer to the function return value.
-    ///
-    pub fn return_pointer(&self) -> Option<Pointer<'ctx>> {
-        match self {
-            Return::None => None,
-            Return::Primitive { pointer } => Some(pointer.to_owned()),
-            Return::Compound { pointer, .. } => Some(pointer.to_owned()),
-        }
-    }
-
-    ///
-    /// Returns the return data size in bytes, based on the default stack alignment.
-    ///
-    pub fn return_data_size(&self) -> usize {
-        revive_common::BYTE_LENGTH_FIELD
-            * match self {
-                Self::None => 0,
-                Self::Primitive { .. } => 1,
-                Self::Compound { size, .. } => *size,
-            }
-    }
-}

crates/llvm-context/src/eravm/context/function/runtime/default_call.rs

@@ -1,255 +0,0 @@
-//!
-//! The `default_call` function.
-//!
-
-use inkwell::types::BasicType;
-
-use crate::eravm::context::function::declaration::Declaration as FunctionDeclaration;
-use crate::eravm::context::function::llvm_runtime::LLVMRuntime;
-use crate::eravm::context::function::Function;
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-use crate::eravm::WriteLLVM;
-
-///
-/// The `default_call` function.
-///
-/// Generates a default contract call, if the `msg.value` is zero.
-///
-#[derive(Debug)]
-pub struct DefaultCall {
-    /// The name of the inner function used for the low-level call.
-    inner_name: String,
-    /// The function name with the low-level function name as an element.
-    name: String,
-}
-
-#[allow(unused)]
-impl DefaultCall {
-    /// The gas argument index.
-    pub const ARGUMENT_INDEX_GAS: usize = 0;
-
-    /// The address argument index.
-    pub const ARGUMENT_INDEX_ADDRESS: usize = 1;
-
-    /// The input offset argument index.
-    pub const ARGUMENT_INDEX_INPUT_OFFSET: usize = 2;
-
-    /// The input length argument index.
-    pub const ARGUMENT_INDEX_INPUT_LENGTH: usize = 3;
-
-    /// The output offset argument index.
-    pub const ARGUMENT_INDEX_OUTPUT_OFFSET: usize = 4;
-
-    /// The output length argument index.
-    pub const ARGUMENT_INDEX_OUTPUT_LENGTH: usize = 5;
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(call_function: FunctionDeclaration) -> Self {
-        let inner_name = call_function.value.get_name().to_string_lossy().to_string();
-        let name = Self::name(call_function);
-
-        Self { inner_name, name }
-    }
-
-    ///
-    /// Returns the function name.
-    ///
-    pub fn name(call_function: FunctionDeclaration) -> String {
-        let suffix = match call_function.value.get_name().to_string_lossy() {
-            name if name == LLVMRuntime::FUNCTION_FARCALL => "far",
-            name if name == LLVMRuntime::FUNCTION_STATICCALL => "static",
-            name if name == LLVMRuntime::FUNCTION_DELEGATECALL => "delegate",
-            name => panic!("Invalid low-level call inner function `{name}`"),
-        };
-        format!("__default_{suffix}_call")
-    }
-
-    ///
-    /// Returns the low-level call function.
-    ///
-    fn inner_function<'ctx, D>(&self, context: &Context<'ctx, D>) -> FunctionDeclaration<'ctx>
-    where
-        D: Dependency + Clone,
-    {
-        match self.inner_name.as_str() {
-            //name if name == LLVMRuntime::FUNCTION_FARCALL => context.llvm_runtime().far_call,
-            name if name == LLVMRuntime::FUNCTION_STATICCALL => context.llvm_runtime().static_call,
-            name if name == LLVMRuntime::FUNCTION_DELEGATECALL => {
-                context.llvm_runtime().delegate_call
-            }
-            name => panic!("Invalid low-level call inner function `{name}`"),
-        }
-    }
-}
-
-impl<D> WriteLLVM<D> for DefaultCall
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        let function_type = context.function_type(
-            vec![
-                context.field_type().as_basic_type_enum(),
-                context.field_type().as_basic_type_enum(),
-                context.field_type().as_basic_type_enum(),
-                context.field_type().as_basic_type_enum(),
-                context.field_type().as_basic_type_enum(),
-                context.field_type().as_basic_type_enum(),
-            ],
-            1,
-            false,
-        );
-        let function = context.add_function(
-            self.name.as_str(),
-            function_type,
-            1,
-            Some(inkwell::module::Linkage::Private),
-        )?;
-        Function::set_frontend_runtime_attributes(
-            context.llvm,
-            function.borrow().declaration(),
-            &context.optimizer,
-        );
-
-        Ok(())
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        context.set_current_function(self.name.as_str())?;
-
-        /*
-               let gas = context
-                   .current_function()
-                   .borrow()
-                   .get_nth_param(Self::ARGUMENT_INDEX_GAS)
-                   .into_int_value();
-               let address = context
-                   .current_function()
-                   .borrow()
-                   .get_nth_param(Self::ARGUMENT_INDEX_ADDRESS)
-                   .into_int_value();
-               let input_offset = context
-                   .current_function()
-                   .borrow()
-                   .get_nth_param(Self::ARGUMENT_INDEX_INPUT_OFFSET)
-                   .into_int_value();
-               let input_length = context
-                   .current_function()
-                   .borrow()
-                   .get_nth_param(Self::ARGUMENT_INDEX_INPUT_LENGTH)
-                   .into_int_value();
-               let output_offset = context
-                   .current_function()
-                   .borrow()
-                   .get_nth_param(Self::ARGUMENT_INDEX_OUTPUT_OFFSET)
-                   .into_int_value();
-               let output_length = context
-                   .current_function()
-                   .borrow()
-                   .get_nth_param(Self::ARGUMENT_INDEX_OUTPUT_LENGTH)
-                   .into_int_value();
-        */
-        context.set_basic_block(context.current_function().borrow().entry_block());
-
-        let status_code_result_pointer = context.build_alloca(
-            context.field_type(),
-            "contract_call_result_status_code_pointer",
-        );
-        /*
-        context.build_store(status_code_result_pointer, context.field_const(0));
-
-        let abi_data = crate::eravm::utils::abi_data(
-            context,
-            input_offset,
-            input_length,
-            Some(gas),
-            AddressSpace::Heap,
-            false,
-        )?
-        .into_int_value();
-
-        let result = context
-            .build_call(
-                self.inner_function(context),
-                crate::eravm::utils::external_call_arguments(
-                    context,
-                    abi_data.as_basic_value_enum(),
-                    address,
-                    vec![],
-                    None,
-                )
-                .as_slice(),
-                "contract_call_external",
-            )
-            .expect("IntrinsicFunction always returns a flag");
-
-        let result_abi_data = context
-            .builder()
-            .build_extract_value(
-                result.into_struct_value(),
-                0,
-                "contract_call_external_result_abi_data",
-            )
-            .expect("Always exists");
-        let result_abi_data_pointer = Pointer::new(
-            context.byte_type(),
-            AddressSpace::Generic,
-            result_abi_data.into_pointer_value(),
-        );
-        let result_abi_data_casted = result_abi_data_pointer.cast(context.field_type());
-
-        let result_status_code_boolean = context
-            .builder()
-            .build_extract_value(
-                result.into_struct_value(),
-                1,
-                "contract_call_external_result_status_code_boolean",
-            )
-            .expect("Always exists");
-        let result_status_code = context.builder().build_int_z_extend_or_bit_cast(
-            result_status_code_boolean.into_int_value(),
-            context.field_type(),
-            "contract_call_external_result_status_code",
-        )?;
-        context.build_store(status_code_result_pointer, result_status_code);
-
-        let source = result_abi_data_casted;
-
-        let destination = Pointer::new_with_offset(
-            context,
-            AddressSpace::Heap,
-            context.byte_type(),
-            output_offset,
-            "contract_call_destination",
-        );
-
-        context.build_memcpy_return_data(
-            context.intrinsics().memory_copy_from_generic,
-            destination,
-            source,
-            output_length,
-            "contract_call_memcpy_from_child",
-        );
-
-        context.write_abi_pointer(
-            result_abi_data_pointer,
-            crate::eravm::GLOBAL_RETURN_DATA_POINTER,
-        );
-        context.write_abi_data_size(
-            result_abi_data_pointer,
-            crate::eravm::GLOBAL_RETURN_DATA_SIZE,
-        );
-        */
-        context.build_unconditional_branch(context.current_function().borrow().return_block());
-
-        context.set_basic_block(context.current_function().borrow().return_block());
-        let status_code_result =
-            context.build_load(status_code_result_pointer, "contract_call_status_code")?;
-        context.build_return(Some(&status_code_result));
-
-        Ok(())
-    }
-}

crates/llvm-context/src/eravm/context/function/runtime/deploy_code.rs

@@ -1,105 +0,0 @@
-//!
-//! The deploy code function.
-//!
-
-use std::marker::PhantomData;
-
-use crate::eravm::context::address_space::AddressSpace;
-use crate::eravm::context::code_type::CodeType;
-use crate::eravm::context::function::runtime::Runtime;
-use crate::eravm::context::pointer::Pointer;
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-use crate::eravm::WriteLLVM;
-
-///
-/// The deploy code function.
-///
-/// Is a special function that is only used by the front-end generated code.
-///
-#[derive(Debug)]
-pub struct DeployCode<B, D>
-where
-    B: WriteLLVM<D>,
-    D: Dependency + Clone,
-{
-    /// The deploy code AST representation.
-    inner: B,
-    /// The `D` phantom data.
-    _pd: PhantomData<D>,
-}
-
-impl<B, D> DeployCode<B, D>
-where
-    B: WriteLLVM<D>,
-    D: Dependency + Clone,
-{
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(inner: B) -> Self {
-        Self {
-            inner,
-            _pd: PhantomData,
-        }
-    }
-}
-
-impl<B, D> WriteLLVM<D> for DeployCode<B, D>
-where
-    B: WriteLLVM<D>,
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        let function_type =
-            context.function_type::<inkwell::types::BasicTypeEnum>(vec![], 0, false);
-        context.add_function(
-            Runtime::FUNCTION_DEPLOY_CODE,
-            function_type,
-            0,
-            Some(inkwell::module::Linkage::External),
-        )?;
-
-        self.inner.declare(context)
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        context.set_current_function(Runtime::FUNCTION_DEPLOY_CODE)?;
-
-        context.set_basic_block(context.current_function().borrow().entry_block());
-        context.set_code_type(CodeType::Deploy);
-        if let Some(vyper) = context.vyper_data.as_ref() {
-            for index in 0..vyper.immutables_size() / revive_common::BYTE_LENGTH_FIELD {
-                let offset = (crate::eravm::r#const::HEAP_AUX_OFFSET_CONSTRUCTOR_RETURN_DATA
-                    as usize)
-                    + (1 + index) * 2 * revive_common::BYTE_LENGTH_FIELD;
-                let value = index * revive_common::BYTE_LENGTH_FIELD;
-                let pointer = Pointer::new_with_offset(
-                    context,
-                    AddressSpace::HeapAuxiliary,
-                    context.field_type(),
-                    context.field_const(offset as u64),
-                    "immutable_index_initializer",
-                );
-                context.build_store(pointer, context.field_const(value as u64))?;
-            }
-        }
-
-        self.inner.into_llvm(context)?;
-        match context
-            .basic_block()
-            .get_last_instruction()
-            .map(|instruction| instruction.get_opcode())
-        {
-            Some(inkwell::values::InstructionOpcode::Br) => {}
-            Some(inkwell::values::InstructionOpcode::Switch) => {}
-            _ => context
-                .build_unconditional_branch(context.current_function().borrow().return_block()),
-        }
-
-        context.set_basic_block(context.current_function().borrow().return_block());
-        context.build_return(None);
-
-        Ok(())
-    }
-}

crates/llvm-context/src/eravm/context/function/runtime/deployer_call.rs

@@ -1,332 +0,0 @@
-//!
-//! The `deployer_call` function.
-//!
-
-use inkwell::types::BasicType;
-
-use crate::eravm::context::address_space::AddressSpace;
-use crate::eravm::context::function::Function;
-use crate::eravm::context::pointer::Pointer;
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-use crate::eravm::WriteLLVM;
-
-///
-/// The `deployer_call` function.
-///
-/// Calls the deployer system contract, which returns the newly deployed contract address or 0.
-///
-/// The address is returned in the first 32-byte word of the return data. If it is 0, the 0 is
-/// returned. If the entire call has failed, there is also a 0 returned.
-///
-#[derive(Debug)]
-pub struct DeployerCall {
-    /// The address space where the calldata is allocated.
-    /// Solidity uses the ordinary heap. Vyper uses the auxiliary heap.
-    address_space: AddressSpace,
-}
-
-impl DeployerCall {
-    /// The default function name.
-    pub const FUNCTION_NAME: &'static str = "__deployer_call";
-
-    /// The value argument index.
-    pub const ARGUMENT_INDEX_VALUE: usize = 0;
-
-    /// The input offset argument index.
-    pub const ARGUMENT_INDEX_INPUT_OFFSET: usize = 1;
-
-    /// The input length argument index.
-    pub const ARGUMENT_INDEX_INPUT_LENGTH: usize = 2;
-
-    /// The signature hash argument index.
-    pub const ARGUMENT_INDEX_SIGNATURE_HASH: usize = 3;
-
-    /// The salt argument index.
-    pub const ARGUMENT_INDEX_SALT: usize = 4;
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(address_space: AddressSpace) -> Self {
-        Self { address_space }
-    }
-}
-
-impl<D> WriteLLVM<D> for DeployerCall
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        let function_type = context.function_type(
-            vec![
-                context.field_type().as_basic_type_enum(),
-                context.field_type().as_basic_type_enum(),
-                context.field_type().as_basic_type_enum(),
-                context.field_type().as_basic_type_enum(),
-                context.field_type().as_basic_type_enum(),
-            ],
-            1,
-            false,
-        );
-        let function = context.add_function(
-            Self::FUNCTION_NAME,
-            function_type,
-            1,
-            Some(inkwell::module::Linkage::External),
-        )?;
-        Function::set_frontend_runtime_attributes(
-            context.llvm,
-            function.borrow().declaration(),
-            &context.optimizer,
-        );
-
-        Ok(())
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        context.set_current_function(Self::FUNCTION_NAME)?;
-
-        let value = context
-            .current_function()
-            .borrow()
-            .get_nth_param(Self::ARGUMENT_INDEX_VALUE)
-            .into_int_value();
-        let input_offset = context
-            .current_function()
-            .borrow()
-            .get_nth_param(Self::ARGUMENT_INDEX_INPUT_OFFSET)
-            .into_int_value();
-        let input_length = context
-            .current_function()
-            .borrow()
-            .get_nth_param(Self::ARGUMENT_INDEX_INPUT_LENGTH)
-            .into_int_value();
-        let signature_hash = context
-            .current_function()
-            .borrow()
-            .get_nth_param(Self::ARGUMENT_INDEX_SIGNATURE_HASH)
-            .into_int_value();
-        let salt = context
-            .current_function()
-            .borrow()
-            .get_nth_param(Self::ARGUMENT_INDEX_SALT)
-            .into_int_value();
-
-        let error_block = context.append_basic_block("deployer_call_error_block");
-        let success_block = context.append_basic_block("deployer_call_success_block");
-        let value_zero_block = context.append_basic_block("deployer_call_value_zero_block");
-        let value_non_zero_block = context.append_basic_block("deployer_call_value_non_zero_block");
-        let value_join_block = context.append_basic_block("deployer_call_value_join_block");
-
-        context.set_basic_block(context.current_function().borrow().entry_block());
-        let _abi_data = crate::eravm::utils::abi_data(
-            context,
-            input_offset,
-            input_length,
-            None,
-            self.address_space,
-            true,
-        )?;
-
-        let signature_pointer = Pointer::new_with_offset(
-            context,
-            self.address_space,
-            context.field_type(),
-            input_offset,
-            "deployer_call_signature_pointer",
-        );
-        context.build_store(signature_pointer, signature_hash)?;
-
-        let salt_offset = context.builder().build_int_add(
-            input_offset,
-            context.field_const(revive_common::BYTE_LENGTH_X32 as u64),
-            "deployer_call_salt_offset",
-        )?;
-        let salt_pointer = Pointer::new_with_offset(
-            context,
-            self.address_space,
-            context.field_type(),
-            salt_offset,
-            "deployer_call_salt_pointer",
-        );
-        context.build_store(salt_pointer, salt)?;
-
-        let arguments_offset_offset = context.builder().build_int_add(
-            salt_offset,
-            context.field_const((revive_common::BYTE_LENGTH_FIELD * 2) as u64),
-            "deployer_call_arguments_offset_offset",
-        )?;
-        let arguments_offset_pointer = Pointer::new_with_offset(
-            context,
-            self.address_space,
-            context.field_type(),
-            arguments_offset_offset,
-            "deployer_call_arguments_offset_pointer",
-        );
-        context.build_store(
-            arguments_offset_pointer,
-            context.field_const(
-                (crate::eravm::DEPLOYER_CALL_HEADER_SIZE
-                    - (revive_common::BYTE_LENGTH_X32 + revive_common::BYTE_LENGTH_FIELD))
-                    as u64,
-            ),
-        )?;
-
-        let arguments_length_offset = context.builder().build_int_add(
-            arguments_offset_offset,
-            context.field_const(revive_common::BYTE_LENGTH_FIELD as u64),
-            "deployer_call_arguments_length_offset",
-        )?;
-        let arguments_length_pointer = Pointer::new_with_offset(
-            context,
-            self.address_space,
-            context.field_type(),
-            arguments_length_offset,
-            "deployer_call_arguments_length_pointer",
-        );
-        let arguments_length_value = context.builder().build_int_sub(
-            input_length,
-            context.field_const(crate::eravm::DEPLOYER_CALL_HEADER_SIZE as u64),
-            "deployer_call_arguments_length",
-        )?;
-        context.build_store(arguments_length_pointer, arguments_length_value)?;
-
-        let result_pointer =
-            context.build_alloca(context.field_type(), "deployer_call_result_pointer");
-        context.build_store(result_pointer, context.field_const(0))?;
-        let deployer_call_result_type = context.structure_type(&[
-            context
-                .llvm()
-                .ptr_type(AddressSpace::Generic.into())
-                .as_basic_type_enum(),
-            context.bool_type().as_basic_type_enum(),
-        ]);
-        let deployer_call_result_pointer =
-            context.build_alloca(deployer_call_result_type, "deployer_call_result_pointer");
-        context.build_store(
-            deployer_call_result_pointer,
-            deployer_call_result_type.const_zero(),
-        )?;
-        let is_value_zero = context.builder().build_int_compare(
-            inkwell::IntPredicate::EQ,
-            value,
-            context.field_const(0),
-            "deployer_call_is_value_zero",
-        )?;
-        context.build_conditional_branch(is_value_zero, value_zero_block, value_non_zero_block)?;
-
-        context.set_basic_block(value_zero_block);
-        //let deployer_call_result = context
-        //    .build_call(
-        //        context.llvm_runtime().far_call,
-        //        crate::eravm::utils::external_call_arguments(
-        //            context,
-        //            abi_data,
-        //            context.field_const(zkevm_opcode_defs::ADDRESS_CONTRACT_DEPLOYER.into()),
-        //            vec![],
-        //            None,
-        //        )
-        //        .as_slice(),
-        //        "deployer_call_ordinary",
-        //    )
-        //    .expect("Always returns a value");
-        //context.build_store(deployer_call_result_pointer, deployer_call_result)?;
-        context.build_unconditional_branch(value_join_block);
-
-        context.set_basic_block(value_non_zero_block);
-        //let deployer_call_result = context
-        //    .build_call(
-        //        context.llvm_runtime().far_call,
-        //        crate::eravm::utils::external_call_arguments(
-        //            context,
-        //            abi_data.as_basic_value_enum(),
-        //            context.field_const(zkevm_opcode_defs::ADDRESS_MSG_VALUE.into()),
-        //            vec![
-        //                value,
-        //                context.field_const(zkevm_opcode_defs::ADDRESS_CONTRACT_DEPLOYER.into()),
-        //                context.field_const(u64::from(crate::eravm::r#const::SYSTEM_CALL_BIT)),
-        //            ],
-        //            None,
-        //        )
-        //        .as_slice(),
-        //        "deployer_call_system",
-        //    )
-        //    .expect("Always returns a value");
-        //context.build_store(deployer_call_result_pointer, deployer_call_result)?;
-        context.build_unconditional_branch(value_join_block);
-
-        context.set_basic_block(value_join_block);
-        let result_abi_data_pointer = context.build_gep(
-            deployer_call_result_pointer,
-            &[
-                context.field_const(0),
-                context
-                    .integer_type(revive_common::BIT_LENGTH_X32)
-                    .const_zero(),
-            ],
-            context
-                .llvm()
-                .ptr_type(AddressSpace::Generic.into())
-                .as_basic_type_enum(),
-            "deployer_call_result_abi_data_pointer",
-        );
-        let result_abi_data =
-            context.build_load(result_abi_data_pointer, "deployer_call_result_abi_data")?;
-
-        let result_status_code_pointer = context.build_gep(
-            deployer_call_result_pointer,
-            &[
-                context.field_const(0),
-                context
-                    .integer_type(revive_common::BIT_LENGTH_X32)
-                    .const_int(1, false),
-            ],
-            context.bool_type().as_basic_type_enum(),
-            "contract_call_external_result_status_code_pointer",
-        );
-        let result_status_code_boolean = context
-            .build_load(
-                result_status_code_pointer,
-                "contract_call_external_result_status_code_boolean",
-            )?
-            .into_int_value();
-
-        context.build_conditional_branch(result_status_code_boolean, success_block, error_block)?;
-
-        context.set_basic_block(success_block);
-        let result_abi_data_pointer = Pointer::new(
-            context.field_type(),
-            AddressSpace::Generic,
-            result_abi_data.into_pointer_value(),
-        );
-        let address_or_status_code = context.build_load(
-            result_abi_data_pointer,
-            "deployer_call_address_or_status_code",
-        )?;
-        context.build_store(result_pointer, address_or_status_code)?;
-        context.build_unconditional_branch(context.current_function().borrow().return_block());
-
-        context.set_basic_block(error_block);
-        let result_abi_data_pointer = Pointer::new(
-            context.byte_type(),
-            AddressSpace::Generic,
-            result_abi_data.into_pointer_value(),
-        );
-        context.write_abi_pointer(
-            result_abi_data_pointer,
-            crate::eravm::GLOBAL_RETURN_DATA_POINTER,
-        );
-        context.write_abi_data_size(
-            result_abi_data_pointer,
-            crate::eravm::GLOBAL_RETURN_DATA_SIZE,
-        );
-        context.build_unconditional_branch(context.current_function().borrow().return_block());
-
-        context.set_basic_block(context.current_function().borrow().return_block());
-        let result = context.build_load(result_pointer, "deployer_call_result")?;
-        context.build_return(Some(&result));
-
-        Ok(())
-    }
-}

crates/llvm-context/src/eravm/context/function/runtime/entry.rs

@@ -1,282 +0,0 @@
-//!
-//! The entry function.
-//!
-
-use inkwell::types::BasicType;
-
-use crate::eravm::context::address_space::AddressSpace;
-use crate::eravm::context::function::runtime::Runtime;
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-use crate::eravm::WriteLLVM;
-use crate::EraVMPointer as Pointer;
-
-///
-/// The entry function.
-///
-/// The function is a wrapper managing the runtime and deploy code calling logic.
-///
-/// Is a special runtime function that is only used by the front-end generated code.
-///
-#[derive(Debug, Default)]
-pub struct Entry {}
-
-impl Entry {
-    /// The call flags argument index.
-    pub const ARGUMENT_INDEX_CALL_FLAGS: usize = 0;
-
-    /// The number of mandatory arguments.
-    pub const MANDATORY_ARGUMENTS_COUNT: usize = 2;
-
-    /// Reserve 1kb for calldata.
-    pub const MAX_CALLDATA_SIZE: usize = 1024;
-
-    /// Initializes the global variables.
-    /// The pointers are not initialized, because it's not possible to create a null pointer.
-    pub fn initialize_globals<D>(context: &mut Context<D>) -> anyhow::Result<()>
-    where
-        D: Dependency + Clone,
-    {
-        let calldata_type = context.array_type(context.byte_type(), Self::MAX_CALLDATA_SIZE);
-        context.set_global(
-            crate::eravm::GLOBAL_CALLDATA_POINTER,
-            calldata_type,
-            AddressSpace::Stack,
-            calldata_type.get_undef(),
-        );
-
-        context.set_global(
-            crate::eravm::GLOBAL_HEAP_MEMORY_POINTER,
-            context.llvm().ptr_type(AddressSpace::Generic.into()),
-            AddressSpace::Stack,
-            context.xlen_type().get_undef(),
-        );
-        context.build_store(
-            context
-                .get_global(crate::eravm::GLOBAL_HEAP_MEMORY_POINTER)?
-                .into(),
-            context.build_sbrk(context.integer_const(32, 0))?,
-        )?;
-
-        context.set_global(
-            crate::eravm::GLOBAL_CALLDATA_SIZE,
-            context.field_type(),
-            AddressSpace::Stack,
-            context.field_undef(),
-        );
-        context.set_global(
-            crate::eravm::GLOBAL_RETURN_DATA_SIZE,
-            context.field_type(),
-            AddressSpace::Stack,
-            context.field_const(0),
-        );
-
-        context.set_global(
-            crate::eravm::GLOBAL_CALL_FLAGS,
-            context.field_type(),
-            AddressSpace::Stack,
-            context.field_const(0),
-        );
-
-        let extra_abi_data_type = context.array_type(
-            context.field_type().as_basic_type_enum(),
-            crate::eravm::EXTRA_ABI_DATA_SIZE,
-        );
-        context.set_global(
-            crate::eravm::GLOBAL_EXTRA_ABI_DATA,
-            extra_abi_data_type,
-            AddressSpace::Stack,
-            extra_abi_data_type.const_zero(),
-        );
-
-        Ok(())
-    }
-
-    /// Load the calldata via seal `input` and initialize the calldata end
-    /// and calldata size globals.
-    pub fn load_calldata<D>(context: &mut Context<D>) -> anyhow::Result<()>
-    where
-        D: Dependency + Clone,
-    {
-        let input_pointer = context
-            .get_global(crate::eravm::GLOBAL_CALLDATA_POINTER)?
-            .value
-            .as_pointer_value();
-        let input_pointer_casted = context.builder.build_ptr_to_int(
-            input_pointer,
-            context.xlen_type(),
-            "input_pointer_casted",
-        )?;
-
-        let length_pointer = context.build_alloca(context.xlen_type(), "len_ptr");
-        let length_pointer_casted = context.builder.build_ptr_to_int(
-            length_pointer.value,
-            context.xlen_type(),
-            "length_pointer_casted",
-        )?;
-
-        context.build_store(
-            length_pointer,
-            context.integer_const(32, Self::MAX_CALLDATA_SIZE as u64),
-        )?;
-        context.builder().build_call(
-            context.module().get_function("input").expect("is declared"),
-            &[input_pointer_casted.into(), length_pointer_casted.into()],
-            "call_seal_input",
-        )?;
-
-        // Store the calldata size
-        let calldata_size = context
-            .build_load(length_pointer, "input_size")?
-            .into_int_value();
-        let calldata_size_casted = context.builder().build_int_z_extend(
-            calldata_size,
-            context.field_type(),
-            "zext_input_len",
-        )?;
-        context.set_global(
-            crate::eravm::GLOBAL_CALLDATA_SIZE,
-            context.field_type(),
-            AddressSpace::Stack,
-            calldata_size_casted,
-        );
-
-        // Store calldata end pointer
-        let input_pointer = Pointer::new(
-            input_pointer.get_type(),
-            AddressSpace::Generic,
-            input_pointer,
-        );
-        let calldata_end_pointer = context.build_gep(
-            input_pointer,
-            &[calldata_size_casted],
-            context
-                .llvm()
-                .ptr_type(AddressSpace::Generic.into())
-                .as_basic_type_enum(),
-            "return_data_abi_initializer",
-        );
-        context.write_abi_pointer(
-            calldata_end_pointer,
-            crate::eravm::GLOBAL_RETURN_DATA_POINTER,
-        );
-        context.write_abi_pointer(calldata_end_pointer, crate::eravm::GLOBAL_ACTIVE_POINTER);
-
-        Ok(())
-    }
-
-    /// Calls the deploy code if the first function argument was `1`.
-    /// Calls the runtime code otherwise.
-    pub fn leave_entry<D>(context: &mut Context<D>) -> anyhow::Result<()>
-    where
-        D: Dependency + Clone,
-    {
-        let is_deploy = context
-            .current_function()
-            .borrow()
-            .get_nth_param(Self::ARGUMENT_INDEX_CALL_FLAGS);
-
-        context.set_global(
-            crate::eravm::GLOBAL_CALL_FLAGS,
-            is_deploy.get_type(),
-            AddressSpace::Stack,
-            is_deploy.into_int_value(),
-        );
-
-        let deploy_code_call_block = context.append_basic_block("deploy_code_call_block");
-        let runtime_code_call_block = context.append_basic_block("runtime_code_call_block");
-
-        context.build_conditional_branch(
-            is_deploy.into_int_value(),
-            deploy_code_call_block,
-            runtime_code_call_block,
-        )?;
-
-        let deploy_code = context
-            .functions
-            .get(Runtime::FUNCTION_DEPLOY_CODE)
-            .cloned()
-            .ok_or_else(|| anyhow::anyhow!("Contract deploy code not found"))?;
-        let runtime_code = context
-            .functions
-            .get(Runtime::FUNCTION_RUNTIME_CODE)
-            .cloned()
-            .ok_or_else(|| anyhow::anyhow!("Contract runtime code not found"))?;
-
-        context.set_basic_block(deploy_code_call_block);
-        context.build_invoke(deploy_code.borrow().declaration, &[], "deploy_code_call");
-        context.build_unconditional_branch(context.current_function().borrow().return_block());
-
-        context.set_basic_block(runtime_code_call_block);
-        context.build_invoke(runtime_code.borrow().declaration, &[], "runtime_code_call");
-        context.build_unconditional_branch(context.current_function().borrow().return_block());
-
-        Ok(())
-    }
-}
-
-impl<D> WriteLLVM<D> for Entry
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        let entry_arguments = vec![context.bool_type().as_basic_type_enum()];
-        let entry_function_type = context.function_type(entry_arguments, 0, false);
-        context.add_function(Runtime::FUNCTION_ENTRY, entry_function_type, 0, None)?;
-
-        context.declare_extern_function("deploy")?;
-        context.declare_extern_function("call")?;
-
-        Ok(())
-    }
-
-    /// Instead of a single entrypoint, the runtime expects two exports: `call ` and `deploy`.
-    /// `call` and `deploy` directly call `entry`, signaling a deploy if the first arg is `1`.
-    /// The `entry` function loads calldata, sets globals and calls the runtime or deploy code.
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        let entry = context
-            .get_function(Runtime::FUNCTION_ENTRY)
-            .expect("the entry function should already be declared")
-            .borrow()
-            .declaration;
-        crate::EraVMFunction::set_attributes(
-            context.llvm(),
-            entry,
-            vec![crate::EraVMAttribute::NoReturn],
-            true,
-        );
-
-        context.set_current_function("deploy")?;
-        context.set_basic_block(context.current_function().borrow().entry_block());
-
-        assert!(context
-            .build_call(entry, &[context.bool_const(true).into()], "entry_deploy")
-            .is_none());
-
-        context.set_basic_block(context.current_function().borrow().return_block);
-        context.build_unreachable();
-
-        context.set_current_function("call")?;
-        context.set_basic_block(context.current_function().borrow().entry_block());
-
-        assert!(context
-            .build_call(entry, &[context.bool_const(false).into()], "entry_call")
-            .is_none());
-
-        context.set_basic_block(context.current_function().borrow().return_block);
-        context.build_unreachable();
-
-        context.set_current_function(Runtime::FUNCTION_ENTRY)?;
-        context.set_basic_block(context.current_function().borrow().entry_block());
-
-        Self::initialize_globals(context)?;
-        Self::load_calldata(context)?;
-        Self::leave_entry(context)?;
-
-        context.build_unconditional_branch(context.current_function().borrow().return_block());
-        context.set_basic_block(context.current_function().borrow().return_block());
-        context.build_unreachable();
-
-        Ok(())
-    }
-}

crates/llvm-context/src/eravm/context/function/runtime/mod.rs

@@ -1,100 +0,0 @@
-//!
-//! The front-end runtime functions.
-//!
-
-pub mod default_call;
-pub mod deploy_code;
-pub mod deployer_call;
-pub mod entry;
-pub mod runtime_code;
-
-use crate::eravm::context::address_space::AddressSpace;
-use crate::eravm::context::function::declaration::Declaration as FunctionDeclaration;
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-use crate::eravm::WriteLLVM;
-
-use self::default_call::DefaultCall;
-use self::deployer_call::DeployerCall;
-
-///
-/// The front-end runtime functions.
-///
-#[derive(Debug, Clone)]
-pub struct Runtime {
-    /// The address space where the calldata is allocated.
-    /// Solidity uses the ordinary heap. Vyper uses the auxiliary heap.
-    address_space: AddressSpace,
-}
-
-impl Runtime {
-    /// The main entry function name.
-    pub const FUNCTION_ENTRY: &'static str = "__entry";
-
-    /// The deploy code function name.
-    pub const FUNCTION_DEPLOY_CODE: &'static str = "__deploy";
-
-    /// The runtime code function name.
-    pub const FUNCTION_RUNTIME_CODE: &'static str = "__runtime";
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(address_space: AddressSpace) -> Self {
-        Self { address_space }
-    }
-
-    ///
-    /// Returns the corresponding runtime function.
-    ///
-    pub fn default_call<'ctx, D>(
-        context: &Context<'ctx, D>,
-        call_function: FunctionDeclaration<'ctx>,
-    ) -> FunctionDeclaration<'ctx>
-    where
-        D: Dependency + Clone,
-    {
-        context
-            .get_function(DefaultCall::name(call_function).as_str())
-            .expect("Always exists")
-            .borrow()
-            .declaration()
-    }
-
-    ///
-    /// Returns the corresponding runtime function.
-    ///
-    pub fn deployer_call<'ctx, D>(context: &Context<'ctx, D>) -> FunctionDeclaration<'ctx>
-    where
-        D: Dependency + Clone,
-    {
-        context
-            .get_function(DeployerCall::FUNCTION_NAME)
-            .expect("Always exists")
-            .borrow()
-            .declaration()
-    }
-}
-
-impl<D> WriteLLVM<D> for Runtime
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        //DefaultCall::new(context.llvm_runtime().far_call).declare(context)?;
-        DefaultCall::new(context.llvm_runtime().static_call).declare(context)?;
-        DefaultCall::new(context.llvm_runtime().delegate_call).declare(context)?;
-        DeployerCall::new(self.address_space).declare(context)?;
-
-        Ok(())
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        //DefaultCall::new(context.llvm_runtime().far_call).into_llvm(context)?;
-        DefaultCall::new(context.llvm_runtime().static_call).into_llvm(context)?;
-        DefaultCall::new(context.llvm_runtime().delegate_call).into_llvm(context)?;
-        DeployerCall::new(self.address_space).into_llvm(context)?;
-
-        Ok(())
-    }
-}

crates/llvm-context/src/eravm/context/function/runtime/runtime_code.rs

@@ -1,86 +0,0 @@
-//!
-//! The runtime code function.
-//!
-
-use std::marker::PhantomData;
-
-use crate::eravm::context::code_type::CodeType;
-use crate::eravm::context::function::runtime::Runtime;
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-use crate::eravm::WriteLLVM;
-
-///
-/// The runtime code function.
-///
-/// Is a special function that is only used by the front-end generated code.
-///
-#[derive(Debug)]
-pub struct RuntimeCode<B, D>
-where
-    B: WriteLLVM<D>,
-    D: Dependency + Clone,
-{
-    /// The runtime code AST representation.
-    inner: B,
-    /// The `D` phantom data.
-    _pd: PhantomData<D>,
-}
-
-impl<B, D> RuntimeCode<B, D>
-where
-    B: WriteLLVM<D>,
-    D: Dependency + Clone,
-{
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(inner: B) -> Self {
-        Self {
-            inner,
-            _pd: PhantomData,
-        }
-    }
-}
-
-impl<B, D> WriteLLVM<D> for RuntimeCode<B, D>
-where
-    B: WriteLLVM<D>,
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        let function_type =
-            context.function_type::<inkwell::types::BasicTypeEnum>(vec![], 0, false);
-        context.add_function(
-            Runtime::FUNCTION_RUNTIME_CODE,
-            function_type,
-            0,
-            Some(inkwell::module::Linkage::External),
-        )?;
-
-        self.inner.declare(context)
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        context.set_current_function(Runtime::FUNCTION_RUNTIME_CODE)?;
-
-        context.set_basic_block(context.current_function().borrow().entry_block());
-        context.set_code_type(CodeType::Runtime);
-        self.inner.into_llvm(context)?;
-        match context
-            .basic_block()
-            .get_last_instruction()
-            .map(|instruction| instruction.get_opcode())
-        {
-            Some(inkwell::values::InstructionOpcode::Br) => {}
-            Some(inkwell::values::InstructionOpcode::Switch) => {}
-            _ => context
-                .build_unconditional_branch(context.current_function().borrow().return_block()),
-        }
-
-        context.set_basic_block(context.current_function().borrow().return_block());
-        context.build_unreachable();
-
-        Ok(())
-    }
-}

crates/llvm-context/src/eravm/context/function/vyper_data.rs

@@ -1,52 +0,0 @@
-//!
-//! The LLVM function Vyper data.
-//!
-
-use std::collections::HashMap;
-
-///
-/// The LLVM function Vyper data.
-///
-/// Describes some data that is only relevant to Vyper.
-///
-#[derive(Debug)]
-pub struct VyperData {
-    /// The block-local variables. They are still allocated at the beginning of the function,
-    /// but their parent block must be known in order to pass the implicit arguments thereto.
-    /// Is only used by the Vyper LLL IR compiler.
-    label_arguments: HashMap<String, Vec<String>>,
-}
-
-impl Default for VyperData {
-    fn default() -> Self {
-        Self {
-            label_arguments: HashMap::with_capacity(Self::LABEL_ARGUMENTS_HASHMAP_INITIAL_CAPACITY),
-        }
-    }
-}
-
-impl VyperData {
-    /// The label arguments hashmap default capacity.
-    const LABEL_ARGUMENTS_HASHMAP_INITIAL_CAPACITY: usize = 16;
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    ///
-    /// Returns the list of a Vyper label arguments.
-    ///
-    pub fn label_arguments(&self, label_name: &str) -> Option<Vec<String>> {
-        self.label_arguments.get(label_name).cloned()
-    }
-
-    ///
-    /// Inserts arguments for the specified label.
-    ///
-    pub fn insert_label_arguments(&mut self, label_name: String, arguments: Vec<String>) {
-        self.label_arguments.insert(label_name, arguments);
-    }
-}

crates/llvm-context/src/eravm/context/function/yul_data.rs

@@ -1,53 +0,0 @@
-//!
-//! The LLVM function Yul data.
-//!
-
-use std::collections::HashMap;
-
-use num::BigUint;
-
-///
-/// The LLVM function Yul data.
-///
-/// Describes some data that is only relevant to Yul.
-///
-#[derive(Debug)]
-pub struct YulData {
-    /// The constants saved to variables. Used for peculiar cases like call simulation.
-    /// It is a partial implementation of the constant propagation.
-    constants: HashMap<String, BigUint>,
-}
-
-impl Default for YulData {
-    fn default() -> Self {
-        Self {
-            constants: HashMap::with_capacity(Self::CONSTANTS_HASHMAP_INITIAL_CAPACITY),
-        }
-    }
-}
-
-impl YulData {
-    /// The constants hashmap default capacity.
-    const CONSTANTS_HASHMAP_INITIAL_CAPACITY: usize = 16;
-
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    ///
-    /// Returns a constant if it has been saved.
-    ///
-    pub fn get_constant(&self, name: &str) -> Option<BigUint> {
-        self.constants.get(name).cloned()
-    }
-
-    ///
-    /// Saves a constant detected with the partial constant propagation.
-    ///
-    pub fn insert_constant(&mut self, name: String, value: BigUint) {
-        self.constants.insert(name, value);
-    }
-}

crates/llvm-context/src/eravm/context/global.rs

@@ -1,63 +0,0 @@
-//!
-//! The LLVM global value.
-//!
-
-use inkwell::types::BasicType;
-use inkwell::values::BasicValue;
-
-use crate::eravm::context::address_space::AddressSpace;
-use crate::eravm::context::Context;
-use crate::EraVMDependency;
-
-///
-/// The LLVM global value.
-///
-#[derive(Debug, Clone, Copy)]
-pub struct Global<'ctx> {
-    /// The global type.
-    pub r#type: inkwell::types::BasicTypeEnum<'ctx>,
-    /// The global value.
-    pub value: inkwell::values::GlobalValue<'ctx>,
-}
-
-impl<'ctx> Global<'ctx> {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new<D, T, V>(
-        context: &mut Context<'ctx, D>,
-        r#type: T,
-        address_space: AddressSpace,
-        initializer: V,
-        name: &str,
-    ) -> Self
-    where
-        D: EraVMDependency + Clone,
-        T: BasicType<'ctx>,
-        V: BasicValue<'ctx>,
-    {
-        let r#type = r#type.as_basic_type_enum();
-
-        let value = context
-            .module()
-            .add_global(r#type, Some(address_space.into()), name);
-        let global = Self { r#type, value };
-
-        global.value.set_linkage(inkwell::module::Linkage::Private);
-        global
-            .value
-            .set_visibility(inkwell::GlobalVisibility::Default);
-        global.value.set_externally_initialized(false);
-        if let AddressSpace::Code = address_space {
-            global.value.set_constant(true);
-        }
-        if !r#type.is_pointer_type() {
-            global.value.set_initializer(&initializer);
-        } else {
-            global.value.set_initializer(&r#type.const_zero());
-            context.build_store(global.into(), initializer).unwrap();
-        }
-
-        global
-    }
-}

crates/llvm-context/src/eravm/context/loop.rs

@@ -1,33 +0,0 @@
-//!
-//! The LLVM IR generator loop.
-//!
-
-///
-/// The LLVM IR generator loop.
-///
-#[derive(Debug, Clone)]
-pub struct Loop<'ctx> {
-    /// The loop current block.
-    pub body_block: inkwell::basic_block::BasicBlock<'ctx>,
-    /// The increment block before the body.
-    pub continue_block: inkwell::basic_block::BasicBlock<'ctx>,
-    /// The join block after the body.
-    pub join_block: inkwell::basic_block::BasicBlock<'ctx>,
-}
-
-impl<'ctx> Loop<'ctx> {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(
-        body_block: inkwell::basic_block::BasicBlock<'ctx>,
-        continue_block: inkwell::basic_block::BasicBlock<'ctx>,
-        join_block: inkwell::basic_block::BasicBlock<'ctx>,
-    ) -> Self {
-        Self {
-            body_block,
-            continue_block,
-            join_block,
-        }
-    }
-}

crates/llvm-context/src/eravm/context/pointer.rs

@@ -1,134 +0,0 @@
-//!
-//! The LLVM pointer.
-//!
-
-use inkwell::types::BasicType;
-
-use crate::eravm::context::address_space::AddressSpace;
-use crate::eravm::context::global::Global;
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-
-///
-/// The LLVM pointer.
-///
-#[derive(Debug, Clone, Copy)]
-pub struct Pointer<'ctx> {
-    /// The pointee type.
-    pub r#type: inkwell::types::BasicTypeEnum<'ctx>,
-    /// The address space.
-    pub address_space: AddressSpace,
-    /// The pointer value.
-    pub value: inkwell::values::PointerValue<'ctx>,
-}
-
-impl<'ctx> Pointer<'ctx> {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new<T>(
-        r#type: T,
-        address_space: AddressSpace,
-        value: inkwell::values::PointerValue<'ctx>,
-    ) -> Self
-    where
-        T: BasicType<'ctx>,
-    {
-        Self {
-            r#type: r#type.as_basic_type_enum(),
-            address_space,
-            value,
-        }
-    }
-
-    ///
-    /// Wraps a 256-bit primitive type pointer.
-    ///
-    pub fn new_stack_field<D>(
-        context: &Context<'ctx, D>,
-        value: inkwell::values::PointerValue<'ctx>,
-    ) -> Self
-    where
-        D: Dependency + Clone,
-    {
-        Self {
-            r#type: context.field_type().as_basic_type_enum(),
-            address_space: AddressSpace::Stack,
-            value,
-        }
-    }
-
-    ///
-    /// Creates a new pointer with the specified `offset`.
-    ///
-    pub fn new_with_offset<D, T>(
-        context: &Context<'ctx, D>,
-        address_space: AddressSpace,
-        r#type: T,
-        offset: inkwell::values::IntValue<'ctx>,
-        name: &str,
-    ) -> Self
-    where
-        D: Dependency + Clone,
-        T: BasicType<'ctx>,
-    {
-        assert_ne!(
-            address_space,
-            AddressSpace::Stack,
-            "Stack pointers cannot be addressed"
-        );
-
-        let offset = context.safe_truncate_int_to_i32(offset).unwrap();
-        let value = context
-            .builder
-            .build_int_to_ptr(offset, context.llvm().ptr_type(address_space.into()), name)
-            .unwrap();
-        Self::new(r#type, address_space, value)
-    }
-
-    ///
-    /// Casts the pointer into another type.
-    ///
-    pub fn cast<T>(self, r#type: T) -> Self
-    where
-        T: BasicType<'ctx>,
-    {
-        Self {
-            r#type: r#type.as_basic_type_enum(),
-            address_space: self.address_space,
-            value: self.value,
-        }
-    }
-
-    pub fn address_space_cast<D>(
-        self,
-        context: &Context<'ctx, D>,
-        address_space: AddressSpace,
-        name: &str,
-    ) -> anyhow::Result<Self>
-    where
-        D: Dependency + Clone,
-    {
-        let value = context.builder().build_address_space_cast(
-            self.value,
-            context.llvm().ptr_type(address_space.into()),
-            name,
-        )?;
-
-        Ok(Self {
-            address_space,
-            value,
-            ..self
-        })
-    }
-}
-
-impl<'ctx> From<Global<'ctx>> for Pointer<'ctx> {
-    fn from(global: Global<'ctx>) -> Self {
-        Self {
-            r#type: global.r#type,
-            address_space: AddressSpace::Stack,
-            value: global.value.as_pointer_value(),
-        }
-    }
-}

crates/llvm-context/src/eravm/context/solidity_data.rs

@@ -1,59 +0,0 @@
-//!
-//! The LLVM IR generator Solidity data.
-//!
-
-use std::collections::BTreeMap;
-
-///
-/// The LLVM IR generator Solidity data.
-///
-/// Describes some data that is only relevant to Solidity.
-///
-#[derive(Debug, Default)]
-pub struct SolidityData {
-    /// The immutables identifier-to-offset mapping. Is only used by Solidity due to
-    /// the arbitrariness of its identifiers.
-    immutables: BTreeMap<String, usize>,
-}
-
-impl SolidityData {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    ///
-    /// Returns the current number of immutables values in the contract.
-    ///
-    pub fn immutables_size(&self) -> usize {
-        self.immutables.len() * revive_common::BYTE_LENGTH_FIELD
-    }
-
-    ///
-    /// Allocates memory for an immutable value in the auxiliary heap.
-    ///
-    /// If the identifier is already known, just returns its offset.
-    ///
-    pub fn allocate_immutable(&mut self, identifier: &str) -> usize {
-        let number_of_elements = self.immutables.len();
-        let new_offset = number_of_elements * revive_common::BYTE_LENGTH_FIELD;
-        *self
-            .immutables
-            .entry(identifier.to_owned())
-            .or_insert(new_offset)
-    }
-
-    ///
-    /// Gets the offset of the immutable value.
-    ///
-    /// If the value is not yet allocated, then it is done forcibly.
-    ///
-    pub fn get_or_allocate_immutable(&mut self, identifier: &str) -> usize {
-        match self.immutables.get(identifier).copied() {
-            Some(offset) => offset,
-            None => self.allocate_immutable(identifier),
-        }
-    }
-}

crates/llvm-context/src/eravm/context/tests.rs

@@ -1,136 +0,0 @@
-//!
-//! The LLVM IR generator context tests.
-//!
-
-use crate::eravm::context::attribute::Attribute;
-use crate::eravm::context::Context;
-use crate::eravm::DummyDependency;
-use crate::optimizer::settings::Settings as OptimizerSettings;
-use crate::optimizer::Optimizer;
-
-pub fn create_context(
-    llvm: &inkwell::context::Context,
-    optimizer_settings: OptimizerSettings,
-) -> Context<DummyDependency> {
-    crate::eravm::initialize_target();
-
-    let module = llvm.create_module("test");
-    let optimizer = Optimizer::new(optimizer_settings);
-
-    Context::<DummyDependency>::new(llvm, module, optimizer, None, true, None)
-}
-
-#[test]
-pub fn check_attribute_null_pointer_is_invalid() {
-    let llvm = inkwell::context::Context::create();
-    let mut context = create_context(&llvm, OptimizerSettings::cycles());
-
-    let function = context
-        .add_function(
-            "test",
-            context
-                .field_type()
-                .fn_type(&[context.field_type().into()], false),
-            1,
-            Some(inkwell::module::Linkage::External),
-        )
-        .expect("Failed to add function");
-    assert!(function
-        .borrow()
-        .declaration()
-        .value
-        .attributes(inkwell::attributes::AttributeLoc::Function)
-        .contains(&llvm.create_enum_attribute(Attribute::NullPointerIsValid as u32, 0)));
-}
-
-#[test]
-pub fn check_attribute_optimize_for_size_mode_3() {
-    let llvm = inkwell::context::Context::create();
-    let mut context = create_context(&llvm, OptimizerSettings::cycles());
-
-    let function = context
-        .add_function(
-            "test",
-            context
-                .field_type()
-                .fn_type(&[context.field_type().into()], false),
-            1,
-            Some(inkwell::module::Linkage::External),
-        )
-        .expect("Failed to add function");
-    assert!(!function
-        .borrow()
-        .declaration()
-        .value
-        .attributes(inkwell::attributes::AttributeLoc::Function)
-        .contains(&llvm.create_enum_attribute(Attribute::OptimizeForSize as u32, 0)));
-}
-
-#[test]
-pub fn check_attribute_optimize_for_size_mode_z() {
-    let llvm = inkwell::context::Context::create();
-    let mut context = create_context(&llvm, OptimizerSettings::size());
-
-    let function = context
-        .add_function(
-            "test",
-            context
-                .field_type()
-                .fn_type(&[context.field_type().into()], false),
-            1,
-            Some(inkwell::module::Linkage::External),
-        )
-        .expect("Failed to add function");
-    assert!(function
-        .borrow()
-        .declaration()
-        .value
-        .attributes(inkwell::attributes::AttributeLoc::Function)
-        .contains(&llvm.create_enum_attribute(Attribute::OptimizeForSize as u32, 0)));
-}
-
-#[test]
-pub fn check_attribute_min_size_mode_3() {
-    let llvm = inkwell::context::Context::create();
-    let mut context = create_context(&llvm, OptimizerSettings::cycles());
-
-    let function = context
-        .add_function(
-            "test",
-            context
-                .field_type()
-                .fn_type(&[context.field_type().into()], false),
-            1,
-            Some(inkwell::module::Linkage::External),
-        )
-        .expect("Failed to add function");
-    assert!(!function
-        .borrow()
-        .declaration()
-        .value
-        .attributes(inkwell::attributes::AttributeLoc::Function)
-        .contains(&llvm.create_enum_attribute(Attribute::MinSize as u32, 0)));
-}
-
-#[test]
-pub fn check_attribute_min_size_mode_z() {
-    let llvm = inkwell::context::Context::create();
-    let mut context = create_context(&llvm, OptimizerSettings::size());
-
-    let function = context
-        .add_function(
-            "test",
-            context
-                .field_type()
-                .fn_type(&[context.field_type().into()], false),
-            1,
-            Some(inkwell::module::Linkage::External),
-        )
-        .expect("Failed to add function");
-    assert!(function
-        .borrow()
-        .declaration()
-        .value
-        .attributes(inkwell::attributes::AttributeLoc::Function)
-        .contains(&llvm.create_enum_attribute(Attribute::MinSize as u32, 0)));
-}

crates/llvm-context/src/eravm/context/vyper_data.rs

@@ -1,50 +0,0 @@
-//!
-//! The LLVM IR generator Vyper data.
-//!
-
-///
-/// The LLVM IR generator Vyper data.
-///
-/// Describes some data that is only relevant to Vyper.
-///
-#[derive(Debug)]
-pub struct VyperData {
-    /// The immutables size tracker. Stores the size in bytes.
-    /// Does not take into account the size of the indexes.
-    immutables_size: usize,
-    /// Whether the contract forwarder has been used.
-    is_forwarder_used: bool,
-}
-
-impl VyperData {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(immutables_size: usize, is_forwarder_used: bool) -> Self {
-        Self {
-            immutables_size,
-            is_forwarder_used,
-        }
-    }
-
-    ///
-    /// Returns the size of the immutables data of the contract.
-    ///
-    pub fn immutables_size(&self) -> usize {
-        self.immutables_size
-    }
-
-    ///
-    /// Sets the forwarder usage flag.
-    ///
-    pub fn set_is_forwarder_used(&mut self) {
-        self.is_forwarder_used = true;
-    }
-
-    ///
-    /// Returns the forwarder usage flag.
-    ///
-    pub fn is_forwarder_used(&self) -> bool {
-        self.is_forwarder_used
-    }
-}

crates/llvm-context/src/eravm/context/yul_data.rs

@@ -1,92 +0,0 @@
-//!
-//! The LLVM IR generator Yul data.
-//!
-
-use std::collections::BTreeMap;
-
-use num::Zero;
-
-///
-/// The LLVM IR generator Yul data.
-///
-/// Describes some data that is only relevant to Yul.
-///
-#[derive(Debug, Default)]
-pub struct YulData {
-    /// The system mode flag.
-    /// The call simulations only work if this mode is enabled.
-    is_system_mode: bool,
-    /// The list of constant arrays in the code section.
-    /// It is a temporary storage used until the finalization method is called.
-    const_arrays: BTreeMap<u8, Vec<num::BigUint>>,
-}
-
-impl YulData {
-    ///
-    /// A shortcut constructor.
-    ///
-    pub fn new(is_system_mode: bool) -> Self {
-        Self {
-            is_system_mode,
-            const_arrays: BTreeMap::new(),
-        }
-    }
-
-    ///
-    /// Whether the system mode is enabled.
-    ///
-    pub fn is_system_mode(&self) -> bool {
-        self.is_system_mode
-    }
-
-    ///
-    /// Declares a temporary constant array representation.
-    ///
-    pub fn const_array_declare(&mut self, index: u8, size: u16) -> anyhow::Result<()> {
-        if self.const_arrays.contains_key(&index) {
-            anyhow::bail!(
-                "The constant array with index {} is already declared",
-                index
-            );
-        }
-
-        self.const_arrays
-            .insert(index, vec![num::BigUint::zero(); size as usize]);
-
-        Ok(())
-    }
-
-    ///
-    /// Sets a value in the constant array representation.
-    ///
-    pub fn const_array_set(
-        &mut self,
-        index: u8,
-        offset: u16,
-        value: num::BigUint,
-    ) -> anyhow::Result<()> {
-        let array = self.const_arrays.get_mut(&index).ok_or_else(|| {
-            anyhow::anyhow!("The constant array with index {} is not declared", index)
-        })?;
-        if offset >= array.len() as u16 {
-            anyhow::bail!(
-                "The constant array with index {} has size {} but the offset is {}",
-                index,
-                array.len(),
-                offset,
-            );
-        }
-        array[offset as usize] = value;
-
-        Ok(())
-    }
-
-    ///
-    /// Finalizes the constant array declaration.
-    ///
-    pub fn const_array_take(&mut self, index: u8) -> anyhow::Result<Vec<num::BigUint>> {
-        self.const_arrays.remove(&index).ok_or_else(|| {
-            anyhow::anyhow!("The constant array with index {} is not declared", index)
-        })
-    }
-}

crates/llvm-context/src/eravm/evm/arithmetic.rs

@@ -1,149 +0,0 @@
-//!
-//! Translates the arithmetic operations.
-//!
-
-use inkwell::values::BasicValue;
-
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-
-///
-/// Translates the arithmetic addition.
-///
-pub fn addition<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    operand_1: inkwell::values::IntValue<'ctx>,
-    operand_2: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    Ok(context
-        .builder()
-        .build_int_add(operand_1, operand_2, "addition_result")?
-        .as_basic_value_enum())
-}
-
-///
-/// Translates the arithmetic subtraction.
-///
-pub fn subtraction<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    operand_1: inkwell::values::IntValue<'ctx>,
-    operand_2: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    Ok(context
-        .builder()
-        .build_int_sub(operand_1, operand_2, "subtraction_result")?
-        .as_basic_value_enum())
-}
-
-///
-/// Translates the arithmetic multiplication.
-///
-pub fn multiplication<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    operand_1: inkwell::values::IntValue<'ctx>,
-    operand_2: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    Ok(context
-        .builder()
-        .build_int_mul(operand_1, operand_2, "multiplication_result")?
-        .as_basic_value_enum())
-}
-
-///
-/// Translates the arithmetic division.
-///
-pub fn division<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    operand_1: inkwell::values::IntValue<'ctx>,
-    operand_2: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    Ok(context
-        .builder()
-        .build_int_unsigned_div(operand_1, operand_2, "udiv")?
-        .into())
-}
-
-///
-/// Translates the arithmetic remainder.
-///
-pub fn remainder<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    operand_1: inkwell::values::IntValue<'ctx>,
-    operand_2: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    Ok(context
-        .build_call(
-            context.llvm_runtime().r#mod,
-            &[
-                operand_1.as_basic_value_enum(),
-                operand_2.as_basic_value_enum(),
-            ],
-            "add_mod_call",
-        )
-        .expect("Always exists"))
-}
-
-///
-/// Translates the signed arithmetic division.
-///
-/// Two differences between the EVM and LLVM IR:
-/// 1. In case of division by zero, 0 is returned.
-/// 2. In case of overflow, the first argument is returned.
-///
-pub fn division_signed<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    operand_1: inkwell::values::IntValue<'ctx>,
-    operand_2: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    Ok(context
-        .build_call(
-            context.llvm_runtime().sdiv,
-            &[
-                operand_1.as_basic_value_enum(),
-                operand_2.as_basic_value_enum(),
-            ],
-            "add_mod_call",
-        )
-        .expect("Always exists"))
-}
-
-///
-/// Translates the signed arithmetic remainder.
-///
-pub fn remainder_signed<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    operand_1: inkwell::values::IntValue<'ctx>,
-    operand_2: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    Ok(context
-        .build_call(
-            context.llvm_runtime().smod,
-            &[
-                operand_1.as_basic_value_enum(),
-                operand_2.as_basic_value_enum(),
-            ],
-            "add_mod_call",
-        )
-        .expect("Always exists"))
-}

crates/llvm-context/src/eravm/evm/bitwise.rs

@@ -1,235 +0,0 @@
-//!
-//! Translates the bitwise operations.
-//!
-
-use inkwell::values::BasicValue;
-
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-
-///
-/// Translates the bitwise OR.
-///
-pub fn or<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    operand_1: inkwell::values::IntValue<'ctx>,
-    operand_2: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    Ok(context
-        .builder()
-        .build_or(operand_1, operand_2, "or_result")?
-        .as_basic_value_enum())
-}
-
-///
-/// Translates the bitwise XOR.
-///
-pub fn xor<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    operand_1: inkwell::values::IntValue<'ctx>,
-    operand_2: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    Ok(context
-        .builder()
-        .build_xor(operand_1, operand_2, "xor_result")?
-        .as_basic_value_enum())
-}
-
-///
-/// Translates the bitwise AND.
-///
-pub fn and<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    operand_1: inkwell::values::IntValue<'ctx>,
-    operand_2: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    Ok(context
-        .builder()
-        .build_and(operand_1, operand_2, "and_result")?
-        .as_basic_value_enum())
-}
-
-///
-/// Translates the bitwise shift left.
-///
-pub fn shift_left<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    shift: inkwell::values::IntValue<'ctx>,
-    value: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    let overflow_block = context.append_basic_block("shift_left_overflow");
-    let non_overflow_block = context.append_basic_block("shift_left_non_overflow");
-    let join_block = context.append_basic_block("shift_left_join");
-
-    let result_pointer = context.build_alloca(context.field_type(), "shift_left_result_pointer");
-    let condition_is_overflow = context.builder().build_int_compare(
-        inkwell::IntPredicate::UGT,
-        shift,
-        context.field_const((revive_common::BIT_LENGTH_FIELD - 1) as u64),
-        "shift_left_is_overflow",
-    )?;
-    context.build_conditional_branch(condition_is_overflow, overflow_block, non_overflow_block)?;
-
-    context.set_basic_block(overflow_block);
-    context.build_store(result_pointer, context.field_const(0))?;
-    context.build_unconditional_branch(join_block);
-
-    context.set_basic_block(non_overflow_block);
-    let value =
-        context
-            .builder()
-            .build_left_shift(value, shift, "shift_left_non_overflow_result")?;
-    context.build_store(result_pointer, value)?;
-    context.build_unconditional_branch(join_block);
-
-    context.set_basic_block(join_block);
-    context.build_load(result_pointer, "shift_left_result")
-}
-
-///
-/// Translates the bitwise shift right.
-///
-pub fn shift_right<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    shift: inkwell::values::IntValue<'ctx>,
-    value: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    let overflow_block = context.append_basic_block("shift_right_overflow");
-    let non_overflow_block = context.append_basic_block("shift_right_non_overflow");
-    let join_block = context.append_basic_block("shift_right_join");
-
-    let result_pointer = context.build_alloca(context.field_type(), "shift_right_result_pointer");
-    let condition_is_overflow = context.builder().build_int_compare(
-        inkwell::IntPredicate::UGT,
-        shift,
-        context.field_const((revive_common::BIT_LENGTH_FIELD - 1) as u64),
-        "shift_right_is_overflow",
-    )?;
-    context.build_conditional_branch(condition_is_overflow, overflow_block, non_overflow_block)?;
-
-    context.set_basic_block(overflow_block);
-    context.build_store(result_pointer, context.field_const(0))?;
-    context.build_unconditional_branch(join_block);
-
-    context.set_basic_block(non_overflow_block);
-    let value = context.builder().build_right_shift(
-        value,
-        shift,
-        false,
-        "shift_right_non_overflow_result",
-    )?;
-    context.build_store(result_pointer, value)?;
-    context.build_unconditional_branch(join_block);
-
-    context.set_basic_block(join_block);
-    context.build_load(result_pointer, "shift_right_result")
-}
-
-///
-/// Translates the arithmetic bitwise shift right.
-///
-pub fn shift_right_arithmetic<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    shift: inkwell::values::IntValue<'ctx>,
-    value: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    let overflow_block = context.append_basic_block("shift_right_arithmetic_overflow");
-    let overflow_positive_block =
-        context.append_basic_block("shift_right_arithmetic_overflow_positive");
-    let overflow_negative_block =
-        context.append_basic_block("shift_right_arithmetic_overflow_negative");
-    let non_overflow_block = context.append_basic_block("shift_right_arithmetic_non_overflow");
-    let join_block = context.append_basic_block("shift_right_arithmetic_join");
-
-    let result_pointer = context.build_alloca(
-        context.field_type(),
-        "shift_right_arithmetic_result_pointer",
-    );
-    let condition_is_overflow = context.builder().build_int_compare(
-        inkwell::IntPredicate::UGT,
-        shift,
-        context.field_const((revive_common::BIT_LENGTH_FIELD - 1) as u64),
-        "shift_right_arithmetic_is_overflow",
-    )?;
-    context.build_conditional_branch(condition_is_overflow, overflow_block, non_overflow_block)?;
-
-    context.set_basic_block(overflow_block);
-    let sign_bit = context.builder().build_right_shift(
-        value,
-        context.field_const((revive_common::BIT_LENGTH_FIELD - 1) as u64),
-        false,
-        "shift_right_arithmetic_sign_bit",
-    )?;
-    let condition_is_negative = context.builder().build_int_truncate_or_bit_cast(
-        sign_bit,
-        context.bool_type(),
-        "shift_right_arithmetic_sign_bit_truncated",
-    )?;
-    context.build_conditional_branch(
-        condition_is_negative,
-        overflow_negative_block,
-        overflow_positive_block,
-    )?;
-
-    context.set_basic_block(overflow_positive_block);
-    context.build_store(result_pointer, context.field_const(0))?;
-    context.build_unconditional_branch(join_block);
-
-    context.set_basic_block(overflow_negative_block);
-    context.build_store(result_pointer, context.field_type().const_all_ones())?;
-    context.build_unconditional_branch(join_block);
-
-    context.set_basic_block(non_overflow_block);
-    let value = context.builder().build_right_shift(
-        value,
-        shift,
-        true,
-        "shift_right_arithmetic_non_overflow_result",
-    )?;
-    context.build_store(result_pointer, value)?;
-    context.build_unconditional_branch(join_block);
-
-    context.set_basic_block(join_block);
-    context.build_load(result_pointer, "shift_right_arithmetic_result")
-}
-
-///
-/// Translates the `byte` instruction.
-///
-pub fn byte<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    operand_1: inkwell::values::IntValue<'ctx>,
-    operand_2: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    Ok(context
-        .build_call(
-            context.llvm_runtime().byte,
-            &[
-                operand_1.as_basic_value_enum(),
-                operand_2.as_basic_value_enum(),
-            ],
-            "byte_call",
-        )
-        .expect("Always exists"))
-}