Apply comment

Signed-off-by: xermicus <cyrill@parity.io>

.github/workflows/rust.yml

@@ -0,0 +1,52 @@
+name: Build
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build-ubuntu-x86:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install solc
+        run: |
+          mkdir -p solc
+          curl -sSL --output solc/solc https://github.com/ethereum/solidity/releases/download/v0.8.26/solc-static-linux
+          chmod +x solc/solc
+          echo "$(pwd)/solc/" >> $GITHUB_PATH
+
+      - name: Install LLVM
+        run: |
+          curl -sSL --output llvm.tar.xz https://github.com/llvm/llvm-project/releases/download/llvmorg-18.1.4/clang+llvm-18.1.4-x86_64-linux-gnu-ubuntu-18.04.tar.xz
+          tar Jxf llvm.tar.xz
+          mv clang+llvm-18.1.4-x86_64-linux-gnu-ubuntu-18.04 llvm18/
+          echo "$(pwd)/llvm18/bin" >> $GITHUB_PATH
+
+      - name: Install apt dependencies
+        run: sudo apt update && sudo apt install -y libtinfo5
+
+      - name: Format
+        run: make format
+
+      - name: Clippy
+        run: make clippy
+
+      - name: Test cargo workspace
+        run: make test-workspace
+
+      - name: Test CLI
+        run: make test-cli
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ github.job }}-resolc
+          path: ./target/release/resolc
+          retention-days: 1

.gitignore

@@ -11,4 +11,6 @@
 node_modules
 artifacts
 tmp
-package-lock.json
+package-lock.json
+/*.html
+/build

Cargo.toml

@@ -2,7 +2,30 @@
 resolver = "2"
 members = ["crates/*"]
 
+[workspace.package]
+version = "0.1.0"
+authors = [
+    "Cyrill Leutwiler <cyrill@parity.io>",
+    "Parity Technologies <admin@parity.io>",
+]
+license = "MIT/Apache-2.0"
+edition = "2021"
+repository = "https://github.com/xermicus/revive"
+
 [workspace.dependencies]
+revive-benchmarks = { version = "0.1.0", path = "crates/benchmarks" }
+revive-builtins = { version = "0.1.0", path = "crates/builtins" }
+revive-common = { version = "0.1.0", path = "crates/common" }
+revive-differential = { version = "0.1.0", path = "crates/differential" }
+revive-integration = { version = "0.1.0", path = "crates/integration" }
+revive-linker = { version = "0.1.0", path = "crates/linker" }
+lld-sys = { version = "0.1.0", path = "crates/lld-sys" }
+revive-llvm-context = { version = "0.1.0", path = "crates/llvm-context" }
+pallet-contracts-pvm-llapi = { version = "0.1.0", path = "crates/pallet-contracts-pvm-llapi" }
+revive-runner = { version = "0.1.0", path = "crates/runner" }
+revive-solidity = { version = "0.1.0", path = "crates/solidity" }
+revive-stdlib = { version = "0.1.0", path = "crates/stdlib" }
+
 hex = "0.4"
 petgraph = "0.6"
 cc = "1.0"
@@ -25,27 +48,32 @@ thiserror = "1.0"
 which = "5.0"
 path-slash = "0.2"
 rayon = "1.8"
-structopt = { version = "0.3", default-features = false }
+clap = { version = "4", default-features = false, features = ["derive"] }
 rand = "0.8"
-polkavm-common = { branch = "master_byteswap", git = "https://github.com/koute/polkavm.git" } 
-polkavm-linker = { branch = "master_byteswap", git = "https://github.com/koute/polkavm.git" } 
-polkavm = { branch = "master_byteswap", git = "https://github.com/koute/polkavm.git" } 
+polkavm-common = { git = "https://github.com/koute/polkavm.git", rev = "360029e" } 
+polkavm-linker = { git = "https://github.com/koute/polkavm.git", rev = "360029e" } 
+polkavm-disassembler = { git = "https://github.com/koute/polkavm.git", rev = "360029e" }
+polkavm = { git = "https://github.com/koute/polkavm.git", rev = "360029e" } 
 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"] }
+log = { version = "0.4" }
+codec = { version = "3.6.12", default-features = false, package = "parity-scale-codec" }
+scale-info = { version = "2.11.1", default-features = false }
+polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk", rev = "559fa1db0594a81d5dbf343613ba2f3fc16708da" }
 
 # 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"
+version = "0.5"
 default-features = false
 features = ["serde", "llvm18-0", "no-libffi-linking", "target-riscv"]
 
 [profile.benchmark]
 inherits = "release"
 lto = true
+codegen-units = 1

Makefile

@@ -1,4 +1,4 @@
-.PHONY: install test test-solidity test-cli test-integration clean
+.PHONY: install format test test-solidity test-cli test-integration test-workspace clean docs docs-build
 
 install: install-bin install-npm
 
@@ -8,7 +8,11 @@ install-bin:
 install-npm:
 	npm install && npm fund
 
-test: install test-integration test-cli test-solidity
+format:
+	cargo fmt --all --check
+
+test: format clippy test-cli test-workspace
+	cargo test --workspace
 
 test-integration: install-bin
 	cargo test --package revive-integration
@@ -16,6 +20,9 @@ test-integration: install-bin
 test-solidity: install
 	cargo test --package revive-solidity
 
+test-workspace: install
+	cargo test --workspace
+
 test-cli: install
 	npm run test:cli
 
@@ -38,6 +45,14 @@ 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
+
+docs: docs-build
+	mdbook serve --open docs/
+
+docs-build:
+	mdbook test docs/ && mdbook build docs/
 
 clean:
 	cargo clean ; \

README.md

@@ -1,38 +1,38 @@
+![CI](https://github.com/xermicus/revive/actions/workflows/rust.yml/badge.svg)
+
 # revive
 
-YUL and EVM bytecode recompiler to LLVM, targetting RISC-V on PolkaVM.
+YUL and EVM assembly recompiler to LLVM, targetting RISC-V on [PolkaVM](https://github.com/koute/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`.
+[Frontend](https://github.com/matter-labs/era-compiler-solidity) and [code generator](https://github.com/matter-labs/era-compiler-llvm-context) are based of ZKSync `zksolc`.
 
-# Status
+## Status
 
-Currently, primary goal of this codebase is to allow for benchmarks comparing performance against ink! and solang artifacts as well as EVM interpreters.
+This is experimental software in active development and not ready just yet for production usage.
 
-# TODO
+Discussion around the development is hosted on the [Polkadot Forum](https://forum.polkadot.network/t/contracts-update-solidity-on-polkavm/6949#a-new-solidity-compiler-1).
 
-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.
+## Installation
 
-- [ ] 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
+`resolc` depends on the [solc](https://github.com/ethereum/solidity) binary installed on your system.
+
+To install the `resolc` Solidity frontend executable:
+
+```bash
+bash build-llvm.sh
+export PATH=${PWD}/llvm18.0/bin:$PATH
+make install-bin
+resolc --version
+```
+
+### LLVM
+
+`revive` requires a build of LLVM 18.1.4 or later including `compiler-rt`. Use the provided [build-llvm.sh](build-llvm.sh) build script to compile a compatible LLVM build locally in `$PWD/llvm18.0` (don't forget to add that to `$PATH` afterwards). 
+
+### Development
+
+Please consult the [Makefile](Makefile) targets to learn how to run tests and benchmarks. 
+Ensure that your branch passes `make test` locally when submitting a pull request.
+
+## Design overview
+`revive` uses [solc](https://github.com/ethereum/solidity/), the Ethereum Solidity compiler, as the [Solidity frontend](crates/solidity/src/lib.rs) to process smart contracts written in Solidity. The YUL IR code (or legacy EVM assembly as a fallback for older `solc` versions) emitted by `solc` is then translated to LLVM IR, targetting a runtime similar to [Polkadots `contracts` pallet](https://docs.rs/pallet-contracts/latest/pallet_contracts/api_doc/trait.Current.html).

build-llvm.sh

@@ -3,7 +3,7 @@
 set -euo pipefail
 
 INSTALL_DIR="${PWD}/llvm18.0"
-mkdir -p $INSTALL_DIR
+mkdir -p ${INSTALL_DIR}
 
 
 # Clone LLVM 18 (any revision after commit bd32aaa is supposed to work)
@@ -13,11 +13,17 @@ fi
 
 
 # Build LLVM, clang
-cd llvm-project
+LLVM_SRC_PREFIX=${PWD}/llvm-project
+LLVM_SRC_DIR=${LLVM_SRC_PREFIX}/llvm
+LLVM_BUILD_DIR=${PWD}/build/llvm
+if [ ! -d ${LLVM_BUILD_DIR} ] ; then
+	mkdir -p ${LLVM_BUILD_DIR}
+fi
 
-mkdir -p build
-cd build
-cmake -G Ninja -DLLVM_ENABLE_ASSERTIONS=On \
+cmake -G Ninja \
+  -S ${LLVM_SRC_DIR} \
+  -B ${LLVM_BUILD_DIR} \
+  -DLLVM_ENABLE_ASSERTIONS=On \
   -DLLVM_ENABLE_TERMINFO=Off \
   -DLLVM_ENABLE_LIBXML2=Off \
   -DLLVM_ENABLE_ZLIB=Off \
@@ -25,45 +31,61 @@ cmake -G Ninja -DLLVM_ENABLE_ASSERTIONS=On \
   -DLLVM_TARGETS_TO_BUILD='RISCV' \
   -DLLVM_ENABLE_ZSTD=Off \
   -DCMAKE_BUILD_TYPE=MinSizeRel \
-  -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR \
-	../llvm
-
-ninja
-ninja install
+  -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR}
 
+cmake --build ${LLVM_BUILD_DIR}
+cmake --install ${LLVM_BUILD_DIR}
 
 # Build compiler builtins
-cd ../compiler-rt
-mkdir -p build
-cd build
+COMPILER_RT_SRC_DIR=${LLVM_SRC_PREFIX}/compiler-rt
+COMPILER_RT_BUILD_DIR=${PWD}/build/compiler-rt
+if [ ! -d ${COMPILER_RT_BUILD_DIR} ] ; then
+	mkdir -p ${COMPILER_RT_BUILD_DIR}
+fi
 
-CFLAGS="--target=riscv32 -march=rv32em -mabi=ilp32e -nostdlib -nodefaultlibs -mcpu=generic-rv32"
-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="riscv32" \
-  -DCMAKE_ASM_COMPILER_TARGET="riscv32" \
-  -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 \
-  ..
+build_compiler_rt() {
+	case "$1" in
+		64) TARGET_ABI=lp64e ;;
+		32) TARGET_ABI=ilp32e ;;
+		*) exit -1
+	esac
+	CFLAGS="--target=riscv${1} -march=rv${1}em -mabi=${TARGET_ABI} -mcpu=generic-rv${1} -nostdlib -nodefaultlibs"
 
-ninja
-ninja install
+	cmake -G Ninja \
+	  -S ${COMPILER_RT_SRC_DIR} \
+	  -B ${COMPILER_RT_BUILD_DIR} \
+	  -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=riscv${1} \
+	  -DCMAKE_ASM_COMPILER_TARGET=riscv${1} \
+	  -DCMAKE_CXX_COMPILER_TARGET=riscv${1} \
+	  -DCMAKE_C_TARGET_BITS=riscv${1} \
+	  -DCMAKE_ASM_TARGET_BITS=riscv${1} \
+	  -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}" \
+	  -DCMAKE_SYSTEM_NAME=unknown \
+	  -DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON 
+	
+	cmake --build ${COMPILER_RT_BUILD_DIR}
+	cmake --install ${COMPILER_RT_BUILD_DIR} 
+}
 
+build_compiler_rt 32
+build_compiler_rt 64
 
 echo ""
 echo "success"

crates/benchmarks/Cargo.toml

@@ -1,10 +1,11 @@
 [package]
 name = "revive-benchmarks"
-version = "0.1.0"
-edition = "2021"
-authors = [
-    "Cyrill Leutwiler <cyrill@parity.io>",
-]
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+authors.workspace = true
+description = "revive compiler benchmarks"
 
 [features]
 default = ["bench-pvm-interpreter"]
@@ -16,8 +17,8 @@ bench-extensive = []
 [dependencies]
 hex = { workspace = true }
 polkavm = { workspace = true }
-revive-integration = { path = "../integration" }
-revive-differential = { path = "../differential", optional = true }
+revive-integration = { workspace = true }
+revive-differential = { workspace = true, optional = true }
 alloy-primitives = { workspace = true }
 
 [dev-dependencies]

crates/benchmarks/benches/execute.rs

@@ -1,14 +1,8 @@
-#[cfg(feature = "bench-extensive")]
-use std::time::Duration;
-
+use alloy_primitives::U256;
 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)
@@ -24,82 +18,118 @@ where
         #[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());
+                    revive_differential::execute(revive_differential::prepare(
+                        contract.evm_runtime.clone(),
+                        contract.calldata.clone(),
+                    ));
                 });
             });
         }
 
-        #[cfg(feature = "bench-pvm-interpreter")]
+        #[cfg(not(feature = "bench-extensive"))]
         {
-            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(all(feature = "bench-pvm-interpreter", not(feature = "bench-extensive")))]
+            {
+                let contract = contract(p.clone());
+                let (transaction, mut instance, export) = revive_benchmarks::prepare_pvm(
+                    &contract.pvm_runtime,
+                    contract.calldata,
+                    polkavm::BackendKind::Interpreter,
+                );
+                group.bench_with_input(BenchmarkId::new("PVMInterpreter", l), p, |b, _| {
+                    b.iter(|| {
+                        let _ = transaction.clone().call_on(&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);
+            #[cfg(all(feature = "bench-pvm", not(feature = "bench-extensive")))]
+            {
+                let contract = contract(p.clone());
+                let (transaction, mut instance, export) = revive_benchmarks::prepare_pvm(
+                    &contract.pvm_runtime,
+                    contract.calldata,
+                    polkavm::BackendKind::Compiler,
+                );
+                group.bench_with_input(BenchmarkId::new("PVM", l), p, |b, _| {
+                    b.iter(|| {
+                        let _ = transaction.clone().call_on(&mut instance, export);
+                    });
                 });
-            });
+            }
+        }
+        #[cfg(feature = "bench-extensive")]
+        {
+            use revive_benchmarks::instantiate_engine;
+            use revive_integration::mock_runtime::{instantiate_module, recompile_code, State};
+
+            #[cfg(feature = "bench-pvm-interpreter")]
+            {
+                let contract = contract(p.clone());
+                let engine = instantiate_engine(polkavm::BackendKind::Interpreter);
+                let module = recompile_code(&contract.pvm_runtime, &engine);
+                let transaction = State::default()
+                    .transaction()
+                    .with_default_account(&contract.pvm_runtime)
+                    .calldata(contract.calldata);
+                group.bench_with_input(BenchmarkId::new("PVMInterpreter", l), p, |b, _| {
+                    b.iter(|| {
+                        let (mut instance, export) = instantiate_module(&module, &engine);
+                        let _ = transaction.clone().call_on(&mut instance, export);
+                    });
+                });
+            }
+
+            #[cfg(feature = "bench-pvm")]
+            {
+                let contract = contract(p.clone());
+                let engine = instantiate_engine(polkavm::BackendKind::Compiler);
+                let module = recompile_code(&contract.pvm_runtime, &engine);
+                let transaction = State::default()
+                    .transaction()
+                    .with_default_account(&contract.pvm_runtime)
+                    .calldata(contract.calldata);
+                group.bench_with_input(BenchmarkId::new("PVM", l), p, |b, _| {
+                    b.iter(|| {
+                        let (mut instance, export) = instantiate_module(&module, &engine);
+                        let _ = transaction.clone().call_on(&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>
+fn group<'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
+    #[cfg(feature = "bench-extensive")]
+    {
+        let mut group = c.benchmark_group(group_name);
+        group.sample_size(10);
+        group
+    }
+
+    #[cfg(not(feature = "bench-extensive"))]
+    return c.benchmark_group(group_name);
 }
 
 fn bench_baseline(c: &mut Criterion) {
+    let group = group(c, "Baseline");
     let parameters = &[0u8];
 
-    bench(
-        c.benchmark_group("Baseline"),
-        parameters,
-        parameters,
-        |_| Contract::baseline(),
-    );
+    bench(group, parameters, parameters, |_| Contract::baseline());
 }
 
 fn bench_odd_product(c: &mut Criterion) {
+    let group = group(c, "OddPorduct");
     #[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];
+    let parameters = &[300000, 1200000, 12000000, 180000000, 720000000];
     #[cfg(not(feature = "bench-extensive"))]
     let parameters = &[10_000, 100_000];
 
@@ -107,13 +137,9 @@ fn bench_odd_product(c: &mut Criterion) {
 }
 
 fn bench_triangle_number(c: &mut Criterion) {
+    let group = group(c, "TriangleNumber");
     #[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];
+    let parameters = &[360000, 1440000, 14400000, 216000000, 864000000];
     #[cfg(not(feature = "bench-extensive"))]
     let parameters = &[10_000, 100_000];
 
@@ -121,54 +147,53 @@ fn bench_triangle_number(c: &mut Criterion) {
 }
 
 fn bench_fibonacci_recurisve(c: &mut Criterion) {
-    #[cfg(not(feature = "bench-extensive"))]
-    let group = c.benchmark_group("FibonacciRecursive");
+    let group = group(c, "FibonacciRecursive");
     #[cfg(feature = "bench-extensive")]
-    let group = group_extensive(c, "FibonacciRecursive");
-
-    #[cfg(feature = "bench-extensive")]
-    let parameters = &[26, 30, 34, 38];
+    let parameters = [24, 27, 31, 36, 39]
+        .iter()
+        .map(|p| U256::from(*p))
+        .collect::<Vec<_>>();
     #[cfg(not(feature = "bench-extensive"))]
-    let parameters = &[12, 16, 20];
+    let parameters = [12, 16, 20]
+        .iter()
+        .map(|p| U256::from(*p))
+        .collect::<Vec<_>>();
 
-    bench(group, parameters, parameters, Contract::fib_recursive);
+    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");
+    let group = group(c, "FibonacciIterative");
     #[cfg(feature = "bench-extensive")]
-    let group = group_extensive(c, "FibonacciIterative");
-
-    #[cfg(feature = "bench-extensive")]
-    let parameters = &[256, 100000, 1000000, 100000000];
+    let parameters = [256, 162500, 650000, 6500000, 100000000, 400000000]
+        .iter()
+        .map(|p| U256::from(*p))
+        .collect::<Vec<_>>();
     #[cfg(not(feature = "bench-extensive"))]
-    let parameters = &[64, 128, 256];
+    let parameters = [64, 128, 256]
+        .iter()
+        .map(|p| U256::from(*p))
+        .collect::<Vec<_>>();
 
-    bench(group, parameters, parameters, Contract::fib_iterative);
+    bench(group, &parameters, &parameters, Contract::fib_iterative);
 }
 
 fn bench_fibonacci_binet(c: &mut Criterion) {
-    let parameters = &[64, 128, 256];
+    let group = group(c, "FibonacciBinet");
+    let parameters = [64, 128, 256]
+        .iter()
+        .map(|p| U256::from(*p))
+        .collect::<Vec<_>>();
 
-    bench(
-        c.benchmark_group("FibonacciBinet"),
-        parameters,
-        parameters,
-        Contract::fib_binet,
-    );
+    bench(group, &parameters, &parameters, Contract::fib_binet);
 }
 
 fn bench_sha1(c: &mut Criterion) {
+    let group = group(c, "SHA1");
     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,
-    );
+    bench(group, parameters, &labels, Contract::sha1);
 }
 
 criterion_group!(

crates/benchmarks/benches/prepare.rs

@@ -1,7 +1,6 @@
+use alloy_primitives::U256;
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use polkavm::BackendKind;
 
-use revive_benchmarks::instantiate_engine;
 use revive_integration::cases::Contract;
 
 fn bench(
@@ -22,7 +21,7 @@ fn bench(
 
     #[cfg(feature = "bench-pvm-interpreter")]
     {
-        let engine = instantiate_engine(BackendKind::Interpreter);
+        let engine = revive_benchmarks::instantiate_engine(polkavm::BackendKind::Interpreter);
         group.bench_with_input(
             BenchmarkId::new("PVMInterpreterCompile", code_size),
             &(&pvm_runtime, engine),
@@ -36,7 +35,7 @@ fn bench(
 
     #[cfg(feature = "bench-pvm-interpreter")]
     {
-        let engine = instantiate_engine(BackendKind::Interpreter);
+        let engine = revive_benchmarks::instantiate_engine(polkavm::BackendKind::Interpreter);
         let module = revive_integration::mock_runtime::recompile_code(&pvm_runtime, &engine);
         group.bench_with_input(
             BenchmarkId::new("PVMInterpreterInstantiate", code_size),
@@ -51,7 +50,7 @@ fn bench(
 
     #[cfg(feature = "bench-pvm")]
     {
-        let engine = instantiate_engine(BackendKind::Compiler);
+        let engine = revive_benchmarks::instantiate_engine(polkavm::BackendKind::Compiler);
         group.bench_with_input(
             BenchmarkId::new("PVMCompile", code_size),
             &(&pvm_runtime, engine),
@@ -65,7 +64,7 @@ fn bench(
 
     #[cfg(feature = "bench-pvm")]
     {
-        let engine = instantiate_engine(BackendKind::Compiler);
+        let engine = revive_benchmarks::instantiate_engine(polkavm::BackendKind::Compiler);
         let module = revive_integration::mock_runtime::recompile_code(&pvm_runtime, &engine);
         group.bench_with_input(
             BenchmarkId::new("PVMInstantiate", code_size),
@@ -119,9 +118,9 @@ fn bench_fibonacci_recursive(c: &mut Criterion) {
         c,
         "PrepareFibonacciRecursive",
         #[cfg(feature = "bench-evm")]
-        Contract::fib_recursive(0).evm_runtime,
+        Contract::fib_recursive(U256::ZERO).evm_runtime,
         #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::fib_recursive(0).pvm_runtime,
+        Contract::fib_recursive(U256::ZERO).pvm_runtime,
     );
 }
 
@@ -130,9 +129,9 @@ fn bench_fibonacci_iterative(c: &mut Criterion) {
         c,
         "PrepareFibonacciIterative",
         #[cfg(feature = "bench-evm")]
-        Contract::fib_iterative(0).evm_runtime,
+        Contract::fib_iterative(U256::ZERO).evm_runtime,
         #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::fib_iterative(0).pvm_runtime,
+        Contract::fib_iterative(U256::ZERO).pvm_runtime,
     );
 }
 
@@ -141,9 +140,9 @@ fn bench_fibonacci_binet(c: &mut Criterion) {
         c,
         "PrepareFibonacciBinet",
         #[cfg(feature = "bench-evm")]
-        Contract::fib_binet(0).evm_runtime,
+        Contract::fib_binet(U256::ZERO).evm_runtime,
         #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::fib_binet(0).pvm_runtime,
+        Contract::fib_binet(U256::ZERO).pvm_runtime,
     );
 }
 

crates/benchmarks/src/lib.rs

@@ -1,19 +1,23 @@
 use polkavm::{BackendKind, Config, Engine, ExportIndex, Instance, SandboxKind};
-use revive_integration::mock_runtime;
-use revive_integration::mock_runtime::State;
+use revive_integration::mock_runtime::{self, TransactionBuilder};
+use revive_integration::mock_runtime::{State, Transaction};
 
 pub fn prepare_pvm(
     code: &[u8],
-    input: &[u8],
+    input: Vec<u8>,
     backend: BackendKind,
-) -> (State, Instance<State>, ExportIndex) {
+) -> (TransactionBuilder, Instance<Transaction>, 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));
+    let transaction = State::default()
+        .transaction()
+        .with_default_account(code)
+        .calldata(input);
 
-    (State::new(input.to_vec()), instance, export_index)
+    (transaction, instance, export_index)
 }
 
 pub fn instantiate_engine(backend: BackendKind) -> Engine {

crates/builtins/Cargo.toml

@@ -1,9 +1,14 @@
 [package]
 name = "revive-builtins"
-version = "0.1.0"
-edition = "2021"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+authors.workspace = true
 build = "build.rs"
+description = "compiler builtins for the revive compiler"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+riscv-64 = []
 
 [dependencies]

crates/builtins/build.rs

@@ -1,7 +1,11 @@
 use std::{env, fs, io::Read, path::Path, process::Command};
 
+#[cfg(not(feature = "riscv-64"))]
+pub const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv32.a";
+#[cfg(feature = "riscv-64")]
+pub const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv64.a";
+
 fn main() {
-    let lib = "libclang_rt.builtins-riscv32.a";
     let mut llvm_lib_dir = String::new();
 
     Command::new("llvm-config")
@@ -13,18 +17,24 @@ fn main() {
         .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())
+    let mut lib_path = std::path::PathBuf::from(llvm_lib_dir.trim())
         .join("linux")
-        .join(lib);
-    let archive = fs::read(lib_path).expect("clang builtins for riscv32 not found");
+        .join(BUILTINS_ARCHIVE_FILE);
+    if !lib_path.exists() {
+        lib_path = std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join(BUILTINS_ARCHIVE_FILE);
+    }
+    let archive = fs::read(lib_path).expect("clang builtins not found");
 
     let out_dir = env::var_os("OUT_DIR").expect("has OUT_DIR");
-    let archive_path = Path::new(&out_dir).join(lib);
+    let archive_path = Path::new(&out_dir).join(BUILTINS_ARCHIVE_FILE);
     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}\");");
+    let src = format!(
+        "pub static COMPILER_RT: &[u8; {len}] = include_bytes!(\"{BUILTINS_ARCHIVE_FILE}\");"
+    );
     fs::write(src_path, src).expect("can write to OUT_DIR");
 
     println!("cargo:rerun-if-changed=build.rs");

crates/common/Cargo.toml

@@ -1,17 +1,21 @@
 [package]
 name = "revive-common"
-version = "0.1.0"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
 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
 
+[features]
+riscv-64 = []
+
 [dependencies]
 anyhow = { workspace = true }
 serde = { workspace = true, features = ["derive"] }

crates/common/README.md

@@ -1,13 +1,4 @@
-# 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.
+# revive: Compiler Common
 
 ## License
 
@@ -17,19 +8,3 @@ This library is distributed under the terms of either
 - 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,6 +1,4 @@
-//!
 //! The number base constants.
-//!
 
 /// The binary number base.
 pub const BASE_BINARY: u32 = 2;

crates/common/src/bit_length.rs

@@ -1,6 +1,4 @@
-//!
 //! The common sizes in bits.
-//!
 
 /// The `bool` type bit-length.
 pub const BIT_LENGTH_BOOLEAN: usize = 1;
@@ -18,8 +16,16 @@ pub const BIT_LENGTH_X64: usize = crate::byte_length::BYTE_LENGTH_X64 * BIT_LENG
 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;
+/// The VM word (usually `u256` or `i256`) bit-length.
+pub const BIT_LENGTH_WORD: usize = crate::byte_length::BYTE_LENGTH_WORD * 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;
+
+/// Bit length of thre runimte block number type.
+pub const BIT_LENGTH_BLOCK_NUMBER: usize =
+    crate::byte_length::BYTE_LENGTH_BLOCK_NUMBER * BIT_LENGTH_BYTE;
+
+/// Bit length of thre runimte block timestamp type.
+pub const BIT_LENGTH_BLOCK_TIMESTAMP: usize =
+    crate::byte_length::BYTE_LENGTH_BLOCK_TIMESTAMP * BIT_LENGTH_BYTE;

crates/common/src/byte_length.rs

@@ -1,6 +1,4 @@
-//!
 //! The common sizes in bytes.
-//!
 
 /// The byte-length.
 pub const BYTE_LENGTH_BYTE: usize = 1;
@@ -9,7 +7,10 @@ pub const BYTE_LENGTH_BYTE: usize = 1;
 pub const BYTE_LENGTH_X32: usize = 4;
 
 /// Native stack alignment size in bytes
+#[cfg(not(feature = "riscv-64"))]
 pub const BYTE_LENGTH_STACK_ALIGN: usize = 4;
+#[cfg(feature = "riscv-64")]
+pub const BYTE_LENGTH_STACK_ALIGN: usize = 8;
 
 /// The x86_64 word byte-length.
 pub const BYTE_LENGTH_X64: usize = 8;
@@ -17,8 +18,14 @@ 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;
+/// The word byte-length.
+pub const BYTE_LENGTH_WORD: usize = 32;
 
 /// Byte length of the runtime value type.
-pub const BYTE_LENGTH_VALUE: usize = 16;
+pub const BYTE_LENGTH_VALUE: usize = 32;
+
+/// Byte length of the runtime block number type.
+pub const BYTE_LENGTH_BLOCK_NUMBER: usize = 8;
+
+/// Byte length of the runtime block timestamp type.
+pub const BYTE_LENGTH_BLOCK_TIMESTAMP: usize = 8;

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,13 +1,9 @@
-//!
 //! 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 {

crates/common/src/extension.rs

@@ -1,6 +1,4 @@
-//!
 //! The file extensions.
-//!
 
 /// The manifest file extension.
 pub static EXTENSION_MANIFEST: &str = "toml";
@@ -32,17 +30,14 @@ 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 PolkaVM assembly file extension.
+pub static EXTENSION_POLKAVM_ASSEMBLY: &str = "pvmasm";
 
-/// The EraVM bytecode file extension.
-pub static EXTENSION_ERAVM_BINARY: &str = "zbin";
+/// The PolkaVM bytecode file extension.
+pub static EXTENSION_POLKAVM_BINARY: &str = "pvm";

crates/common/src/lib.rs

@@ -1,21 +1,19 @@
-//!
 //! 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 polkavm;
 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::polkavm::address::*;
 pub use self::utils::*;

crates/common/src/polkavm/address.rs

@@ -0,0 +1,115 @@
+//! The PolkaVM address constants.
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_TO_L1: u16 = 0xFFFF;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_PRECOMPILE: u16 = 0xFFFD;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_META: u16 = 0xFFFC;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_MIMIC_CALL: u16 = 0xFFFB;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_SYSTEM_MIMIC_CALL: u16 = 0xFFFA;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_MIMIC_CALL_BYREF: u16 = 0xFFF9;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_SYSTEM_MIMIC_CALL_BYREF: u16 = 0xFFF8;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_RAW_FAR_CALL: u16 = 0xFFF7;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_RAW_FAR_CALL_BYREF: u16 = 0xFFF6;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_SYSTEM_CALL: u16 = 0xFFF5;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_SYSTEM_CALL_BYREF: u16 = 0xFFF4;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_SET_CONTEXT_VALUE_CALL: u16 = 0xFFF3;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_SET_PUBDATA_PRICE: u16 = 0xFFF2;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_INCREMENT_TX_COUNTER: u16 = 0xFFF1;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_GET_GLOBAL_PTR_CALLDATA: u16 = 0xFFF0;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_GET_GLOBAL_CALL_FLAGS: u16 = 0xFFEF;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_GET_GLOBAL_PTR_RETURN_DATA: u16 = 0xFFEE;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_EVENT_INITIALIZE: u16 = 0xFFED;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_EVENT_WRITE: u16 = 0xFFEC;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_ACTIVE_PTR_LOAD_CALLDATA: u16 = 0xFFEB;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_ACTIVE_PTR_LOAD_RETURN_DATA: u16 = 0xFFEA;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_ACTIVE_PTR_ADD: u16 = 0xFFE9;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_ACTIVE_PTR_SHRINK: u16 = 0xFFE8;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_ACTIVE_PTR_PACK: u16 = 0xFFE7;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_MULTIPLICATION_HIGH_REGISTER: u16 = 0xFFE6;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_GET_GLOBAL_EXTRA_ABI_DATA: u16 = 0xFFE5;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_ACTIVE_PTR_DATA_LOAD: u16 = 0xFFE4;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_ACTIVE_PTR_DATA_COPY: u16 = 0xFFE3;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_ACTIVE_PTR_DATA_SIZE: u16 = 0xFFE2;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_CONST_ARRAY_DECLARE: u16 = 0xFFE1;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_CONST_ARRAY_SET: u16 = 0xFFE0;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_CONST_ARRAY_FINALIZE: u16 = 0xFFDF;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_CONST_ARRAY_GET: u16 = 0xFFDE;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_DECOMMIT: u16 = 0xFFDD;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_ACTIVE_PTR_LOAD_DECOMMIT: u16 = 0xFFDC;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_RETURN_FORWARD: u16 = 0xFFDB;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_REVERT_FORWARD: u16 = 0xFFDA;
+
+/// The corresponding simulation predefined address.
+pub const POLKAVM_ADDRESS_ACTIVE_PTR_SWAP: u16 = 0xFFD9;

crates/common/src/polkavm/mod.rs

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

crates/common/src/utils.rs

@@ -1,12 +1,7 @@
-//!
 //! 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,
@@ -18,11 +13,8 @@ where
     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,

crates/differential/Cargo.toml

@@ -1,10 +1,12 @@
 [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
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+authors.workspace = true
+repository.workspace = true
 
 [dependencies]
 evm-interpreter = { workspace = true }
 primitive-types = { workspace = true }
+alloy-primitives = { workspace = true }

crates/differential/src/lib.rs

@@ -1,3 +1,4 @@
+use alloy_primitives::{keccak256, Address, B256};
 use evm_interpreter::{
     interpreter::{EtableInterpreter, RunInterpreter},
     trap::CallCreateTrap,
@@ -9,20 +10,23 @@ use primitive_types::{H160, H256, U256};
 static RUNTIME_ETABLE: Etable<RuntimeState, UnimplementedHandler, CallCreateTrap> =
     Etable::runtime();
 
-pub struct UnimplementedHandler;
+#[derive(Default)]
+pub struct UnimplementedHandler {
+    logs: Vec<Log>,
+}
 
 impl RuntimeEnvironment for UnimplementedHandler {
     fn block_hash(&self, _number: U256) -> H256 {
         unimplemented!()
     }
     fn block_number(&self) -> U256 {
-        unimplemented!()
+        U256::from(123)
     }
     fn block_coinbase(&self) -> H160 {
         unimplemented!()
     }
     fn block_timestamp(&self) -> U256 {
-        unimplemented!()
+        U256::from(456)
     }
     fn block_difficulty(&self) -> U256 {
         unimplemented!()
@@ -86,8 +90,9 @@ impl RuntimeBackend for UnimplementedHandler {
     fn set_storage(&mut self, _address: H160, _index: H256, _value: H256) -> Result<(), ExitError> {
         unimplemented!()
     }
-    fn log(&mut self, _log: Log) -> Result<(), ExitError> {
-        unimplemented!()
+    fn log(&mut self, log: Log) -> Result<(), ExitError> {
+        self.logs.push(log);
+        Ok(())
     }
     fn mark_delete(&mut self, _address: H160) {
         unimplemented!()
@@ -123,10 +128,13 @@ pub struct PreparedEvm {
 }
 
 pub fn prepare(code: Vec<u8>, data: Vec<u8>) -> PreparedEvm {
+    let address = Address::default().create2(B256::default(), keccak256([]).0);
+    let caller = Address::default().create2(B256::default(), keccak256([]).0);
+
     let state = RuntimeState {
         context: Context {
-            address: H160::default(),
-            caller: H160::default(),
+            address: H160::from(address.0 .0),
+            caller: H160::from(caller.0 .0),
             apparent_value: U256::default(),
         },
         transaction_context: TransactionContext {
@@ -143,12 +151,9 @@ pub fn prepare(code: Vec<u8>, data: Vec<u8>) -> PreparedEvm {
     }
 }
 
-pub fn execute(pre: PreparedEvm) -> Vec<u8> {
+pub fn execute(pre: PreparedEvm) -> (Vec<u8>, Vec<Log>) {
     let mut vm = EtableInterpreter::new_valid(pre.vm, &RUNTIME_ETABLE, pre.valids);
-    vm.run(&mut UnimplementedHandler {})
-        .exit()
-        .unwrap()
-        .unwrap();
-
-    vm.retval.clone()
+    let mut handler = UnimplementedHandler::default();
+    vm.run(&mut handler).exit().unwrap().unwrap();
+    (vm.retval.clone(), handler.logs)
 }

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,13 +0,0 @@
-target datalayout = "e-m:e-p:32:32-i64:64-n32-S128"
-target triple = "riscv32-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,+m",
-            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,9 +1,11 @@
 [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
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+authors.workspace = true
+description = "revive compiler integration test cases"
 
 [dependencies]
 polkavm = { workspace = true }
@@ -11,10 +13,15 @@ alloy-primitives = { workspace = true }
 alloy-sol-types = { workspace = true }
 hex = { workspace = true }
 env_logger = { workspace = true }
+log = { workspace = true }
 
-revive-solidity = { path = "../solidity" }
-revive-differential = { path = "../differential" }
-era-compiler-llvm-context = { path = "../llvm-context" }
+revive-solidity = { workspace = true }
+revive-differential = { workspace = true }
+revive-llvm-context = { workspace = true }
+revive-common = { workspace = true }
 
 [dev-dependencies]
 sha1 = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+rayon = { workspace = true }

crates/integration/codesize.json

@@ -0,0 +1,10 @@
+{
+  "Baseline": 934,
+  "Computation": 4360,
+  "DivisionArithmetics": 39824,
+  "ERC20": 46471,
+  "Events": 1749,
+  "FibonacciIterative": 2973,
+  "Flipper": 3563,
+  "SHA1": 32543
+}

crates/integration/contracts/Baseline.sol

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

crates/integration/contracts/Bitwise.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+contract Bitwise {
+    function opByte(uint i, uint x) public payable returns (uint ret) {
+        assembly {
+            ret := byte(i, x)
+        }
+    }
+}

crates/integration/contracts/Block.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+contract Block {
+    function timestamp() public view returns (uint ret) {
+        ret = block.timestamp;
+    }
+
+    function number() public view returns (uint ret) {
+        ret = block.number;
+    }
+}

crates/integration/contracts/Call.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+contract Call {
+    function value_transfer(address payable destination) public payable {
+        destination.transfer(msg.value);
+    }
+
+    function echo(bytes memory payload) public pure returns (bytes memory) {
+        return payload;
+    }
+
+    function call(
+        address callee,
+        bytes memory payload
+    ) public pure returns (bytes memory) {
+        return Call(callee).echo(payload);
+    }
+}

crates/integration/contracts/Computation.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity ^0.8.24;
+pragma solidity ^0.8;
 
 contract Computation {
     function triangle_number(int64 n) public pure returns (int64 sum) {

crates/integration/contracts/Context.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+contract Context {
+    function address_this() public view returns (address ret) {
+        ret = address(this);
+    }
+
+    function caller() public view returns (address ret) {
+        ret = msg.sender;
+    }
+}

crates/integration/contracts/Create.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.24;
+
+contract CreateA {
+    address creator;
+
+    constructor() payable {
+        creator = msg.sender;
+    }
+}
+
+contract CreateB {
+    receive() external payable {
+        new CreateA{value: msg.value}();
+    }
+
+    fallback() external {
+        new CreateA{salt: hex"01"}();
+    }
+}

crates/integration/contracts/DivisionArithmetics.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+contract DivisionArithmetics {
+    function div(uint n, uint d) public pure returns (uint q) {
+        assembly {
+            q := div(n, d)
+        }
+    }
+
+    function sdiv(int n, int d) public pure returns (int q) {
+        assembly {
+            q := sdiv(n, d)
+        }
+    }
+
+    function mod(uint n, uint d) public pure returns (uint r) {
+        assembly {
+            r := mod(n, d)
+        }
+    }
+
+    function smod(int n, int d) public pure returns (int r) {
+        assembly {
+            r := smod(n, d)
+        }
+    }
+}

crates/integration/contracts/ERC20.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity ^0.8.20;
+pragma solidity ^0.8;
 
 // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.0.0/contracts/token/ERC20/IERC20.sol
 interface IERC20 {

crates/integration/contracts/Events.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+contract Events {
+    event A() anonymous;
+    event E(uint, uint indexed, uint indexed, uint indexed);
+
+    function emitEvent(uint topics) public {
+        if (topics == 0) {
+            emit A();
+        } else {
+            emit E(topics, 1, 2, 3);
+        }
+    }
+}

crates/integration/contracts/ExtCode.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+contract ExtCode {
+    function ExtCodeSize(address who) public view returns (uint ret) {
+        assembly {
+            ret := extcodesize(who)
+        }
+    }
+
+    function CodeSize() public pure returns (uint ret) {
+        assembly {
+            ret := codesize()
+        }
+    }
+}

crates/integration/contracts/Fibonacci.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: UNLICENSED
 
-pragma solidity ^0.8.24;
+pragma solidity ^0.8;
 
 // https://medium.com/coinmonks/fibonacci-in-solidity-8477d907e22a
 

crates/integration/contracts/MCopy.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+contract MCopy {
+    function memcpy(bytes memory payload) public pure returns (bytes memory) {
+        return payload;
+    }
+}

crates/integration/contracts/MSize.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity ^0.8.24;
+pragma solidity ^0.8;
 
 contract MSize {
     uint[] public data;

crates/integration/contracts/Storage.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+contract Storage {
+    function transient(uint value) public returns (uint ret) {
+        assembly {
+            let slot := 123
+            tstore(slot, value)
+            let success := call(0, 0, 0, 0, 0, 0, 0)
+            ret := tload(slot)
+        }
+    }
+}

crates/integration/contracts/Value.sol

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

crates/integration/contracts/flipper.sol

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

crates/integration/contracts/mStore8.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity ^0.8.24;
+pragma solidity ^0.8;
 
 contract MStore8 {
     function mStore8(uint value) public pure returns (uint256 word) {

crates/integration/src/cases.rs

@@ -1,119 +1,320 @@
-use alloy_primitives::U256;
-use alloy_sol_types::{sol, SolCall};
+use alloy_primitives::{Address, I256, U256};
+use alloy_sol_types::{sol, SolCall, SolConstructor};
+
+use revive_solidity::test_utils::*;
+
+use crate::mock_runtime::{CallOutput, State};
 
 #[derive(Clone)]
 pub struct Contract {
+    pub name: &'static str,
     pub evm_runtime: Vec<u8>,
     pub pvm_runtime: Vec<u8>,
     pub calldata: Vec<u8>,
 }
 
+macro_rules! case {
+    // Arguments:
+    //     1. The file name, expect to live under "../contracts/"
+    //     2. The Solidity contract name
+    //     3. The derived Solidity function call name
+    //     4. The method name on [Contract]
+    //     5. Any parameters to the Solidity functions
+    ($file_name:literal, $contract_name:ident, $contract_method:ident, $method_name:ident, $( $v:ident: $t:ty ),* ) => {
+        impl Contract {
+            pub fn $method_name($($v: $t),*) -> Self {
+                let code = include_str!(concat!("../contracts/", $file_name));
+                let args = $contract_name::$contract_method::new(($($v,)*)).abi_encode();
+                let name = stringify!($contract_name);
+                Contract::build(args, name, code)
+            }
+        }
+    };
+
+    // Arguments:
+    //     1. The file name, expect to live under "../contracts/"
+    //     2. The Solidity contract name
+    //     3. Raw Calldata
+    //     4. The method name on [Contract]
+    ($file_name:literal, $contract_name:literal, $calldata:expr, $method_name:ident) => {
+        impl Contract {
+            pub fn $method_name() -> Self {
+                let code = include_str!(concat!("../contracts/", $file_name));
+                Contract::build($calldata, $contract_name, code)
+            }
+        }
+    };
+}
+
+case!("Create.sol", "CreateA", vec![0; 4], create_a);
+case!("Create.sol", "CreateB", vec![0; 4], create_b);
+
 sol!(contract Baseline { function baseline() public payable; });
+case!("Baseline.sol", Baseline, baselineCall, baseline,);
+
+sol!(contract Flipper {
+    constructor (bool);
+
+    function flip() public;
+});
+case!("flipper.sol", Flipper, flipCall, flipper,);
+case!("flipper.sol", Flipper, constructorCall, flipper_constructor, coin: bool);
 
 sol!(contract Computation {
     function odd_product(int32 n) public pure returns (int64);
     function triangle_number(int64 n) public pure returns (int64 sum);
 });
+case!("Computation.sol", Computation, odd_productCall, odd_product, n: i32);
+case!("Computation.sol", Computation, triangle_numberCall, triangle_number, n: i64);
 
 sol!(
     contract FibonacciRecursive {
         function fib3(uint n) public pure returns (uint);
     }
 );
+case!("Fibonacci.sol", FibonacciRecursive, fib3Call, fib_recursive, n: U256);
 
 sol!(
     contract FibonacciIterative {
         function fib3(uint n) external pure returns (uint b);
     }
 );
+case!("Fibonacci.sol", FibonacciIterative, fib3Call, fib_iterative, n: U256);
 
 sol!(
     contract FibonacciBinet {
         function fib3(uint n) external pure returns (uint a);
     }
 );
+case!("Fibonacci.sol", FibonacciBinet, fib3Call, fib_binet, n: U256);
 
 sol!(
     contract SHA1 {
         function sha1(bytes memory data) public pure returns (bytes20 ret);
     }
 );
+case!("SHA1.sol", SHA1, sha1Call, sha1, pre: Vec<u8>);
+
+sol!(
+    contract ERC20 {
+        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);
+    }
+);
+case!("ERC20.sol", ERC20, totalSupplyCall, erc20,);
+
+sol!(
+    contract Block {
+        function timestamp() public view returns (uint ret);
+
+        function number() public view returns (uint ret);
+    }
+);
+case!("Block.sol", Block, numberCall, block_number,);
+case!("Block.sol", Block, timestampCall, block_timestamp,);
+
+sol!(
+    contract Context {
+        function address_this() public view returns (address);
+
+        function caller() public pure returns (address);
+    }
+);
+case!("Context.sol", Context, address_thisCall, context_address,);
+case!("Context.sol", Context, callerCall, context_caller,);
+
+sol!(
+    contract DivisionArithmetics {
+        function div(uint n, uint d) public pure returns (uint q);
+
+        function sdiv(int n, int d) public pure returns (int q);
+
+        function mod(uint n, uint d) public pure returns (uint r);
+
+        function smod(int n, int d) public pure returns (int r);
+    }
+);
+case!("DivisionArithmetics.sol", DivisionArithmetics, divCall, division_arithmetics_div, n: U256, d: U256);
+case!("DivisionArithmetics.sol", DivisionArithmetics, sdivCall, division_arithmetics_sdiv, n: I256, d: I256);
+case!("DivisionArithmetics.sol", DivisionArithmetics, modCall, division_arithmetics_mod, n: U256, d: U256);
+case!("DivisionArithmetics.sol", DivisionArithmetics, smodCall, division_arithmetics_smod, n: I256, d: I256);
+
+sol!(
+    contract MStore8 {
+        function mStore8(uint value) public pure returns (uint256 word);
+    }
+);
+case!("mStore8.sol", MStore8, mStore8Call, mstore8, value: U256);
+
+sol!(
+    contract Events {
+        event A(uint) anonymous;
+        event E(uint indexed, uint indexed, uint indexed);
+
+        function emitEvent(uint topics) public;
+    }
+);
+case!("Events.sol", Events, emitEventCall, event, topics: U256);
+
+sol!(
+    contract ExtCode {
+        function ExtCodeSize(address who) public view returns (uint ret);
+
+        function CodeSize() public pure returns (uint ret);
+    }
+);
+case!("ExtCode.sol", ExtCode, ExtCodeSizeCall, ext_code_size, address: Address);
+case!("ExtCode.sol", ExtCode, CodeSizeCall, code_size,);
+
+sol!(
+    contract MCopy {
+        function memcpy(bytes memory payload) public pure returns (bytes memory);
+    }
+);
+case!("MCopy.sol", MCopy, memcpyCall, memcpy, payload: Vec<u8>);
+
+sol!(
+    contract Call {
+        function value_transfer(address payable destination) public payable;
+
+        function echo(bytes memory payload) public payable returns (bytes memory);
+
+        function call(
+            address callee,
+            bytes memory payload
+        ) public payable returns (bytes memory);
+    }
+);
+case!("Call.sol", Call, value_transferCall, call_value_transfer, destination: Address);
+case!("Call.sol", Call, callCall, call_call, destination: Address, payload: Vec<u8>);
+case!("Call.sol", "Call", vec![], call_constructor);
+
+sol!(
+    contract Value {
+        function balance_of(address _address) public view returns (uint ret);
+    }
+);
+case!("Value.sol", Value, balance_ofCall, value_balance_of, address: Address);
+
+sol!(
+    contract Bitwise {
+        function opByte(uint i, uint x) public payable returns (uint ret);
+    }
+);
+case!("Bitwise.sol", Bitwise, opByteCall, bitwise_byte, index: U256, value: U256);
+
+sol!(
+    contract Storage {
+        function transient(uint value) public returns (uint ret);
+    }
+);
+case!("Storage.sol", Storage, transientCall, storage_transient, value: U256);
 
 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(),
-        }
+    /// Execute the contract.
+    ///
+    /// Useful helper if the contract state can be ignored,
+    /// as it spares the deploy transaciton.
+    ///
+    /// - Inserts an account with given `code` into a new state.
+    /// - Callee and caller account will be `Transaction::default_address()`.
+    /// - Sets the calldata.
+    /// - Doesn't execute the constructor or deploy code.
+    /// - Calls the "call" export on a default backend config.
+    pub fn execute(&self) -> (State, CallOutput) {
+        State::default()
+            .transaction()
+            .with_default_account(&self.pvm_runtime)
+            .calldata(self.calldata.clone())
+            .call()
     }
 
-    pub fn odd_product(n: i32) -> Self {
-        let code = include_str!("../contracts/Computation.sol");
-        let name = "Computation";
-
+    fn build(calldata: Vec<u8>, name: &'static str, code: &str) -> Self {
         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(),
+            name,
+            evm_runtime: compile_evm_bin_runtime(name, code),
+            pvm_runtime: compile_blob(name, code),
+            calldata,
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use alloy_primitives::U256;
+    use rayon::iter::{IntoParallelIterator, ParallelIterator};
+    use serde::{de::Deserialize, Serialize};
+    use std::{collections::BTreeMap, fs::File};
+
+    use super::Contract;
+
+    #[test]
+    fn codesize() {
+        let path = "codesize.json";
+
+        let existing = File::open(path)
+            .map(|file| {
+                BTreeMap::<String, usize>::deserialize(&mut serde_json::Deserializer::from_reader(
+                    file,
+                ))
+                .expect("should be able to deserialze codesize data")
+            })
+            .ok();
+
+        let extract_code_size = |compile: fn() -> Contract| {
+            let contract = compile();
+            let contract_length = contract.pvm_runtime.len();
+            let size_change = existing
+                .as_ref()
+                .and_then(|map| map.get(contract.name))
+                .filter(|old| **old != 0)
+                .map(|old| {
+                    let old = *old as f32;
+                    let p = (contract_length as f32 - old) / old * 100.0;
+                    format!("({p}% change from {old} bytes)",)
+                })
+                .unwrap_or_default();
+
+            println!("{}: {contract_length} bytes {size_change}", contract.name);
+
+            (contract.name, contract_length)
+        };
+
+        [
+            Contract::baseline as fn() -> Contract,
+            Contract::flipper as fn() -> Contract,
+            (|| Contract::odd_product(0)) as fn() -> Contract,
+            (|| Contract::fib_iterative(U256::ZERO)) as fn() -> Contract,
+            Contract::erc20 as fn() -> Contract,
+            (|| Contract::sha1(Vec::new())) as fn() -> Contract,
+            (|| Contract::division_arithmetics_div(U256::ZERO, U256::ZERO)) as fn() -> Contract,
+            (|| Contract::event(U256::ZERO)) as fn() -> Contract,
+        ]
+        .into_par_iter()
+        .map(extract_code_size)
+        .collect::<BTreeMap<_, _>>()
+        .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,5 +1,8 @@
+use alloy_primitives::{Address, U256};
 use cases::Contract;
-use mock_runtime::State;
+use mock_runtime::{CallOutput, State};
+
+use crate::mock_runtime::{Event, ReturnFlags};
 
 pub mod cases;
 pub mod mock_runtime;
@@ -7,79 +10,33 @@ 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);
+pub fn assert_success(contract: &Contract, differential: bool) -> (State, CallOutput) {
+    let (state, output) = contract.execute();
+    assert_eq!(output.flags, ReturnFlags::Success);
 
     if differential {
-        let evm = revive_differential::prepare(contract.evm_runtime, contract.calldata);
-        assert_eq!(state.output.data.clone(), revive_differential::execute(evm));
+        let evm =
+            revive_differential::prepare(contract.evm_runtime.clone(), contract.calldata.clone());
+        let (evm_output, evm_log) = revive_differential::execute(evm);
+
+        assert_eq!(output.data.clone(), evm_output);
+        assert_eq!(output.events.len(), evm_log.len());
+        assert_eq!(
+            output.events,
+            evm_log
+                .iter()
+                .map(|log| Event {
+                    address: Address::from_slice(log.address.as_bytes()),
+                    data: log.data.clone(),
+                    topics: log
+                        .topics
+                        .iter()
+                        .map(|topic| U256::from_be_bytes(topic.0))
+                        .collect(),
+                })
+                .collect::<Vec<_>>()
+        );
     }
 
-    state
+    (state, output)
 }

crates/integration/src/tests.rs

@@ -1,11 +1,16 @@
-use alloy_primitives::{FixedBytes, Keccak256, I256, U256};
-use alloy_sol_types::{sol, SolCall};
+use std::str::FromStr;
+
+use alloy_primitives::{keccak256, Address, FixedBytes, B256, I256, U256};
+use alloy_sol_types::{sol, SolCall, SolValue};
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use sha1::Digest;
 
+use revive_solidity::test_utils::*;
+
 use crate::{
     assert_success,
     cases::Contract,
-    mock_runtime::{self, State},
+    mock_runtime::{self, ReturnFlags, State, Transaction},
 };
 
 #[test]
@@ -13,12 +18,12 @@ fn fibonacci() {
     let parameter = 6;
 
     for contract in [
-        Contract::fib_recursive(parameter),
-        Contract::fib_iterative(parameter),
-        Contract::fib_binet(parameter),
+        Contract::fib_recursive(U256::from(parameter)),
+        Contract::fib_iterative(U256::from(parameter)),
+        Contract::fib_binet(U256::from(parameter)),
     ] {
-        let state = assert_success(contract, true);
-        let received = U256::from_be_bytes::<32>(state.output.data.try_into().unwrap());
+        let (_, output) = assert_success(&contract, true);
+        let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
         let expected = U256::from(8);
         assert_eq!(received, expected);
     }
@@ -26,17 +31,24 @@ fn fibonacci() {
 
 #[test]
 fn flipper() {
-    let code = crate::compile_blob("Flipper", include_str!("../contracts/flipper.sol"));
-    let state = State::new(0xcde4efa9u32.to_be_bytes().to_vec());
-    let (mut instance, export) = mock_runtime::prepare(&code, None);
+    let (state, address) = State::new_deployed(Contract::flipper_constructor(true));
 
-    let state = crate::mock_runtime::call(state, &mut instance, export);
-    assert_eq!(state.output.flags, 0);
-    assert_eq!(state.storage[&U256::ZERO], U256::try_from(1).unwrap());
+    let contract = Contract::flipper();
+    let (state, output) = state
+        .transaction()
+        .calldata(contract.calldata.clone())
+        .callee(address)
+        .call();
+    assert_eq!(output.flags, ReturnFlags::Success);
+    state.assert_storage_key(address, U256::ZERO, U256::ZERO);
 
-    let state = crate::mock_runtime::call(state, &mut instance, export);
-    assert_eq!(state.output.flags, 0);
-    assert_eq!(state.storage[&U256::ZERO], U256::ZERO);
+    let (state, output) = state
+        .transaction()
+        .calldata(contract.calldata)
+        .callee(address)
+        .call();
+    assert_eq!(output.flags, ReturnFlags::Success);
+    state.assert_storage_key(address, U256::ZERO, U256::from(1));
 }
 
 #[test]
@@ -52,41 +64,41 @@ fn hash_keccak_256() {
                 hash = keccak256(bytes(_pre));
             }
         }"#;
-    let code = crate::compile_blob("TestSha3", source);
+    let code = 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);
+    let (_, output) = State::default()
+        .transaction()
+        .with_default_account(&code)
+        .calldata(input)
+        .call();
 
-    assert_eq!(state.output.flags, 0);
+    assert_eq!(output.flags, ReturnFlags::Success);
 
-    let mut hasher = Keccak256::new();
-    hasher.update(param);
-    let expected = hasher.finalize();
-    let received = FixedBytes::<32>::from_slice(&state.output.data);
+    let expected = keccak256(param.as_bytes());
+    let received = FixedBytes::<32>::from_slice(&output.data);
     assert_eq!(received, expected);
 }
 
 #[test]
 fn erc20() {
-    let _ = crate::compile_blob("ERC20", include_str!("../contracts/ERC20.sol"));
+    let _ = 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 (_, output) = assert_success(&Contract::triangle_number(13), true);
+    let received = U256::from_be_bytes::<32>(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 (_, output) = assert_success(&Contract::odd_product(5), true);
+    let received = I256::from_be_bytes::<32>(output.data.try_into().unwrap());
     let expected = I256::try_from(945i64).unwrap();
     assert_eq!(received, expected);
 }
@@ -99,22 +111,25 @@ fn msize_plain() {
             function mSize() public pure returns (uint);
         }
     );
-    let code = crate::compile_blob_with_options(
+    let code = 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);
+    let (_, output) = State::default()
+        .transaction()
+        .calldata(input)
+        .with_default_account(&code)
+        .call();
 
-    assert_eq!(state.output.flags, 0);
+    assert_eq!(output.flags, ReturnFlags::Success);
 
     // 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());
+    let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
     assert_eq!(received, expected);
 }
 
@@ -125,17 +140,19 @@ fn transferred_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 code = compile_blob("Value", include_str!("../contracts/Value.sol"));
 
-    let (mut instance, export) = mock_runtime::prepare(&code, None);
-    let state = crate::mock_runtime::call(state, &mut instance, export);
+    let (_, output) = State::default()
+        .transaction()
+        .calldata(Value::valueCall::SELECTOR.to_vec())
+        .callvalue(U256::from(123))
+        .with_default_account(&code)
+        .call();
 
-    assert_eq!(state.output.flags, 0);
+    assert_eq!(output.flags, ReturnFlags::Success);
 
-    let expected = I256::try_from(state.value).unwrap();
-    let received = I256::from_be_bytes::<32>(state.output.data.try_into().unwrap());
+    let expected = I256::try_from(123).unwrap();
+    let received = I256::from_be_bytes::<32>(output.data.try_into().unwrap());
     assert_eq!(received, expected);
 }
 
@@ -147,49 +164,33 @@ fn msize_non_word_sized_access() {
             function mStore100() public pure returns (uint);
         }
     );
-    let code = crate::compile_blob_with_options(
+    let code = 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);
+    let (_, output) = State::default()
+        .transaction()
+        .with_default_account(&code)
+        .calldata(input)
+        .call();
 
-    assert_eq!(state.output.flags, 0);
+    assert_eq!(output.flags, ReturnFlags::Success);
 
     // 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());
+    let received = U256::from_be_bytes::<32>(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 [
+    for (received, expected) in [
         (U256::MIN, U256::MIN),
         (
             U256::from(1),
@@ -248,8 +249,16 @@ fn mstore8() {
             )
             .unwrap(),
         ),
-    ] {
-        assert(parameter, expected);
+    ]
+    .par_iter()
+    .map(|(parameter, expected)| {
+        let (_, output) = assert_success(&Contract::mstore8(*parameter), true);
+        let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
+        (received, *expected)
+    })
+    .collect::<Vec<_>>()
+    {
+        assert_eq!(received, expected);
     }
 }
 
@@ -260,8 +269,372 @@ fn sha1() {
     hasher.update(&pre);
     let hash = hasher.finalize();
 
-    let state = assert_success(Contract::sha1(pre), true);
+    let (_, output) = assert_success(&Contract::sha1(pre), true);
     let expected = FixedBytes::<20>::from_slice(&hash[..]);
-    let received = FixedBytes::<20>::from_slice(&state.output.data[..20]);
+    let received = FixedBytes::<20>::from_slice(&output.data[..20]);
     assert_eq!(received, expected);
 }
+
+#[test]
+fn block_number() {
+    let (_, output) = assert_success(&Contract::block_number(), true);
+    let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
+    let expected = U256::from(mock_runtime::State::BLOCK_NUMBER);
+    assert_eq!(received, expected);
+}
+
+#[test]
+fn block_timestamp() {
+    let (_, output) = assert_success(&Contract::block_timestamp(), true);
+    let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
+    let expected = U256::from(mock_runtime::State::BLOCK_TIMESTAMP);
+    assert_eq!(received, expected);
+}
+
+#[test]
+fn address() {
+    let contract = Contract::context_address();
+    let (_, output) = assert_success(&contract, true);
+    let received = Address::from_slice(&output.data[12..]);
+    let expected = Transaction::default_address();
+    assert_eq!(received, expected);
+}
+
+#[test]
+fn caller() {
+    let (_, output) = assert_success(&Contract::context_caller(), true);
+    let received = Address::from_slice(&output.data[12..]);
+    let expected = Transaction::default_address();
+    assert_eq!(received, expected);
+}
+
+#[test]
+fn unsigned_division() {
+    let one = U256::from(1);
+    let two = U256::from(2);
+    let five = U256::from(5);
+    for (received, expected) in [
+        (five, five, one),
+        (five, one, five),
+        (U256::ZERO, U256::MAX, U256::ZERO),
+        (five, two, two),
+        (one, U256::ZERO, U256::ZERO),
+    ]
+    .par_iter()
+    .map(|(n, d, q)| {
+        let (_, output) = assert_success(&Contract::division_arithmetics_div(*n, *d), true);
+        let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
+        (received, *q)
+    })
+    .collect::<Vec<_>>()
+    {
+        assert_eq!(received, expected)
+    }
+}
+
+#[test]
+fn signed_division() {
+    let one = I256::try_from(1).unwrap();
+    let two = I256::try_from(2).unwrap();
+    let minus_two = I256::try_from(-2).unwrap();
+    let five = I256::try_from(5).unwrap();
+    let minus_five = I256::try_from(-5).unwrap();
+    for (received, expected) in [
+        (five, five, one),
+        (five, one, five),
+        (I256::ZERO, I256::MAX, I256::ZERO),
+        (I256::ZERO, I256::MINUS_ONE, I256::ZERO),
+        (five, two, two),
+        (five, I256::MINUS_ONE, minus_five),
+        (I256::MINUS_ONE, minus_two, I256::ZERO),
+        (minus_five, minus_five, one),
+        (minus_five, two, minus_two),
+        (I256::MINUS_ONE, I256::MIN, I256::ZERO),
+        (one, I256::ZERO, I256::ZERO),
+    ]
+    .par_iter()
+    .map(|(n, d, q)| {
+        let (_, output) = assert_success(&Contract::division_arithmetics_sdiv(*n, *d), true);
+        let received = I256::from_be_bytes::<32>(output.data.try_into().unwrap());
+        (received, *q)
+    })
+    .collect::<Vec<_>>()
+    {
+        assert_eq!(received, expected);
+    }
+}
+
+#[test]
+fn unsigned_remainder() {
+    let one = U256::from(1);
+    let two = U256::from(2);
+    let five = U256::from(5);
+    for (received, expected) in [
+        (five, five, U256::ZERO),
+        (five, one, U256::ZERO),
+        (U256::ZERO, U256::MAX, U256::ZERO),
+        (U256::MAX, U256::MAX, U256::ZERO),
+        (five, two, one),
+        (two, five, two),
+        (U256::MAX, U256::ZERO, U256::ZERO),
+    ]
+    .par_iter()
+    .map(|(n, d, q)| {
+        let (_, output) = assert_success(&Contract::division_arithmetics_mod(*n, *d), true);
+        let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
+        (received, *q)
+    })
+    .collect::<Vec<_>>()
+    {
+        assert_eq!(received, expected);
+    }
+}
+
+#[test]
+fn signed_remainder() {
+    let one = I256::try_from(1).unwrap();
+    let two = I256::try_from(2).unwrap();
+    let minus_two = I256::try_from(-2).unwrap();
+    let five = I256::try_from(5).unwrap();
+    let minus_five = I256::try_from(-5).unwrap();
+    for (received, expected) in [
+        (five, five, I256::ZERO),
+        (five, one, I256::ZERO),
+        (I256::ZERO, I256::MAX, I256::ZERO),
+        (I256::MAX, I256::MAX, I256::ZERO),
+        (five, two, one),
+        (two, five, two),
+        (five, minus_five, I256::ZERO),
+        (five, I256::MINUS_ONE, I256::ZERO),
+        (five, minus_two, one),
+        (minus_five, two, I256::MINUS_ONE),
+        (minus_two, five, minus_two),
+        (minus_five, minus_five, I256::ZERO),
+        (minus_five, I256::MINUS_ONE, I256::ZERO),
+        (minus_five, minus_two, I256::MINUS_ONE),
+        (minus_two, minus_five, minus_two),
+        (I256::MIN, I256::MINUS_ONE, I256::ZERO),
+        (I256::ZERO, I256::ZERO, I256::ZERO),
+    ]
+    .par_iter()
+    .map(|(n, d, q)| {
+        let (_, output) = assert_success(&Contract::division_arithmetics_smod(*n, *d), true);
+        let received = I256::from_be_bytes::<32>(output.data.try_into().unwrap());
+        (received, *q)
+    })
+    .collect::<Vec<_>>()
+    {
+        assert_eq!(received, expected);
+    }
+}
+
+#[test]
+fn events() {
+    assert_success(&Contract::event(U256::ZERO), true);
+    assert_success(&Contract::event(U256::from(123)), true);
+}
+
+#[test]
+fn create2() {
+    let mut state = State::default();
+    let contract_a = Contract::create_a();
+    state.upload_code(&contract_a.pvm_runtime);
+
+    let contract = Contract::create_b();
+    let (state, output) = state
+        .transaction()
+        .with_default_account(&contract.pvm_runtime)
+        .calldata(contract.calldata)
+        .call();
+
+    assert_eq!(output.flags, ReturnFlags::Success);
+    assert_eq!(state.accounts().len(), 2);
+
+    for address in state.accounts().keys() {
+        if *address != Transaction::default_address() {
+            let derived_address = Transaction::default_address().create2(
+                B256::from(U256::from(1)),
+                keccak256(&contract_a.pvm_runtime).0,
+            );
+            assert_eq!(*address, derived_address);
+        }
+    }
+}
+
+#[test]
+fn create2_failure() {
+    let mut state = State::default();
+    let contract_a = Contract::create_a();
+    state.upload_code(&contract_a.pvm_runtime);
+
+    let contract = Contract::create_b();
+    let (state, output) = state
+        .transaction()
+        .with_default_account(&contract.pvm_runtime)
+        .calldata(contract.calldata.clone())
+        .call();
+
+    assert_eq!(output.flags, ReturnFlags::Success);
+
+    // The address already exists, which should cause the contract to revert
+
+    let (_, output) = state
+        .transaction()
+        .with_default_account(&contract.pvm_runtime)
+        .calldata(contract.calldata)
+        .call();
+
+    assert_eq!(output.flags, ReturnFlags::Revert);
+}
+
+#[test]
+fn create_with_value() {
+    let mut state = State::default();
+    state.upload_code(&Contract::create_a().pvm_runtime);
+    let amount = U256::from(123);
+
+    let contract = Contract::create_b();
+    let (state, output) = state
+        .transaction()
+        .with_default_account(&contract.pvm_runtime)
+        .callvalue(amount)
+        .call();
+
+    assert_eq!(output.flags, ReturnFlags::Success);
+    assert_eq!(state.accounts().len(), 2);
+
+    for (address, account) in state.accounts() {
+        if *address == Transaction::default_address() {
+            assert_eq!(account.value, U256::ZERO);
+        } else {
+            assert_eq!(account.value, amount);
+        }
+    }
+}
+
+#[test]
+fn ext_code_size() {
+    let contract = Contract::ext_code_size(Transaction::default_address());
+    let (_, output) = assert_success(&contract, false);
+    let received = U256::from_be_slice(&output.data);
+    let expected = U256::from(contract.pvm_runtime.len());
+    assert_eq!(received, expected);
+
+    let contract = Contract::ext_code_size(Default::default());
+    let (_, output) = assert_success(&contract, false);
+    let received = U256::from_be_slice(&output.data);
+    let expected = U256::ZERO;
+    assert_eq!(received, expected);
+}
+
+#[test]
+fn code_size() {
+    let contract = Contract::code_size();
+    let (_, output) = assert_success(&contract, false);
+    let expected = U256::from(contract.pvm_runtime.len());
+    let received = U256::from_be_slice(&output.data);
+    assert_eq!(expected, received);
+}
+
+#[test]
+fn value_transfer() {
+    // Succeeds in remix (shanghai) but traps the interpreter
+    let (state, _) = assert_success(&Contract::call_value_transfer(Default::default()), false);
+
+    assert_eq!(state.accounts().len(), 2);
+    assert!(state.accounts().get(&Address::default()).is_some());
+}
+
+#[test]
+fn echo() {
+    let (state, address) = State::new_deployed(Contract::call_constructor());
+
+    let expected = vec![1, 2, 3, 4, 5];
+    let contract = Contract::call_call(address, expected.clone());
+    let (_, output) = state
+        .transaction()
+        .with_default_account(&contract.pvm_runtime)
+        .calldata(contract.calldata)
+        .call();
+
+    assert_eq!(output.flags, ReturnFlags::Success);
+
+    let received = alloy_primitives::Bytes::abi_decode(&output.data, true)
+        .unwrap()
+        .to_vec();
+
+    assert_eq!(expected, received);
+}
+
+#[test]
+fn mcopy() {
+    let expected = vec![1, 2, 3];
+
+    let (_, output) = assert_success(&Contract::memcpy(expected.clone()), false);
+
+    let received = alloy_primitives::Bytes::abi_decode(&output.data, true)
+        .unwrap()
+        .to_vec();
+
+    assert_eq!(expected, received);
+}
+
+#[test]
+fn balance() {
+    let (_, output) = assert_success(&Contract::value_balance_of(Default::default()), false);
+
+    let expected = U256::ZERO;
+    let received = U256::from_be_slice(&output.data);
+    assert_eq!(expected, received);
+
+    let expected = U256::from(54589);
+    let (mut state, address) = State::new_deployed(Contract::value_balance_of(Default::default()));
+    state.accounts_mut().get_mut(&address).unwrap().value = expected;
+
+    let contract = Contract::value_balance_of(address);
+    let (_, output) = state
+        .transaction()
+        .with_default_account(&contract.pvm_runtime)
+        .calldata(contract.calldata)
+        .call();
+
+    assert_eq!(ReturnFlags::Success, output.flags);
+
+    let received = U256::from_be_slice(&output.data);
+    assert_eq!(expected, received)
+}
+
+#[test]
+fn bitwise_byte() {
+    assert_success(&Contract::bitwise_byte(U256::ZERO, U256::ZERO), true);
+    assert_success(&Contract::bitwise_byte(U256::ZERO, U256::MAX), true);
+    assert_success(&Contract::bitwise_byte(U256::MAX, U256::ZERO), true);
+    assert_success(
+        &Contract::bitwise_byte(U256::from_str("18446744073709551619").unwrap(), U256::MAX),
+        true,
+    );
+
+    let de_bruijn_sequence =
+        hex::decode("4060503824160d0784426150b864361d0f88c4a27148ac5a2f198d46e391d8f4").unwrap();
+    let value = U256::from_be_bytes::<32>(de_bruijn_sequence.clone().try_into().unwrap());
+
+    for (index, byte) in de_bruijn_sequence.iter().enumerate() {
+        let (_, output) = assert_success(&Contract::bitwise_byte(U256::from(index), value), true);
+        let expected = U256::from(*byte as i32);
+        let received = U256::abi_decode(&output.data, true).unwrap();
+        assert_eq!(expected, received)
+    }
+}
+
+#[test]
+fn transient_storage() {
+    let expected = U256::MAX;
+    let (state, output) = assert_success(&Contract::storage_transient(expected), false);
+    let received = U256::abi_decode(&output.data, true).unwrap();
+    assert_eq!(expected, received);
+
+    assert!(state
+        .accounts()
+        .values()
+        .all(|account| account.storage.is_empty()));
+}

crates/linker/Cargo.toml

@@ -1,9 +1,14 @@
 [package]
 name = "revive-linker"
-version = "0.1.0"
-edition = "2021"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+authors.workspace = true
+description = "revive compiler linker utils"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+riscv-64 = []
 
 [dependencies]
 inkwell = { workspace = true }
@@ -13,5 +18,5 @@ polkavm-common = { workspace = true }
 libc = { workspace = true }
 anyhow = { workspace = true }
 
-revive-builtins = { path = "../builtins" }
-lld-sys = { path = "../lld-sys" }
+revive-builtins = { workspace = true }
+lld-sys = { workspace = true }

crates/linker/src/lib.rs

@@ -8,6 +8,16 @@ SECTIONS {
     .text : { KEEP(*(.text.polkavm_export)) *(.text .text.*) }
 }"#;
 
+#[cfg(not(feature = "riscv-64"))]
+const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv32.a";
+#[cfg(feature = "riscv-64")]
+const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv64.a";
+
+#[cfg(not(feature = "riscv-64"))]
+const BUILTINS_LIB_NAME: &str = "clang_rt.builtins-riscv32";
+#[cfg(feature = "riscv-64")]
+const BUILTINS_LIB_NAME: &str = "clang_rt.builtins-riscv64";
+
 fn invoke_lld(cmd_args: &[&str]) -> bool {
     let c_strings = cmd_args
         .iter()
@@ -24,7 +34,6 @@ fn polkavm_linker<T: AsRef<[u8]>>(code: T) -> anyhow::Result<Vec<u8>> {
     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))
 }
 
@@ -33,7 +42,7 @@ pub fn link<T: AsRef<[u8]>>(input: T) -> anyhow::Result<Vec<u8>> {
     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-riscv32.a");
+    let compiler_rt_path = dir.path().join(BUILTINS_ARCHIVE_FILE);
 
     fs::write(&object_path, input).map_err(|msg| anyhow::anyhow!("{msg} {object_path:?}"))?;
 
@@ -58,7 +67,7 @@ pub fn link<T: AsRef<[u8]>>(input: T) -> anyhow::Result<Vec<u8>> {
         "--library-path",
         dir.path().to_str().expect("should be utf8"),
         "--library",
-        "clang_rt.builtins-riscv32",
+        BUILTINS_LIB_NAME,
         linker_script_path.to_str().expect("should be utf8"),
         object_path.to_str().expect("should be utf8"),
         "-o",

crates/lld-sys/Cargo.toml

@@ -1,11 +1,12 @@
 [package]
 name = "lld-sys"
-version = "0.1.0"
-edition = "2021"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+authors.workspace = true
 build = "build.rs"
-
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+description = "bindings for ld.lld core"
 
 [dependencies]
 libc = { workspace = true }

crates/lld-sys/build.rs

@@ -27,7 +27,10 @@ fn set_rustc_link_flags() {
     }
 
     #[cfg(target_os = "linux")]
-    println!("cargo:rustc-link-lib=dylib=stdc++");
+    {
+        println!("cargo:rustc-link-lib=dylib=stdc++");
+        println!("cargo:rustc-link-lib=tinfo");
+    }
 }
 
 fn main() {

crates/llvm-context/Cargo.toml

@@ -1,17 +1,22 @@
 [package]
-name = "era-compiler-llvm-context"
-version = "1.4.1"
+name = "revive-llvm-context"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
 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"
+description = "Shared front end code of the revive PolkaVM compilers"
 
 [lib]
 doctest = false
 
+[features]
+riscv-zbb = []
+riscv-64 = []
+
 [dependencies]
 anyhow = { workspace = true }
 semver = { workspace = true }
@@ -25,12 +30,11 @@ sha2 = { workspace = true }
 sha3 = { workspace = true }
 md5 = { workspace = true }
 inkwell = { workspace = true }
+polkavm-disassembler = { workspace = true }
+polkavm-common = { 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" }
-revive-extensions = { path = "../extensions" }
+revive-common = { workspace = true }
+pallet-contracts-pvm-llapi = { workspace = true }
+revive-linker = { workspace = true }
+revive-builtins = { workspace = true }
+revive-stdlib = { workspace = true }

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

@@ -1,10 +1,6 @@
-//!
 //! 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)]
@@ -15,26 +11,26 @@ pub enum IRType {
     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,
+    /// Whether to jump JSON
+    #[cfg(debug_assertions)]
+    JSON,
 }
 
 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,
+            Self::Assembly => revive_common::EXTENSION_POLKAVM_ASSEMBLY,
+            #[cfg(debug_assertions)]
+            Self::JSON => revive_common::EXTENSION_JSON,
         }
     }
 }

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

@@ -1,6 +1,4 @@
-//!
 //! The debug configuration.
-//!
 
 pub mod ir_type;
 
@@ -11,9 +9,7 @@ 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.
@@ -21,16 +17,12 @@ pub struct DebugConfig {
 }
 
 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);
@@ -40,9 +32,7 @@ impl DebugConfig {
         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);
@@ -52,9 +42,7 @@ impl DebugConfig {
         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);
@@ -64,21 +52,7 @@ impl DebugConfig {
         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,
@@ -94,9 +68,7 @@ impl DebugConfig {
         Ok(())
     }
 
-    ///
     /// Dumps the optimized LLVM IR.
-    ///
     pub fn dump_llvm_ir_optimized(
         &self,
         contract_path: &str,
@@ -112,9 +84,7 @@ impl DebugConfig {
         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);
@@ -124,9 +94,23 @@ impl DebugConfig {
         Ok(())
     }
 
-    ///
+    /// Dumps the stage output as a json file suitable for use with --recursive-process
+    #[cfg(debug_assertions)]
+    pub fn dump_stage_output(
+        &self,
+        contract_path: &str,
+        contract_suffix: Option<&str>,
+        stage_json: &Vec<u8>,
+    ) -> anyhow::Result<()> {
+        let mut file_path = self.output_directory.to_owned();
+        let full_file_name = Self::full_file_name(contract_path, contract_suffix, IRType::JSON);
+        file_path.push(full_file_name);
+        std::fs::write(file_path, stage_json)?;
+
+        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 {

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/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/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/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/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/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/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/call.rs

@@ -1,116 +0,0 @@
-//!
-//! Translates a contract call.
-//!
-
-use inkwell::values::BasicValue;
-
-use crate::eravm::context::argument::Argument;
-use crate::eravm::context::function::declaration::Declaration as FunctionDeclaration;
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-
-///
-/// Translates a contract call.
-///
-/// If the `simulation_address` is specified, the call is substituted with another instruction
-/// according to the specification.
-///
-#[allow(clippy::too_many_arguments)]
-pub fn default<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-    _function: FunctionDeclaration<'ctx>,
-    _gas: inkwell::values::IntValue<'ctx>,
-    _address: inkwell::values::IntValue<'ctx>,
-    _value: Option<inkwell::values::IntValue<'ctx>>,
-    _input_offset: inkwell::values::IntValue<'ctx>,
-    _input_length: inkwell::values::IntValue<'ctx>,
-    _output_offset: inkwell::values::IntValue<'ctx>,
-    _output_length: inkwell::values::IntValue<'ctx>,
-    _constants: Vec<Option<num::BigUint>>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!();
-
-    /*
-    let ordinary_block = context.append_basic_block("contract_call_ordinary_block");
-    let join_block = context.append_basic_block("contract_call_join_block");
-
-    let result_pointer = context.build_alloca(context.field_type(), "contract_call_result_pointer");
-    context.build_store(result_pointer, context.field_const(0));
-
-    context.builder().build_switch(
-        address,
-        ordinary_block,
-        &[(
-            context.field_const(zkevm_opcode_defs::ADDRESS_IDENTITY.into()),
-            identity_block,
-        )],
-    )?;
-
-    {
-        context.set_basic_block(identity_block);
-        let result = identity(context, output_offset, input_offset, output_length)?;
-        context.build_store(result_pointer, result);
-        context.build_unconditional_branch(join_block);
-    }
-
-    context.set_basic_block(ordinary_block);
-    let result = if let Some(value) = value {
-        default_wrapped(
-            context,
-            function,
-            gas,
-            value,
-            address,
-            input_offset,
-            input_length,
-            output_offset,
-            output_length,
-        )?
-    } else {
-        let function = Runtime::default_call(context, function);
-        context
-            .build_call(
-                function,
-                &[
-                    gas.as_basic_value_enum(),
-                    address.as_basic_value_enum(),
-                    input_offset.as_basic_value_enum(),
-                    input_length.as_basic_value_enum(),
-                    output_offset.as_basic_value_enum(),
-                    output_length.as_basic_value_enum(),
-                ],
-                "default_call",
-            )
-            .expect("Always exists")
-    };
-    context.build_store(result_pointer, result);
-    context.build_unconditional_branch(join_block);
-
-    context.set_basic_block(join_block);
-    let result = context.build_load(result_pointer, "contract_call_result");
-    Ok(result)
-    */
-}
-
-///
-/// Translates the Yul `linkersymbol` instruction.
-///
-pub fn linker_symbol<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    mut arguments: [Argument<'ctx>; 1],
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    let path = arguments[0]
-        .original
-        .take()
-        .ok_or_else(|| anyhow::anyhow!("Linker symbol literal is missing"))?;
-
-    Ok(context
-        .resolve_library(path.as_str())?
-        .as_basic_value_enum())
-}

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

@@ -1,158 +0,0 @@
-//!
-//! Translates the context getter instructions.
-//!
-
-use inkwell::values::BasicValue;
-
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-
-///
-/// Translates the `gas_limit` instruction.
-///
-pub fn gas_limit<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!()
-}
-
-///
-/// Translates the `gas_price` instruction.
-///
-pub fn gas_price<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!()
-}
-
-///
-/// Translates the `tx.origin` instruction.
-///
-pub fn origin<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!()
-}
-
-///
-/// Translates the `chain_id` instruction.
-///
-pub fn chain_id<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!()
-}
-
-///
-/// Translates the `block_number` instruction.
-///
-pub fn block_number<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!()
-}
-
-///
-/// Translates the `block_timestamp` instruction.
-///
-pub fn block_timestamp<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!()
-}
-
-///
-/// Translates the `block_hash` instruction.
-///
-pub fn block_hash<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-    _index: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!()
-}
-
-///
-/// Translates the `difficulty` instruction.
-///
-pub fn difficulty<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!()
-}
-
-///
-/// Translates the `coinbase` instruction.
-///
-pub fn coinbase<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!()
-}
-
-///
-/// Translates the `basefee` instruction.
-///
-pub fn basefee<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!()
-}
-
-///
-/// Translates the `msize` instruction.
-///
-pub fn msize<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    let heap_end = context.build_sbrk(context.xlen_type().const_zero())?;
-    let heap_start = context
-        .get_global(crate::eravm::GLOBAL_HEAP_MEMORY_POINTER)?
-        .value
-        .as_pointer_value();
-    let heap_size = context.builder().build_int_nuw_sub(
-        context
-            .builder()
-            .build_ptr_to_int(heap_end, context.xlen_type(), "heap_end")?,
-        context
-            .builder()
-            .build_ptr_to_int(heap_start, context.xlen_type(), "heap_start")?,
-        "heap_size",
-    )?;
-    Ok(context
-        .builder()
-        .build_int_z_extend(heap_size, context.field_type(), "heap_size_extended")?
-        .as_basic_value_enum())
-}

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

@@ -1,51 +0,0 @@
-//!
-//! Translates the cryptographic operations.
-//!
-
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-
-///
-/// Translates the `sha3` instruction.
-///
-pub fn sha3<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    offset: inkwell::values::IntValue<'ctx>,
-    length: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    let offset_casted = context.safe_truncate_int_to_i32(offset)?;
-    let length_casted = context.safe_truncate_int_to_i32(length)?;
-    let input_pointer = context.build_heap_gep(offset_casted, length_casted)?;
-    let input_pointer_casted = context.builder().build_ptr_to_int(
-        input_pointer.value,
-        context.xlen_type(),
-        "input_pointer_casted",
-    )?;
-
-    let output_pointer = context.build_alloca(context.field_type(), "output_pointer");
-    let output_pointer_casted = context.builder().build_ptr_to_int(
-        output_pointer.value,
-        context.xlen_type(),
-        "output_pointer_casted",
-    )?;
-
-    let function = context
-        .module()
-        .get_function("hash_keccak_256")
-        .expect("is declared");
-
-    context.builder().build_call(
-        function,
-        &[
-            input_pointer_casted.into(),
-            length_casted.into(),
-            output_pointer_casted.into(),
-        ],
-        "call_seal_hash_keccak_256",
-    )?;
-
-    context.build_byte_swap(context.build_load(output_pointer, "sha3_output")?)
-}

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

@@ -1,81 +0,0 @@
-//!
-//! Translates the value and balance operations.
-//!
-
-use inkwell::values::BasicValue;
-
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-
-///
-/// Translates the `gas` instruction.
-///
-pub fn gas<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    Ok(context.integer_const(256, 0).as_basic_value_enum())
-}
-
-///
-/// Translates the `value` instruction.
-///
-pub fn value<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    let output_pointer = context.build_alloca(context.value_type(), "output_pointer");
-    let output_pointer_casted = context.builder().build_ptr_to_int(
-        output_pointer.value,
-        context.xlen_type(),
-        "output_pointer_casted",
-    )?;
-
-    let output_length_pointer = context.build_alloca(context.xlen_type(), "output_len_pointer");
-    let output_length_pointer_casted = context.builder().build_ptr_to_int(
-        output_length_pointer.value,
-        context.xlen_type(),
-        "output_pointer_casted",
-    )?;
-    context.build_store(
-        output_length_pointer,
-        context.integer_const(crate::eravm::XLEN, revive_common::BYTE_LENGTH_VALUE as u64),
-    )?;
-
-    context.builder().build_call(
-        context
-            .module()
-            .get_function("value_transferred")
-            .expect("is declared"),
-        &[
-            output_pointer_casted.into(),
-            output_length_pointer_casted.into(),
-        ],
-        "call_seal_value_transferred",
-    )?;
-
-    let value = context.build_load(output_pointer, "transferred_value")?;
-    let value_extended = context.builder().build_int_z_extend(
-        value.into_int_value(),
-        context.field_type(),
-        "transferred_value_extended",
-    )?;
-    Ok(value_extended.as_basic_value_enum())
-}
-
-///
-/// Translates the `balance` instructions.
-///
-pub fn balance<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-    _address: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!()
-}

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

@@ -1,78 +0,0 @@
-//!
-//! Translates a log or event call.
-//!
-
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-
-///
-/// Translates a log or event call.
-///
-/// The decoding logic is implemented in a system contract, which is called from here.
-///
-/// There are several cases of the translation for the sake of efficiency, since the front-end
-/// emits topics and values sequentially by one, but the LLVM intrinsic and bytecode instruction
-/// accept two at once.
-///
-pub fn log<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-    _input_offset: inkwell::values::IntValue<'ctx>,
-    _input_length: inkwell::values::IntValue<'ctx>,
-    _topics: Vec<inkwell::values::IntValue<'ctx>>,
-) -> anyhow::Result<()>
-where
-    D: Dependency + Clone,
-{
-    /*
-    let failure_block = context.append_basic_block("event_failure_block");
-    let join_block = context.append_basic_block("event_join_block");
-
-    let gas = crate::eravm::evm::ether_gas::gas(context)?.into_int_value();
-    let abi_data = crate::eravm::utils::abi_data(
-        context,
-        input_offset,
-        input_length,
-        Some(gas),
-        AddressSpace::Heap,
-        true,
-    )?;
-    let mut extra_abi_data = Vec::with_capacity(1 + topics.len());
-    extra_abi_data.push(context.field_const(topics.len() as u64));
-    extra_abi_data.extend(topics);
-
-    let 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_EVENT_WRITER as u64),
-                extra_abi_data,
-                None,
-            )
-            .as_slice(),
-            "event_writer_call_external",
-        )
-        .expect("Always returns a value");
-
-    let result_status_code_boolean = context
-        .builder()
-        .build_extract_value(
-            result.into_struct_value(),
-            1,
-            "event_writer_external_result_status_code_boolean",
-        )
-        .expect("Always exists");
-    context.build_conditional_branch(
-        result_status_code_boolean.into_int_value(),
-        join_block,
-        failure_block,
-    )?;
-
-    context.set_basic_block(failure_block);
-    crate::eravm::evm::r#return::revert(context, context.field_const(0), context.field_const(0))?;
-
-    context.set_basic_block(join_block);
-    */
-    Ok(())
-}

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

@@ -1,32 +0,0 @@
-//!
-//! Translates the external code operations.
-//!
-
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-
-///
-/// Translates the `extcodesize` instruction.
-///
-pub fn size<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-    _address: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!()
-}
-
-///
-/// Translates the `extcodehash` instruction.
-///
-pub fn hash<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-    _address: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    todo!()
-}

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

@@ -1,128 +0,0 @@
-//!
-//! Translates the transaction return operations.
-//!
-
-use crate::eravm::context::address_space::AddressSpace;
-use crate::eravm::context::code_type::CodeType;
-use crate::eravm::context::pointer::Pointer;
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-
-///
-/// Translates the `return` instruction.
-///
-/// Unlike in EVM, zkSync constructors return the array of contract immutables.
-///
-pub fn r#return<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    offset: inkwell::values::IntValue<'ctx>,
-    length: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<()>
-where
-    D: Dependency + Clone,
-{
-    match context.code_type() {
-        None => {
-            anyhow::bail!("Return is not available if the contract part is undefined");
-        }
-        Some(CodeType::Deploy) => {
-            let immutables_offset_pointer = Pointer::new_with_offset(
-                context,
-                AddressSpace::HeapAuxiliary,
-                context.field_type(),
-                context.field_const(crate::eravm::HEAP_AUX_OFFSET_CONSTRUCTOR_RETURN_DATA),
-                "immutables_offset_pointer",
-            );
-            context.build_store(
-                immutables_offset_pointer,
-                context.field_const(revive_common::BYTE_LENGTH_FIELD as u64),
-            )?;
-
-            let immutables_number_pointer = Pointer::new_with_offset(
-                context,
-                AddressSpace::HeapAuxiliary,
-                context.field_type(),
-                context.field_const(
-                    crate::eravm::HEAP_AUX_OFFSET_CONSTRUCTOR_RETURN_DATA
-                        + (revive_common::BYTE_LENGTH_FIELD as u64),
-                ),
-                "immutables_number_pointer",
-            );
-            let immutable_values_size = context.immutables_size()?;
-            context.build_store(
-                immutables_number_pointer,
-                context
-                    .field_const((immutable_values_size / revive_common::BYTE_LENGTH_FIELD) as u64),
-            )?;
-            let immutables_size = context.builder().build_int_mul(
-                context.field_const(immutable_values_size as u64),
-                context.field_const(2),
-                "immutables_size",
-            )?;
-            let return_data_length = context.builder().build_int_add(
-                immutables_size,
-                context.field_const((revive_common::BYTE_LENGTH_FIELD * 2) as u64),
-                "return_data_length",
-            )?;
-
-            context.build_exit(
-                context.integer_const(32, 0),
-                context.field_const(crate::eravm::HEAP_AUX_OFFSET_CONSTRUCTOR_RETURN_DATA),
-                return_data_length,
-            )?;
-        }
-        Some(CodeType::Runtime) => {
-            context.build_exit(context.integer_const(32, 0), offset, length)?;
-        }
-    }
-
-    Ok(())
-}
-
-///
-/// Translates the `revert` instruction.
-///
-pub fn revert<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    offset: inkwell::values::IntValue<'ctx>,
-    length: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<()>
-where
-    D: Dependency + Clone,
-{
-    context.build_exit(context.integer_const(32, 1), offset, length)
-}
-
-///
-/// Translates the `stop` instruction.
-///
-/// Is the same as `return(0, 0)`.
-///
-pub fn stop<D>(context: &mut Context<D>) -> anyhow::Result<()>
-where
-    D: Dependency + Clone,
-{
-    r#return(
-        context,
-        context.integer_const(32, 0),
-        context.integer_const(32, 0),
-    )
-}
-
-///
-/// Translates the `invalid` instruction.
-///
-/// Burns all gas using an out-of-bounds memory store, causing a panic.
-///
-pub fn invalid<D>(context: &mut Context<D>) -> anyhow::Result<()>
-where
-    D: Dependency + Clone,
-{
-    crate::eravm::evm::memory::store(
-        context,
-        context.field_type().const_all_ones(),
-        context.field_const(0),
-    )?;
-    context.build_call(context.intrinsics().trap, &[], "invalid_trap");
-    Ok(())
-}

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

@@ -1,93 +0,0 @@
-//!
-//! Translates the return data instructions.
-//!
-
-use inkwell::types::BasicType;
-use inkwell::values::BasicValue;
-
-use crate::eravm::context::address_space::AddressSpace;
-use crate::eravm::context::pointer::Pointer;
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-
-///
-/// Translates the return data size.
-///
-pub fn size<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    match context.get_global_value(crate::eravm::GLOBAL_RETURN_DATA_SIZE) {
-        Ok(global) => Ok(global),
-        Err(_error) => Ok(context.field_const(0).as_basic_value_enum()),
-    }
-}
-
-///
-/// Translates the return data copy.
-///
-pub fn copy<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    destination_offset: inkwell::values::IntValue<'ctx>,
-    source_offset: inkwell::values::IntValue<'ctx>,
-    size: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<()>
-where
-    D: Dependency + Clone,
-{
-    let error_block = context.append_basic_block("return_data_copy_error_block");
-    let join_block = context.append_basic_block("return_data_copy_join_block");
-
-    let return_data_size = self::size(context)?.into_int_value();
-    let copy_slice_end =
-        context
-            .builder()
-            .build_int_add(source_offset, size, "return_data_copy_slice_end")?;
-    let is_copy_out_of_bounds = context.builder().build_int_compare(
-        inkwell::IntPredicate::UGT,
-        copy_slice_end,
-        return_data_size,
-        "return_data_copy_is_out_of_bounds",
-    )?;
-    context.build_conditional_branch(is_copy_out_of_bounds, error_block, join_block)?;
-
-    context.set_basic_block(error_block);
-    crate::eravm::evm::r#return::revert(context, context.field_const(0), context.field_const(0))?;
-
-    context.set_basic_block(join_block);
-    let destination = Pointer::new_with_offset(
-        context,
-        AddressSpace::Heap,
-        context.byte_type(),
-        destination_offset,
-        "return_data_copy_destination_pointer",
-    );
-
-    let return_data_pointer_global =
-        context.get_global(crate::eravm::GLOBAL_RETURN_DATA_POINTER)?;
-    let return_data_pointer_pointer = return_data_pointer_global.into();
-    let return_data_pointer =
-        context.build_load(return_data_pointer_pointer, "return_data_pointer")?;
-    let source = context.build_gep(
-        Pointer::new(
-            context.byte_type(),
-            return_data_pointer_pointer.address_space,
-            return_data_pointer.into_pointer_value(),
-        ),
-        &[source_offset],
-        context.byte_type().as_basic_type_enum(),
-        "return_data_source_pointer",
-    );
-
-    context.build_memcpy(
-        context.intrinsics().memory_copy_from_generic,
-        destination,
-        source,
-        size,
-        "return_data_copy_memcpy_from_return_data",
-    )?;
-
-    todo!("Build heap GEP to allocate if necessary")
-}

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

@@ -1,234 +0,0 @@
-//!
-//! Some LLVM IR generator utilies.
-//!
-
-use inkwell::values::BasicValue;
-
-use crate::eravm::context::address_space::AddressSpace;
-use crate::eravm::context::function::llvm_runtime::LLVMRuntime;
-use crate::eravm::context::Context;
-use crate::eravm::Dependency;
-
-///
-/// Clamps `value` to `max_value`, if `value` is bigger than `max_value`.
-///
-pub fn clamp<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    value: inkwell::values::IntValue<'ctx>,
-    max_value: inkwell::values::IntValue<'ctx>,
-    name: &str,
-) -> anyhow::Result<inkwell::values::IntValue<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    let in_bounds_block = context.append_basic_block(format!("{name}_is_bounds_block").as_str());
-    let join_block = context.append_basic_block(format!("{name}_join_block").as_str());
-
-    let pointer = context.build_alloca(context.field_type(), format!("{name}_pointer").as_str());
-    context.build_store(pointer, max_value)?;
-
-    let is_in_bounds = context.builder().build_int_compare(
-        inkwell::IntPredicate::ULE,
-        value,
-        max_value,
-        format!("{name}_is_in_bounds").as_str(),
-    )?;
-    context.build_conditional_branch(is_in_bounds, in_bounds_block, join_block)?;
-
-    context.set_basic_block(in_bounds_block);
-    context.build_store(pointer, value)?;
-    context.build_unconditional_branch(join_block);
-
-    context.set_basic_block(join_block);
-    let result = context.build_load(pointer, name)?;
-    Ok(result.into_int_value())
-}
-
-///
-/// Generates an exception.
-///
-pub fn throw<D>(context: &Context<D>)
-where
-    D: Dependency + Clone,
-{
-    context.build_call(
-        context.llvm_runtime().cxa_throw,
-        &[context
-            .llvm()
-            .ptr_type(AddressSpace::Stack.into())
-            .get_undef()
-            .as_basic_value_enum(); 3],
-        LLVMRuntime::FUNCTION_CXA_THROW,
-    );
-    context.build_unreachable();
-}
-
-///
-/// Returns the full list of arguments for an external call.
-///
-/// Performs the extra ABI data padding and adds the mimic call extra argument.
-///
-pub fn external_call_arguments<'ctx, D>(
-    _context: &Context<'ctx, D>,
-    abi_data: inkwell::values::BasicValueEnum<'ctx>,
-    address: inkwell::values::IntValue<'ctx>,
-    _extra_abi_data: Vec<inkwell::values::IntValue<'ctx>>,
-    mimic: Option<inkwell::values::IntValue<'ctx>>,
-) -> Vec<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    let mut result = Vec::with_capacity(
-        crate::eravm::context::function::runtime::entry::Entry::MANDATORY_ARGUMENTS_COUNT
-            + crate::eravm::EXTRA_ABI_DATA_SIZE
-            + usize::from(mimic.is_some()),
-    );
-    result.push(abi_data);
-    result.push(address.as_basic_value_enum());
-    //result.extend(
-    //    pad_extra_abi_data(context, extra_abi_data)
-    //        .into_iter()
-    //        .map(|value| value.as_basic_value_enum()),
-    //);
-    if let Some(mimic) = mimic {
-        result.push(mimic.as_basic_value_enum());
-    }
-    result
-}
-
-///
-/// Generates an ABI data for an external call.
-///
-/// If `gas` is `None`, it is fetched from the contract context.
-///
-pub fn abi_data<'ctx, D>(
-    context: &mut Context<'ctx, D>,
-    input_offset: inkwell::values::IntValue<'ctx>,
-    input_length: inkwell::values::IntValue<'ctx>,
-    gas: Option<inkwell::values::IntValue<'ctx>>,
-    address_space: AddressSpace,
-    is_system_call: bool,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
-where
-    D: Dependency + Clone,
-{
-    let input_offset = crate::eravm::utils::clamp(
-        context,
-        input_offset,
-        context.field_const(u32::MAX as u64),
-        "abi_data_input_offset",
-    )?;
-    let input_length = crate::eravm::utils::clamp(
-        context,
-        input_length,
-        context.field_const(u32::MAX as u64),
-        "abi_data_input_length",
-    )?;
-
-    let gas = match gas {
-        Some(gas) => gas,
-        None => crate::eravm::evm::ether_gas::gas(context)?.into_int_value(),
-    };
-    let gas = crate::eravm::utils::clamp(
-        context,
-        gas,
-        context.field_const(u32::MAX as u64),
-        "abi_data_gas",
-    )?;
-
-    let input_offset_shifted = context.builder().build_left_shift(
-        input_offset,
-        context.field_const((revive_common::BIT_LENGTH_X32 * 2) as u64),
-        "abi_data_input_offset_shifted",
-    )?;
-    let input_length_shifted = context.builder().build_left_shift(
-        input_length,
-        context.field_const((revive_common::BIT_LENGTH_X32 * 3) as u64),
-        "abi_data_input_length_shifted",
-    )?;
-    let gas_shifted = context.builder().build_left_shift(
-        gas,
-        context.field_const((revive_common::BIT_LENGTH_X32 * 6) as u64),
-        "abi_data_gas_shifted",
-    )?;
-
-    let mut abi_data = context.builder().build_int_add(
-        input_offset_shifted,
-        input_length_shifted,
-        "abi_data_offset_and_length",
-    )?;
-    abi_data = context
-        .builder()
-        .build_int_add(abi_data, gas_shifted, "abi_data_add_gas")?;
-    if let AddressSpace::HeapAuxiliary = address_space {
-        let auxiliary_heap_marker_shifted = context.builder().build_left_shift(
-            context.field_const(zkevm_opcode_defs::FarCallForwardPageType::UseAuxHeap as u64),
-            context.field_const((revive_common::BIT_LENGTH_X32 * 7) as u64),
-            "abi_data_auxiliary_heap_marker_shifted",
-        )?;
-        abi_data = context.builder().build_int_add(
-            abi_data,
-            auxiliary_heap_marker_shifted,
-            "abi_data_add_heap_auxiliary_marker",
-        )?;
-    }
-    if is_system_call {
-        let auxiliary_heap_marker_shifted = context.builder().build_left_shift(
-            context.field_const(zkevm_opcode_defs::FarCallForwardPageType::UseAuxHeap as u64),
-            context.field_const(
-                ((revive_common::BIT_LENGTH_X32 * 7) + (revive_common::BIT_LENGTH_BYTE * 3)) as u64,
-            ),
-            "abi_data_system_call_marker_shifted",
-        )?;
-        abi_data = context.builder().build_int_add(
-            abi_data,
-            auxiliary_heap_marker_shifted,
-            "abi_data_add_system_call_marker",
-        )?;
-    }
-
-    Ok(abi_data.as_basic_value_enum())
-}
-
-///
-/// Pads the extra ABI data with `i256::undef`, so it always consists of 10 values.
-///
-pub fn pad_extra_abi_data<'ctx, D>(
-    context: &Context<'ctx, D>,
-    initial_data: Vec<inkwell::values::IntValue<'ctx>>,
-) -> [inkwell::values::IntValue<'ctx>; crate::eravm::EXTRA_ABI_DATA_SIZE]
-where
-    D: Dependency + Clone,
-{
-    let mut padded_data = initial_data;
-    padded_data.extend(vec![
-        context.field_undef();
-        crate::eravm::EXTRA_ABI_DATA_SIZE - padded_data.len()
-    ]);
-    padded_data.try_into().expect("Always valid")
-}
-
-///
-/// Computes the `keccak256` hash for `preimage`.
-///
-pub fn keccak256(preimage: &[u8]) -> String {
-    use sha3::Digest;
-
-    let hash_bytes = sha3::Keccak256::digest(preimage);
-    hash_bytes
-        .into_iter()
-        .map(|byte| format!("{byte:02x}"))
-        .collect::<Vec<String>>()
-        .join("")
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn keccak256() {
-        assert_eq!(
-            super::keccak256("zksync".as_bytes()),
-            "0238fb1ab06c28c32885f9a4842207ac480c2467df26b6c58e201679628c5a5b"
-        );
-    }
-}

crates/llvm-context/src/lib.rs

@@ -1,78 +1,74 @@
-//!
 //! The LLVM context library.
-//!
 
 pub(crate) mod debug_config;
-pub(crate) mod eravm;
 pub(crate) mod optimizer;
+pub(crate) mod polkavm;
 pub(crate) mod target_machine;
 
 pub use self::debug_config::ir_type::IRType as DebugConfigIR;
 pub use self::debug_config::DebugConfig;
-pub use self::eravm::build_assembly_text as eravm_build_assembly_text;
-pub use self::eravm::context::address_space::AddressSpace as EraVMAddressSpace;
-pub use self::eravm::context::argument::Argument as EraVMArgument;
-pub use self::eravm::context::attribute::Attribute as EraVMAttribute;
-pub use self::eravm::context::build::Build as EraVMBuild;
-pub use self::eravm::context::code_type::CodeType as EraVMCodeType;
-pub use self::eravm::context::evmla_data::EVMLAData as EraVMContextEVMLAData;
-pub use self::eravm::context::function::block::evmla_data::key::Key as EraVMFunctionBlockKey;
-pub use self::eravm::context::function::block::evmla_data::EVMLAData as EraVMFunctionBlockEVMLAData;
-pub use self::eravm::context::function::block::Block as EraVMFunctionBlock;
-pub use self::eravm::context::function::declaration::Declaration as EraVMFunctionDeclaration;
-pub use self::eravm::context::function::evmla_data::EVMLAData as EraVMFunctionEVMLAData;
-pub use self::eravm::context::function::intrinsics::Intrinsics as EraVMIntrinsicFunction;
-pub use self::eravm::context::function::llvm_runtime::LLVMRuntime as EraVMLLVMRuntime;
-pub use self::eravm::context::function::r#return::Return as EraVMFunctionReturn;
-pub use self::eravm::context::function::runtime::deploy_code::DeployCode as EraVMDeployCodeFunction;
-pub use self::eravm::context::function::runtime::entry::Entry as EraVMEntryFunction;
-pub use self::eravm::context::function::runtime::runtime_code::RuntimeCode as EraVMRuntimeCodeFunction;
-pub use self::eravm::context::function::runtime::Runtime as EraVMRuntime;
-pub use self::eravm::context::function::vyper_data::VyperData as EraVMFunctionVyperData;
-pub use self::eravm::context::function::yul_data::YulData as EraVMFunctionYulData;
-pub use self::eravm::context::function::Function as EraVMFunction;
-pub use self::eravm::context::global::Global as EraVMGlobal;
-pub use self::eravm::context::pointer::Pointer as EraVMPointer;
-pub use self::eravm::context::r#loop::Loop as EraVMLoop;
-pub use self::eravm::context::solidity_data::SolidityData as EraVMContextSolidityData;
-pub use self::eravm::context::vyper_data::VyperData as EraVMContextVyperData;
-pub use self::eravm::context::yul_data::YulData as EraVMContextYulData;
-pub use self::eravm::context::Context as EraVMContext;
-pub use self::eravm::evm::arithmetic as eravm_evm_arithmetic;
-pub use self::eravm::evm::bitwise as eravm_evm_bitwise;
-pub use self::eravm::evm::call as eravm_evm_call;
-pub use self::eravm::evm::calldata as eravm_evm_calldata;
-pub use self::eravm::evm::comparison as eravm_evm_comparison;
-pub use self::eravm::evm::context as eravm_evm_contract_context;
-pub use self::eravm::evm::create as eravm_evm_create;
-pub use self::eravm::evm::crypto as eravm_evm_crypto;
-pub use self::eravm::evm::ether_gas as eravm_evm_ether_gas;
-pub use self::eravm::evm::event as eravm_evm_event;
-pub use self::eravm::evm::ext_code as eravm_evm_ext_code;
-pub use self::eravm::evm::immutable as eravm_evm_immutable;
-pub use self::eravm::evm::math as eravm_evm_math;
-pub use self::eravm::evm::memory as eravm_evm_memory;
-pub use self::eravm::evm::r#return as eravm_evm_return;
-pub use self::eravm::evm::return_data as eravm_evm_return_data;
-pub use self::eravm::evm::storage as eravm_evm_storage;
-pub use self::eravm::metadata_hash::MetadataHash as EraVMMetadataHash;
-pub use self::eravm::r#const as eravm_const;
-pub use self::eravm::utils as eravm_utils;
-pub use self::eravm::Dependency as EraVMDependency;
-pub use self::eravm::DummyDependency as EraVMDummyDependency;
-pub use self::eravm::DummyLLVMWritable as EraVMDummyLLVMWritable;
-pub use self::eravm::WriteLLVM as EraVMWriteLLVM;
 pub use self::optimizer::settings::size_level::SizeLevel as OptimizerSettingsSizeLevel;
 pub use self::optimizer::settings::Settings as OptimizerSettings;
 pub use self::optimizer::Optimizer;
+pub use self::polkavm::build_assembly_text as polkavm_build_assembly_text;
+pub use self::polkavm::context::address_space::AddressSpace as PolkaVMAddressSpace;
+pub use self::polkavm::context::argument::Argument as PolkaVMArgument;
+pub use self::polkavm::context::attribute::Attribute as PolkaVMAttribute;
+pub use self::polkavm::context::build::Build as PolkaVMBuild;
+pub use self::polkavm::context::code_type::CodeType as PolkaVMCodeType;
+pub use self::polkavm::context::evmla_data::EVMLAData as PolkaVMContextEVMLAData;
+pub use self::polkavm::context::function::block::evmla_data::key::Key as PolkaVMFunctionBlockKey;
+pub use self::polkavm::context::function::block::evmla_data::EVMLAData as PolkaVMFunctionBlockEVMLAData;
+pub use self::polkavm::context::function::block::Block as PolkaVMFunctionBlock;
+pub use self::polkavm::context::function::declaration::Declaration as PolkaVMFunctionDeclaration;
+pub use self::polkavm::context::function::evmla_data::EVMLAData as PolkaVMFunctionEVMLAData;
+pub use self::polkavm::context::function::intrinsics::Intrinsics as PolkaVMIntrinsicFunction;
+pub use self::polkavm::context::function::llvm_runtime::LLVMRuntime as PolkaVMLLVMRuntime;
+pub use self::polkavm::context::function::r#return::Return as PolkaVMFunctionReturn;
+pub use self::polkavm::context::function::runtime::deploy_code::DeployCode as PolkaVMDeployCodeFunction;
+pub use self::polkavm::context::function::runtime::entry::Entry as PolkaVMEntryFunction;
+pub use self::polkavm::context::function::runtime::runtime_code::RuntimeCode as PolkaVMRuntimeCodeFunction;
+pub use self::polkavm::context::function::runtime::FUNCTION_DEPLOY_CODE as PolkaVMFunctionDeployCode;
+pub use self::polkavm::context::function::runtime::FUNCTION_ENTRY as PolkaVMFunctionEntry;
+pub use self::polkavm::context::function::runtime::FUNCTION_RUNTIME_CODE as PolkaVMFunctionRuntimeCode;
+pub use self::polkavm::context::function::yul_data::YulData as PolkaVMFunctionYulData;
+pub use self::polkavm::context::function::Function as PolkaVMFunction;
+pub use self::polkavm::context::global::Global as PolkaVMGlobal;
+pub use self::polkavm::context::pointer::Pointer as PolkaVMPointer;
+pub use self::polkavm::context::r#loop::Loop as PolkaVMLoop;
+pub use self::polkavm::context::solidity_data::SolidityData as PolkaVMContextSolidityData;
+pub use self::polkavm::context::yul_data::YulData as PolkaVMContextYulData;
+pub use self::polkavm::context::Context as PolkaVMContext;
+pub use self::polkavm::evm::arithmetic as polkavm_evm_arithmetic;
+pub use self::polkavm::evm::bitwise as polkavm_evm_bitwise;
+pub use self::polkavm::evm::call as polkavm_evm_call;
+pub use self::polkavm::evm::calldata as polkavm_evm_calldata;
+pub use self::polkavm::evm::comparison as polkavm_evm_comparison;
+pub use self::polkavm::evm::context as polkavm_evm_contract_context;
+pub use self::polkavm::evm::create as polkavm_evm_create;
+pub use self::polkavm::evm::crypto as polkavm_evm_crypto;
+pub use self::polkavm::evm::ether_gas as polkavm_evm_ether_gas;
+pub use self::polkavm::evm::event as polkavm_evm_event;
+pub use self::polkavm::evm::ext_code as polkavm_evm_ext_code;
+pub use self::polkavm::evm::immutable as polkavm_evm_immutable;
+pub use self::polkavm::evm::math as polkavm_evm_math;
+pub use self::polkavm::evm::memory as polkavm_evm_memory;
+pub use self::polkavm::evm::r#return as polkavm_evm_return;
+pub use self::polkavm::evm::return_data as polkavm_evm_return_data;
+pub use self::polkavm::evm::storage as polkavm_evm_storage;
+pub use self::polkavm::metadata_hash::MetadataHash as PolkaVMMetadataHash;
+pub use self::polkavm::r#const as polkavm_const;
+pub use self::polkavm::utils as polkavm_utils;
+pub use self::polkavm::Dependency as PolkaVMDependency;
+pub use self::polkavm::DummyDependency as PolkaVMDummyDependency;
+pub use self::polkavm::DummyLLVMWritable as PolkaVMDummyLLVMWritable;
+pub use self::polkavm::WriteLLVM as PolkaVMWriteLLVM;
 pub use self::target_machine::target::Target;
 pub use self::target_machine::TargetMachine;
 
-///
 /// Initializes the target machine.
-///
 pub fn initialize_target(target: Target) {
     match target {
-        Target::PVM => self::eravm::initialize_target(),
+        Target::PVM => self::polkavm::initialize_target(),
     }
 }

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

@@ -1,6 +1,4 @@
-//!
 //! The LLVM optimizing tools.
-//!
 
 pub mod settings;
 
@@ -11,9 +9,7 @@ use crate::target_machine::TargetMachine;
 
 use self::settings::Settings;
 
-///
 /// The LLVM optimizing tools.
-///
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Optimizer {
     /// The optimizer settings.
@@ -21,16 +17,12 @@ pub struct Optimizer {
 }
 
 impl Optimizer {
-    ///
     /// A shortcut constructor.
-    ///
     pub fn new(settings: Settings) -> Self {
         Self { settings }
     }
 
-    ///
     /// Runs the new pass manager.
-    ///
     pub fn run(
         &self,
         target_machine: &TargetMachine,
@@ -42,9 +34,7 @@ impl Optimizer {
         )
     }
 
-    ///
     /// Returns the optimizer settings reference.
-    ///
     pub fn settings(&self) -> &Settings {
         &self.settings
     }

crates/llvm-context/src/optimizer/settings/mod.rs

@@ -1,6 +1,4 @@
-//!
 //! The LLVM optimizer settings.
-//!
 
 pub mod size_level;
 
@@ -11,9 +9,7 @@ use itertools::Itertools;
 
 use self::size_level::SizeLevel;
 
-///
 /// The LLVM optimizer settings.
-///
 #[derive(Debug, Serialize, Deserialize, Clone, Eq)]
 pub struct Settings {
     /// The middle-end optimization level.
@@ -35,9 +31,7 @@ pub struct Settings {
 }
 
 impl Settings {
-    ///
     /// A shortcut constructor.
-    ///
     pub fn new(
         level_middle_end: inkwell::OptimizationLevel,
         level_middle_end_size: SizeLevel,
@@ -56,9 +50,7 @@ impl Settings {
         }
     }
 
-    ///
     /// A shortcut constructor with debugging tools.
-    ///
     pub fn new_debug(
         level_middle_end: inkwell::OptimizationLevel,
         level_middle_end_size: SizeLevel,
@@ -80,9 +72,7 @@ impl Settings {
         }
     }
 
-    ///
     /// Creates settings from a CLI optimization parameter.
-    ///
     pub fn try_from_cli(value: char) -> anyhow::Result<Self> {
         Ok(match value {
             '0' => Self::new(
@@ -126,9 +116,7 @@ impl Settings {
         })
     }
 
-    ///
     /// Returns the settings without optimizations.
-    ///
     pub fn none() -> Self {
         Self::new(
             inkwell::OptimizationLevel::None,
@@ -137,9 +125,7 @@ impl Settings {
         )
     }
 
-    ///
     /// Returns the settings for the optimal number of VM execution cycles.
-    ///
     pub fn cycles() -> Self {
         Self::new(
             inkwell::OptimizationLevel::Aggressive,
@@ -148,9 +134,7 @@ impl Settings {
         )
     }
 
-    ///
     /// Returns the settings for the optimal size.
-    ///
     pub fn size() -> Self {
         Self::new(
             inkwell::OptimizationLevel::Default,
@@ -159,9 +143,7 @@ impl Settings {
         )
     }
 
-    ///
     /// Returns the middle-end optimization parameter as string.
-    ///
     pub fn middle_end_as_string(&self) -> String {
         match self.level_middle_end_size {
             SizeLevel::Zero => (self.level_middle_end as u8).to_string(),
@@ -169,19 +151,14 @@ impl Settings {
         }
     }
 
-    ///
     /// Checks whether there are middle-end optimizations enabled.
-    ///
     pub fn is_middle_end_enabled(&self) -> bool {
         self.level_middle_end != inkwell::OptimizationLevel::None
             || self.level_middle_end_size != SizeLevel::Zero
     }
 
-    ///
     /// Returns all possible combinations of the optimizer settings.
-    ///
     /// Used only for testing purposes.
-    ///
     pub fn combinations() -> Vec<Self> {
         let performance_combinations: Vec<Self> = vec![
             inkwell::OptimizationLevel::None,
@@ -224,30 +201,22 @@ impl Settings {
         combinations
     }
 
-    ///
     /// Sets the fallback to optimizing for size if the bytecode is too large.
-    ///
     pub fn enable_fallback_to_size(&mut self) {
         self.is_fallback_to_size_enabled = true;
     }
 
-    ///
     /// Disables the system request memoization.
-    ///
     pub fn disable_system_request_memoization(&mut self) {
         self.is_system_request_memoization_disabled = true;
     }
 
-    ///
     /// Whether the fallback to optimizing for size is enabled.
-    ///
     pub fn is_fallback_to_size_enabled(&self) -> bool {
         self.is_fallback_to_size_enabled
     }
 
-    ///
     /// Whether the system request memoization is disabled.
-    ///
     pub fn is_system_request_memoization_disabled(&self) -> bool {
         self.is_system_request_memoization_disabled
     }

crates/llvm-context/src/optimizer/settings/size_level.rs

@@ -1,13 +1,9 @@
-//!
 //! The LLVM optimizer settings size level.
-//!
 
 use serde::Deserialize;
 use serde::Serialize;
 
-///
 /// The LLVM optimizer settings size level.
-///
 #[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq)]
 pub enum SizeLevel {
     /// No size optimizations.

crates/llvm-context/src/polkavm/const/mod.rs

@@ -1,11 +1,12 @@
-//!
 //! The LLVM context constants.
-//!
+
+/// Runtime API methods.
+pub mod runtime_api;
 
 /// The LLVM framework version.
 pub const LLVM_VERSION: semver::Version = semver::Version::new(18, 1, 4);
 
-/// The EraVM version.
+/// The PolkaVM version.
 pub const ZKEVM_VERSION: semver::Version = semver::Version::new(1, 3, 2);
 
 /// The register width sized type
@@ -32,21 +33,27 @@ 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 static word size.
+pub static GLOBAL_I256_SIZE: &str = "i256_size";
+
+/// The static value size.
+pub static GLOBAL_I160_SIZE: &str = "i160_size";
+
+/// The static i64 size.
+pub static GLOBAL_I64_SIZE: &str = "i64_size";
+
 /// 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);
+    8 * (revive_common::BYTE_LENGTH_WORD as u64);
 
 /// The number of the extra ABI data arguments.
 pub const EXTRA_ABI_DATA_SIZE: usize = 0;
@@ -63,13 +70,6 @@ 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);
+pub const DEPLOYER_CALL_HEADER_SIZE: usize = revive_common::BYTE_LENGTH_WORD;

crates/llvm-context/src/polkavm/const/runtime_api.rs

@@ -0,0 +1,71 @@
+//! Runtime API import and export symbols.
+
+pub mod exports {
+    /// The contract deploy export.
+    pub static CALL: &str = "call";
+
+    /// The contract call export.
+    pub static DEPLOY: &str = "deploy";
+
+    /// All exported symbols.
+    /// Useful for configuring common attributes and linkage.
+    pub static EXPORTS: [&str; 2] = [CALL, DEPLOY];
+}
+
+pub mod imports {
+    pub static ADDRESS: &str = "address";
+
+    pub static BALANCE: &str = "balance";
+
+    pub static BLOCK_NUMBER: &str = "block_number";
+
+    pub static CALL: &str = "seal_call";
+
+    pub static CALLER: &str = "caller";
+
+    pub static CODE_SIZE: &str = "code_size";
+
+    pub static DEPOSIT_EVENT: &str = "deposit_event";
+
+    pub static GET_STORAGE: &str = "get_storage";
+
+    pub static HASH_KECCAK_256: &str = "hash_keccak_256";
+
+    pub static INPUT: &str = "input";
+
+    pub static INSTANTIATE: &str = "instantiate";
+
+    pub static NOW: &str = "now";
+
+    pub static RETURN: &str = "seal_return";
+
+    pub static RETURNDATACOPY: &str = "returndatacopy";
+
+    pub static SET_STORAGE: &str = "set_storage";
+
+    pub static VALUE_TRANSFERRED: &str = "value_transferred";
+
+    /// All imported runtime API symbols.
+    /// Useful for configuring common attributes and linkage.
+    pub static IMPORTS: [&str; 16] = [
+        ADDRESS,
+        BALANCE,
+        BLOCK_NUMBER,
+        CALL,
+        CALLER,
+        CODE_SIZE,
+        DEPOSIT_EVENT,
+        GET_STORAGE,
+        HASH_KECCAK_256,
+        INPUT,
+        INSTANTIATE,
+        NOW,
+        RETURN,
+        RETURNDATACOPY,
+        SET_STORAGE,
+        VALUE_TRANSFERRED,
+    ];
+}
+
+/// PolkaVM __sbrk API symbol to extend the heap memory.
+pub static SBRK: &str = "__sbrk";

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

@@ -1,10 +1,6 @@
-//!
 //! The address space aliases.
-//!
 
-///
 /// The address space aliases.
-///
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum AddressSpace {
     /// The stack memory.
@@ -12,13 +8,7 @@ pub enum AddressSpace {
     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,
@@ -29,9 +19,6 @@ impl From<AddressSpace> for inkwell::AddressSpace {
         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/polkavm/context/argument.rs

@@ -1,10 +1,6 @@
-//!
 //! The LLVM argument with metadata.
-//!
 
-///
 /// The LLVM argument with metadata.
-///
 #[derive(Debug, Clone)]
 pub struct Argument<'ctx> {
     /// The actual LLVM operand.
@@ -22,9 +18,7 @@ impl<'ctx> Argument<'ctx> {
     /// 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,
@@ -33,9 +27,7 @@ impl<'ctx> Argument<'ctx> {
         }
     }
 
-    ///
     /// A shortcut constructor.
-    ///
     pub fn new_with_original(
         value: inkwell::values::BasicValueEnum<'ctx>,
         original: String,
@@ -47,9 +39,7 @@ impl<'ctx> Argument<'ctx> {
         }
     }
 
-    ///
     /// A shortcut constructor.
-    ///
     pub fn new_with_constant(
         value: inkwell::values::BasicValueEnum<'ctx>,
         constant: num::BigUint,
@@ -61,9 +51,7 @@ impl<'ctx> Argument<'ctx> {
         }
     }
 
-    ///
     /// Returns the inner LLVM value.
-    ///
     pub fn to_llvm(&self) -> inkwell::values::BasicValueEnum<'ctx> {
         self.value
     }

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

@@ -4,11 +4,8 @@ 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,
@@ -84,7 +81,7 @@ pub enum Attribute {
     Writable = 70,
     WriteOnly = 71,
     ZExt = 72,
-    //LastEnumAttr = 72,
+    // LastEnumAttr = 72,
     // FirstTypeAttr = 73,
     ByRef = 73,
     ByVal = 74,
@@ -119,12 +116,7 @@ impl TryFrom<&str> for Attribute {
             "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/polkavm/context/build.rs

@@ -1,36 +1,30 @@
-//!
 //! 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.
+    /// The PolkaVM text assembly.
     pub assembly_text: String,
     /// The metadata hash.
-    pub metadata_hash: Option<[u8; revive_common::BYTE_LENGTH_FIELD]>,
-    /// The EraVM binary bytecode.
+    pub metadata_hash: Option<[u8; revive_common::BYTE_LENGTH_WORD]>,
+    /// The PolkaVM binary bytecode.
     pub bytecode: Vec<u8>,
-    /// The EraVM bytecode hash.
+    /// The PolkaVM 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]>,
+        metadata_hash: Option<[u8; revive_common::BYTE_LENGTH_WORD]>,
         bytecode: Vec<u8>,
         bytecode_hash: String,
     ) -> Self {

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

@@ -1,13 +1,8 @@
-//!
 //! 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.

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

@@ -1,13 +1,9 @@
-//!
 //! 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>,
@@ -16,9 +12,7 @@ pub struct DebugInfo<'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,
@@ -44,16 +38,14 @@ impl<'ctx> DebugInfo<'ctx> {
         }
     }
 
-    ///
     /// 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)?),
+            Some(self.create_type(revive_common::BIT_LENGTH_FIELD)?),
             &[],
             inkwell::debug_info::DIFlags::zero(),
         );
@@ -82,9 +74,7 @@ impl<'ctx> DebugInfo<'ctx> {
         Ok(function)
     }
 
-    ///
     /// Creates a primitive type info.
-    ///
     pub fn create_type(
         &self,
         bit_length: usize,
@@ -100,9 +90,7 @@ impl<'ctx> DebugInfo<'ctx> {
             .map_err(|error| anyhow::anyhow!("Debug info error: {}", error))
     }
 
-    ///
     /// Finalizes the builder.
-    ///
     pub fn finalize(&self) {
         self.builder.finalize();
     }

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

@@ -1,14 +1,9 @@
-//!
 //! The LLVM IR generator EVM legacy assembly data.
-//!
 
-use crate::eravm::context::argument::Argument;
+use crate::polkavm::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.
@@ -22,9 +17,7 @@ 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,

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

@@ -1,14 +1,9 @@
-//!
 //! The LLVM IR generator function block key.
-//!
 
-use crate::eravm::context::code_type::CodeType;
+use crate::polkavm::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.
@@ -18,9 +13,7 @@ pub struct Key {
 }
 
 impl Key {
-    ///
     /// A shortcut constructor.
-    ///
     pub fn new(code_type: CodeType, tag: num::BigUint) -> Self {
         Self { code_type, tag }
     }

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

@@ -1,14 +1,9 @@
-//!
 //! 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.
@@ -16,9 +11,7 @@ pub struct EVMLAData {
 }
 
 impl EVMLAData {
-    ///
     /// A shortcut constructor.
-    ///
     pub fn new(stack_hashes: Vec<md5::Digest>) -> Self {
         Self { stack_hashes }
     }

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

@@ -1,14 +1,10 @@
-//!
 //! 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.
@@ -18,9 +14,7 @@ pub struct Block<'ctx> {
 }
 
 impl<'ctx> Block<'ctx> {
-    ///
     /// A shortcut constructor.
-    ///
     pub fn new(inner: inkwell::basic_block::BasicBlock<'ctx>) -> Self {
         Self {
             inner,
@@ -28,38 +22,28 @@ impl<'ctx> Block<'ctx> {
         }
     }
 
-    ///
     /// 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()

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

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