resolc-0.1.0-dev.7 (#143 )

Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>
the basefee opcode (#142 )
2026-06-14 22:41:07 +00:00 · 2024-12-20 14:33:08 +01:00 · 2024-12-19 18:59:10 +01:00 · 2024-12-19 12:44:15 +01:00 · 2024-12-18 23:11:06 +01:00 · 2024-12-18 20:31:42 +01:00
146 changed files with 4598 additions and 3027 deletions
@@ -14,7 +14,7 @@ env:
 jobs:
  build-revive-debian-x86:
    name: debian-container-x86
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v4

@@ -0,0 +1,79 @@
+name: Build revive-wasm
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+  workflow_dispatch:
+
+env:
+  CARGO_TERM_COLOR: always
+  REVIVE_WASM_INSTALL_DIR: ${{ github.workspace }}/target/wasm32-unknown-emscripten/release
+  EMSCRIPTEN_VERSION: 3.1.64
+
+jobs:
+  build-revive-wasm:
+    runs-on: ubuntu-22.04
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Cache LLVM build
+        id: cache-llvm
+        uses: actions/cache@v3
+        with:
+          path: |
+            llvm18.0-emscripten
+          # Use a unique key based on LLVM version or configuration files to avoid cache invalidation
+          key: llvm-build-${{ runner.os }}-${{ hashFiles('clone-llvm.sh', 'emscripten-build-llvm.sh') }}
+
+      - name: Install Dependencies
+        run: |
+          sudo apt-get update && sudo apt-get install -y cmake ninja-build libncurses5
+          rustup target add wasm32-unknown-emscripten
+          # Install LLVM required for the compiler runtime, runtime-api and stdlib
+          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
+          # Install Emscripten
+          git clone https://github.com/emscripten-core/emsdk.git
+          cd emsdk
+          ./emsdk install ${{ env.EMSCRIPTEN_VERSION }}
+          ./emsdk activate ${{ env.EMSCRIPTEN_VERSION }}
+
+      - run: |
+          rustup show
+          cargo --version
+          rustup +nightly show
+          cargo +nightly --version
+          cmake --version
+          bash --version
+          llvm-config --version
+
+      - name: Build LLVM
+        if: steps.cache-llvm.outputs.cache-hit != 'true'
+        run: |
+          export EMSDK_ROOT=${PWD}/emsdk
+          ./emscripten-build-llvm.sh
+
+      - name: Use Cached LLVM
+        if: steps.cache-llvm.outputs.cache-hit == 'true'
+        run: |
+          echo "Using cached LLVM"
+
+      - name: Build revive
+        run: |
+          export LLVM_LINK_PREFIX=${PWD}/llvm18.0-emscripten
+          source ./emsdk/emsdk_env.sh
+          make install-wasm
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: revive-wasm
+          path: |
+            ${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc.js
+            ${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc.wasm
+          retention-days: 1
@@ -11,7 +11,7 @@ env:

 jobs:
  build-ubuntu-x86:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04

    steps:
      - uses: actions/checkout@v4
@@ -8,9 +8,11 @@
 /*.s
 /llvm-project
 /llvm18.0
+/llvm18.0-emscripten
 node_modules
 artifacts
 tmp
 package-lock.json
 /*.html
 /build
+soljson.js
@@ -0,0 +1,67 @@
+# Changelog
+
+## Unreleased
+
+## v0.1.0-dev.7
+
+This is a development pre-release.
+
+### Added
+- Implement the `GASPRICE` opcode.
+- Implement the `BASEFEE` opcode.
+- Implement the `GASLIMIT` opcode.
+
+### Changed
+- The `GAS` opcode now returns the remaining `ref_time`.
+- Contracts can now be supplied call data input of arbitrary size.
+- Some syscalls now return the value in a register, slightly improving  emitted contract code.
+- Calls forward maximum weight limits instead of 0, anticipating a change in polkadot-sdk where weight limits of 0 no longer interprets as uncapped limit.
+
+### Fixed
+- A linker bug which was preventing certain contracts from linking with the PVM linker. 
+- JS: Fix encoding conversion from JS string (UTF-16) to UTF-8.
+- The git commit hash slug is always displayed in the version string. 
+
+## v0.1.0-dev.6
+
+This is a development pre-release.
+
+# Added
+- Implement the `BLOCKHASH` opcode.
+- Implement delegate calls.
+- Implement the `GASPRICE` opcode. Currently hard-coded to return `1`.
+- The ELF shared object contract artifact is dumped into the debug output directory.
+- Initial support for emitting debug info (opt in via the `-g` flag)
+
+# Changed
+- resolc now emits 64bit PolkaVM blobs, reducing contract code size and execution time.
+- The RISC-V bit-manipulation target feature (`zbb`) is enabled.
+
+# Fixed
+- Compilation to Wasm (for usage in node and web browsers)
+
+
+## v0.1.0-dev.5
+
+This is development pre-release.
+
+# Added
+- Implement the `CODESIZE` and `EXTCODESIZE` opcodes.
+
+# Changed
+- Include the full revive version in the contract metadata.
+
+# Fixed
+
+## v0.1.0-dev-4
+
+This is development pre-release.
+
+# Added
+- Support the `ORIGIN` opcode.
+
+# Changed
+- Update polkavm to `v0.14.0`.
+- Enable the `a`, `fast-unaligned-access` and `xtheadcondmov` LLVM target features, decreasing the code size for some contracts.
+
+# Fixed
@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/*"]

 [workspace.package]
-version = "0.1.0"
+version = "0.1.0-dev.7"
 authors = [
    "Cyrill Leutwiler <cyrill@parity.io>",
    "Parity Technologies <admin@parity.io>",
@@ -14,18 +14,18 @@ repository = "https://github.com/paritytech/revive"
 rust-version = "1.80.0"

 [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" }
-revive-runtime-api = { version = "0.1.0", path = "crates/runtime-api" }
-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" }
+revive-benchmarks = { version = "0.1.0-dev.7", path = "crates/benchmarks" }
+revive-builtins = { version = "0.1.0-dev.7", path = "crates/builtins" }
+revive-common = { version = "0.1.0-dev.7", path = "crates/common" }
+revive-differential = { version = "0.1.0-dev.7", path = "crates/differential" }
+revive-integration = { version = "0.1.0-dev.7", path = "crates/integration" }
+revive-linker = { version = "0.1.0-dev.7", path = "crates/linker" }
+lld-sys = { version = "0.1.0-dev.7", path = "crates/lld-sys" }
+revive-llvm-context = { version = "0.1.0-dev.7", path = "crates/llvm-context" }
+revive-runtime-api = { version = "0.1.0-dev.7", path = "crates/runtime-api" }
+revive-runner = { version = "0.1.0-dev.7", path = "crates/runner" }
+revive-solidity = { version = "0.1.0-dev.7", path = "crates/solidity" }
+revive-stdlib = { version = "0.1.0-dev.7", path = "crates/stdlib" }

 hex = "0.4"
 petgraph = "0.6"
@@ -51,10 +51,10 @@ path-slash = "0.2"
 rayon = "1.8"
 clap = { version = "4", default-features = false, features = ["derive"] }
 rand = "0.8"
-polkavm-common = "0.13"
-polkavm-linker = "0.13"
-polkavm-disassembler = "0.13"
-polkavm = "0.13"
+polkavm-common = "0.18"
+polkavm-linker = "0.18"
+polkavm-disassembler = "0.18"
+polkavm = "0.18"
 alloy-primitives = { version = "0.8", features = ["serde"] }
 alloy-sol-types = "0.8"
 alloy-genesis = "0.3"
@@ -63,15 +63,17 @@ env_logger = { version = "0.10.0", default-features = false }
 serde_stacker = "0.1"
 criterion = { version = "0.5", features = ["html_reports"] }
 log = { version = "0.4" }
+git2 = "0.19.0"

 # polkadot-sdk and friends
 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 = "aeebf2f383390f2f86527d70212162d5dbea8b93" }
+polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk", rev = "243b751abbb94369bbd92c83d8ab159ddfc3c556" }

 # llvm
 [workspace.dependencies.inkwell]
-version = "0.5"
+git = "https://github.com/TheDan64/inkwell.git"
+rev = "7b410298b6a93450adaa90b1841d5805a3038f12"
 default-features = false
 features = ["serde", "llvm18-0", "no-libffi-linking", "target-riscv"]

@@ -1,5 +1,22 @@
 .PHONY: install format test test-solidity test-cli test-integration test-workspace clean docs docs-build

+RUSTFLAGS_EMSCRIPTEN := \
+	-C link-arg=-sEXPORTED_FUNCTIONS=_main,_free,_malloc \
+	-C link-arg=-sNO_INVOKE_RUN=1 \
+	-C link-arg=-sEXIT_RUNTIME=1 \
+	-C link-arg=-sALLOW_MEMORY_GROWTH=1 \
+	-C link-arg=-sEXPORTED_RUNTIME_METHODS=FS,callMain,stringToNewUTF8 \
+	-C link-arg=-sMODULARIZE=1 \
+	-C link-arg=-sEXPORT_NAME=createRevive \
+	-C link-arg=-sWASM_ASYNC_COMPILATION=0 \
+	-C link-arg=-sDYNAMIC_EXECUTION=0 \
+	-C link-arg=-sALLOW_TABLE_GROWTH=1 \
+	-C link-arg=--js-library=js/embed/soljson_interface.js \
+	-C link-arg=--pre-js=js/embed/pre.js \
+	-C link-arg=-sNODEJS_CATCH_EXIT=0 \
+	-C link-arg=-sDISABLE_EXCEPTION_CATCHING=0 \
+	-C opt-level=3
+
 install: install-bin install-npm

 install-bin:
@@ -8,6 +25,10 @@ install-bin:
 install-npm:
 	npm install && npm fund

+install-wasm:
+	RUSTFLAGS='$(RUSTFLAGS_EMSCRIPTEN)' cargo build --target wasm32-unknown-emscripten -p revive-solidity --release --no-default-features
+	npm install
+
 # install-revive: Build and install to the directory specified in REVIVE_INSTALL_DIR
 ifeq ($(origin REVIVE_INSTALL_DIR), undefined)
 REVIVE_INSTALL_DIR=`pwd`/release/revive-debian
@@ -58,4 +79,6 @@ clean:
 	rm -rf node_modules ; \
 	rm -rf crates/solidity/src/tests/cli-tests/artifacts ; \
 	cargo uninstall revive-solidity ; \
-	rm -f package-lock.json
+	rm -f package-lock.json ; \
+	rm -rf js/dist ; \
+	rm -f js/src/resolc.{wasm,js}
@@ -1,14 +1,15 @@
 ![CI](https://github.com/paritytech/revive/actions/workflows/rust.yml/badge.svg)
+[![Docs](https://img.shields.io/badge/Docs-contracts.polkadot.io-brightgreen.svg)](https://contracts.polkadot.io)

 # revive

 YUL and EVM assembly recompiler to LLVM, targetting RISC-V on [PolkaVM](https://github.com/koute/polkavm).

-[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`.
+Visit [contracts.polkadot.io](https://contracts.polkadot.io) to learn more about contracts on Polkadot!

 ## Status

-This is experimental software in active development and not ready just yet for production usage.
+This is experimental software in active development and not ready just yet for production usage. Please do report any compiler related issues or missing features that are [not yet known to us](https://contracts.polkadot.io/known_issues/) here.

 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).

@@ -16,6 +17,14 @@ Discussion around the development is hosted on the [Polkadot Forum](https://foru

 `resolc` depends on the [solc](https://github.com/ethereum/solidity) binary installed on your system.

+Building from source requires a compatible LLVM build.
+
+### LLVM
+
+`revive` requires a build of LLVM 18.1.4 or later with the RISC-V _embedded_ target, 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).
+
+### The `resolc` Solidity frontend
+
 To install the `resolc` Solidity frontend executable:

 ```bash
@@ -24,10 +33,23 @@ export PATH=${PWD}/llvm18.0/bin:$PATH
 make install-bin
 resolc --version
 ```
+### Cross-compilation to WASM

-### LLVM
+Cross-compiles the Revive compiler to WASM for running it in a Node.js or browser environment.

-`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). 
+Install [emscripten](https://emscripten.org/docs/getting_started/downloads.html). Tested on version 3.1.64.
+To build resolc.js execute:
+
+```bash
+bash build-llvm.sh
+export PATH=${PWD}/llvm18.0/bin:$PATH
+export EMSDK_ROOT=<PATH_TO_EMSCRIPTEN_SDK>
+bash emscripten-build-llvm.sh
+source $EMSDK_ROOT/emsdk_env.sh
+export LLVM_LINK_PREFIX=${PWD}/llvm18.0-emscripten
+export PATH=$PATH:$PWD/llvm18.0-emscripten/bin/
+make install-wasm
+```

 ### Development

@@ -35,4 +57,15 @@ Please consult the [Makefile](Makefile) targets to learn how to run tests and be
 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 [Polkadots `revive` pallet](https://docs.rs/pallet-revive/latest/pallet_revive/trait.SyscallDoc.html).
+[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`.
+
+## Tests
+
+Before running the tests, ensure that Geth (Go Ethereum) is installed on your system. Follow the installation guide here: [Installing Geth](https://geth.ethereum.org/docs/getting-started/installing-geth).
+Once Geth is installed, you can run the tests using the following command:
+
+```bash
+make test
+```
@@ -0,0 +1,12 @@
+# Release checklist
+
+Prior to the first stable release we neither have formal release processes nor do we follow a fixed release schedule.
+
+To create a new pre-release:
+
+1. Merge a release PR which updates the `-dev.X` versions in the workspace `Cargo.toml` and updates the `CHANGELOG.md` accordingly
+2. Push a release tag to `main`
+3. Manually trigger the `Build revive-debian` action
+4. Create a __pre-release__ from the tag and manually upload the build artifact generated by the action
+5. Manually upload `resolc.js` and `resolc.wasm` from the `build-revive-wasm` action artifacts.
+6. Update the [contract-docs](https://github.com/paritytech/contract-docs/) accordingly
@@ -0,0 +1,30 @@
+# Known issues
+
+The following is known and we are either working on it or it is a hard limitation. Please do not open a new issue.
+
+## Release
+
+`0.1.0-dev-2`
+
+## Missing features
+
+- [Libraries with public functions are not supported](https://github.com/paritytech/revive/issues/91)
+- [Automatic import resolution is not supported](https://github.com/paritytech/revive/issues/98)
+- The emulated EVM linear contract memory is limited to 64kb in size. Will be fixed with support for metered dynamic memory.
+- [The contract calldata is currently limited to 1kb in size](https://github.com/paritytech/revive/issues/57)
+- [EIP-4844 opcodes are not supported](https://github.com/paritytech/revive/issues/64)
+- [Delegate calls are not supported](https://github.com/paritytech/revive/issues/67)
+- [The `blockhash` opcode is not supported](https://github.com/paritytech/revive/issues/61)
+- [The `extcodesize` opcode is not supported](https://github.com/paritytech/revive/issues/58)
+- [The `origin` opcode is not supported](https://github.com/paritytech/revive/issues/59)
+- [Gas limits for contract calls are ignored](https://github.com/paritytech/revive/issues/60)
+- [Gas related opcodes are not supported](https://github.com/paritytech/revive/issues/60)
+- IPFS metadata hashes are not supported
+- [Compiled contract artifacts can exceed the pallet static memory limit and fail to deploy](https://github.com/paritytech/revive/issues/96).
+- [Transfers to inexistant accounts will fail if the transferred value lies below the ED.](https://github.com/paritytech/revive/issues/83) Will be fixed in the pallet to make the ED completely transparent for contracts.
+
+## Wontfix
+
+Please consult our documentation to learn more about Solidity and EVM features likely to remain unsupported (and why they will not be supported).
+
+TODO: Insert link to the relevant documentation section.
@@ -5,17 +5,13 @@ set -euo pipefail
 INSTALL_DIR="${PWD}/llvm18.0"
 mkdir -p ${INSTALL_DIR}

-
-# Clone LLVM 18 (any revision after commit bd32aaa is supposed to work)
-if [ ! -d "llvm-project" ]; then
-  git clone --depth 1 --branch release/18.x https://github.com/llvm/llvm-project.git
-fi
-
-
 # Build LLVM, clang
 LLVM_SRC_PREFIX=${PWD}/llvm-project
 LLVM_SRC_DIR=${LLVM_SRC_PREFIX}/llvm
 LLVM_BUILD_DIR=${PWD}/build/llvm
+
+./clone-llvm.sh "${LLVM_SRC_PREFIX}"
+
 if [ ! -d ${LLVM_BUILD_DIR} ] ; then
 	mkdir -p ${LLVM_BUILD_DIR}
 fi
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -euo pipefail
+
+# Default directory for cloning the llvm-project repository
+DEFAULT_DIR="llvm-project"
+
+# Check if a directory argument is provided
+if [ $# -eq 1 ]; then
+  DIR=$1
+else
+  DIR=$DEFAULT_DIR
+fi
+
+# Clone LLVM 18 (any revision after commit bd32aaa is supposed to work)
+if [ ! -d "${DIR}" ]; then
+  git clone --depth 1 --branch release/18.x https://github.com/llvm/llvm-project.git "${DIR}"
+fi
@@ -17,56 +17,56 @@

 |         | `EVM`                   | `PVMInterpreter`                 |
 |:--------|:------------------------|:-------------------------------- |
-| **`0`** | `5.97 us` (✅ **1.00x**) | `27.04 us` (❌ *4.53x slower*)    |
+| **`0`** | `3.36 us` (✅ **1.00x**) | `11.84 us` (❌ *3.52x slower*)    |

 ### OddPorduct

-|              | `EVM`                     | `PVMInterpreter`                 |
-|:-------------|:--------------------------|:-------------------------------- |
-| **`10000`**  | `4.26 ms` (✅ **1.00x**)   | `2.88 ms` (✅ **1.48x faster**)   |
-| **`100000`** | `42.37 ms` (✅ **1.00x**)  | `28.35 ms` (✅ **1.49x faster**)  |
-| **`300000`** | `127.88 ms` (✅ **1.00x**) | `88.43 ms` (✅ **1.45x faster**)  |
+|              | `EVM`                    | `PVMInterpreter`                 |
+|:-------------|:-------------------------|:-------------------------------- |
+| **`10000`**  | `3.11 ms` (✅ **1.00x**)  | `1.53 ms` (🚀 **2.03x faster**)   |
+| **`100000`** | `30.70 ms` (✅ **1.00x**) | `15.54 ms` (🚀 **1.98x faster**)  |
+| **`300000`** | `92.68 ms` (✅ **1.00x**) | `45.47 ms` (🚀 **2.04x faster**)  |

 ### TriangleNumber

-|              | `EVM`                     | `PVMInterpreter`                 |
-|:-------------|:--------------------------|:-------------------------------- |
-| **`10000`**  | `2.85 ms` (✅ **1.00x**)   | `2.37 ms` (✅ **1.20x faster**)   |
-| **`100000`** | `27.85 ms` (✅ **1.00x**)  | `23.01 ms` (✅ **1.21x faster**)  |
-| **`360000`** | `103.01 ms` (✅ **1.00x**) | `83.66 ms` (✅ **1.23x faster**)  |
+|              | `EVM`                    | `PVMInterpreter`                 |
+|:-------------|:-------------------------|:-------------------------------- |
+| **`10000`**  | `2.29 ms` (✅ **1.00x**)  | `1.09 ms` (🚀 **2.11x faster**)   |
+| **`100000`** | `22.84 ms` (✅ **1.00x**) | `10.66 ms` (🚀 **2.14x faster**)  |
+| **`360000`** | `82.29 ms` (✅ **1.00x**) | `37.01 ms` (🚀 **2.22x faster**)  |

 ### FibonacciRecursive

 |          | `EVM`                     | `PVMInterpreter`                  |
 |:---------|:--------------------------|:--------------------------------- |
-| **`12`** | `195.19 us` (✅ **1.00x**) | `333.53 us` (❌ *1.71x slower*)    |
-| **`16`** | `1.22 ms` (✅ **1.00x**)   | `1.97 ms` (❌ *1.62x slower*)      |
-| **`20`** | `8.14 ms` (✅ **1.00x**)   | `13.20 ms` (❌ *1.62x slower*)     |
-| **`24`** | `55.09 ms` (✅ **1.00x**)  | `88.56 ms` (❌ *1.61x slower*)     |
+| **`12`** | `135.67 us` (✅ **1.00x**) | `125.02 us` (✅ **1.09x faster**)  |
+| **`16`** | `903.75 us` (✅ **1.00x**) | `762.79 us` (✅ **1.18x faster**)  |
+| **`20`** | `6.12 ms` (✅ **1.00x**)   | `4.96 ms` (✅ **1.23x faster**)    |
+| **`24`** | `42.05 ms` (✅ **1.00x**)  | `33.86 ms` (✅ **1.24x faster**)   |

 ### FibonacciIterative

-|           | `EVM`                    | `PVMInterpreter`                  |
-|:----------|:-------------------------|:--------------------------------- |
-| **`64`**  | `33.39 us` (✅ **1.00x**) | `86.02 us` (❌ *2.58x slower*)     |
-| **`128`** | `52.91 us` (✅ **1.00x**) | `126.38 us` (❌ *2.39x slower*)    |
-| **`256`** | `82.33 us` (✅ **1.00x**) | `208.74 us` (❌ *2.54x slower*)    |
+|           | `EVM`                    | `PVMInterpreter`                 |
+|:----------|:-------------------------|:-------------------------------- |
+| **`64`**  | `15.04 us` (✅ **1.00x**) | `29.45 us` (❌ *1.96x slower*)    |
+| **`128`** | `26.36 us` (✅ **1.00x**) | `42.19 us` (❌ *1.60x slower*)    |
+| **`256`** | `48.61 us` (✅ **1.00x**) | `65.71 us` (❌ *1.35x slower*)    |

 ### FibonacciBinet

-|           | `EVM`                    | `PVMInterpreter`                  |
-|:----------|:-------------------------|:--------------------------------- |
-| **`64`**  | `32.29 us` (✅ **1.00x**) | `161.75 us` (❌ *5.01x slower*)    |
-| **`128`** | `36.02 us` (✅ **1.00x**) | `172.59 us` (❌ *4.79x slower*)    |
-| **`256`** | `41.21 us` (✅ **1.00x**) | `185.30 us` (❌ *4.50x slower*)    |
+|           | `EVM`                    | `PVMInterpreter`                 |
+|:----------|:-------------------------|:-------------------------------- |
+| **`64`**  | `15.22 us` (✅ **1.00x**) | `41.46 us` (❌ *2.72x slower*)    |
+| **`128`** | `17.05 us` (✅ **1.00x**) | `42.84 us` (❌ *2.51x slower*)    |
+| **`256`** | `19.00 us` (✅ **1.00x**) | `44.36 us` (❌ *2.34x slower*)    |

 ### SHA1

 |           | `EVM`                     | `PVMInterpreter`                  |
 |:----------|:--------------------------|:--------------------------------- |
-| **`1`**   | `160.17 us` (✅ **1.00x**) | `403.46 us` (❌ *2.52x slower*)    |
-| **`64`**  | `286.69 us` (✅ **1.00x**) | `479.79 us` (❌ *1.67x slower*)    |
-| **`512`** | `1.18 ms` (✅ **1.00x**)   | `1.37 ms` (❌ *1.16x slower*)      |
+| **`1`**   | `110.04 us` (✅ **1.00x**) | `216.11 us` (❌ *1.96x slower*)    |
+| **`64`**  | `209.04 us` (✅ **1.00x**) | `309.48 us` (❌ *1.48x slower*)    |
+| **`512`** | `903.65 us` (✅ **1.00x**) | `980.49 us` (✅ **1.09x slower**)  |

 ---
 Made with [criterion-table](https://github.com/nu11ptr/criterion-table)
@@ -46,7 +46,7 @@ fn group<'error, M>(c: &'error mut Criterion<M>, group_name: &str) -> BenchmarkG
 where
    M: Measurement,
 {
-    return c.benchmark_group(group_name);
+    c.benchmark_group(group_name)
 }

 fn bench_baseline(c: &mut Criterion) {
@@ -8,7 +8,4 @@ authors.workspace = true
 build = "build.rs"
 description = "compiler builtins for the revive compiler"

-[features]
-riscv-64 = []
-
 [dependencies]
@@ -1,8 +1,5 @@
 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() {
@@ -13,9 +13,6 @@ description = "Shared constants of the revive compiler"
 [lib]
 doctest = false

-[features]
-riscv-64 = []
-
 [dependencies]
 anyhow = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
@@ -41,3 +41,6 @@ pub static EXTENSION_POLKAVM_ASSEMBLY: &str = "pvmasm";

 /// The PolkaVM bytecode file extension.
 pub static EXTENSION_POLKAVM_BINARY: &str = "pvm";
+
+/// The ELF shared object file extension.
+pub static EXTENSION_SHARED_OBJECT: &str = "so";
@@ -557,6 +557,7 @@ allocated bytes: 3711"#;
    }

    #[test]
+    #[ignore] // https://github.com/ethereum/go-ethereum/issues/30778
    fn bench_flipper() {
        let log_runtime = Evm::default()
            .code_blob(EVM_BIN_RUNTIME_FIXTURE.as_bytes().to_vec())
@@ -1,10 +1,10 @@
 {
-  "Baseline": 989,
-  "Computation": 4153,
-  "DivisionArithmetics": 40614,
-  "ERC20": 47343,
-  "Events": 1781,
-  "FibonacciIterative": 3035,
-  "Flipper": 3393,
-  "SHA1": 33553
+  "Baseline": 1110,
+  "Computation": 2389,
+  "DivisionArithmetics": 14822,
+  "ERC20": 23973,
+  "Events": 1605,
+  "FibonacciIterative": 2023,
+  "Flipper": 1989,
+  "SHA1": 17026
 }
@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": false,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "BaseFee"
+                    }
+                }
+            }
+        },
+        {
+            "VerifyCall": {
+                "success": true
+            }
+        }
+    ]
+}
+*/
+
+contract BaseFee {
+    constructor() payable {
+        assert(block.basefee == 0);
+    }
+}
@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": false,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "BlockHash"
+                    }
+                },
+                "data": "4545454545454545454545454545454545454545454545454545454545454545"
+            }
+        }
+    ]
+}
+*/
+
+contract BlockHash {
+    constructor(bytes32 expected) payable {
+        assert(blockhash(0) == expected);
+        assert(blockhash(1) == 0);
+        assert(
+            blockhash(
+                0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+            ) == 0
+        );
+    }
+}
@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Upload": {
+                "code": {
+                    "Solidity": {
+                        "contract": "Logic"
+                    }
+                }
+            }
+        },
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "Tester"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "value": 123,
+                "data": "6466414b0000000000000000000000000000000000000000000000000000000000000020"
+            }
+        }
+    ]
+}
+*/
+
+contract Logic {
+    // NOTE: storage layout must be the same as contract Tester
+    uint256 public num;
+    address public sender;
+    uint256 public value;
+
+    uint public immutable multiplier = 4;
+
+    event DidSetVars();
+
+    function setVars(uint256 _num) public payable returns (uint256) {
+        num = _num * multiplier;
+        sender = msg.sender;
+        value = msg.value;
+        emit DidSetVars();
+        return _num;
+    }
+}
+
+contract Tester {
+    uint256 public num;
+    address public sender;
+    uint256 public value;
+
+    uint public immutable multiplier = 2;
+
+    function setVars(uint256 _num) public payable returns (bool, bytes memory) {
+        Logic impl = new Logic();
+
+        // Tester's storage is set, Logic is not modified.
+        (bool success, bytes memory data) = address(impl).delegatecall(
+            abi.encodeWithSignature("setVars(uint256)", _num)
+        );
+
+        assert(success);
+        assert(impl.num() == 0);
+        assert(impl.sender() == address(0));
+        assert(impl.value() == 0);
+        assert(num == _num * 4);
+        assert(sender == msg.sender);
+        assert(value == msg.value);
+
+        return (success, data);
+    }
+}
@@ -4,11 +4,27 @@ pragma solidity ^0.8;

 /* runner.json
 {
+    "differential": true,
    "actions": [
-    {
-      "Instantiate": {}
-    }
-  ]
+        {
+            "Upload": {
+                "code": {
+                    "Solidity": {
+                        "contract": "ERC20"
+                    }
+                }
+            }
+        },
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "ERC20Tester"
+                    }
+                }
+            }
+        }
+    ]
 }
 */

@@ -82,3 +98,26 @@ contract ERC20 is IERC20 {
        emit Transfer(msg.sender, address(0), amount);
    }
 }
+
+contract ERC20Tester {
+    constructor() {
+        address BOB = address(0xffffffffffffffffffffffffffffffffffffff);
+        ERC20 token = new ERC20();
+        assert(token.decimals() == 18);
+
+        token.mint(300);
+        assert(token.balanceOf(address(this)) == 300);
+        token.transfer(BOB, 100);
+        assert(token.balanceOf(address(this)) == 200);
+        assert(token.balanceOf(BOB) == 100);
+
+        token.approve(address(this), 100);
+
+        token.transferFrom(address(this), BOB, 100);
+        assert(token.balanceOf(BOB) == 200);
+        assert(token.balanceOf(address(this)) == 100);
+
+        token.burn(100);
+        assert(token.balanceOf(address(this)) == 0);
+    }
+}
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": false,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "GasLeft"
+                    }
+                }
+            }
+        },
+        {
+            "VerifyCall": {
+                "success": true
+            }
+        }
+    ]
+}
+*/
+
+contract GasLeft {
+    constructor() payable {
+        assert(gasleft() > gasleft());
+        assert(gasleft() > 0 && gasleft() < 0xffffffffffffffff);
+    }
+}
@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": false,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "GasLimit"
+                    }
+                }
+            }
+        },
+        {
+            "VerifyCall": {
+                "success": true
+            }
+        }
+    ]
+}
+*/
+
+contract GasLimit {
+    constructor() payable {
+        assert(block.gaslimit == 2000000000000);
+    }
+}
@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": false,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "GasPrice"
+                    }
+                }
+            }
+        },
+        {
+            "VerifyCall": {
+                "success": true
+            }
+        }
+    ]
+}
+*/
+
+contract GasPrice {
+    constructor() payable {
+        assert(tx.gasprice == 1);
+    }
+}
@@ -22,6 +22,14 @@ pragma solidity ^0.8;
                },
                "data": "fabc9efaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "558b9f9bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+            }
        }
    ]
 }
@@ -30,10 +38,18 @@ pragma solidity ^0.8;
 contract Storage {
    function transient(uint value) public returns (uint ret) {
        assembly {
-            let slot := 123
+            let slot := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
            tstore(slot, value)
            let success := call(0, 0, 0, 0, 0, 0, 0)
            ret := tload(slot)
        }
    }
+
+    function persistent(uint value) public returns (uint ret) {
+        assembly {
+            let slot := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
+            sstore(slot, value)
+            ret := sload(slot)
+        }
+    }
 }
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Upload": {
+                "code": {
+                    "Solidity": {
+                        "contract": "TransactionOrigin"
+                    }
+                }
+            }
+        },
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "TransactionTester"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "f8a8fd6d"
+            }
+        }
+    ]
+}
+*/
+
+contract TransactionTester {
+    constructor() payable {
+        assert(tx.origin == new TransactionOrigin().test());
+    }
+
+    function test() public payable returns (address ret) {
+        ret = tx.origin;
+    }
+}
+
+contract TransactionOrigin {
+    function test() public payable returns (address ret) {
+        assert(msg.sender != tx.origin);
+
+        ret = tx.origin;
+    }
+}
@@ -43,6 +43,13 @@ test_spec!(call, "Caller", "Call.sol");
 test_spec!(transfer, "Transfer", "Transfer.sol");
 test_spec!(return_data_oob, "ReturnDataOob", "ReturnDataOob.sol");
 test_spec!(immutables, "Immutables", "Immutables.sol");
+test_spec!(transaction, "Transaction", "Transaction.sol");
+test_spec!(block_hash, "BlockHash", "BlockHash.sol");
+test_spec!(delegate, "Delegate", "Delegate.sol");
+test_spec!(gas_price, "GasPrice", "GasPrice.sol");
+test_spec!(gas_left, "GasLeft", "GasLeft.sol");
+test_spec!(gas_limit, "GasLimit", "GasLimit.sol");
+test_spec!(base_fee, "BaseFee", "BaseFee.sol");

 fn instantiate(path: &str, contract: &str) -> Vec<SpecsAction> {
    vec![Instantiate {
@@ -320,6 +327,114 @@ fn ext_code_hash() {
    .run();
 }

+#[test]
+fn ext_code_size() {
+    let alice = Address::from(ALICE.0);
+    let own_address = alice.create(0);
+    let baseline_address = alice.create2([0u8; 32], keccak256(Contract::baseline().pvm_runtime));
+
+    let own_code_size = U256::from(
+        Contract::ext_code_size(Default::default())
+            .pvm_runtime
+            .len(),
+    );
+    let baseline_code_size = U256::from(Contract::baseline().pvm_runtime.len());
+
+    Specs {
+        actions: vec![
+            // Instantiate the test contract
+            instantiate("contracts/ExtCode.sol", "ExtCode").remove(0),
+            // Instantiate the baseline contract
+            Instantiate {
+                origin: TestAddress::Alice,
+                value: 0,
+                gas_limit: Some(GAS_LIMIT),
+                storage_deposit_limit: None,
+                code: Code::Solidity {
+                    path: Some("contracts/Baseline.sol".into()),
+                    contract: "Baseline".to_string(),
+                    solc_optimizer: None,
+                    pipeline: None,
+                },
+                data: vec![],
+                salt: OptionalHex::from([0; 32]),
+            },
+            // Alice is not a contract and returns a code size of 0
+            Call {
+                origin: TestAddress::Alice,
+                dest: TestAddress::Instantiated(0),
+                value: 0,
+                gas_limit: None,
+                storage_deposit_limit: None,
+                data: Contract::ext_code_size(alice).calldata,
+            },
+            VerifyCall(VerifyCallExpectation {
+                success: true,
+                output: OptionalHex::from([0u8; 32].to_vec()),
+                gas_consumed: None,
+            }),
+            // Unknown address returns a code size of 0
+            Call {
+                origin: TestAddress::Alice,
+                dest: TestAddress::Instantiated(0),
+                value: 0,
+                gas_limit: None,
+                storage_deposit_limit: None,
+                data: Contract::ext_code_size(Address::from([0xff; 20])).calldata,
+            },
+            VerifyCall(VerifyCallExpectation {
+                success: true,
+                output: OptionalHex::from([0u8; 32].to_vec()),
+                gas_consumed: None,
+            }),
+            // Own address via extcodesize returns own code size
+            Call {
+                origin: TestAddress::Alice,
+                dest: TestAddress::Instantiated(0),
+                value: 0,
+                gas_limit: None,
+                storage_deposit_limit: None,
+                data: Contract::ext_code_size(own_address).calldata,
+            },
+            VerifyCall(VerifyCallExpectation {
+                success: true,
+                output: OptionalHex::from(own_code_size.to_be_bytes::<32>().to_vec()),
+                gas_consumed: None,
+            }),
+            // Own address via codesize returns own code size
+            Call {
+                origin: TestAddress::Alice,
+                dest: TestAddress::Instantiated(0),
+                value: 0,
+                gas_limit: None,
+                storage_deposit_limit: None,
+                data: Contract::code_size().calldata,
+            },
+            VerifyCall(VerifyCallExpectation {
+                success: true,
+                output: OptionalHex::from(own_code_size.to_be_bytes::<32>().to_vec()),
+                gas_consumed: None,
+            }),
+            // Baseline address returns the baseline code size
+            Call {
+                origin: TestAddress::Alice,
+                dest: TestAddress::Instantiated(0),
+                value: 0,
+                gas_limit: None,
+                storage_deposit_limit: None,
+                data: Contract::ext_code_size(baseline_address).calldata,
+            },
+            VerifyCall(VerifyCallExpectation {
+                success: true,
+                output: OptionalHex::from(baseline_code_size.to_be_bytes::<32>().to_vec()),
+                gas_consumed: None,
+            }),
+        ],
+        ..Default::default()
+    }
+    .run();
+}
+
 /*
 // These test were implement for the mock-runtime and need to be ported yet.

@@ -348,28 +463,4 @@ fn create2_failure() {

    assert_eq!(output.flags, ReturnFlags::Revert);
 }
-
-#[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);
-}
 */
@@ -7,9 +7,6 @@ repository.workspace = true
 authors.workspace = true
 description = "revive compiler linker utils"

-[features]
-riscv-64 = []
-
 [dependencies]
 inkwell = { workspace = true }
 tempfile = { workspace = true }
@@ -8,14 +8,7 @@ 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 {
@@ -29,9 +22,9 @@ fn invoke_lld(cmd_args: &[&str]) -> bool {
    unsafe { LLDELFLink(args.as_ptr(), args.len()) == 0 }
 }

-fn polkavm_linker<T: AsRef<[u8]>>(code: T) -> anyhow::Result<Vec<u8>> {
+pub fn polkavm_linker<T: AsRef<[u8]>>(code: T, strip_binary: bool) -> anyhow::Result<Vec<u8>> {
    let mut config = polkavm_linker::Config::default();
-    config.set_strip(true);
+    config.set_strip(strip_binary);
    config.set_optimize(true);

    polkavm_linker::program_from_elf(config, code.as_ref())
@@ -64,6 +57,7 @@ pub fn link<T: AsRef<[u8]>>(input: T) -> anyhow::Result<Vec<u8>> {
        "--relocatable",
        "--emit-relocs",
        "--no-relax",
+        "--unique",
        "--gc-sections",
        "--library-path",
        dir.path().to_str().expect("should be utf8"),
@@ -79,10 +73,5 @@ pub fn link<T: AsRef<[u8]>>(input: T) -> anyhow::Result<Vec<u8>> {
        return Err(anyhow::anyhow!("ld.lld failed"));
    }

-    if env::var("PVM_LINKER_DUMP_SO").is_ok() {
-        fs::copy(&output_path, "/tmp/out.so")?;
-    };
-
-    let blob = fs::read(&output_path)?;
-    polkavm_linker(blob)
+    Ok(fs::read(&output_path)?)
 }
@@ -1,5 +1,19 @@
-fn llvm_config(arg: &str) -> String {
-    let output = std::process::Command::new("llvm-config")
+use std::{
+    env,
+    path::{Path, PathBuf},
+};
+
+const LLVM_LINK_PREFIX: &str = "LLVM_LINK_PREFIX";
+
+fn locate_llvm_config() -> PathBuf {
+    let prefix = env::var_os(LLVM_LINK_PREFIX)
+        .map(|p| PathBuf::from(p).join("bin"))
+        .unwrap_or_default();
+    prefix.join("llvm-config")
+}
+
+fn llvm_config(llvm_config_path: &Path, arg: &str) -> String {
+    let output = std::process::Command::new(llvm_config_path)
        .args([arg])
        .output()
        .unwrap_or_else(|_| panic!("`llvm-config {arg}` failed"));
@@ -8,8 +22,11 @@ fn llvm_config(arg: &str) -> String {
        .unwrap_or_else(|_| panic!("output of `llvm-config {arg}` should be utf8"))
 }

-fn set_rustc_link_flags() {
-    println!("cargo:rustc-link-search=native={}", llvm_config("--libdir"));
+fn set_rustc_link_flags(llvm_config_path: &Path) {
+    println!(
+        "cargo:rustc-link-search=native={}",
+        llvm_config(llvm_config_path, "--libdir")
+    );

    for lib in [
        "lldELF",
@@ -22,19 +39,70 @@ fn set_rustc_link_flags() {
        "LLVMTargetParser",
        "LLVMBinaryFormat",
        "LLVMDemangle",
+        // The `llvm-sys` crate relies on `llvm-config` to obtain a list of required LLVM libraries
+        // during the build process. This works well in typical native environments, where `llvm-config`
+        // can accurately list the necessary libraries.
+        // However, when cross-compiling to WebAssembly using Emscripten, `llvm-config` fails to recognize
+        // JavaScript-based libraries, making it necessary to manually inject the required dependencies.
+        "LLVMRISCVDisassembler",
+        "LLVMRISCVAsmParser",
+        "LLVMRISCVCodeGen",
+        "LLVMRISCVDesc",
+        "LLVMRISCVInfo",
+        "LLVMExecutionEngine",
+        "LLVMOption",
+        "LLVMMCDisassembler",
+        "LLVMPasses",
+        "LLVMHipStdPar",
+        "LLVMCFGuard",
+        "LLVMCoroutines",
+        "LLVMipo",
+        "LLVMVectorize",
+        "LLVMInstrumentation",
+        "LLVMFrontendOpenMP",
+        "LLVMFrontendOffloading",
+        "LLVMGlobalISel",
+        "LLVMAsmPrinter",
+        "LLVMSelectionDAG",
+        "LLVMCodeGen",
+        "LLVMTarget",
+        "LLVMObjCARCOpts",
+        "LLVMCodeGenTypes",
+        "LLVMIRPrinter",
+        "LLVMScalarOpts",
+        "LLVMInstCombine",
+        "LLVMAggressiveInstCombine",
+        "LLVMTransformUtils",
+        "LLVMBitWriter",
+        "LLVMAnalysis",
+        "LLVMProfileData",
+        "LLVMDebugInfoDWARF",
+        "LLVMObject",
+        "LLVMMCParser",
+        "LLVMIRReader",
+        "LLVMAsmParser",
+        "LLVMMC",
+        "LLVMDebugInfoCodeView",
+        "LLVMBitReader",
+        "LLVMRemarks",
+        "LLVMBitstreamReader",
    ] {
        println!("cargo:rustc-link-lib=static={lib}");
    }

-    #[cfg(target_os = "linux")]
-    {
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
+    if target_os == "linux" {
        println!("cargo:rustc-link-lib=dylib=stdc++");
        println!("cargo:rustc-link-lib=tinfo");
    }
 }

 fn main() {
-    llvm_config("--cxxflags")
+    println!("cargo:rerun-if-env-changed={}", LLVM_LINK_PREFIX);
+
+    let llvm_config_path = locate_llvm_config();
+
+    llvm_config(&llvm_config_path, "--cxxflags")
        .split_whitespace()
        .fold(&mut cc::Build::new(), |builder, flag| builder.flag(flag))
        .flag("-Wno-unused-parameter")
@@ -42,7 +110,7 @@ fn main() {
        .file("src/linker.cpp")
        .compile("liblinker.a");

-    set_rustc_link_flags();
+    set_rustc_link_flags(&llvm_config_path);

    println!("cargo:rerun-if-changed=build.rs");
 }
@@ -13,10 +13,6 @@ 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 }
@@ -15,6 +15,8 @@ pub enum IRType {
    LLVM,
    /// Whether to dump the assembly code.
    Assembly,
+    /// Whether to dump the ELF shared object
+    SO,
    /// Whether to jump JSON
    #[cfg(debug_assertions)]
    JSON,
@@ -31,6 +33,7 @@ impl IRType {
            Self::Assembly => revive_common::EXTENSION_POLKAVM_ASSEMBLY,
            #[cfg(debug_assertions)]
            Self::JSON => revive_common::EXTENSION_JSON,
+            Self::SO => revive_common::EXTENSION_SHARED_OBJECT,
        }
    }
 }
@@ -13,41 +13,52 @@ use self::ir_type::IRType;
 #[derive(Debug, Default, Serialize, Deserialize, Clone)]
 pub struct DebugConfig {
    /// The directory to dump the IRs to.
-    pub output_directory: PathBuf,
+    pub output_directory: Option<PathBuf>,
+    /// Whether debug info should be emitted.
+    pub emit_debug_info: bool,
 }

 impl DebugConfig {
    /// A shortcut constructor.
-    pub fn new(output_directory: PathBuf) -> Self {
-        Self { output_directory }
+    pub const fn new(output_directory: Option<PathBuf>, emit_debug_info: bool) -> Self {
+        Self {
+            output_directory,
+            emit_debug_info,
+        }
    }

    /// Dumps the Yul IR.
    pub fn dump_yul(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, None, IRType::Yul);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, code)?;
+        if let Some(output_directory) = self.output_directory.as_ref() {
+            let mut file_path = output_directory.to_owned();
+            let full_file_name = Self::full_file_name(contract_path, None, IRType::Yul);
+            file_path.push(full_file_name);
+            std::fs::write(file_path, code)?;
+        }

        Ok(())
    }

    /// Dumps the EVM legacy assembly IR.
    pub fn dump_evmla(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, None, IRType::EVMLA);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, code)?;
+        if let Some(output_directory) = self.output_directory.as_ref() {
+            let mut file_path = output_directory.to_owned();
+            let full_file_name = Self::full_file_name(contract_path, None, IRType::EVMLA);
+            file_path.push(full_file_name);
+            std::fs::write(file_path, code)?;
+        }

        Ok(())
    }

    /// Dumps the Ethereal IR.
    pub fn dump_ethir(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, None, IRType::EthIR);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, code)?;
+        if let Some(output_directory) = self.output_directory.as_ref() {
+            let mut file_path = output_directory.to_owned();
+            let full_file_name = Self::full_file_name(contract_path, None, IRType::EthIR);
+            file_path.push(full_file_name);
+            std::fs::write(file_path, code)?;
+        }

        Ok(())
    }
@@ -58,12 +69,15 @@ impl DebugConfig {
        contract_path: &str,
        module: &inkwell::module::Module,
    ) -> anyhow::Result<()> {
-        let llvm_code = module.print_to_string().to_string();
+        if let Some(output_directory) = self.output_directory.as_ref() {
+            let llvm_code = module.print_to_string().to_string();

-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, Some("unoptimized"), IRType::LLVM);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, llvm_code)?;
+            let mut file_path = output_directory.to_owned();
+            let full_file_name =
+                Self::full_file_name(contract_path, Some("unoptimized"), IRType::LLVM);
+            file_path.push(full_file_name);
+            std::fs::write(file_path, llvm_code)?;
+        }

        Ok(())
    }
@@ -74,22 +88,39 @@ impl DebugConfig {
        contract_path: &str,
        module: &inkwell::module::Module,
    ) -> anyhow::Result<()> {
-        let llvm_code = module.print_to_string().to_string();
+        if let Some(output_directory) = self.output_directory.as_ref() {
+            let llvm_code = module.print_to_string().to_string();

-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, Some("optimized"), IRType::LLVM);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, llvm_code)?;
+            let mut file_path = output_directory.to_owned();
+            let full_file_name =
+                Self::full_file_name(contract_path, Some("optimized"), IRType::LLVM);
+            file_path.push(full_file_name);
+            std::fs::write(file_path, llvm_code)?;
+        }

        Ok(())
    }

    /// Dumps the assembly.
    pub fn dump_assembly(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, None, IRType::Assembly);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, code)?;
+        if let Some(output_directory) = self.output_directory.as_ref() {
+            let mut file_path = output_directory.to_owned();
+            let full_file_name = Self::full_file_name(contract_path, None, IRType::Assembly);
+            file_path.push(full_file_name);
+            std::fs::write(file_path, code)?;
+        }
+
+        Ok(())
+    }
+
+    /// Dumps the code object.
+    pub fn dump_object(&self, contract_path: &str, code: &[u8]) -> anyhow::Result<()> {
+        if let Some(output_directory) = self.output_directory.as_ref() {
+            let mut file_path = output_directory.to_owned();
+            let full_file_name = Self::full_file_name(contract_path, None, IRType::SO);
+            file_path.push(full_file_name);
+            std::fs::write(file_path, code)?;
+        }

        Ok(())
    }
@@ -102,10 +133,12 @@ impl DebugConfig {
        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)?;
+        if let Some(output_directory) = self.output_directory.as_ref() {
+            let mut file_path = 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(())
    }
@@ -16,6 +16,7 @@ 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::debug_info::DebugInfo;
 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;
@@ -60,7 +61,6 @@ 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;
@@ -9,7 +9,7 @@ use itertools::Itertools;

 use self::size_level::SizeLevel;

-/// The LLVM optimizer settings.
+/// The LLVM optimizer and code-gen settings.
 #[derive(Debug, Serialize, Deserialize, Clone, Eq)]
 pub struct Settings {
    /// The middle-end optimization level.
@@ -3,15 +3,12 @@
 /// The LLVM framework version.
 pub const LLVM_VERSION: semver::Version = semver::Version::new(18, 1, 4);

-/// The register width sized type
+/// The pointer width sized type.
 pub static XLEN: usize = revive_common::BIT_LENGTH_X32;

 /// The heap memory pointer pointer global variable name.
 pub static GLOBAL_HEAP_MEMORY_POINTER: &str = "memory_pointer";

-/// The calldata pointer global variable name.
-pub static GLOBAL_CALLDATA_POINTER: &str = "ptr_calldata";
-
 /// The calldata size global variable name.
 pub static GLOBAL_CALLDATA_SIZE: &str = "calldatasize";

@@ -1,7 +1,43 @@
 //! The LLVM debug information.

+use std::cell::RefCell;
+
 use inkwell::debug_info::AsDIScope;
-use num::Zero;
+use inkwell::debug_info::DIScope;
+
+/// Debug info scope stack
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ScopeStack<'ctx> {
+    stack: Vec<DIScope<'ctx>>,
+}
+
+// Abstract the type of the DIScope stack.
+impl<'ctx> ScopeStack<'ctx> {
+    pub fn from(item: DIScope<'ctx>) -> Self {
+        Self { stack: vec![item] }
+    }
+
+    /// Return the top of the scope stack, or None if the stack is empty.
+    pub fn top(&self) -> Option<DIScope<'ctx>> {
+        self.stack.last().copied()
+    }
+
+    /// Push a scope onto the stack.
+    pub fn push(&mut self, scope: DIScope<'ctx>) {
+        self.stack.push(scope)
+    }
+
+    /// Pop the scope at the top of the stack and return it.
+    /// Return None if the stack is empty.
+    pub fn pop(&mut self) -> Option<DIScope<'ctx>> {
+        self.stack.pop()
+    }
+
+    /// Return the number of scopes on the stack.
+    pub fn len(&self) -> usize {
+        self.stack.len()
+    }
+}

 /// The LLVM debug information.
 pub struct DebugInfo<'ctx> {
@@ -9,6 +45,8 @@ pub struct DebugInfo<'ctx> {
    compile_unit: inkwell::debug_info::DICompileUnit<'ctx>,
    /// The debug info builder.
    builder: inkwell::debug_info::DebugInfoBuilder<'ctx>,
+    /// Enclosing debug info scopes.
+    scope_stack: RefCell<ScopeStack<'ctx>>,
 }

 impl<'ctx> DebugInfo<'ctx> {
@@ -35,19 +73,43 @@ impl<'ctx> DebugInfo<'ctx> {
        Self {
            compile_unit,
            builder,
+            scope_stack: RefCell::new(ScopeStack::from(compile_unit.as_debug_info_scope())),
        }
    }

+    /// Prepare an LLVM-IR module for debug-info generation
+    pub fn initialize_module(
+        &self,
+        llvm: &'ctx inkwell::context::Context,
+        module: &inkwell::module::Module<'ctx>,
+    ) {
+        let debug_metadata_value = llvm
+            .i32_type()
+            .const_int(inkwell::debug_info::debug_metadata_version() as u64, false);
+        module.add_basic_value_flag(
+            "Debug Info Version",
+            inkwell::module::FlagBehavior::Warning,
+            debug_metadata_value,
+        );
+        self.push_scope(self.compilation_unit().get_file().as_debug_info_scope());
+    }
+
+    /// Finalize debug-info for an LLVM-IR module.
+    pub fn finalize_module(&self) {
+        self.builder().finalize()
+    }
+
    /// Creates a function info.
    pub fn create_function(
        &self,
        name: &str,
    ) -> anyhow::Result<inkwell::debug_info::DISubprogram<'ctx>> {
+        let flags = inkwell::debug_info::DIFlagsConstants::ZERO;
        let subroutine_type = self.builder.create_subroutine_type(
            self.compile_unit.get_file(),
-            Some(self.create_type(revive_common::BIT_LENGTH_FIELD)?),
+            Some(self.create_word_type(Some(flags))?.as_type()),
            &[],
-            inkwell::debug_info::DIFlags::zero(),
+            flags,
        );

        let function = self.builder.create_function(
@@ -60,7 +122,7 @@ impl<'ctx> DebugInfo<'ctx> {
            true,
            false,
            1,
-            inkwell::debug_info::DIFlags::zero(),
+            flags,
            false,
        );

@@ -74,24 +136,55 @@ impl<'ctx> DebugInfo<'ctx> {
        Ok(function)
    }

-    /// Creates a primitive type info.
-    pub fn create_type(
+    /// Creates primitive integer type debug-info.
+    pub fn create_primitive_type(
        &self,
        bit_length: usize,
-    ) -> anyhow::Result<inkwell::debug_info::DIType<'ctx>> {
+        flags: Option<inkwell::debug_info::DIFlags>,
+    ) -> anyhow::Result<inkwell::debug_info::DIBasicType<'ctx>> {
+        let di_flags = flags.unwrap_or(inkwell::debug_info::DIFlagsConstants::ZERO);
+        let di_encoding: u32 = 0;
+        let type_name = String::from("U") + bit_length.to_string().as_str();
        self.builder
-            .create_basic_type(
-                "U256",
-                bit_length as u64,
-                0,
-                inkwell::debug_info::DIFlags::zero(),
-            )
-            .map(|basic_type| basic_type.as_type())
+            .create_basic_type(type_name.as_str(), bit_length as u64, di_encoding, di_flags)
            .map_err(|error| anyhow::anyhow!("Debug info error: {}", error))
    }

-    /// Finalizes the builder.
-    pub fn finalize(&self) {
-        self.builder.finalize();
+    /// Returns the debug-info model of word-sized integer types.
+    pub fn create_word_type(
+        &self,
+        flags: Option<inkwell::debug_info::DIFlags>,
+    ) -> anyhow::Result<inkwell::debug_info::DIBasicType<'ctx>> {
+        self.create_primitive_type(revive_common::BIT_LENGTH_WORD, flags)
+    }
+
+    /// Return the DIBuilder.
+    pub fn builder(&self) -> &inkwell::debug_info::DebugInfoBuilder<'ctx> {
+        &self.builder
+    }
+
+    /// Return the compilation unit. {
+    pub fn compilation_unit(&self) -> &inkwell::debug_info::DICompileUnit<'ctx> {
+        &self.compile_unit
+    }
+
+    /// Push a debug-info scope onto the stack.
+    pub fn push_scope(&self, scope: DIScope<'ctx>) {
+        self.scope_stack.borrow_mut().push(scope)
+    }
+
+    /// Pop the top of the debug-info scope stack and return it.
+    pub fn pop_scope(&self) -> Option<DIScope<'ctx>> {
+        self.scope_stack.borrow_mut().pop()
+    }
+
+    /// Return the top of the debug-info scope stack.
+    pub fn top_scope(&self) -> Option<DIScope<'ctx>> {
+        self.scope_stack.borrow().top()
+    }
+
+    /// Return the number of debug-info scopes on the scope stack.
+    pub fn num_scopes(&self) -> usize {
+        self.scope_stack.borrow().len()
    }
 }
@@ -13,7 +13,7 @@ pub struct EVMLAData<'ctx> {
    pub stack: Vec<Argument<'ctx>>,
 }

-impl<'ctx> EVMLAData<'ctx> {
+impl EVMLAData<'_> {
    /// The default stack size.
    pub const DEFAULT_STACK_SIZE: usize = 64;

@@ -17,4 +17,8 @@ impl<'ctx> Declaration<'ctx> {
    ) -> Self {
        Self { r#type, value }
    }
+
+    pub fn function_value(&self) -> inkwell::values::FunctionValue<'ctx> {
+        self.value
+    }
 }
@@ -11,6 +11,8 @@ pub mod yul_data;

 use std::collections::HashMap;

+use inkwell::debug_info::AsDIScope;
+
 use crate::optimizer::settings::size_level::SizeLevel;
 use crate::optimizer::Optimizer;
 use crate::polkavm::context::attribute::Attribute;
@@ -94,6 +96,14 @@ impl<'ctx> Function<'ctx> {
        self.declaration
    }

+    /// Returns the debug-info scope.
+    pub fn get_debug_scope(&self) -> Option<inkwell::debug_info::DIScope<'ctx>> {
+        self.declaration()
+            .function_value()
+            .get_subprogram()
+            .map(|scp| scp.as_debug_info_scope())
+    }
+
    /// Returns the N-th parameter of the function.
    pub fn get_nth_param(&self, index: usize) -> inkwell::values::BasicValueEnum<'ctx> {
        self.declaration()
@@ -54,12 +54,14 @@ where
    }

    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        context.set_current_function(runtime::FUNCTION_DEPLOY_CODE)?;
+        context.set_current_function(runtime::FUNCTION_DEPLOY_CODE, None)?;

        context.set_basic_block(context.current_function().borrow().entry_block());
        context.set_code_type(CodeType::Deploy);

        self.inner.into_llvm(context)?;
+        context.set_debug_location(0, 0, None)?;
+
        match context
            .basic_block()
            .get_last_instruction()
@@ -72,8 +74,11 @@ where
        }

        context.set_basic_block(context.current_function().borrow().return_block());
+        context.set_debug_location(0, 0, None)?;
        context.build_return(None);

+        context.pop_debug_scope();
+
        Ok(())
    }
 }
@@ -18,35 +18,12 @@ impl Entry {
    /// The call flags argument index.
    pub const ARGUMENT_INDEX_CALL_FLAGS: usize = 0;

-    /// Reserve 1kb for calldata.
-    pub const MAX_CALLDATA_SIZE: usize = 1024;
-
    /// Initializes the global variables.
    /// The pointers are not initialized, because it's not possible to create a null pointer.
    pub fn initialize_globals<D>(context: &mut Context<D>) -> anyhow::Result<()>
    where
        D: Dependency + Clone,
    {
-        context.declare_global(
-            revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER,
-            context.word_type().array_type(0),
-            AddressSpace::Stack,
-        );
-
-        context.declare_global(
-            revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE,
-            context.xlen_type(),
-            AddressSpace::Stack,
-        );
-
-        let calldata_type = context.array_type(context.byte_type(), Self::MAX_CALLDATA_SIZE);
-        context.set_global(
-            crate::polkavm::GLOBAL_CALLDATA_POINTER,
-            calldata_type,
-            AddressSpace::Stack,
-            calldata_type.get_undef(),
-        );
-
        context.set_global(
            crate::polkavm::GLOBAL_HEAP_MEMORY_POINTER,
            context.llvm().ptr_type(AddressSpace::Heap.into()),
@@ -65,9 +42,9 @@ impl Entry {

        context.set_global(
            crate::polkavm::GLOBAL_CALLDATA_SIZE,
-            context.word_type(),
+            context.xlen_type(),
            AddressSpace::Stack,
-            context.word_undef(),
+            context.xlen_type().get_undef(),
        );

        context.set_global(
@@ -80,53 +57,22 @@ impl Entry {
        Ok(())
    }

-    /// Load the calldata via seal `input` and initialize the calldata end
-    /// and calldata size globals.
-    pub fn load_calldata<D>(context: &mut Context<D>) -> anyhow::Result<()>
+    /// Populate the calldata size global value.
+    pub fn load_calldata_size<D>(context: &mut Context<D>) -> anyhow::Result<()>
    where
        D: Dependency + Clone,
    {
-        let input_pointer = context
-            .get_global(crate::polkavm::GLOBAL_CALLDATA_POINTER)?
+        let call_data_size_pointer = context
+            .get_global(crate::polkavm::GLOBAL_CALLDATA_SIZE)?
            .value
            .as_pointer_value();
-        let input_pointer_casted = context.builder.build_ptr_to_int(
-            input_pointer,
-            context.xlen_type(),
-            "input_pointer_casted",
-        )?;
-
-        let length_pointer = context.build_alloca_at_entry(context.xlen_type(), "len_ptr");
-        let length_pointer_casted = context.builder.build_ptr_to_int(
-            length_pointer.value,
-            context.xlen_type(),
-            "length_pointer_casted",
-        )?;
-
-        context.build_store(
-            length_pointer,
-            context.integer_const(crate::polkavm::XLEN, Self::MAX_CALLDATA_SIZE as u64),
-        )?;
-        context.build_runtime_call(
-            revive_runtime_api::polkavm_imports::INPUT,
-            &[input_pointer_casted.into(), length_pointer_casted.into()],
-        );
-
-        // Store the calldata size
-        let calldata_size = context
-            .build_load(length_pointer, "input_size")?
+        let call_data_size_value = context
+            .build_runtime_call(revive_runtime_api::polkavm_imports::CALL_DATA_SIZE, &[])
+            .expect("the call_data_size syscall method should return a value")
            .into_int_value();
-        let calldata_size_casted = context.builder().build_int_z_extend(
-            calldata_size,
-            context.word_type(),
-            "zext_input_len",
-        )?;
-        context.set_global(
-            crate::polkavm::GLOBAL_CALLDATA_SIZE,
-            context.word_type(),
-            AddressSpace::Stack,
-            calldata_size_casted,
-        );
+        context
+            .builder()
+            .build_store(call_data_size_pointer, call_data_size_value)?;

        Ok(())
    }
@@ -137,6 +83,8 @@ impl Entry {
    where
        D: Dependency + Clone,
    {
+        context.set_debug_location(0, 0, None)?;
+
        let is_deploy = context
            .current_function()
            .borrow()
@@ -195,6 +143,18 @@ where
            Some(inkwell::module::Linkage::External),
        )?;

+        context.declare_global(
+            revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER,
+            context.word_type().array_type(0),
+            AddressSpace::Stack,
+        );
+
+        context.declare_global(
+            revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE,
+            context.xlen_type(),
+            AddressSpace::Stack,
+        );
+
        Ok(())
    }

@@ -214,17 +174,19 @@ where
            true,
        );

-        context.set_current_function(runtime::FUNCTION_ENTRY)?;
+        context.set_current_function(runtime::FUNCTION_ENTRY, None)?;
        context.set_basic_block(context.current_function().borrow().entry_block());

        Self::initialize_globals(context)?;
-        Self::load_calldata(context)?;
+        Self::load_calldata_size(context)?;
        Self::leave_entry(context)?;

        context.build_unconditional_branch(context.current_function().borrow().return_block());
        context.set_basic_block(context.current_function().borrow().return_block());
        context.build_unreachable();

+        context.pop_debug_scope();
+
        Ok(())
    }
 }
@@ -27,14 +27,14 @@ where
            runtime::FUNCTION_LOAD_IMMUTABLE_DATA,
            context.void_type().fn_type(Default::default(), false),
            0,
-            Some(inkwell::module::Linkage::Private),
+            Some(inkwell::module::Linkage::External),
        )?;

        Ok(())
    }

    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        context.set_current_function(runtime::FUNCTION_LOAD_IMMUTABLE_DATA)?;
+        context.set_current_function(runtime::FUNCTION_LOAD_IMMUTABLE_DATA, None)?;
        context.set_basic_block(context.current_function().borrow().entry_block());

        let immutable_data_size_pointer = context
@@ -111,6 +111,8 @@ where
        context.set_basic_block(return_block);
        context.build_return(None);

+        context.pop_debug_scope();
+
        Ok(())
    }
 }
@@ -54,11 +54,14 @@ where
    }

    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        context.set_current_function(runtime::FUNCTION_RUNTIME_CODE)?;
+        context.set_current_function(runtime::FUNCTION_RUNTIME_CODE, None)?;

        context.set_basic_block(context.current_function().borrow().entry_block());
        context.set_code_type(CodeType::Runtime);
+
        self.inner.into_llvm(context)?;
+        context.set_debug_location(0, 0, None)?;
+
        match context
            .basic_block()
            .get_last_instruction()
@@ -73,6 +76,8 @@ where
        context.set_basic_block(context.current_function().borrow().return_block());
        context.build_unreachable();

+        context.pop_debug_scope();
+
        Ok(())
    }
 }
@@ -37,7 +37,7 @@ impl<'ctx> Global<'ctx> {
            .add_global(r#type, Some(address_space.into()), name);
        let global = Self { r#type, value };

-        global.value.set_linkage(inkwell::module::Linkage::Private);
+        global.value.set_linkage(inkwell::module::Linkage::External);
        global
            .value
            .set_visibility(inkwell::GlobalVisibility::Default);
@@ -5,7 +5,7 @@ pub mod argument;
 pub mod attribute;
 pub mod build;
 pub mod code_type;
-// pub mod debug_info;
+pub mod debug_info;
 pub mod evmla_data;
 pub mod function;
 pub mod global;
@@ -21,6 +21,8 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;

+use inkwell::debug_info::AsDIScope;
+use inkwell::debug_info::DIScope;
 use inkwell::types::BasicType;
 use inkwell::values::BasicValue;

@@ -35,7 +37,7 @@ use self::address_space::AddressSpace;
 use self::attribute::Attribute;
 use self::build::Build;
 use self::code_type::CodeType;
-// use self::debug_info::DebugInfo;
+use self::debug_info::DebugInfo;
 use self::evmla_data::EVMLAData;
 use self::function::declaration::Declaration as FunctionDeclaration;
 use self::function::intrinsics::Intrinsics;
@@ -85,9 +87,9 @@ where
    /// Whether to append the metadata hash at the end of bytecode.
    include_metadata_hash: bool,
    /// The debug info of the current module.
-    // debug_info: DebugInfo<'ctx>,
+    debug_info: Option<DebugInfo<'ctx>>,
    /// The debug configuration telling whether to dump the needed IRs.
-    debug_config: Option<DebugConfig>,
+    debug_config: DebugConfig,

    /// The Solidity data.
    solidity_data: Option<SolidityData>,
@@ -138,7 +140,7 @@ where
        for import in revive_runtime_api::polkavm_imports::IMPORTS {
            module
                .get_function(import)
-                .expect("should be declared")
+                .unwrap_or_else(|| panic!("{import} import should be declared"))
                .set_linkage(inkwell::module::Linkage::External);
        }
    }
@@ -163,8 +165,9 @@ where

    fn link_immutable_data(&self, contract_path: &str) -> anyhow::Result<()> {
        let size = self.solidity().immutables_size() as u32;
-        let exports = revive_runtime_api::immutable_data::module(self.llvm(), size);
-        self.module.link_in_module(exports).map_err(|error| {
+        let immutables = revive_runtime_api::immutable_data::module(self.llvm(), size);
+
+        self.module.link_in_module(immutables).map_err(|error| {
            anyhow::anyhow!(
                "The contract `{}` immutable data module linking error: {}",
                contract_path,
@@ -200,6 +203,16 @@ where
        );
    }

+    /// Configure the revive datalayout.
+    fn set_data_layout(
+        llvm: &'ctx inkwell::context::Context,
+        module: &inkwell::module::Module<'ctx>,
+    ) {
+        let source_module = revive_stdlib::module(llvm, "revive_stdlib").unwrap();
+        let data_layout = source_module.get_data_layout();
+        module.set_data_layout(&data_layout);
+    }
+
    /// Initializes a new LLVM context.
    pub fn new(
        llvm: &'ctx inkwell::context::Context,
@@ -207,8 +220,9 @@ where
        optimizer: Optimizer,
        dependency_manager: Option<D>,
        include_metadata_hash: bool,
-        debug_config: Option<DebugConfig>,
+        debug_config: DebugConfig,
    ) -> Self {
+        Self::set_data_layout(llvm, &module);
        Self::link_stdlib_module(llvm, &module);
        Self::link_polkavm_imports(llvm, &module);
        Self::set_polkavm_stack_size(llvm, &module, Self::POLKAVM_STACK_SIZE);
@@ -216,6 +230,11 @@ where

        let intrinsics = Intrinsics::new(llvm, &module);
        let llvm_runtime = LLVMRuntime::new(llvm, &module, &optimizer);
+        let debug_info = debug_config.emit_debug_info.then(|| {
+            let debug_info = DebugInfo::new(&module);
+            debug_info.initialize_module(llvm, &module);
+            debug_info
+        });

        Self {
            llvm,
@@ -232,7 +251,8 @@ where

            dependency_manager,
            include_metadata_hash,
-            // debug_info,
+
+            debug_info,
            debug_config,

            solidity_data: None,
@@ -253,11 +273,11 @@ where
        self.link_immutable_data(contract_path)?;

        let target_machine = TargetMachine::new(Target::PVM, self.optimizer.settings())?;
-        target_machine.set_target_data(self.module());
+        self.module().set_triple(&target_machine.get_triple());
+
+        self.debug_config
+            .dump_llvm_ir_unoptimized(contract_path, self.module())?;

-        if let Some(ref debug_config) = self.debug_config {
-            debug_config.dump_llvm_ir_unoptimized(contract_path, self.module())?;
-        }
        self.verify().map_err(|error| {
            anyhow::anyhow!(
                "The contract `{}` unoptimized LLVM IR verification error: {}",
@@ -275,9 +295,10 @@ where
                    error
                )
            })?;
-        if let Some(ref debug_config) = self.debug_config {
-            debug_config.dump_llvm_ir_optimized(contract_path, self.module())?;
-        }
+
+        self.debug_config
+            .dump_llvm_ir_optimized(contract_path, self.module())?;
+
        self.verify().map_err(|error| {
            anyhow::anyhow!(
                "The contract `{}` optimized LLVM IR verification error: {}",
@@ -296,11 +317,17 @@ where
                )
            })?;

-        let bytecode = revive_linker::link(buffer.as_slice())?;
+        let shared_object = revive_linker::link(buffer.as_slice())?;
+
+        self.debug_config
+            .dump_object(contract_path, &shared_object)?;
+
+        let polkavm_bytecode =
+            revive_linker::polkavm_linker(shared_object, !self.debug_config().emit_debug_info)?;

        let build = match crate::polkavm::build_assembly_text(
            contract_path,
-            &bytecode,
+            &polkavm_bytecode,
            metadata_hash,
            self.debug_config(),
        ) {
@@ -422,6 +449,21 @@ where
    ) -> anyhow::Result<Rc<RefCell<Function<'ctx>>>> {
        let value = self.module().add_function(name, r#type, linkage);

+        if self.debug_info().is_some() {
+            self.builder().unset_current_debug_location();
+            let func_scope = match value.get_subprogram() {
+                None => {
+                    let fn_name = value.get_name().to_str()?;
+                    let scp = self.build_function_debug_info(fn_name, 0)?;
+                    value.set_subprogram(scp);
+                    scp
+                }
+                Some(scp) => scp,
+            };
+            self.push_debug_scope(func_scope.as_debug_info_scope());
+            self.set_debug_location(0, 0, Some(func_scope.as_debug_info_scope()))?;
+        }
+
        let entry_block = self.llvm.append_basic_block(value, "entry");
        let return_block = self.llvm.append_basic_block(value, "return");

@@ -455,6 +497,8 @@ where
        let function = Rc::new(RefCell::new(function));
        self.functions.insert(name.to_string(), function.clone());

+        self.pop_debug_scope();
+
        Ok(function)
    }

@@ -470,15 +514,95 @@ where
            .expect("Must be declared before use")
    }

-    /// Sets the current active function.
-    pub fn set_current_function(&mut self, name: &str) -> anyhow::Result<()> {
+    /// Sets the current active function. If debug-info generation is enabled,
+    /// constructs a debug-scope and pushes in on the scope-stack.
+    pub fn set_current_function(&mut self, name: &str, line: Option<u32>) -> anyhow::Result<()> {
        let function = self.functions.get(name).cloned().ok_or_else(|| {
            anyhow::anyhow!("Failed to activate an undeclared function `{}`", name)
        })?;
        self.current_function = Some(function);
+
+        if let Some(scope) = self.current_function().borrow().get_debug_scope() {
+            self.push_debug_scope(scope);
+        }
+        self.set_debug_location(line.unwrap_or_default(), 0, None)?;
+
        Ok(())
    }

+    /// Builds a debug-info scope for a function.
+    pub fn build_function_debug_info(
+        &self,
+        name: &str,
+        line_no: u32,
+    ) -> anyhow::Result<inkwell::debug_info::DISubprogram<'ctx>> {
+        let Some(debug_info) = self.debug_info() else {
+            anyhow::bail!("expected debug-info builders");
+        };
+        let builder = debug_info.builder();
+        let file = debug_info.compilation_unit().get_file();
+        let scope = file.as_debug_info_scope();
+        let flags = inkwell::debug_info::DIFlagsConstants::PUBLIC;
+        let return_type = debug_info.create_word_type(Some(flags))?.as_type();
+        let subroutine_type = builder.create_subroutine_type(file, Some(return_type), &[], flags);
+
+        Ok(builder.create_function(
+            scope,
+            name,
+            None,
+            file,
+            line_no,
+            subroutine_type,
+            false,
+            true,
+            1,
+            flags,
+            false,
+        ))
+    }
+
+    /// Set the debug info location.
+    ///
+    /// No-op if the emitting debug info is disabled.
+    ///
+    /// If `scope` is `None` the top scope will be used.
+    pub fn set_debug_location(
+        &self,
+        line: u32,
+        column: u32,
+        scope: Option<DIScope<'ctx>>,
+    ) -> anyhow::Result<()> {
+        let Some(debug_info) = self.debug_info() else {
+            return Ok(());
+        };
+        let scope = match scope {
+            Some(scp) => scp,
+            None => debug_info.top_scope().expect("expected a debug-info scope"),
+        };
+        let location =
+            debug_info
+                .builder()
+                .create_debug_location(self.llvm(), line, column, scope, None);
+
+        self.builder().set_current_debug_location(location);
+
+        Ok(())
+    }
+
+    /// Pushes a debug-info scope to the stack.
+    pub fn push_debug_scope(&self, scope: DIScope<'ctx>) {
+        if let Some(debug_info) = self.debug_info() {
+            debug_info.push_scope(scope);
+        }
+    }
+
+    /// Pops the top of the debug-info scope stack.
+    pub fn pop_debug_scope(&self) {
+        if let Some(debug_info) = self.debug_info() {
+            debug_info.pop_scope();
+        }
+    }
+
    /// Pushes a new loop context to the stack.
    pub fn push_loop(
        &mut self,
@@ -548,9 +672,14 @@ where
            .expect("The dependency manager is unset")
    }

+    /// Returns the debug info.
+    pub fn debug_info(&self) -> Option<&DebugInfo<'ctx>> {
+        self.debug_info.as_ref()
+    }
+
    /// Returns the debug config reference.
-    pub fn debug_config(&self) -> Option<&DebugConfig> {
-        self.debug_config.as_ref()
+    pub fn debug_config(&self) -> &DebugConfig {
+        &self.debug_config
    }

    /// Appends a new basic block to the current function.
@@ -669,22 +798,10 @@ where
                self.build_byte_swap(value)
            }
            AddressSpace::Storage | AddressSpace::TransientStorage => {
-                let storage_key_value = self.builder().build_ptr_to_int(
-                    pointer.value,
-                    self.word_type(),
-                    "storage_ptr_to_int",
-                )?;
-                let storage_key_pointer = self.build_alloca(self.word_type(), "storage_key");
-                let storage_key_pointer_casted = self.builder().build_ptr_to_int(
-                    storage_key_pointer.value,
-                    self.xlen_type(),
-                    "storage_key_pointer_casted",
-                )?;
-                self.builder()
-                    .build_store(storage_key_pointer.value, storage_key_value)?;
-
                let storage_value_pointer =
                    self.build_alloca(self.word_type(), "storage_value_pointer");
+                self.build_store(storage_value_pointer, self.word_const(0))?;
+
                let storage_value_length_pointer =
                    self.build_alloca(self.xlen_type(), "storage_value_length_pointer");
                self.build_store(
@@ -698,7 +815,7 @@ where
                    revive_runtime_api::polkavm_imports::GET_STORAGE,
                    &[
                        self.xlen_type().const_int(transient as u64, false).into(),
-                        storage_key_pointer_casted.into(),
+                        pointer.to_int(self).into(),
                        self.xlen_type().const_all_ones().into(),
                        storage_value_pointer.to_int(self).into(),
                        storage_value_length_pointer.to_int(self).into(),
@@ -767,18 +884,6 @@ where
                    self.word_type().as_basic_type_enum()
                );

-                let storage_key_value = self.builder().build_ptr_to_int(
-                    pointer.value,
-                    self.word_type(),
-                    "storage_ptr_to_int",
-                )?;
-                let storage_key_pointer = self.build_alloca(self.word_type(), "storage_key");
-                let storage_key_pointer_casted = self.builder().build_ptr_to_int(
-                    storage_key_pointer.value,
-                    self.xlen_type(),
-                    "storage_key_pointer_casted",
-                )?;
-
                let storage_value_pointer = self.build_alloca(self.word_type(), "storage_value");
                let storage_value_pointer_casted = self.builder().build_ptr_to_int(
                    storage_value_pointer.value,
@@ -786,8 +891,6 @@ where
                    "storage_value_pointer_casted",
                )?;

-                self.builder()
-                    .build_store(storage_key_pointer.value, storage_key_value)?;
                self.builder()
                    .build_store(storage_value_pointer.value, value)?;

@@ -797,7 +900,7 @@ where
                    revive_runtime_api::polkavm_imports::SET_STORAGE,
                    &[
                        self.xlen_type().const_int(transient as u64, false).into(),
-                        storage_key_pointer_casted.into(),
+                        pointer.to_int(self).into(),
                        self.xlen_type().const_all_ones().into(),
                        storage_value_pointer_casted.into(),
                        self.integer_const(crate::polkavm::XLEN, 32).into(),
@@ -15,7 +15,7 @@ pub fn create_context(
    let module = llvm.create_module("test");
    let optimizer = Optimizer::new(optimizer_settings);

-    Context::<DummyDependency>::new(llvm, module, optimizer, None, true, None)
+    Context::<DummyDependency>::new(llvm, module, optimizer, None, true, Default::default())
 }

 #[test]
@@ -13,7 +13,7 @@ const REENTRANT_CALL_FLAG: u32 = 0b0000_1000;
 #[allow(clippy::too_many_arguments)]
 pub fn call<'ctx, D>(
    context: &mut Context<'ctx, D>,
-    _gas: inkwell::values::IntValue<'ctx>,
+    gas: inkwell::values::IntValue<'ctx>,
    address: inkwell::values::IntValue<'ctx>,
    value: Option<inkwell::values::IntValue<'ctx>>,
    input_offset: inkwell::values::IntValue<'ctx>,
@@ -40,7 +40,7 @@ where
    // TODO: What to supply here? Is there a weight to gas?
    let _gas = context
        .builder()
-        .build_int_truncate(_gas, context.integer_type(64), "gas")?;
+        .build_int_truncate(gas, context.integer_type(64), "gas")?;

    let input_pointer = context.build_heap_gep(input_offset, input_length)?;
    let output_pointer = context.build_heap_gep(output_offset, output_length)?;
@@ -60,8 +60,8 @@ where
    let arguments = &[
        flags.as_basic_value_enum(),
        address_pointer.value.as_basic_value_enum(),
-        context.integer_const(64, 0).as_basic_value_enum(),
-        context.integer_const(64, 0).as_basic_value_enum(),
+        context.integer_const(64, u64::MAX).as_basic_value_enum(),
+        context.integer_const(64, u64::MAX).as_basic_value_enum(),
        context.sentinel_pointer().value.as_basic_value_enum(),
        value_pointer.value.as_basic_value_enum(),
        input_pointer.value.as_basic_value_enum(),
@@ -90,7 +90,7 @@ where
    let is_success = context.builder().build_int_compare(
        inkwell::IntPredicate::EQ,
        success,
-        context.xlen_type().const_zero(),
+        context.integer_const(revive_common::BIT_LENGTH_X64, 0),
        "is_success",
    )?;

@@ -102,20 +102,84 @@ where

 #[allow(clippy::too_many_arguments)]
 pub fn delegate_call<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-    _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>,
+    context: &mut Context<'ctx, D>,
+    gas: inkwell::values::IntValue<'ctx>,
+    address: 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 address_pointer = context.build_address_argument_store(address)?;
+
+    let input_offset = context.safe_truncate_int_to_xlen(input_offset)?;
+    let input_length = context.safe_truncate_int_to_xlen(input_length)?;
+    let output_offset = context.safe_truncate_int_to_xlen(output_offset)?;
+    let output_length = context.safe_truncate_int_to_xlen(output_length)?;
+
+    // TODO: What to supply here? Is there a weight to gas?
+    let _gas = context
+        .builder()
+        .build_int_truncate(gas, context.integer_type(64), "gas")?;
+
+    let input_pointer = context.build_heap_gep(input_offset, input_length)?;
+    let output_pointer = context.build_heap_gep(output_offset, output_length)?;
+
+    let output_length_pointer = context.build_alloca_at_entry(context.xlen_type(), "output_length");
+    context.build_store(output_length_pointer, output_length)?;
+
+    let flags = context.xlen_type().const_int(0u64, false);
+
+    let argument_type = revive_runtime_api::calling_convention::delegate_call(context.llvm());
+    let argument_pointer = context.build_alloca_at_entry(argument_type, "delegate_call_arguments");
+    let arguments = &[
+        flags.as_basic_value_enum(),
+        address_pointer.value.as_basic_value_enum(),
+        context
+            .integer_const(revive_common::BIT_LENGTH_X64, u64::MAX)
+            .as_basic_value_enum(),
+        context
+            .integer_const(revive_common::BIT_LENGTH_X64, u64::MAX)
+            .as_basic_value_enum(),
+        context.sentinel_pointer().value.as_basic_value_enum(),
+        input_pointer.value.as_basic_value_enum(),
+        input_length.as_basic_value_enum(),
+        output_pointer.value.as_basic_value_enum(),
+        output_length_pointer.value.as_basic_value_enum(),
+    ];
+    revive_runtime_api::calling_convention::spill(
+        context.builder(),
+        argument_pointer.value,
+        argument_type,
+        arguments,
+    )?;
+
+    let name = revive_runtime_api::polkavm_imports::DELEGATE_CALL;
+    let argument_pointer = context.builder().build_ptr_to_int(
+        argument_pointer.value,
+        context.xlen_type(),
+        "delegate_call_argument_pointer",
+    )?;
+    let success = context
+        .build_runtime_call(name, &[argument_pointer.into()])
+        .unwrap_or_else(|| panic!("{name} should return a value"))
+        .into_int_value();
+
+    let is_success = context.builder().build_int_compare(
+        inkwell::IntPredicate::EQ,
+        success,
+        context.integer_const(revive_common::BIT_LENGTH_X64, 0),
+        "is_success",
+    )?;
+
+    Ok(context
+        .builder()
+        .build_int_z_extend(is_success, context.word_type(), "success")?
+        .as_basic_value_enum())
 }

 /// Translates the Yul `linkersymbol` instruction.
@@ -1,10 +1,7 @@
 //! Translates the calldata instructions.

-use crate::polkavm::context::address_space::AddressSpace;
-use crate::polkavm::context::pointer::Pointer;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
-use inkwell::types::BasicType;

 /// Translates the calldata load.
 pub fn load<'ctx, D>(
@@ -14,19 +11,15 @@ pub fn load<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let calldata_pointer = context
-        .get_global(crate::polkavm::GLOBAL_CALLDATA_POINTER)?
-        .value
-        .as_pointer_value();
-    let offset = context.build_gep(
-        Pointer::new(context.byte_type(), AddressSpace::Stack, calldata_pointer),
-        &[offset],
-        context.word_type().as_basic_type_enum(),
-        "calldata_pointer_with_offset",
+    let output_pointer = context.build_alloca_at_entry(context.word_type(), "call_data_output");
+    let offset = context.safe_truncate_int_to_xlen(offset)?;
+
+    context.build_runtime_call(
+        revive_runtime_api::polkavm_imports::CALL_DATA_LOAD,
+        &[output_pointer.to_int(context).into(), offset.into()],
    );
-    context
-        .build_load(offset, "calldata_value")
-        .and_then(|value| context.build_byte_swap(value))
+
+    context.build_load(output_pointer, "call_data_load_value")
 }

 /// Translates the calldata size.
@@ -37,8 +30,14 @@ where
    D: Dependency + Clone,
 {
    let value = context.get_global_value(crate::polkavm::GLOBAL_CALLDATA_SIZE)?;
-
-    Ok(value)
+    Ok(context
+        .builder()
+        .build_int_z_extend(
+            value.into_int_value(),
+            context.word_type(),
+            "call_data_size_value",
+        )?
+        .into())
 }

 /// Translates the calldata copy.
@@ -51,20 +50,19 @@ pub fn copy<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let offset = context.safe_truncate_int_to_xlen(destination_offset)?;
+    let source_offset = context.safe_truncate_int_to_xlen(source_offset)?;
    let size = context.safe_truncate_int_to_xlen(size)?;
-    let destination = context.build_heap_gep(offset, size)?;
+    let destination_offset = context.safe_truncate_int_to_xlen(destination_offset)?;
+    let output_pointer = context.build_heap_gep(destination_offset, size)?;

-    let calldata_pointer = context
-        .get_global(crate::polkavm::GLOBAL_CALLDATA_POINTER)?
-        .value
-        .as_pointer_value();
-    let source = context.build_gep(
-        Pointer::new(context.byte_type(), AddressSpace::Stack, calldata_pointer),
-        &[context.safe_truncate_int_to_xlen(source_offset)?],
-        context.byte_type(),
-        "calldata_pointer_with_offset",
+    context.build_runtime_call(
+        revive_runtime_api::polkavm_imports::CALL_DATA_COPY,
+        &[
+            output_pointer.to_int(context).into(),
+            size.into(),
+            source_offset.into(),
+        ],
    );

-    context.build_memcpy(destination, source, size, "calldata_copy_memcpy_from_child")
+    Ok(())
 }
@@ -7,32 +7,55 @@ use crate::polkavm::Dependency;

 /// Translates the `gas_limit` instruction.
 pub fn gas_limit<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
+    context: &mut Context<'ctx, D>,
 ) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
 where
    D: Dependency + Clone,
 {
-    todo!()
+    let gas_limit_value = context
+        .build_runtime_call(revive_runtime_api::polkavm_imports::GAS_LIMIT, &[])
+        .expect("the gas_limit syscall method should return a value")
+        .into_int_value();
+
+    Ok(context
+        .builder()
+        .build_int_z_extend(gas_limit_value, context.word_type(), "gas_limit")?
+        .into())
 }

 /// Translates the `gas_price` instruction.
 pub fn gas_price<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
+    context: &mut Context<'ctx, D>,
 ) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
 where
    D: Dependency + Clone,
 {
-    todo!()
+    let gas_price_value = context
+        .build_runtime_call(revive_runtime_api::polkavm_imports::GAS_PRICE, &[])
+        .expect("the gas_price syscall method should return a value")
+        .into_int_value();
+
+    Ok(context
+        .builder()
+        .build_int_z_extend(gas_price_value, context.word_type(), "gas_price")?
+        .into())
 }

 /// Translates the `tx.origin` instruction.
 pub fn origin<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
+    context: &mut Context<'ctx, D>,
 ) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
 where
    D: Dependency + Clone,
 {
-    todo!()
+    let address_type = context.integer_type(revive_common::BIT_LENGTH_ETH_ADDRESS);
+    let address_pointer = context.build_alloca_at_entry(address_type, "origin_address");
+    context.build_store(address_pointer, address_type.const_zero())?;
+    context.build_runtime_call(
+        revive_runtime_api::polkavm_imports::ORIGIN,
+        &[address_pointer.to_int(context).into()],
+    );
+    context.build_load_address(address_pointer)
 }

 /// Translates the `chain_id` instruction.
@@ -67,13 +90,24 @@ where

 /// Translates the `block_hash` instruction.
 pub fn block_hash<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
-    _index: inkwell::values::IntValue<'ctx>,
+    context: &mut Context<'ctx, D>,
+    index: inkwell::values::IntValue<'ctx>,
 ) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
 where
    D: Dependency + Clone,
 {
-    todo!()
+    let output_pointer = context.build_alloca_at_entry(context.word_type(), "blockhash_out_ptr");
+    let index_ptr = context.build_alloca_at_entry(context.word_type(), "blockhash_index_ptr");
+    context.build_store(index_ptr, index)?;
+
+    context.build_runtime_call(
+        revive_runtime_api::polkavm_imports::BLOCK_HASH,
+        &[
+            index_ptr.to_int(context).into(),
+            output_pointer.to_int(context).into(),
+        ],
+    );
+    context.build_byte_swap(context.build_load(output_pointer, "block_hash")?)
 }

 /// Translates the `difficulty` instruction.
@@ -103,7 +137,7 @@ pub fn basefee<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    Ok(context.word_const(0).as_basic_value_enum())
+    context.build_runtime_call_to_getter(revive_runtime_api::polkavm_imports::BASE_FEE)
 }

 /// Translates the `address` instruction.
@@ -1,7 +1,5 @@
 //! Translates the value and balance operations.

-use inkwell::values::BasicValue;
-
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;

@@ -12,7 +10,15 @@ pub fn gas<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    Ok(context.integer_const(256, 0).as_basic_value_enum())
+    let ref_time_left_value = context
+        .build_runtime_call(revive_runtime_api::polkavm_imports::REF_TIME_LEFT, &[])
+        .expect("the ref_time_left syscall method should return a value")
+        .into_int_value();
+
+    Ok(context
+        .builder()
+        .build_int_z_extend(ref_time_left_value, context.word_type(), "gas_left")?
+        .into())
 }

 /// Translates the `value` instruction.
@@ -1,7 +1,5 @@
 //! Translates the external code operations.

-use inkwell::values::BasicValue;
-
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;

@@ -14,37 +12,24 @@ pub fn size<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let address_pointer = match address {
-        Some(address) => {
-            let address_pointer = context.build_alloca(context.word_type(), "value");
-            context.build_store(address_pointer, address)?;
-            address_pointer
-        }
-        None => context.sentinel_pointer(),
+    let address = match address {
+        Some(address) => address,
+        None => super::context::address(context)?.into_int_value(),
    };
+    let address_pointer = context.build_address_argument_store(address)?;

-    let address_pointer_casted = context.builder().build_ptr_to_int(
-        address_pointer.value,
-        context.xlen_type(),
-        "address_pointer",
-    )?;
-    let value = context
+    let code_size_value = context
        .build_runtime_call(
            revive_runtime_api::polkavm_imports::CODE_SIZE,
-            &[address_pointer_casted.into()],
+            &[address_pointer.to_int(context).into()],
        )
-        .unwrap_or_else(|| {
-            panic!(
-                "{} should return a value",
-                revive_runtime_api::polkavm_imports::CODE_SIZE
-            )
-        })
+        .expect("the code_size syscall method should return a value")
        .into_int_value();

    Ok(context
        .builder()
-        .build_int_z_extend(value, context.word_type(), "extcodesize")?
-        .as_basic_value_enum())
+        .build_int_z_extend(code_size_value, context.word_type(), "code_size")?
+        .into())
 }

 /// Translates the `extcodehash` instruction.
@@ -10,17 +10,19 @@ pub fn size<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let output_pointer = context.build_alloca_at_entry(context.word_type(), "return_data_size");
-    let output_pointer_parameter = context.builder().build_ptr_to_int(
-        output_pointer.value,
-        context.xlen_type(),
-        "return_data_copy_output_pointer",
-    )?;
-    context.build_runtime_call(
-        revive_runtime_api::polkavm_imports::RETURNDATASIZE,
-        &[output_pointer_parameter.into()],
-    );
-    context.build_load(output_pointer, "return_data_size_load")
+    let return_data_size_value = context
+        .build_runtime_call(revive_runtime_api::polkavm_imports::RETURNDATASIZE, &[])
+        .expect("the return_data_size syscall method should return a value")
+        .into_int_value();
+
+    Ok(context
+        .builder()
+        .build_int_z_extend(
+            return_data_size_value,
+            context.word_type(),
+            "return_data_size",
+        )?
+        .into())
 }

 /// Translates the return data copy, trapping if
@@ -1,7 +1,6 @@
 //! Translates the storage operations.

 use crate::polkavm::context::address_space::AddressSpace;
-use crate::polkavm::context::pointer::Pointer;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;

@@ -13,14 +12,10 @@ pub fn load<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let position_pointer = Pointer::new_with_offset(
-        context,
-        AddressSpace::Storage,
-        context.word_type(),
-        position,
-        "storage_load_position_pointer",
-    );
-    context.build_load(position_pointer, "storage_load_value")
+    let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
+    slot_ptr.address_space = AddressSpace::Storage;
+    context.builder().build_store(slot_ptr.value, position)?;
+    context.build_load(slot_ptr, "storage_load_value")
 }

 /// Translates the storage store.
@@ -32,14 +27,10 @@ pub fn store<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let position_pointer = Pointer::new_with_offset(
-        context,
-        AddressSpace::Storage,
-        context.word_type(),
-        position,
-        "storage_store_position_pointer",
-    );
-    context.build_store(position_pointer, value)?;
+    let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
+    slot_ptr.address_space = AddressSpace::Storage;
+    context.builder().build_store(slot_ptr.value, position)?;
+    context.build_store(slot_ptr, value)?;
    Ok(())
 }

@@ -51,14 +42,10 @@ pub fn transient_load<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let position_pointer = Pointer::new_with_offset(
-        context,
-        AddressSpace::TransientStorage,
-        context.word_type(),
-        position,
-        "transient_storage_load_position_pointer",
-    );
-    context.build_load(position_pointer, "transient_storage_load_value")
+    let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
+    slot_ptr.address_space = AddressSpace::TransientStorage;
+    context.builder().build_store(slot_ptr.value, position)?;
+    context.build_load(slot_ptr, "transient_storage_load_value")
 }

 /// Translates the transient storage store.
@@ -70,13 +57,9 @@ pub fn transient_store<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let position_pointer = Pointer::new_with_offset(
-        context,
-        AddressSpace::TransientStorage,
-        context.word_type(),
-        position,
-        "transient_storage_store_position_pointer",
-    );
-    context.build_store(position_pointer, value)?;
+    let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
+    slot_ptr.address_space = AddressSpace::TransientStorage;
+    context.builder().build_store(slot_ptr.value, position)?;
+    context.build_store(slot_ptr, value)?;
    Ok(())
 }
@@ -4,10 +4,8 @@ pub mod r#const;
 pub mod context;
 pub mod evm;
 pub mod metadata_hash;
-pub mod utils;

 pub use self::r#const::*;
-use self::utils::keccak256;

 use crate::debug_config::DebugConfig;
 use crate::optimizer::settings::Settings as OptimizerSettings;
@@ -15,6 +13,7 @@ use crate::optimizer::settings::Settings as OptimizerSettings;
 use anyhow::Context as AnyhowContext;
 use polkavm_common::program::ProgramBlob;
 use polkavm_disassembler::{Disassembler, DisassemblyFormat};
+use sha3::Digest;

 use self::context::build::Build;
 use self::context::Context;
@@ -29,7 +28,7 @@ pub fn build_assembly_text(
    contract_path: &str,
    bytecode: &[u8],
    metadata_hash: Option<[u8; revive_common::BYTE_LENGTH_WORD]>,
-    debug_config: Option<&DebugConfig>,
+    debug_config: &DebugConfig,
 ) -> anyhow::Result<Build> {
    let program_blob = ProgramBlob::parse(bytecode.into())
        .map_err(anyhow::Error::msg)
@@ -49,15 +48,13 @@ pub fn build_assembly_text(
        format!("Failed to convert disassembled code to string for contract: {contract_path}")
    })?;

-    if let Some(debug_config) = debug_config {
-        debug_config.dump_assembly(contract_path, &assembly_text)?;
-    }
+    debug_config.dump_assembly(contract_path, &assembly_text)?;

    Ok(Build::new(
        assembly_text.to_owned(),
        metadata_hash,
        bytecode.to_owned(),
-        keccak256(bytecode),
+        hex::encode(sha3::Keccak256::digest(bytecode)),
    ))
 }

@@ -98,7 +95,7 @@ pub trait Dependency {
        path: &str,
        optimizer_settings: OptimizerSettings,
        include_metadata_hash: bool,
-        debug_config: Option<DebugConfig>,
+        debug_config: DebugConfig,
    ) -> anyhow::Result<String>;

    /// Resolves a full contract path.
@@ -118,7 +115,7 @@ impl Dependency for DummyDependency {
        _path: &str,
        _optimizer_settings: OptimizerSettings,
        _include_metadata_hash: bool,
-        _debug_config: Option<DebugConfig>,
+        _debug_config: DebugConfig,
    ) -> anyhow::Result<String> {
        Ok(String::new())
    }
@@ -1,60 +0,0 @@
-//! Some LLVM IR generator utilies.
-
-use crate::polkavm::context::Context;
-use crate::polkavm::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.word_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())
-}
-
-/// 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"
-        );
-    }
-}
@@ -20,28 +20,16 @@ pub struct TargetMachine {

 impl TargetMachine {
    /// The LLVM target name.
-    #[cfg(not(feature = "riscv-64"))]
-    pub const VM_TARGET_NAME: &'static str = "riscv32";
-    #[cfg(feature = "riscv-64")]
    pub const VM_TARGET_NAME: &'static str = "riscv64";

    /// The LLVM target triple.
-    #[cfg(not(feature = "riscv-64"))]
-    pub const VM_TARGET_TRIPLE: &'static str = "riscv32-unknown-unknown-elf";
-    #[cfg(feature = "riscv-64")]
    pub const VM_TARGET_TRIPLE: &'static str = "riscv64-unknown-unknown-elf";

-    /// The LLVM target cpu
-    #[cfg(not(feature = "riscv-64"))]
-    pub const VM_TARGET_CPU: &'static str = "generic-rv32";
-    #[cfg(feature = "riscv-64")]
    pub const VM_TARGET_CPU: &'static str = "generic-rv64";

    /// LLVM target features.
-    #[cfg(feature = "riscv-zbb")]
-    pub const VM_FEATURES: &'static str = "+zbb,+e,+m,+c";
-    #[cfg(not(feature = "riscv-zbb"))]
-    pub const VM_FEATURES: &'static str = "+e,+m,+c";
+    pub const VM_FEATURES: &'static str =
+        "+e,+m,+a,+c,+zbb,+auipc-addi-fusion,+ld-add-fusion,+lui-addi-fusion,+xtheadcondmov";

    /// A shortcut constructor.
    /// A separate instance for every optimization level is created.
@@ -70,12 +58,6 @@ impl TargetMachine {
        })
    }

-    /// Sets the target-specific data in the module.
-    pub fn set_target_data(&self, module: &inkwell::module::Module) {
-        module.set_triple(&self.target_machine.get_triple());
-        module.set_data_layout(&self.target_machine.get_target_data().get_data_layout());
-    }
-
    /// Writes the LLVM module to a memory buffer.
    pub fn write_to_memory_buffer(
        &self,
@@ -13,9 +13,6 @@ impl Target {
    /// Returns the target name.
    pub fn name(&self) -> &str {
        match self {
-            #[cfg(not(feature = "riscv-64"))]
-            Self::PVM => "riscv32",
-            #[cfg(feature = "riscv-64")]
            Self::PVM => "riscv64",
        }
    }
@@ -23,9 +20,6 @@ impl Target {
    /// Returns the target triple.
    pub fn triple(&self) -> &str {
        match self {
-            #[cfg(not(feature = "riscv-64"))]
-            Self::PVM => "riscv32-unknown-unknown-elf",
-            #[cfg(feature = "riscv-64")]
            Self::PVM => "riscv64-unknown-unknown-elf",
        }
    }
@@ -43,9 +37,6 @@ impl FromStr for Target {

    fn from_str(string: &str) -> Result<Self, Self::Err> {
        match string {
-            #[cfg(not(feature = "riscv-64"))]
-            "riscv32" => Ok(Self::PVM),
-            #[cfg(feature = "riscv-64")]
            "riscv64" => Ok(Self::PVM),
            _ => Err(anyhow::anyhow!(
                "Unknown target `{}`. Supported targets: {:?}",
@@ -59,9 +50,6 @@ impl FromStr for Target {
 impl std::fmt::Display for Target {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            #[cfg(not(feature = "riscv-64"))]
-            Target::PVM => write!(f, "riscv32"),
-            #[cfg(feature = "riscv-64")]
            Target::PVM => write!(f, "riscv64"),
        }
    }
@@ -55,7 +55,7 @@ pub const BOB: H160 = H160([2u8; 20]);
 /// The charlie test account
 pub const CHARLIE: H160 = H160([3u8; 20]);
 /// Default gas limit
-pub const GAS_LIMIT: Weight = Weight::from_parts(100_000_000_000, 3 * 1024 * 1024);
+pub const GAS_LIMIT: Weight = Weight::from_parts(100_000_000_000_000, 3 * 1024 * 1024 * 1024);
 /// Default deposit limit
 pub const DEPOSIT_LIMIT: Balance = 10_000_000;

@@ -72,7 +72,7 @@ impl ExtBuilder {
        Self {
            balance_genesis_config: value
                .iter()
-                .map(|(address, balance)| (AccountId::to_account_id(address), *balance))
+                .map(|(address, balance)| (AccountId::to_fallback_account_id(address), *balance))
                .collect(),
        }
    }
@@ -246,7 +246,7 @@ pub enum Code {
    /// A contract blob
    Bytes(Vec<u8>),
    /// Pre-existing contract hash
-    Hash(Hash),
+    Hash(crate::runtime::Hash),
 }

 impl Default for Code {
@@ -1,5 +1,6 @@
-use frame_support::runtime;
+use frame_support::{runtime, weights::constants::WEIGHT_REF_TIME_PER_SECOND};

+use pallet_revive::AccountId32Mapper;
 use polkadot_sdk::*;
 use polkadot_sdk::{
    polkadot_sdk_frame::{log, runtime::prelude::*},
@@ -7,7 +8,7 @@ use polkadot_sdk::{
 };

 pub type Balance = u128;
-pub type AccountId = pallet_revive::DefaultAddressMapper;
+pub type AccountId = pallet_revive::AccountId32Mapper<Runtime>;
 pub type Block = frame_system::mocking::MockBlock<Runtime>;
 pub type Hash = <Runtime as frame_system::Config>::Hash;
 pub type EventRecord =
@@ -45,6 +46,7 @@ mod runtime {
 #[derive_impl(frame_system::config_preludes::SolochainDefaultConfig)]
 impl frame_system::Config for Runtime {
    type Block = Block;
+    type BlockWeights = BlockWeights;
    type AccountId = AccountId32;
    type AccountData = pallet_balances::AccountData<<Runtime as pallet_balances::Config>::Balance>;
 }
@@ -64,6 +66,10 @@ parameter_types! {
    pub const DepositPerByte: Balance = 1;
    pub const DepositPerItem: Balance = 2;
    pub const CodeHashLockupDepositPercent: Perbill = Perbill::from_percent(0);
+    pub BlockWeights: frame_system::limits::BlockWeights =
+        frame_system::limits::BlockWeights::simple_max(
+            Weight::from_parts(2u64 * WEIGHT_REF_TIME_PER_SECOND, u64::MAX),
+        );
 }

 #[derive_impl(pallet_revive::config_preludes::TestDefaultConfig)]
@@ -74,7 +80,7 @@ impl pallet_revive::Config for Runtime {
    type ChainExtension = ();
    type DepositPerByte = DepositPerByte;
    type DepositPerItem = DepositPerItem;
-    type AddressMapper = AccountId;
+    type AddressMapper = AccountId32Mapper<Self>;
    type RuntimeMemory = ConstU32<{ 512 * 1024 * 1024 }>;
    type PVFMemory = ConstU32<{ 1024 * 1024 * 1024 }>;
    type UnsafeUnstableInterface = UnstableInterface;
@@ -1,6 +1,5 @@
 use std::time::Instant;

-use pallet_revive::AddressMapper;
 use serde::{Deserialize, Serialize};

 use crate::*;
@@ -422,7 +421,7 @@ impl Specs {
                                origin,
                                value,
                                gas_limit.unwrap_or(GAS_LIMIT),
-                                storage_deposit_limit.unwrap_or(DEPOSIT_LIMIT),
+                                storage_deposit_limit.unwrap_or(DEPOSIT_LIMIT).into(),
                                code,
                                data,
                                salt.0,
@@ -462,7 +461,7 @@ impl Specs {
                                dest.to_eth_addr(&results),
                                value,
                                gas_limit.unwrap_or(GAS_LIMIT),
-                                storage_deposit_limit.unwrap_or(DEPOSIT_LIMIT),
+                                storage_deposit_limit.unwrap_or(DEPOSIT_LIMIT).into(),
                                data,
                                DebugInfo::Skip,
                                CollectEvents::Skip,
@@ -7,9 +7,6 @@ repository.workspace = true
 authors.workspace = true
 description = "Implements the low level runtime API bindings with pallet contracts"

-[features]
-riscv-64 = []
-
 [dependencies]
 anyhow = { workspace = true }
 inkwell = { workspace = true, features = ["target-riscv", "no-libffi-linking", "llvm18-0"] }
@@ -1,23 +1,8 @@
 use std::{env, fs, path::Path, process::Command};

-#[cfg(not(feature = "riscv-64"))]
-const TARGET_TRIPLE_FLAG: &str = "-triple=riscv32-unknown-unknown-elf";
-#[cfg(feature = "riscv-64")]
 const TARGET_TRIPLE_FLAG: &str = "-triple=riscv64-unknown-unknown-elf";
-
-#[cfg(not(feature = "riscv-64"))]
-const TARGET_FLAG: &str = "--target=riscv32";
-#[cfg(feature = "riscv-64")]
 const TARGET_FLAG: &str = "--target=riscv64";
-
-#[cfg(not(feature = "riscv-64"))]
-const TARGET_ARCH_FLAG: &str = "-march=rv32em";
-#[cfg(feature = "riscv-64")]
-const TARGET_ARCH_FLAG: &str = "-march=rv64em";
-
-#[cfg(not(feature = "riscv-64"))]
-const TARGET_ABI_FLAG: &str = "-mabi=ilp32e";
-#[cfg(feature = "riscv-64")]
+const TARGET_ARCH_FLAG: &str = "-march=rv64emac";
 const TARGET_ABI_FLAG: &str = "-mabi=lp64e";

 const IMPORTS_SOUCE: &str = "src/polkavm_imports.c";
@@ -36,6 +21,10 @@ fn compile(source_path: &str, bitcode_path: &str) {
            TARGET_TRIPLE_FLAG,
            TARGET_ARCH_FLAG,
            TARGET_ABI_FLAG,
+            "-Xclang",
+            "-target-feature",
+            "-Xclang",
+            "+fast-unaligned-access,+xtheadcondmov",
            "-fno-exceptions",
            "-ffreestanding",
            "-Wall",
@@ -52,29 +52,29 @@ pub fn instantiate(context: &Context) -> StructType {
    context.struct_type(
        &[
            // code_hash_ptr: u32,
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
            // ref_time_limit: u64,
            context.i64_type().as_basic_type_enum(),
            // proof_size_limit: u64,
            context.i64_type().as_basic_type_enum(),
            // deposit_ptr: u32,
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
            // value_ptr: u32,
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
            // input_data_ptr: u32,
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
            // input_data_len: u32,
            context.i32_type().as_basic_type_enum(),
            // address_ptr: u32,
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
            // output_ptr: u32,
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
            // output_len_ptr: u32,
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
            // salt_ptr: u32,
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
        ],
-        true,
+        false,
    )
 }

@@ -85,24 +85,51 @@ pub fn call(context: &Context) -> StructType {
            // flags: u32,
            context.i32_type().as_basic_type_enum(),
            // address_ptr:
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
            // ref_time_limit: u64,
            context.i64_type().as_basic_type_enum(),
            // proof_size_limit: u64,
            context.i64_type().as_basic_type_enum(),
            // deposit_ptr: u32,
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
            // value_ptr: u32,
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
            // input_data_ptr: u32,
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
            // input_data_len: u32,
            context.i32_type().as_basic_type_enum(),
            // output_ptr: u32,
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
            // output_len_ptr: u32,
-            context.ptr_type(Default::default()).as_basic_type_enum(),
+            context.i32_type().as_basic_type_enum(),
        ],
-        true,
+        false,
+    )
+}
+
+/// Returns a packed struct argument type for the `delegate_call` API.
+pub fn delegate_call(context: &Context) -> StructType {
+    context.struct_type(
+        &[
+            // flags: u32,
+            context.i32_type().as_basic_type_enum(),
+            // address_ptr:
+            context.i32_type().as_basic_type_enum(),
+            // ref_time_limit: u64,
+            context.i64_type().as_basic_type_enum(),
+            // proof_size_limit: u64,
+            context.i64_type().as_basic_type_enum(),
+            // deposit_ptr: u32,
+            context.i32_type().as_basic_type_enum(),
+            // input_data_ptr: u32,
+            context.i32_type().as_basic_type_enum(),
+            // input_data_len: u32,
+            context.i32_type().as_basic_type_enum(),
+            // output_ptr: u32,
+            context.i32_type().as_basic_type_enum(),
+            // output_len_ptr: u32,
+            context.i32_type().as_basic_type_enum(),
+        ],
+        false,
    )
 }
@@ -9,7 +9,11 @@

 #define POLKAVM_REGS_FOR_TY_void 0
 #define POLKAVM_REGS_FOR_TY_i32 1
-#define POLKAVM_REGS_FOR_TY_i64 2
+#ifdef _LP64
+    #define POLKAVM_REGS_FOR_TY_i64 1
+#else
+    #define POLKAVM_REGS_FOR_TY_i64 2
+#endif

 #define POLKAVM_REGS_FOR_TY_int8_t    POLKAVM_REGS_FOR_TY_i32
 #define POLKAVM_REGS_FOR_TY_uint8_t   POLKAVM_REGS_FOR_TY_i32
@@ -107,6 +111,26 @@ struct PolkaVM_Metadata {
    unsigned char output_regs;
 } __attribute__ ((packed));

+#ifdef _LP64
+    #define POLKAVM_EXPORT_DEF()  \
+        ".quad %[metadata]\n" \
+        ".quad %[function]\n"
+#else
+    #define POLKAVM_EXPORT_DEF()  \
+        ".word %[metadata]\n" \
+        ".word %[function]\n"
+#endif
+
+#ifdef _LP64
+    #define POLKAVM_IMPORT_DEF()  \
+        ".word 0x0000000b\n" \
+        ".quad %[metadata]\n"
+#else
+    #define POLKAVM_IMPORT_DEF()  \
+        ".word 0x0000000b\n" \
+        ".word %[metadata]\n"
+#endif
+
 #define POLKAVM_EXPORT(arg_return_ty, fn_name, ...) \
 static struct PolkaVM_Metadata POLKAVM_JOIN(fn_name, __EXPORT_METADATA) __attribute__ ((section(".polkavm_metadata"))) = { \
    1, 0, sizeof(#fn_name) - 1, #fn_name, POLKAVM_COUNT_REGS(__VA_ARGS__), POLKAVM_COUNT_REGS(arg_return_ty) \
@@ -115,8 +139,7 @@ static void __attribute__ ((naked, used)) POLKAVM_UNIQUE(polkavm_export_dummy)()
    __asm__( \
        ".pushsection .polkavm_exports,\"R\",@note\n" \
        ".byte 1\n" \
-        ".word %[metadata]\n" \
-        ".word %[function]\n" \
+        POLKAVM_EXPORT_DEF() \
        ".popsection\n" \
        : \
        : \
@@ -130,10 +153,9 @@ static void __attribute__ ((naked, used)) POLKAVM_UNIQUE(polkavm_export_dummy)()
 static struct PolkaVM_Metadata POLKAVM_JOIN(fn_name, __IMPORT_METADATA) __attribute__ ((section(".polkavm_metadata"))) = { \
    1, 0, sizeof(#fn_name) - 1, #fn_name, POLKAVM_COUNT_REGS(__VA_ARGS__), POLKAVM_COUNT_REGS(arg_return_ty) \
 }; \
-static arg_return_ty __attribute__ ((naked, used)) fn_name(POLKAVM_IMPORT_ARGS_IMPL(__VA_ARGS__)) { \
+static arg_return_ty __attribute__ ((used, naked)) fn_name(POLKAVM_IMPORT_ARGS_IMPL(__VA_ARGS__)) { \
    __asm__( \
-        ".word 0x0000000b\n" \
-        ".word %[metadata]\n" \
+        POLKAVM_IMPORT_DEF() \
        "ret\n" \
        : \
        : \
@@ -70,40 +70,60 @@ POLKAVM_IMPORT(void, balance, uint32_t)

 POLKAVM_IMPORT(void, balance_of, uint32_t, uint32_t)

+POLKAVM_IMPORT(void, base_fee, uint32_t)
+
+POLKAVM_IMPORT(void, block_hash, uint32_t, uint32_t)
+
 POLKAVM_IMPORT(void, block_number, uint32_t)

-POLKAVM_IMPORT(uint32_t, call, uint32_t)
+POLKAVM_IMPORT(uint64_t, call, uint32_t)
+
+POLKAVM_IMPORT(uint64_t, call_data_copy, uint32_t, uint32_t, uint32_t)
+
+POLKAVM_IMPORT(uint64_t, call_data_load, uint32_t, uint32_t)
+
+POLKAVM_IMPORT(uint64_t, call_data_size)

 POLKAVM_IMPORT(void, caller, uint32_t)

 POLKAVM_IMPORT(void, chain_id, uint32_t)

-POLKAVM_IMPORT(uint32_t, code_size, uint32_t)
+POLKAVM_IMPORT(uint64_t, code_size, uint32_t)

 POLKAVM_IMPORT(void, code_hash, uint32_t, uint32_t)

+POLKAVM_IMPORT(uint64_t, delegate_call, uint32_t)
+
 POLKAVM_IMPORT(void, deposit_event, uint32_t, uint32_t, uint32_t, uint32_t)

+POLKAVM_IMPORT(uint64_t, gas_limit);
+
+POLKAVM_IMPORT(uint64_t, gas_price);
+
 POLKAVM_IMPORT(void, get_immutable_data, uint32_t, uint32_t);

-POLKAVM_IMPORT(uint32_t, get_storage, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)
+POLKAVM_IMPORT(uint64_t, get_storage, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)

 POLKAVM_IMPORT(void, hash_keccak_256, uint32_t, uint32_t, uint32_t)

-POLKAVM_IMPORT(void, input, uint32_t, uint32_t)
-
-POLKAVM_IMPORT(uint32_t, instantiate, uint32_t)
+POLKAVM_IMPORT(uint64_t, instantiate, uint32_t)

 POLKAVM_IMPORT(void, now, uint32_t)

+POLKAVM_IMPORT(void, origin, uint32_t)
+
 POLKAVM_IMPORT(void, seal_return, uint32_t, uint32_t, uint32_t)

-POLKAVM_IMPORT(uint32_t, set_storage, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)
+POLKAVM_IMPORT(uint64_t, ref_time_left)

 POLKAVM_IMPORT(void, return_data_copy, uint32_t, uint32_t, uint32_t)

-POLKAVM_IMPORT(void, return_data_size, uint32_t)
+POLKAVM_IMPORT(uint64_t, return_data_size)

 POLKAVM_IMPORT(void, set_immutable_data, uint32_t, uint32_t);

+POLKAVM_IMPORT(uint64_t, set_storage, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)
+
 POLKAVM_IMPORT(void, value_transferred, uint32_t)
+
+POLKAVM_IMPORT(void, weight_to_fee, uint64_t, uint64_t, uint32_t);
@@ -20,10 +20,20 @@ pub static BALANCE: &str = "balance";

 pub static BALANCE_OF: &str = "balance_of";

+pub static BASE_FEE: &str = "base_fee";
+
+pub static BLOCK_HASH: &str = "block_hash";
+
 pub static BLOCK_NUMBER: &str = "block_number";

 pub static CALL: &str = "call";

+pub static CALL_DATA_COPY: &str = "call_data_copy";
+
+pub static CALL_DATA_LOAD: &str = "call_data_load";
+
+pub static CALL_DATA_SIZE: &str = "call_data_size";
+
 pub static CALLER: &str = "caller";

 pub static CHAIN_ID: &str = "chain_id";
@@ -32,23 +42,29 @@ pub static CODE_SIZE: &str = "code_size";

 pub static CODE_HASH: &str = "code_hash";

+pub static DELEGATE_CALL: &str = "delegate_call";
+
 pub static DEPOSIT_EVENT: &str = "deposit_event";

+pub static GAS_LIMIT: &str = "gas_limit";
+
+pub static GAS_PRICE: &str = "gas_price";
+
 pub static GET_IMMUTABLE_DATA: &str = "get_immutable_data";

 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 ORIGIN: &str = "origin";

-pub static SET_STORAGE: &str = "set_storage";
+pub static REF_TIME_LEFT: &str = "ref_time_left";
+
+pub static RETURN: &str = "seal_return";

 pub static RETURNDATACOPY: &str = "return_data_copy";

@@ -56,35 +72,49 @@ pub static RETURNDATASIZE: &str = "return_data_size";

 pub static SET_IMMUTABLE_DATA: &str = "set_immutable_data";

+pub static SET_STORAGE: &str = "set_storage";
+
 pub static VALUE_TRANSFERRED: &str = "value_transferred";

+pub static WEIGHT_TO_FEE: &str = "weight_to_fee";
+
 /// All imported runtime API symbols.
 /// Useful for configuring common attributes and linkage.
-pub static IMPORTS: [&str; 24] = [
+pub static IMPORTS: [&str; 34] = [
    SBRK,
    MEMORY_SIZE,
    ADDRESS,
    BALANCE,
    BALANCE_OF,
+    BASE_FEE,
+    BLOCK_HASH,
    BLOCK_NUMBER,
    CALL,
+    CALL_DATA_COPY,
+    CALL_DATA_LOAD,
+    CALL_DATA_SIZE,
    CALLER,
    CHAIN_ID,
    CODE_SIZE,
    CODE_HASH,
+    DELEGATE_CALL,
    DEPOSIT_EVENT,
+    GAS_LIMIT,
+    GAS_PRICE,
    GET_IMMUTABLE_DATA,
    GET_STORAGE,
    HASH_KECCAK_256,
-    INPUT,
    INSTANTIATE,
    NOW,
+    ORIGIN,
+    REF_TIME_LEFT,
    RETURN,
    RETURNDATACOPY,
    RETURNDATASIZE,
    SET_IMMUTABLE_DATA,
    SET_STORAGE,
    VALUE_TRANSFERRED,
+    WEIGHT_TO_FEE,
 ];

 /// Creates a LLVM module from the [BITCODE].
@@ -24,7 +24,7 @@ thiserror = { workspace = true }
 anyhow = { workspace = true }
 which = { workspace = true }
 path-slash = { workspace = true }
-rayon = { workspace = true }
+rayon = { workspace = true, optional = true }

 serde = { workspace = true }
 serde_json = { workspace = true }
@@ -41,6 +41,16 @@ inkwell = { workspace = true }
 revive-common = { workspace = true }
 revive-llvm-context = { workspace = true }

-
 [target.'cfg(target_env = "musl")'.dependencies]
 mimalloc = { version = "*", default-features = false }
+
+[target.'cfg(target_os = "emscripten")'.dependencies]
+libc = { workspace = true }
+inkwell = { workspace = true, features = ["target-riscv", "llvm18-0-no-llvm-linking"]}
+
+[build-dependencies]
+git2 = { workspace = true }
+
+[features]
+parallel = ["rayon"]
+default = ["parallel"]
@@ -0,0 +1,7 @@
+fn main() {
+    let repo = git2::Repository::open("../..").expect("should be a repository");
+    let head = repo.head().expect("should have head");
+    let commit = head.peel_to_commit().expect("should have commit");
+    let id = &commit.id().to_string()[..7];
+    println!("cargo:rustc-env=GIT_COMMIT_HASH={id}");
+}
@@ -8,6 +8,7 @@ use std::path::Path;
 use crate::solc::combined_json::CombinedJson;
 use crate::solc::standard_json::output::Output as StandardJsonOutput;
 use crate::solc::version::Version as SolcVersion;
+use crate::ResolcVersion;

 use self::contract::Contract;

@@ -40,11 +41,7 @@ impl Build {
    }

    /// Writes all contracts assembly and bytecode to the combined JSON.
-    pub fn write_to_combined_json(
-        self,
-        combined_json: &mut CombinedJson,
-        resolc_version: &semver::Version,
-    ) -> anyhow::Result<()> {
+    pub fn write_to_combined_json(self, combined_json: &mut CombinedJson) -> anyhow::Result<()> {
        for (path, contract) in self.contracts.into_iter() {
            let combined_json_contract = combined_json
                .contracts
@@ -61,7 +58,7 @@ impl Build {
            contract.write_to_combined_json(combined_json_contract)?;
        }

-        combined_json.zk_version = Some(resolc_version.to_string());
+        combined_json.revive_version = Some(ResolcVersion::default().long);

        Ok(())
    }
@@ -71,7 +68,6 @@ impl Build {
        mut self,
        standard_json: &mut StandardJsonOutput,
        solc_version: &SolcVersion,
-        resolc_version: &semver::Version,
    ) -> anyhow::Result<()> {
        let contracts = match standard_json.contracts.as_mut() {
            Some(contracts) => contracts,
@@ -90,7 +86,7 @@ impl Build {

        standard_json.version = Some(solc_version.default.to_string());
        standard_json.long_version = Some(solc_version.long.to_owned());
-        standard_json.zk_version = Some(resolc_version.to_string());
+        standard_json.revive_version = Some(ResolcVersion::default().long);

        Ok(())
    }
@@ -8,6 +8,7 @@ use std::collections::HashSet;

 use serde::Deserialize;
 use serde::Serialize;
+use sha3::Digest;

 use crate::evmla::ethereal_ir::entry_link::EntryLink;
 use crate::evmla::ethereal_ir::EtherealIR;
@@ -45,7 +46,7 @@ impl Assembly {
    /// Gets the contract `keccak256` hash.
    pub fn keccak256(&self) -> String {
        let json = serde_json::to_vec(self).expect("Always valid");
-        revive_llvm_context::polkavm_utils::keccak256(json.as_slice())
+        hex::encode(sha3::Keccak256::digest(json.as_slice()))
    }

    /// Sets the full contract path.
@@ -212,9 +213,10 @@ where
    ) -> anyhow::Result<()> {
        let full_path = self.full_path().to_owned();

-        if let Some(debug_config) = context.debug_config() {
-            debug_config.dump_evmla(full_path.as_str(), self.to_string().as_str())?;
-        }
+        context
+            .debug_config()
+            .dump_evmla(full_path.as_str(), self.to_string().as_str())?;
+
        let deploy_code_blocks = EtherealIR::get_blocks(
            context.evmla().version.to_owned(),
            revive_llvm_context::PolkaVMCodeType::Deploy,
@@ -228,9 +230,11 @@ where
            .ok_or_else(|| anyhow::anyhow!("Runtime code data not found"))?
            .remove("0")
            .expect("Always exists");
-        if let Some(debug_config) = context.debug_config() {
-            debug_config.dump_evmla(full_path.as_str(), data.to_string().as_str())?;
-        }
+
+        context
+            .debug_config()
+            .dump_evmla(full_path.as_str(), data.to_string().as_str())?;
+
        let runtime_code_instructions = match data {
            Data::Assembly(assembly) => assembly
                .code
@@ -253,9 +257,11 @@ where
        blocks.extend(runtime_code_blocks);
        let mut ethereal_ir =
            EtherealIR::new(context.evmla().version.to_owned(), extra_metadata, blocks)?;
-        if let Some(debug_config) = context.debug_config() {
-            debug_config.dump_ethir(full_path.as_str(), ethereal_ir.to_string().as_str())?;
-        }
+
+        context
+            .debug_config()
+            .dump_ethir(full_path.as_str(), ethereal_ir.to_string().as_str())?;
+
        ethereal_ir.declare(context)?;
        ethereal_ir.into_llvm(context)?;

@@ -1096,7 +1096,6 @@ where
                    context,
                    gas,
                    address,
-                    None,
                    input_offset,
                    input_size,
                    output_offset,
@@ -1163,7 +1163,7 @@ where
            self.name.as_str(),
            function_type,
            output_size,
-            Some(inkwell::module::Linkage::Private),
+            Some(inkwell::module::Linkage::External),
        )?;
        function
            .borrow_mut()
@@ -1175,7 +1175,7 @@ where
    }

    fn into_llvm(self, context: &mut revive_llvm_context::PolkaVMContext<D>) -> anyhow::Result<()> {
-        context.set_current_function(self.name.as_str())?;
+        context.set_current_function(self.name.as_str(), None)?;

        for (key, blocks) in self.blocks.iter() {
            for (index, block) in blocks.iter().enumerate() {
@@ -1297,6 +1297,8 @@ where
            }
        }

+        context.pop_debug_scope();
+
        Ok(())
    }
 }
@@ -7,6 +7,7 @@ pub(crate) mod missing_libraries;
 pub(crate) mod process;
 pub(crate) mod project;
 pub(crate) mod solc;
+pub(crate) mod version;
 pub(crate) mod warning;
 pub(crate) mod yul;

@@ -14,15 +15,22 @@ pub use self::build::contract::Contract as ContractBuild;
 pub use self::build::Build;
 pub use self::missing_libraries::MissingLibraries;
 pub use self::process::input::Input as ProcessInput;
+#[cfg(not(target_os = "emscripten"))]
+pub use self::process::native_process::NativeProcess;
 pub use self::process::output::Output as ProcessOutput;
-pub use self::process::run as run_process;
-pub use self::process::EXECUTABLE;
+#[cfg(target_os = "emscripten")]
+pub use self::process::worker_process::WorkerProcess;
+pub use self::process::Process;
 pub use self::project::contract::Contract as ProjectContract;
 pub use self::project::Project;
 pub use self::r#const::*;
 pub use self::solc::combined_json::contract::Contract as SolcCombinedJsonContract;
 pub use self::solc::combined_json::CombinedJson as SolcCombinedJson;
 pub use self::solc::pipeline::Pipeline as SolcPipeline;
+#[cfg(not(target_os = "emscripten"))]
+pub use self::solc::solc_compiler::SolcCompiler;
+#[cfg(target_os = "emscripten")]
+pub use self::solc::soljson_compiler::SoljsonCompiler;
 pub use self::solc::standard_json::input::language::Language as SolcStandardJsonInputLanguage;
 pub use self::solc::standard_json::input::settings::metadata::Metadata as SolcStandardJsonInputSettingsMetadata;
 pub use self::solc::standard_json::input::settings::optimizer::Optimizer as SolcStandardJsonInputSettingsOptimizer;
@@ -37,9 +45,10 @@ pub use self::solc::standard_json::output::contract::evm::EVM as SolcStandardJso
 pub use self::solc::standard_json::output::contract::Contract as SolcStandardJsonOutputContract;
 pub use self::solc::standard_json::output::Output as SolcStandardJsonOutput;
 pub use self::solc::version::Version as SolcVersion;
-pub use self::solc::Compiler as SolcCompiler;
+pub use self::solc::Compiler;
+pub use self::version::Version as ResolcVersion;
 pub use self::warning::Warning;
-
+#[cfg(not(target_os = "emscripten"))]
 pub mod test_utils;
 pub mod tests;

@@ -47,12 +56,12 @@ use std::collections::BTreeSet;
 use std::path::PathBuf;

 /// Runs the Yul mode.
-pub fn yul(
+pub fn yul<T: Compiler>(
    input_files: &[PathBuf],
-    solc: &mut SolcCompiler,
+    solc: &mut T,
    optimizer_settings: revive_llvm_context::OptimizerSettings,
    include_metadata_hash: bool,
-    debug_config: Option<revive_llvm_context::DebugConfig>,
+    debug_config: revive_llvm_context::DebugConfig,
 ) -> anyhow::Result<Build> {
    let path = match input_files.len() {
        1 => input_files.first().expect("Always exists"),
@@ -63,10 +72,10 @@ pub fn yul(
        ),
    };

-    if solc.version()?.default != SolcCompiler::LAST_SUPPORTED_VERSION {
+    if solc.version()?.default != solc::LAST_SUPPORTED_VERSION {
        anyhow::bail!(
                "The Yul mode is only supported with the most recent version of the Solidity compiler: {}",
-                SolcCompiler::LAST_SUPPORTED_VERSION,
+                solc::LAST_SUPPORTED_VERSION,
            );
    }

@@ -83,7 +92,7 @@ pub fn llvm_ir(
    input_files: &[PathBuf],
    optimizer_settings: revive_llvm_context::OptimizerSettings,
    include_metadata_hash: bool,
-    debug_config: Option<revive_llvm_context::DebugConfig>,
+    debug_config: revive_llvm_context::DebugConfig,
 ) -> anyhow::Result<Build> {
    let path = match input_files.len() {
        1 => input_files.first().expect("Always exists"),
@@ -103,10 +112,10 @@ pub fn llvm_ir(

 /// Runs the standard output mode.
 #[allow(clippy::too_many_arguments)]
-pub fn standard_output(
+pub fn standard_output<T: Compiler>(
    input_files: &[PathBuf],
    libraries: Vec<String>,
-    solc: &mut SolcCompiler,
+    solc: &mut T,
    evm_version: Option<revive_common::EVMVersion>,
    solc_optimizer_enabled: bool,
    optimizer_settings: revive_llvm_context::OptimizerSettings,
@@ -117,7 +126,7 @@ pub fn standard_output(
    allow_paths: Option<String>,
    remappings: Option<BTreeSet<String>>,
    suppressed_warnings: Option<Vec<Warning>>,
-    debug_config: Option<revive_llvm_context::DebugConfig>,
+    debug_config: revive_llvm_context::DebugConfig,
 ) -> anyhow::Result<Build> {
    let solc_version = solc.version()?;
    let solc_pipeline = SolcPipeline::new(&solc_version, force_evmla);
@@ -176,7 +185,7 @@ pub fn standard_output(
        libraries,
        solc_pipeline,
        &solc_version,
-        debug_config.as_ref(),
+        &debug_config,
    )?;

    let build = project.compile(optimizer_settings, include_metadata_hash, debug_config)?;
@@ -186,18 +195,17 @@ pub fn standard_output(

 /// Runs the standard JSON mode.
 #[allow(clippy::too_many_arguments)]
-pub fn standard_json(
-    solc: &mut SolcCompiler,
+pub fn standard_json<T: Compiler>(
+    solc: &mut T,
    detect_missing_libraries: bool,
    force_evmla: bool,
    base_path: Option<String>,
    include_paths: Vec<String>,
    allow_paths: Option<String>,
-    debug_config: Option<revive_llvm_context::DebugConfig>,
+    debug_config: revive_llvm_context::DebugConfig,
 ) -> anyhow::Result<()> {
    let solc_version = solc.version()?;
    let solc_pipeline = SolcPipeline::new(&solc_version, force_evmla);
-    let resolc_version = semver::Version::parse(env!("CARGO_PKG_VERSION")).expect("Always valid");

    let solc_input = SolcStandardJsonInput::try_from_stdin(solc_pipeline)?;
    let source_code_files = solc_input
@@ -239,19 +247,15 @@ pub fn standard_json(
        libraries,
        solc_pipeline,
        &solc_version,
-        debug_config.as_ref(),
+        &debug_config,
    )?;

    if detect_missing_libraries {
        let missing_libraries = project.get_missing_libraries();
-        missing_libraries.write_to_standard_json(
-            &mut solc_output,
-            &solc_version,
-            &resolc_version,
-        )?;
+        missing_libraries.write_to_standard_json(&mut solc_output, &solc_version)?;
    } else {
        let build = project.compile(optimizer_settings, include_metadata_hash, debug_config)?;
-        build.write_to_standard_json(&mut solc_output, &solc_version, &resolc_version)?;
+        build.write_to_standard_json(&mut solc_output, &solc_version)?;
    }
    serde_json::to_writer(std::io::stdout(), &solc_output)?;
    std::process::exit(0);
@@ -259,11 +263,11 @@ pub fn standard_json(

 /// Runs the combined JSON mode.
 #[allow(clippy::too_many_arguments)]
-pub fn combined_json(
+pub fn combined_json<T: Compiler>(
    format: String,
    input_files: &[PathBuf],
    libraries: Vec<String>,
-    solc: &mut SolcCompiler,
+    solc: &mut T,
    evm_version: Option<revive_common::EVMVersion>,
    solc_optimizer_enabled: bool,
    optimizer_settings: revive_llvm_context::OptimizerSettings,
@@ -274,12 +278,10 @@ pub fn combined_json(
    allow_paths: Option<String>,
    remappings: Option<BTreeSet<String>>,
    suppressed_warnings: Option<Vec<Warning>>,
-    debug_config: Option<revive_llvm_context::DebugConfig>,
+    debug_config: revive_llvm_context::DebugConfig,
    output_directory: Option<PathBuf>,
    overwrite: bool,
 ) -> anyhow::Result<()> {
-    let resolc_version = semver::Version::parse(env!("CARGO_PKG_VERSION")).expect("Always valid");
-
    let build = standard_output(
        input_files,
        libraries,
@@ -298,7 +300,7 @@ pub fn combined_json(
    )?;

    let mut combined_json = solc.combined_json(input_files, format.as_str())?;
-    build.write_to_combined_json(&mut combined_json, &resolc_version)?;
+    build.write_to_combined_json(&mut combined_json)?;

    match output_directory {
        Some(output_directory) => {
@@ -5,6 +5,7 @@ use std::collections::HashSet;

 use crate::solc::standard_json::output::Output as StandardJsonOutput;
 use crate::solc::version::Version as SolcVersion;
+use crate::ResolcVersion;

 /// The missing Solidity libraries.
 pub struct MissingLibraries {
@@ -23,7 +24,6 @@ impl MissingLibraries {
        mut self,
        standard_json: &mut StandardJsonOutput,
        solc_version: &SolcVersion,
-        resolc_version: &semver::Version,
    ) -> anyhow::Result<()> {
        let contracts = match standard_json.contracts.as_mut() {
            Some(contracts) => contracts,
@@ -43,7 +43,7 @@ impl MissingLibraries {

        standard_json.version = Some(solc_version.default.to_string());
        standard_json.long_version = Some(solc_version.long.to_owned());
-        standard_json.zk_version = Some(resolc_version.to_string());
+        standard_json.revive_version = Some(ResolcVersion::default().long);

        Ok(())
    }
@@ -19,7 +19,7 @@ pub struct Input {
    /// The optimizer settings.
    pub optimizer_settings: revive_llvm_context::OptimizerSettings,
    /// The debug output config.
-    pub debug_config: Option<revive_llvm_context::DebugConfig>,
+    pub debug_config: revive_llvm_context::DebugConfig,
 }

 impl Input {
@@ -29,7 +29,7 @@ impl Input {
        project: Project,
        include_metadata_hash: bool,
        optimizer_settings: revive_llvm_context::OptimizerSettings,
-        debug_config: Option<revive_llvm_context::DebugConfig>,
+        debug_config: revive_llvm_context::DebugConfig,
    ) -> Self {
        Self {
            contract,
@@ -1,125 +1,68 @@
 //! Process for compiling a single compilation unit.

 pub mod input;
+#[cfg(not(target_os = "emscripten"))]
+pub mod native_process;
 pub mod output;
+#[cfg(target_os = "emscripten")]
+pub mod worker_process;

-use std::io::Read;
-use std::io::Write;
-use std::path::PathBuf;
-use std::process::Command;
-
-use once_cell::sync::OnceCell;
+use std::io::{Read, Write};

 use self::input::Input;
 use self::output::Output;

-/// The overriden executable name used when the compiler is run as a library.
-pub static EXECUTABLE: OnceCell<PathBuf> = OnceCell::new();
+pub trait Process {
+    /// Read input from `stdin`, compile a contract, and write the output to `stdout`.
+    fn run(input_file: Option<&mut std::fs::File>) -> anyhow::Result<()> {
+        let mut stdin = std::io::stdin();
+        let mut stdout = std::io::stdout();
+        let mut stderr = std::io::stderr();

-/// Read input from `stdin`, compile a contract, and write the output to `stdout`.
-pub fn run(input_file: Option<&mut std::fs::File>) -> anyhow::Result<()> {
-    let mut stdin = std::io::stdin();
-    let mut stdout = std::io::stdout();
-    let mut stderr = std::io::stderr();
-
-    let mut buffer = Vec::with_capacity(16384);
-    match input_file {
-        Some(ins) => {
-            if let Err(error) = ins.read_to_end(&mut buffer) {
-                anyhow::bail!("Failed to read recursive process input file: {:?}", error);
+        let mut buffer = Vec::with_capacity(16384);
+        match input_file {
+            Some(ins) => {
+                if let Err(error) = ins.read_to_end(&mut buffer) {
+                    anyhow::bail!("Failed to read recursive process input file: {:?}", error);
+                }
+            }
+            None => {
+                if let Err(error) = stdin.read_to_end(&mut buffer) {
+                    anyhow::bail!(
+                        "Failed to read recursive process input from stdin: {:?}",
+                        error
+                    )
+                }
            }
        }
-        None => {
-            if let Err(error) = stdin.read_to_end(&mut buffer) {
-                anyhow::bail!(
-                    "Failed to read recursive process input from stdin: {:?}",
-                    error
-                )
-            }
-        }
-    }

-    let input: Input = revive_common::deserialize_from_slice(buffer.as_slice())?;
-    let result = input.contract.compile(
-        input.project,
-        input.optimizer_settings,
-        input.include_metadata_hash,
-        input.debug_config,
-    );
-
-    match result {
-        Ok(build) => {
-            let output = Output::new(build);
-            let json = serde_json::to_vec(&output).expect("Always valid");
-            stdout
-                .write_all(json.as_slice())
-                .expect("Stdout writing error");
-            Ok(())
-        }
-        Err(error) => {
-            let message = error.to_string();
-            stderr
-                .write_all(message.as_bytes())
-                .expect("Stderr writing error");
-            Err(error)
-        }
-    }
-}
-
-/// Runs this process recursively to compile a single contract.
-pub fn call(input: Input) -> anyhow::Result<Output> {
-    let input_json = serde_json::to_vec(&input).expect("Always valid");
-
-    let executable = match EXECUTABLE.get() {
-        Some(executable) => executable.to_owned(),
-        None => std::env::current_exe()?,
-    };
-
-    let mut command = Command::new(executable.as_path());
-    command.stdin(std::process::Stdio::piped());
-    command.stdout(std::process::Stdio::piped());
-    command.stderr(std::process::Stdio::piped());
-    command.arg("--recursive-process");
-    let process = command.spawn().map_err(|error| {
-        anyhow::anyhow!("{:?} subprocess spawning error: {:?}", executable, error)
-    })?;
-
-    #[cfg(debug_assertions)]
-    if let Some(dbg_config) = &input.debug_config {
-        dbg_config
-            .dump_stage_output(&input.contract.path, Some("stage"), &input_json)
-            .map_err(|error| {
-                anyhow::anyhow!(
-                    "{:?} failed to log the recursive process output: {:?}",
-                    executable,
-                    error,
-                )
-            })?;
-    }
-
-    process
-        .stdin
-        .as_ref()
-        .ok_or_else(|| anyhow::anyhow!("{:?} stdin getting error", executable))?
-        .write_all(input_json.as_slice())
-        .map_err(|error| anyhow::anyhow!("{:?} stdin writing error: {:?}", executable, error))?;
-    let output = process.wait_with_output().map_err(|error| {
-        anyhow::anyhow!("{:?} subprocess output error: {:?}", executable, error)
-    })?;
-    if !output.status.success() {
-        anyhow::bail!(
-            "{}",
-            String::from_utf8_lossy(output.stderr.as_slice()).to_string(),
+        let input: Input = revive_common::deserialize_from_slice(buffer.as_slice())?;
+        let result = input.contract.compile(
+            input.project,
+            input.optimizer_settings,
+            input.include_metadata_hash,
+            input.debug_config,
        );
+
+        match result {
+            Ok(build) => {
+                let output = Output::new(build);
+                let json = serde_json::to_vec(&output).expect("Always valid");
+                stdout
+                    .write_all(json.as_slice())
+                    .expect("Stdout writing error");
+                Ok(())
+            }
+            Err(error) => {
+                let message = error.to_string();
+                stderr
+                    .write_all(message.as_bytes())
+                    .expect("Stderr writing error");
+                Err(error)
+            }
+        }
    }

-    let output: Output =
-        revive_common::deserialize_from_slice(output.stdout.as_slice()).map_err(|error| {
-            anyhow::anyhow!(
-                "{:?} subprocess output parsing error: {}",
-                executable,
-                error,
-            )
-        })?;
-    Ok(output)
+    /// Runs this process recursively to compile a single contract.
+    fn call(input: Input) -> anyhow::Result<Output>;
 }
@@ -0,0 +1,76 @@
+//! Process for compiling a single compilation unit.
+
+use std::io::Write;
+use std::path::PathBuf;
+use std::process::Command;
+
+use once_cell::sync::OnceCell;
+
+use super::Input;
+use super::Output;
+use super::Process;
+
+/// The overriden executable name used when the compiler is run as a library.
+pub static EXECUTABLE: OnceCell<PathBuf> = OnceCell::new();
+
+pub struct NativeProcess;
+
+impl Process for NativeProcess {
+    fn call(input: Input) -> anyhow::Result<Output> {
+        let input_json = serde_json::to_vec(&input).expect("Always valid");
+
+        let executable = match EXECUTABLE.get() {
+            Some(executable) => executable.to_owned(),
+            None => std::env::current_exe()?,
+        };
+
+        let mut command = Command::new(executable.as_path());
+        command.stdin(std::process::Stdio::piped());
+        command.stdout(std::process::Stdio::piped());
+        command.stderr(std::process::Stdio::piped());
+        command.arg("--recursive-process");
+        let process = command.spawn().map_err(|error| {
+            anyhow::anyhow!("{:?} subprocess spawning error: {:?}", executable, error)
+        })?;
+
+        #[cfg(debug_assertions)]
+        input
+            .debug_config
+            .dump_stage_output(&input.contract.path, Some("stage"), &input_json)
+            .map_err(|error| {
+                anyhow::anyhow!(
+                    "{:?} failed to log the recursive process output: {:?}",
+                    executable,
+                    error,
+                )
+            })?;
+
+        process
+            .stdin
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("{:?} stdin getting error", executable))?
+            .write_all(input_json.as_slice())
+            .map_err(|error| {
+                anyhow::anyhow!("{:?} stdin writing error: {:?}", executable, error)
+            })?;
+        let output = process.wait_with_output().map_err(|error| {
+            anyhow::anyhow!("{:?} subprocess output error: {:?}", executable, error)
+        })?;
+        if !output.status.success() {
+            anyhow::bail!(
+                "{}",
+                String::from_utf8_lossy(output.stderr.as_slice()).to_string(),
+            );
+        }
+
+        let output: Output = revive_common::deserialize_from_slice(output.stdout.as_slice())
+            .map_err(|error| {
+                anyhow::anyhow!(
+                    "{:?} subprocess output parsing error: {}",
+                    executable,
+                    error,
+                )
+            })?;
+        Ok(output)
+    }
+}
@@ -0,0 +1,69 @@
+//! Process for compiling a single compilation unit using Web Workers.
+
+use std::ffi::{c_char, c_void, CStr, CString};
+
+use super::Input;
+use super::Output;
+use super::Process;
+
+use anyhow::Context;
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+struct Error {
+    message: String,
+}
+
+#[derive(Deserialize)]
+struct Success {
+    data: String,
+}
+
+#[derive(Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+enum Response {
+    Success(Success),
+    Error(Error),
+}
+
+pub struct WorkerProcess;
+
+impl Process for WorkerProcess {
+    fn call(input: Input) -> anyhow::Result<Output> {
+        let input_json = serde_json::to_vec(&input).expect("Always valid");
+        let input_str = String::from_utf8(input_json).expect("Input shall be valid");
+        // Prepare the input string for the Emscripten function
+        let input_cstring = CString::new(input_str).expect("CString allocation failed");
+
+        // Call the Emscripten function
+        let output_ptr =
+            unsafe { resolc_compile(input_cstring.as_ptr(), input_cstring.as_bytes().len()) };
+
+        // Convert the output pointer back to a Rust string
+        let output_str = unsafe {
+            CStr::from_ptr(output_ptr)
+                .to_str()
+                .with_context(|| "Failed to convert C string to Rust string")
+                .map(str::to_owned)
+        };
+        unsafe { libc::free(output_ptr as *mut c_void) };
+        let output_str = output_str?;
+        let response: Response = serde_json::from_str(&output_str)
+            .map_err(|error| anyhow::anyhow!("Worker output parsing error: {}", error,))?;
+        match response {
+            Response::Success(out) => {
+                let output: Output = revive_common::deserialize_from_slice(out.data.as_bytes())
+                    .map_err(|error| {
+                        anyhow::anyhow!("resolc.js subprocess output parsing error: {}", error,)
+                    })?;
+
+                Ok(output)
+            }
+            Response::Error(err) => anyhow::bail!("Worker error: {}", err.message,),
+        }
+    }
+}
+
+extern "C" {
+    fn resolc_compile(input_ptr: *const c_char, input_len: usize) -> *const c_char;
+}
@@ -2,6 +2,8 @@

 use serde::Serialize;

+use crate::ResolcVersion;
+
 /// The Solidity contract metadata.
 /// Is used to append the metadata hash to the contract bytecode.
 #[derive(Debug, Serialize)]
@@ -9,11 +11,11 @@ pub struct Metadata {
    /// The `solc` metadata.
    pub solc_metadata: serde_json::Value,
    /// The `solc` version.
-    pub solc_version: semver::Version,
-    /// The zkVM `solc` edition.
-    pub solc_zkvm_edition: Option<semver::Version>,
+    pub solc_version: String,
+    /// The pallet revive edition.
+    pub revive_pallet_version: Option<semver::Version>,
    /// The PolkaVM compiler version.
-    pub zk_version: semver::Version,
+    pub revive_version: String,
    /// The PolkaVM compiler optimizer settings.
    pub optimizer_settings: revive_llvm_context::OptimizerSettings,
 }
@@ -22,16 +24,15 @@ impl Metadata {
    /// A shortcut constructor.
    pub fn new(
        solc_metadata: serde_json::Value,
-        solc_version: semver::Version,
-        solc_zkvm_edition: Option<semver::Version>,
-        zk_version: semver::Version,
+        solc_version: String,
+        revive_pallet_version: Option<semver::Version>,
        optimizer_settings: revive_llvm_context::OptimizerSettings,
    ) -> Self {
        Self {
            solc_metadata,
            solc_version,
-            solc_zkvm_edition,
-            zk_version,
+            revive_pallet_version,
+            revive_version: ResolcVersion::default().long,
            optimizer_settings,
        }
    }
@@ -79,7 +79,7 @@ impl Contract {
        project: Project,
        optimizer_settings: revive_llvm_context::OptimizerSettings,
        include_metadata_hash: bool,
-        debug_config: Option<revive_llvm_context::DebugConfig>,
+        debug_config: revive_llvm_context::DebugConfig,
    ) -> anyhow::Result<ContractBuild> {
        let llvm = inkwell::context::Context::create();
        let optimizer = revive_llvm_context::Optimizer::new(optimizer_settings);
@@ -89,9 +89,8 @@ impl Contract {

        let metadata = Metadata::new(
            self.metadata_json.take(),
-            version.default.clone(),
+            version.long.clone(),
            version.l2_revision.clone(),
-            semver::Version::parse(env!("CARGO_PKG_VERSION")).expect("Always valid"),
            optimizer.settings().to_owned(),
        );
        let metadata_json = serde_json::to_value(&metadata).expect("Always valid");
@@ -105,6 +104,7 @@ impl Contract {

        let module = match self.ir {
            IR::LLVMIR(ref llvm_ir) => {
+                // Create the output module
                let memory_buffer =
                    inkwell::memory_buffer::MemoryBuffer::create_from_memory_range_copy(
                        llvm_ir.source.as_bytes(),
@@ -115,6 +115,7 @@ impl Contract {
            }
            _ => llvm.create_module(self.path.as_str()),
        };
+
        let mut context = revive_llvm_context::PolkaVMContext::new(
            &llvm,
            module,
@@ -152,6 +153,10 @@ impl Contract {
            )
        })?;

+        if let Some(debug_info) = context.debug_info() {
+            debug_info.finalize_module()
+        }
+
        let build = context.build(self.path.as_str(), metadata_hash)?;

        Ok(ContractBuild::new(
@@ -7,8 +7,8 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 use std::path::Path;

-use rayon::iter::IntoParallelIterator;
-use rayon::iter::ParallelIterator;
+#[cfg(feature = "parallel")]
+use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use serde::Deserialize;
 use serde::Serialize;
 use sha3::Digest;
@@ -17,9 +17,10 @@ use crate::build::contract::Contract as ContractBuild;
 use crate::build::Build;
 use crate::missing_libraries::MissingLibraries;
 use crate::process::input::Input as ProcessInput;
+use crate::process::Process;
 use crate::project::contract::ir::IR;
 use crate::solc::version::Version as SolcVersion;
-use crate::solc::Compiler as SolcCompiler;
+use crate::solc::Compiler;
 use crate::yul::lexer::Lexer;
 use crate::yul::parser::statement::object::Object;

@@ -63,21 +64,33 @@ impl Project {
        self,
        optimizer_settings: revive_llvm_context::OptimizerSettings,
        include_metadata_hash: bool,
-        debug_config: Option<revive_llvm_context::DebugConfig>,
+        debug_config: revive_llvm_context::DebugConfig,
    ) -> anyhow::Result<Build> {
        let project = self.clone();
-        let results: BTreeMap<String, anyhow::Result<ContractBuild>> = self
-            .contracts
-            .into_par_iter()
+        #[cfg(feature = "parallel")]
+        let iter = self.contracts.into_par_iter();
+        #[cfg(not(feature = "parallel"))]
+        let iter = self.contracts.into_iter();
+
+        let results: BTreeMap<String, anyhow::Result<ContractBuild>> = iter
            .map(|(full_path, contract)| {
-                let process_output = crate::process::call(ProcessInput::new(
+                let process_input = ProcessInput::new(
                    contract,
                    project.clone(),
                    include_metadata_hash,
                    optimizer_settings.clone(),
                    debug_config.clone(),
-                ));
-
+                );
+                let process_output = {
+                    #[cfg(target_os = "emscripten")]
+                    {
+                        crate::WorkerProcess::call(process_input)
+                    }
+                    #[cfg(not(target_os = "emscripten"))]
+                    {
+                        crate::NativeProcess::call(process_input)
+                    }
+                };
                (full_path, process_output.map(|output| output.build))
            })
            .collect();
@@ -155,9 +168,9 @@ impl Project {
    }

    /// Parses the Yul source code file and returns the source data.
-    pub fn try_from_yul_path(
+    pub fn try_from_yul_path<T: Compiler>(
        path: &Path,
-        solc_validator: Option<&SolcCompiler>,
+        solc_validator: Option<&T>,
    ) -> anyhow::Result<Self> {
        let source_code = std::fs::read_to_string(path)
            .map_err(|error| anyhow::anyhow!("Yul file {:?} reading error: {}", path, error))?;
@@ -166,16 +179,16 @@ impl Project {

    /// Parses the test Yul source code string and returns the source data.
    /// Only for integration testing purposes.
-    pub fn try_from_yul_string(
+    pub fn try_from_yul_string<T: Compiler>(
        path: &Path,
        source_code: &str,
-        solc_validator: Option<&SolcCompiler>,
+        solc_validator: Option<&T>,
    ) -> anyhow::Result<Self> {
        if let Some(solc) = solc_validator {
            solc.validate_yul(path)?;
        }

-        let source_version = SolcVersion::new_simple(SolcCompiler::LAST_SUPPORTED_VERSION);
+        let source_version = SolcVersion::new_simple(crate::solc::LAST_SUPPORTED_VERSION);
        let path = path.to_string_lossy().to_string();
        let source_hash = sha3::Keccak256::digest(source_code.as_bytes()).into();

@@ -238,7 +251,7 @@ impl revive_llvm_context::PolkaVMDependency for Project {
        identifier: &str,
        optimizer_settings: revive_llvm_context::OptimizerSettings,
        include_metadata_hash: bool,
-        debug_config: Option<revive_llvm_context::DebugConfig>,
+        debug_config: revive_llvm_context::DebugConfig,
    ) -> anyhow::Result<String> {
        let contract_path = project.resolve_path(identifier)?;
        let contract = project
@@ -138,6 +138,11 @@ pub struct Arguments {
    #[structopt(long = "suppress-warnings")]
    pub suppress_warnings: Option<Vec<String>>,

+    /// Generate source based debug information in the output code file. This only has an effect
+    /// with the LLVM-IR code generator and is ignored otherwise.
+    #[structopt(short = 'g')]
+    pub emit_source_debug_info: bool,
+
    /// Dump all IRs to files in the specified directory.
    /// Only for testing and debugging.
    #[structopt(long = "debug-output-dir")]
@@ -4,8 +4,11 @@ pub mod arguments;

 use std::str::FromStr;

+use revive_solidity::Process;
+
 use self::arguments::Arguments;

+#[cfg(feature = "parallel")]
 /// The rayon worker stack size.
 const RAYON_WORKER_STACK_SIZE: usize = 16 * 1024 * 1024;

@@ -31,10 +34,9 @@ fn main_inner() -> anyhow::Result<()> {

    if arguments.version {
        println!(
-            "{} v{} (LLVM build {:?})",
+            "{} version {}",
            env!("CARGO_PKG_DESCRIPTION"),
-            env!("CARGO_PKG_VERSION"),
-            inkwell::support::get_llvm_version()
+            revive_solidity::ResolcVersion::default().long
        );
        return Ok(());
    }
@@ -47,6 +49,7 @@ fn main_inner() -> anyhow::Result<()> {
        return Ok(());
    }

+    #[cfg(feature = "parallel")]
    rayon::ThreadPoolBuilder::new()
        .stack_size(RAYON_WORKER_STACK_SIZE)
        .build_global()
@@ -58,20 +61,34 @@ fn main_inner() -> anyhow::Result<()> {
        #[cfg(debug_assertions)]
        if let Some(fname) = arguments.recursive_process_input {
            let mut infile = std::fs::File::open(fname)?;
-            return revive_solidity::run_process(Some(&mut infile));
+            #[cfg(target_os = "emscripten")]
+            {
+                return revive_solidity::WorkerProcess::run(Some(&mut infile));
+            }
+            #[cfg(not(target_os = "emscripten"))]
+            {
+                return revive_solidity::NativeProcess::run(Some(&mut infile));
+            }
+        }
+        #[cfg(target_os = "emscripten")]
+        {
+            return revive_solidity::WorkerProcess::run(None);
+        }
+        #[cfg(not(target_os = "emscripten"))]
+        {
+            return revive_solidity::NativeProcess::run(None);
        }
-
-        return revive_solidity::run_process(None);
    }

    let debug_config = match arguments.debug_output_directory {
        Some(ref debug_output_directory) => {
            std::fs::create_dir_all(debug_output_directory.as_path())?;
-            Some(revive_llvm_context::DebugConfig::new(
-                debug_output_directory.to_owned(),
-            ))
+            revive_llvm_context::DebugConfig::new(
+                Some(debug_output_directory.to_owned()),
+                arguments.emit_source_debug_info,
+            )
        }
-        None => None,
+        None => revive_llvm_context::DebugConfig::new(None, arguments.emit_source_debug_info),
    };

    let (input_files, remappings) = arguments.split_input_files_and_remappings()?;
@@ -83,11 +100,19 @@ fn main_inner() -> anyhow::Result<()> {
        None => None,
    };

-    let mut solc = revive_solidity::SolcCompiler::new(
-        arguments
-            .solc
-            .unwrap_or_else(|| revive_solidity::SolcCompiler::DEFAULT_EXECUTABLE_NAME.to_owned()),
-    )?;
+    let mut solc = {
+        #[cfg(target_os = "emscripten")]
+        {
+            revive_solidity::SoljsonCompiler { version: None }
+        }
+
+        #[cfg(not(target_os = "emscripten"))]
+        {
+            revive_solidity::SolcCompiler::new(arguments.solc.unwrap_or_else(|| {
+                revive_solidity::SolcCompiler::DEFAULT_EXECUTABLE_NAME.to_owned()
+            }))?
+        }
+    };

    let evm_version = match arguments.evm_version {
        Some(evm_version) => Some(revive_common::EVMVersion::try_from(evm_version.as_str())?),
@@ -28,7 +28,7 @@ pub struct CombinedJson {
    pub version: String,
    /// The `resolc` compiler version.
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub zk_version: Option<String>,
+    pub revive_version: Option<String>,
 }

 impl CombinedJson {
@@ -2,10 +2,13 @@

 pub mod combined_json;
 pub mod pipeline;
+#[cfg(not(target_os = "emscripten"))]
+pub mod solc_compiler;
+#[cfg(target_os = "emscripten")]
+pub mod soljson_compiler;
 pub mod standard_json;
 pub mod version;

-use std::io::Write;
 use std::path::Path;
 use std::path::PathBuf;

@@ -15,285 +18,40 @@ use self::standard_json::input::Input as StandardJsonInput;
 use self::standard_json::output::Output as StandardJsonOutput;
 use self::version::Version;

+/// The first version of `solc` with the support of standard JSON interface.
+pub const FIRST_SUPPORTED_VERSION: semver::Version = semver::Version::new(0, 4, 12);
+
+/// The first version of `solc`, where Yul codegen is considered robust enough.
+pub const FIRST_YUL_VERSION: semver::Version = semver::Version::new(0, 8, 0);
+
+/// The first version of `solc`, where `--via-ir` codegen mode is supported.
+pub const FIRST_VIA_IR_VERSION: semver::Version = semver::Version::new(0, 8, 13);
+
+/// The last supported version of `solc`.
+pub const LAST_SUPPORTED_VERSION: semver::Version = semver::Version::new(0, 8, 28);
+
 /// The Solidity compiler.
-pub struct Compiler {
-    /// The binary executable name.
-    pub executable: String,
-    /// The lazily-initialized compiler version.
-    pub version: Option<Version>,
-}
-
-impl Compiler {
-    /// The default executable name.
-    pub const DEFAULT_EXECUTABLE_NAME: &'static str = "solc";
-
-    /// The first version of `solc` with the support of standard JSON interface.
-    pub const FIRST_SUPPORTED_VERSION: semver::Version = semver::Version::new(0, 4, 12);
-
-    /// The first version of `solc`, where Yul codegen is considered robust enough.
-    pub const FIRST_YUL_VERSION: semver::Version = semver::Version::new(0, 8, 0);
-
-    /// The first version of `solc`, where `--via-ir` codegen mode is supported.
-    pub const FIRST_VIA_IR_VERSION: semver::Version = semver::Version::new(0, 8, 13);
-
-    /// The last supported version of `solc`.
-    pub const LAST_SUPPORTED_VERSION: semver::Version = semver::Version::new(0, 8, 28);
-
-    /// A shortcut constructor.
-    /// Different tools may use different `executable` names. For example, the integration tester
-    /// uses `solc-<version>` format.
-    pub fn new(executable: String) -> anyhow::Result<Self> {
-        if let Err(error) = which::which(executable.as_str()) {
-            anyhow::bail!(
-                "The `{executable}` executable not found in ${{PATH}}: {}",
-                error
-            );
-        }
-        Ok(Self {
-            executable,
-            version: None,
-        })
-    }
-
+pub trait Compiler {
    /// Compiles the Solidity `--standard-json` input into Yul IR.
-    pub fn standard_json(
+    fn standard_json(
        &mut self,
-        mut input: StandardJsonInput,
+        input: StandardJsonInput,
        pipeline: Pipeline,
        base_path: Option<String>,
        include_paths: Vec<String>,
        allow_paths: Option<String>,
-    ) -> anyhow::Result<StandardJsonOutput> {
-        let version = self.version()?;
-
-        let mut command = std::process::Command::new(self.executable.as_str());
-        command.stdin(std::process::Stdio::piped());
-        command.stdout(std::process::Stdio::piped());
-        command.arg("--standard-json");
-
-        if let Some(base_path) = base_path {
-            command.arg("--base-path");
-            command.arg(base_path);
-        }
-        for include_path in include_paths.into_iter() {
-            command.arg("--include-path");
-            command.arg(include_path);
-        }
-        if let Some(allow_paths) = allow_paths {
-            command.arg("--allow-paths");
-            command.arg(allow_paths);
-        }
-
-        input.normalize(&version.default);
-
-        let suppressed_warnings = input.suppressed_warnings.take().unwrap_or_default();
-
-        let input_json = serde_json::to_vec(&input).expect("Always valid");
-
-        let process = command.spawn().map_err(|error| {
-            anyhow::anyhow!("{} subprocess spawning error: {:?}", self.executable, error)
-        })?;
-        process
-            .stdin
-            .as_ref()
-            .ok_or_else(|| anyhow::anyhow!("{} stdin getting error", self.executable))?
-            .write_all(input_json.as_slice())
-            .map_err(|error| {
-                anyhow::anyhow!("{} stdin writing error: {:?}", self.executable, error)
-            })?;
-
-        let output = process.wait_with_output().map_err(|error| {
-            anyhow::anyhow!("{} subprocess output error: {:?}", self.executable, error)
-        })?;
-        if !output.status.success() {
-            anyhow::bail!(
-                "{} error: {}",
-                self.executable,
-                String::from_utf8_lossy(output.stderr.as_slice()).to_string()
-            );
-        }
-
-        let mut output: StandardJsonOutput =
-            revive_common::deserialize_from_slice(output.stdout.as_slice()).map_err(|error| {
-                anyhow::anyhow!(
-                    "{} subprocess output parsing error: {}\n{}",
-                    self.executable,
-                    error,
-                    revive_common::deserialize_from_slice::<serde_json::Value>(
-                        output.stdout.as_slice()
-                    )
-                    .map(|json| serde_json::to_string_pretty(&json).expect("Always valid"))
-                    .unwrap_or_else(
-                        |_| String::from_utf8_lossy(output.stdout.as_slice()).to_string()
-                    ),
-                )
-            })?;
-        output.preprocess_ast(&version, pipeline, suppressed_warnings.as_slice())?;
-
-        Ok(output)
-    }
+    ) -> anyhow::Result<StandardJsonOutput>;

    /// The `solc --combined-json abi,hashes...` mirror.
-    pub fn combined_json(
+    fn combined_json(
        &self,
        paths: &[PathBuf],
        combined_json_argument: &str,
-    ) -> anyhow::Result<CombinedJson> {
-        let mut command = std::process::Command::new(self.executable.as_str());
-        command.args(paths);
-
-        let mut combined_json_flags = Vec::new();
-        let mut combined_json_fake_flag_pushed = false;
-        let mut filtered_flags = Vec::with_capacity(3);
-        for flag in combined_json_argument.split(',') {
-            match flag {
-                flag @ "asm" | flag @ "bin" | flag @ "bin-runtime" => filtered_flags.push(flag),
-                flag => combined_json_flags.push(flag),
-            }
-        }
-        if combined_json_flags.is_empty() {
-            combined_json_flags.push("ast");
-            combined_json_fake_flag_pushed = true;
-        }
-        command.arg("--combined-json");
-        command.arg(combined_json_flags.join(","));
-
-        let output = command.output().map_err(|error| {
-            anyhow::anyhow!("{} subprocess error: {:?}", self.executable, error)
-        })?;
-        if !output.status.success() {
-            println!("{}", String::from_utf8_lossy(output.stdout.as_slice()));
-            println!("{}", String::from_utf8_lossy(output.stderr.as_slice()));
-            anyhow::bail!(
-                "{} error: {}",
-                self.executable,
-                String::from_utf8_lossy(output.stdout.as_slice()).to_string()
-            );
-        }
-
-        let mut combined_json: CombinedJson =
-            revive_common::deserialize_from_slice(output.stdout.as_slice()).map_err(|error| {
-                anyhow::anyhow!(
-                    "{} subprocess output parsing error: {}\n{}",
-                    self.executable,
-                    error,
-                    revive_common::deserialize_from_slice::<serde_json::Value>(
-                        output.stdout.as_slice()
-                    )
-                    .map(|json| serde_json::to_string_pretty(&json).expect("Always valid"))
-                    .unwrap_or_else(
-                        |_| String::from_utf8_lossy(output.stdout.as_slice()).to_string()
-                    ),
-                )
-            })?;
-        for filtered_flag in filtered_flags.into_iter() {
-            for (_path, contract) in combined_json.contracts.iter_mut() {
-                match filtered_flag {
-                    "asm" => contract.asm = Some(serde_json::Value::Null),
-                    "bin" => contract.bin = Some("".to_owned()),
-                    "bin-runtime" => contract.bin_runtime = Some("".to_owned()),
-                    _ => continue,
-                }
-            }
-        }
-        if combined_json_fake_flag_pushed {
-            combined_json.source_list = None;
-            combined_json.sources = None;
-        }
-        combined_json.remove_evm();
-
-        Ok(combined_json)
-    }
+    ) -> anyhow::Result<CombinedJson>;

    /// The `solc` Yul validator.
-    pub fn validate_yul(&self, path: &Path) -> anyhow::Result<()> {
-        let mut command = std::process::Command::new(self.executable.as_str());
-        command.arg("--strict-assembly");
-        command.arg(path);
-
-        let output = command.output().map_err(|error| {
-            anyhow::anyhow!("{} subprocess error: {:?}", self.executable, error)
-        })?;
-        if !output.status.success() {
-            anyhow::bail!(
-                "{} error: {}",
-                self.executable,
-                String::from_utf8_lossy(output.stderr.as_slice()).to_string()
-            );
-        }
-
-        Ok(())
-    }
+    fn validate_yul(&self, path: &Path) -> anyhow::Result<()>;

    /// The `solc --version` mini-parser.
-    pub fn version(&mut self) -> anyhow::Result<Version> {
-        if let Some(version) = self.version.as_ref() {
-            return Ok(version.to_owned());
-        }
-
-        let mut command = std::process::Command::new(self.executable.as_str());
-        command.arg("--version");
-        let output = command.output().map_err(|error| {
-            anyhow::anyhow!("{} subprocess error: {:?}", self.executable, error)
-        })?;
-        if !output.status.success() {
-            anyhow::bail!(
-                "{} error: {}",
-                self.executable,
-                String::from_utf8_lossy(output.stderr.as_slice()).to_string()
-            );
-        }
-
-        let stdout = String::from_utf8_lossy(output.stdout.as_slice());
-        let long = stdout
-            .lines()
-            .nth(1)
-            .ok_or_else(|| {
-                anyhow::anyhow!("{} version parsing: not enough lines", self.executable)
-            })?
-            .split(' ')
-            .nth(1)
-            .ok_or_else(|| {
-                anyhow::anyhow!(
-                    "{} version parsing: not enough words in the 2nd line",
-                    self.executable
-                )
-            })?
-            .to_owned();
-        let default: semver::Version = long
-            .split('+')
-            .next()
-            .ok_or_else(|| {
-                anyhow::anyhow!("{} version parsing: metadata dropping", self.executable)
-            })?
-            .parse()
-            .map_err(|error| anyhow::anyhow!("{} version parsing: {}", self.executable, error))?;
-
-        let l2_revision: Option<semver::Version> = stdout
-            .lines()
-            .nth(2)
-            .and_then(|line| line.split(' ').nth(1))
-            .and_then(|line| line.split('-').nth(1))
-            .and_then(|version| version.parse().ok());
-
-        let version = Version::new(long, default, l2_revision);
-        if version.default < Self::FIRST_SUPPORTED_VERSION {
-            anyhow::bail!(
-                "`solc` versions <{} are not supported, found {}",
-                Self::FIRST_SUPPORTED_VERSION,
-                version.default
-            );
-        }
-        if version.default > Self::LAST_SUPPORTED_VERSION {
-            anyhow::bail!(
-                "`solc` versions >{} are not supported, found {}",
-                Self::LAST_SUPPORTED_VERSION,
-                version.default
-            );
-        }
-
-        self.version = Some(version.clone());
-
-        Ok(version)
-    }
+    fn version(&mut self) -> anyhow::Result<Version>;
 }
@@ -3,7 +3,6 @@
 use serde::{Deserialize, Serialize};

 use crate::solc::version::Version as SolcVersion;
-use crate::solc::Compiler as SolcCompiler;

 /// The Solidity compiler pipeline type.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -19,7 +18,7 @@ pub enum Pipeline {
 impl Pipeline {
    /// We always use EVMLA for Solidity <=0.7, or if the user does not want to compile via Yul.
    pub fn new(solc_version: &SolcVersion, force_evmla: bool) -> Self {
-        if solc_version.default < SolcCompiler::FIRST_YUL_VERSION || force_evmla {
+        if solc_version.default < crate::solc::FIRST_YUL_VERSION || force_evmla {
            Self::EVMLA
        } else {
            Self::Yul
@@ -0,0 +1,286 @@
+//! The Solidity compiler.
+
+use std::io::Write;
+use std::path::Path;
+use std::path::PathBuf;
+
+use crate::solc::combined_json::CombinedJson;
+use crate::solc::pipeline::Pipeline;
+use crate::solc::standard_json::input::Input as StandardJsonInput;
+use crate::solc::standard_json::output::Output as StandardJsonOutput;
+use crate::solc::version::Version;
+
+use super::Compiler;
+
+/// The Solidity compiler.
+pub struct SolcCompiler {
+    /// The binary executable name.
+    pub executable: String,
+    /// The lazily-initialized compiler version.
+    pub version: Option<Version>,
+}
+
+impl SolcCompiler {
+    /// The default executable name.
+    pub const DEFAULT_EXECUTABLE_NAME: &'static str = "solc";
+
+    /// A shortcut constructor.
+    /// Different tools may use different `executable` names. For example, the integration tester
+    /// uses `solc-<version>` format.
+    pub fn new(executable: String) -> anyhow::Result<Self> {
+        if let Err(error) = which::which(executable.as_str()) {
+            anyhow::bail!(
+                "The `{executable}` executable not found in ${{PATH}}: {}",
+                error
+            );
+        }
+        Ok(Self {
+            executable,
+            version: None,
+        })
+    }
+}
+
+impl Compiler for SolcCompiler {
+    /// Compiles the Solidity `--standard-json` input into Yul IR.
+    fn standard_json(
+        &mut self,
+        mut input: StandardJsonInput,
+        pipeline: Pipeline,
+        base_path: Option<String>,
+        include_paths: Vec<String>,
+        allow_paths: Option<String>,
+    ) -> anyhow::Result<StandardJsonOutput> {
+        let version = self.version()?;
+
+        let mut command = std::process::Command::new(self.executable.as_str());
+        command.stdin(std::process::Stdio::piped());
+        command.stdout(std::process::Stdio::piped());
+        command.arg("--standard-json");
+
+        if let Some(base_path) = base_path {
+            command.arg("--base-path");
+            command.arg(base_path);
+        }
+        for include_path in include_paths.into_iter() {
+            command.arg("--include-path");
+            command.arg(include_path);
+        }
+        if let Some(allow_paths) = allow_paths {
+            command.arg("--allow-paths");
+            command.arg(allow_paths);
+        }
+
+        input.normalize(&version.default);
+
+        let suppressed_warnings = input.suppressed_warnings.take().unwrap_or_default();
+
+        let input_json = serde_json::to_vec(&input).expect("Always valid");
+
+        let process = command.spawn().map_err(|error| {
+            anyhow::anyhow!("{} subprocess spawning error: {:?}", self.executable, error)
+        })?;
+        process
+            .stdin
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("{} stdin getting error", self.executable))?
+            .write_all(input_json.as_slice())
+            .map_err(|error| {
+                anyhow::anyhow!("{} stdin writing error: {:?}", self.executable, error)
+            })?;
+
+        let output = process.wait_with_output().map_err(|error| {
+            anyhow::anyhow!("{} subprocess output error: {:?}", self.executable, error)
+        })?;
+        if !output.status.success() {
+            anyhow::bail!(
+                "{} error: {}",
+                self.executable,
+                String::from_utf8_lossy(output.stderr.as_slice()).to_string()
+            );
+        }
+
+        let mut output: StandardJsonOutput =
+            revive_common::deserialize_from_slice(output.stdout.as_slice()).map_err(|error| {
+                anyhow::anyhow!(
+                    "{} subprocess output parsing error: {}\n{}",
+                    self.executable,
+                    error,
+                    revive_common::deserialize_from_slice::<serde_json::Value>(
+                        output.stdout.as_slice()
+                    )
+                    .map(|json| serde_json::to_string_pretty(&json).expect("Always valid"))
+                    .unwrap_or_else(
+                        |_| String::from_utf8_lossy(output.stdout.as_slice()).to_string()
+                    ),
+                )
+            })?;
+        output.preprocess_ast(&version, pipeline, suppressed_warnings.as_slice())?;
+
+        Ok(output)
+    }
+
+    /// The `solc --combined-json abi,hashes...` mirror.
+    fn combined_json(
+        &self,
+        paths: &[PathBuf],
+        combined_json_argument: &str,
+    ) -> anyhow::Result<CombinedJson> {
+        let mut command = std::process::Command::new(self.executable.as_str());
+        command.args(paths);
+
+        let mut combined_json_flags = Vec::new();
+        let mut combined_json_fake_flag_pushed = false;
+        let mut filtered_flags = Vec::with_capacity(3);
+        for flag in combined_json_argument.split(',') {
+            match flag {
+                flag @ "asm" | flag @ "bin" | flag @ "bin-runtime" => filtered_flags.push(flag),
+                flag => combined_json_flags.push(flag),
+            }
+        }
+        if combined_json_flags.is_empty() {
+            combined_json_flags.push("ast");
+            combined_json_fake_flag_pushed = true;
+        }
+        command.arg("--combined-json");
+        command.arg(combined_json_flags.join(","));
+
+        let output = command.output().map_err(|error| {
+            anyhow::anyhow!("{} subprocess error: {:?}", self.executable, error)
+        })?;
+        if !output.status.success() {
+            println!("{}", String::from_utf8_lossy(output.stdout.as_slice()));
+            println!("{}", String::from_utf8_lossy(output.stderr.as_slice()));
+            anyhow::bail!(
+                "{} error: {}",
+                self.executable,
+                String::from_utf8_lossy(output.stdout.as_slice()).to_string()
+            );
+        }
+
+        let mut combined_json: CombinedJson =
+            revive_common::deserialize_from_slice(output.stdout.as_slice()).map_err(|error| {
+                anyhow::anyhow!(
+                    "{} subprocess output parsing error: {}\n{}",
+                    self.executable,
+                    error,
+                    revive_common::deserialize_from_slice::<serde_json::Value>(
+                        output.stdout.as_slice()
+                    )
+                    .map(|json| serde_json::to_string_pretty(&json).expect("Always valid"))
+                    .unwrap_or_else(
+                        |_| String::from_utf8_lossy(output.stdout.as_slice()).to_string()
+                    ),
+                )
+            })?;
+        for filtered_flag in filtered_flags.into_iter() {
+            for (_path, contract) in combined_json.contracts.iter_mut() {
+                match filtered_flag {
+                    "asm" => contract.asm = Some(serde_json::Value::Null),
+                    "bin" => contract.bin = Some("".to_owned()),
+                    "bin-runtime" => contract.bin_runtime = Some("".to_owned()),
+                    _ => continue,
+                }
+            }
+        }
+        if combined_json_fake_flag_pushed {
+            combined_json.source_list = None;
+            combined_json.sources = None;
+        }
+        combined_json.remove_evm();
+
+        Ok(combined_json)
+    }
+
+    /// The `solc` Yul validator.
+    fn validate_yul(&self, path: &Path) -> anyhow::Result<()> {
+        let mut command = std::process::Command::new(self.executable.as_str());
+        command.arg("--strict-assembly");
+        command.arg(path);
+
+        let output = command.output().map_err(|error| {
+            anyhow::anyhow!("{} subprocess error: {:?}", self.executable, error)
+        })?;
+        if !output.status.success() {
+            anyhow::bail!(
+                "{} error: {}",
+                self.executable,
+                String::from_utf8_lossy(output.stderr.as_slice()).to_string()
+            );
+        }
+
+        Ok(())
+    }
+
+    /// The `solc --version` mini-parser.
+    fn version(&mut self) -> anyhow::Result<Version> {
+        if let Some(version) = self.version.as_ref() {
+            return Ok(version.to_owned());
+        }
+
+        let mut command = std::process::Command::new(self.executable.as_str());
+        command.arg("--version");
+        let output = command.output().map_err(|error| {
+            anyhow::anyhow!("{} subprocess error: {:?}", self.executable, error)
+        })?;
+        if !output.status.success() {
+            anyhow::bail!(
+                "{} error: {}",
+                self.executable,
+                String::from_utf8_lossy(output.stderr.as_slice()).to_string()
+            );
+        }
+
+        let stdout = String::from_utf8_lossy(output.stdout.as_slice());
+        let long = stdout
+            .lines()
+            .nth(1)
+            .ok_or_else(|| {
+                anyhow::anyhow!("{} version parsing: not enough lines", self.executable)
+            })?
+            .split(' ')
+            .nth(1)
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "{} version parsing: not enough words in the 2nd line",
+                    self.executable
+                )
+            })?
+            .to_owned();
+        let default: semver::Version = long
+            .split('+')
+            .next()
+            .ok_or_else(|| {
+                anyhow::anyhow!("{} version parsing: metadata dropping", self.executable)
+            })?
+            .parse()
+            .map_err(|error| anyhow::anyhow!("{} version parsing: {}", self.executable, error))?;
+
+        let l2_revision: Option<semver::Version> = stdout
+            .lines()
+            .nth(2)
+            .and_then(|line| line.split(' ').nth(1))
+            .and_then(|line| line.split('-').nth(1))
+            .and_then(|version| version.parse().ok());
+
+        let version = Version::new(long, default, l2_revision);
+        if version.default < super::FIRST_SUPPORTED_VERSION {
+            anyhow::bail!(
+                "`solc` versions <{} are not supported, found {}",
+                super::FIRST_SUPPORTED_VERSION,
+                version.default
+            );
+        }
+        if version.default > super::LAST_SUPPORTED_VERSION {
+            anyhow::bail!(
+                "`solc` versions >{} are not supported, found {}",
+                super::LAST_SUPPORTED_VERSION,
+                version.default
+            );
+        }
+
+        self.version = Some(version.clone());
+
+        Ok(version)
+    }
+}
@@ -0,0 +1,133 @@
+//! The Solidity compiler.
+
+use std::path::Path;
+use std::path::PathBuf;
+
+use crate::solc::combined_json::CombinedJson;
+use crate::solc::pipeline::Pipeline;
+use crate::solc::standard_json::input::Input as StandardJsonInput;
+use crate::solc::standard_json::output::Output as StandardJsonOutput;
+use crate::solc::version::Version;
+use anyhow::Context;
+use std::ffi::{c_char, c_void, CStr, CString};
+
+use super::Compiler;
+
+extern "C" {
+    fn soljson_version() -> *const c_char;
+    fn soljson_compile(inputPtr: *const c_char, inputLen: usize) -> *const c_char;
+}
+
+/// The Solidity compiler.
+pub struct SoljsonCompiler {
+    /// The lazily-initialized compiler version.
+    pub version: Option<Version>,
+}
+
+impl Compiler for SoljsonCompiler {
+    /// Compiles the Solidity `--standard-json` input into Yul IR.
+    fn standard_json(
+        &mut self,
+        mut input: StandardJsonInput,
+        pipeline: Pipeline,
+        _base_path: Option<String>,
+        _include_paths: Vec<String>,
+        _allow_paths: Option<String>,
+    ) -> anyhow::Result<StandardJsonOutput> {
+        let version = self.version()?;
+        let suppressed_warnings = input.suppressed_warnings.take().unwrap_or_default();
+
+        let input_json = serde_json::to_string(&input).expect("Always valid");
+        let out = Self::compile_standard_json(input_json)?;
+        let mut output: StandardJsonOutput = revive_common::deserialize_from_slice(out.as_bytes())
+            .map_err(|error| {
+                anyhow::anyhow!(
+                    "Soljson output parsing error: {}\n{}",
+                    error,
+                    revive_common::deserialize_from_slice::<serde_json::Value>(out.as_bytes())
+                        .map(|json| serde_json::to_string_pretty(&json).expect("Always valid"))
+                        .unwrap_or_else(|_| String::from_utf8_lossy(out.as_bytes()).to_string()),
+                )
+            })?;
+        output.preprocess_ast(&version, pipeline, suppressed_warnings.as_slice())?;
+
+        Ok(output)
+    }
+
+    fn combined_json(
+        &self,
+        _paths: &[PathBuf],
+        _combined_json_argument: &str,
+    ) -> anyhow::Result<CombinedJson> {
+        unimplemented!();
+    }
+
+    fn validate_yul(&self, _path: &Path) -> anyhow::Result<()> {
+        unimplemented!();
+    }
+
+    fn version(&mut self) -> anyhow::Result<Version> {
+        let version = Self::get_soljson_version()?;
+        let long = version.clone();
+        let default: semver::Version = version
+            .split('+')
+            .next()
+            .ok_or_else(|| anyhow::anyhow!("Soljson version parsing: metadata dropping"))?
+            .parse()
+            .map_err(|error| anyhow::anyhow!("Soljson version parsing: {}", error))?;
+
+        let l2_revision: Option<semver::Version> = version
+            .split('-')
+            .nth(1)
+            .and_then(|version| version.parse().ok());
+
+        let version = Version::new(long, default, l2_revision);
+        if version.default < super::FIRST_SUPPORTED_VERSION {
+            anyhow::bail!(
+                "`Soljson` versions <{} are not supported, found {}",
+                super::FIRST_SUPPORTED_VERSION,
+                version.default
+            );
+        }
+        if version.default > super::LAST_SUPPORTED_VERSION {
+            anyhow::bail!(
+                "`Soljson` versions >{} are not supported, found {}",
+                super::LAST_SUPPORTED_VERSION,
+                version.default
+            );
+        }
+
+        self.version = Some(version.clone());
+
+        Ok(version)
+    }
+}
+
+impl SoljsonCompiler {
+    fn get_soljson_version() -> anyhow::Result<String> {
+        unsafe {
+            let version_ptr = soljson_version();
+            let version = CStr::from_ptr(version_ptr)
+                .to_str()
+                .with_context(|| "Failed to convert C string to Rust string")
+                .map(str::to_owned);
+            libc::free(version_ptr as *mut c_void);
+            Ok(version?)
+        }
+    }
+
+    fn compile_standard_json(input: String) -> anyhow::Result<String> {
+        let c_input = CString::new(input).unwrap();
+        let c_input_len = c_input.as_bytes().len();
+
+        unsafe {
+            let output_ptr = soljson_compile(c_input.as_ptr(), c_input_len);
+            let output_json = CStr::from_ptr(output_ptr)
+                .to_str()
+                .with_context(|| "Failed to convert C string to Rust string")
+                .map(str::to_owned);
+            libc::free(output_ptr as *mut c_void);
+            Ok(output_json?)
+        }
+    }
+}
@@ -8,8 +8,8 @@ use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 use std::path::PathBuf;

-use rayon::iter::IntoParallelIterator;
-use rayon::iter::ParallelIterator;
+#[cfg(feature = "parallel")]
+use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use serde::Deserialize;
 use serde::Serialize;

@@ -64,8 +64,12 @@ impl Input {
        via_ir: bool,
        suppressed_warnings: Option<Vec<Warning>>,
    ) -> anyhow::Result<Self> {
-        let sources = paths
-            .into_par_iter()
+        #[cfg(feature = "parallel")]
+        let iter = paths.into_par_iter(); // Parallel iterator
+
+        #[cfg(not(feature = "parallel"))]
+        let iter = paths.iter(); // Sequential iterator
+        let sources = iter
            .map(|path| {
                let source = Source::try_from(path.as_path()).unwrap_or_else(|error| {
                    panic!("Source code file {path:?} reading error: {error}")
@@ -106,8 +110,12 @@ impl Input {
        via_ir: bool,
        suppressed_warnings: Option<Vec<Warning>>,
    ) -> anyhow::Result<Self> {
-        let sources = sources
-            .into_par_iter()
+        #[cfg(feature = "parallel")]
+        let iter = sources.into_par_iter(); // Parallel iterator
+
+        #[cfg(not(feature = "parallel"))]
+        let iter = sources.into_iter(); // Sequential iterator
+        let sources = iter
            .map(|(path, content)| (path, Source::from(content)))
            .collect();

@@ -35,10 +35,9 @@ impl Error {
        let message = r#"
 ┌──────────────────────────────────────────────────────────────────────────────────────────────────┐
 │ Warning: It looks like you are using 'ecrecover' to validate a signature of a user account.      │
-│ zkSync Era comes with native account abstraction support, therefore it is highly recommended NOT │
+│ Polkadot comes with native account abstraction support, therefore it is highly recommended NOT   │
 │ to rely on the fact that the account has an ECDSA private key attached to it since accounts might│
 │ implement other signature schemes.                                                               │
-│ Read more about Account Abstraction at https://v2-docs.zksync.io/dev/developer-guides/aa.html    │
 └──────────────────────────────────────────────────────────────────────────────────────────────────┘"#
            .to_owned();

@@ -109,10 +108,9 @@ impl Error {
        let message = r#"
 ┌──────────────────────────────────────────────────────────────────────────────────────────────────┐
 │ Warning: You are checking for 'tx.origin' in your code, which might lead to unexpected behavior. │
-│ zkSync Era comes with native account abstraction support, and therefore the initiator of a       │
+│ Polkadot comes with native account abstraction support, and therefore the initiator of a         │
 │ transaction might be different from the contract calling your code. It is highly recommended NOT │
 │ to rely on tx.origin, but use msg.sender instead.                                                │
-│ Read more about Account Abstraction at https://v2-docs.zksync.io/dev/developer-guides/aa.html    │
 └──────────────────────────────────────────────────────────────────────────────────────────────────┘"#
            .to_owned();

@@ -45,7 +45,7 @@ pub struct Output {
    pub long_version: Option<String>,
    /// The `resolc` compiler version.
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub zk_version: Option<String>,
+    pub revive_version: Option<String>,
 }

 impl Output {
@@ -56,7 +56,7 @@ impl Output {
        libraries: BTreeMap<String, BTreeMap<String, String>>,
        pipeline: SolcPipeline,
        solc_version: &SolcVersion,
-        debug_config: Option<&revive_llvm_context::DebugConfig>,
+        debug_config: &revive_llvm_context::DebugConfig,
    ) -> anyhow::Result<Project> {
        if let SolcPipeline::EVMLA = pipeline {
            self.preprocess_dependencies()?;
@@ -90,9 +90,7 @@ impl Output {
                            continue;
                        }

-                        if let Some(debug_config) = debug_config {
-                            debug_config.dump_yul(full_path.as_str(), ir_optimized.as_str())?;
-                        }
+                        debug_config.dump_yul(full_path.as_str(), ir_optimized.as_str())?;

                        let mut lexer = Lexer::new(ir_optimized.to_owned());
                        let object = Object::parse(&mut lexer, None).map_err(|error| {
@@ -3,20 +3,20 @@ use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 use std::collections::HashMap;
 use std::path::PathBuf;
-use std::str::FromStr;
 use std::sync::Mutex;

 use once_cell::sync::Lazy;

 use crate::project::Project;
 use crate::solc::pipeline::Pipeline as SolcPipeline;
+use crate::solc::solc_compiler::SolcCompiler;
 use crate::solc::standard_json::input::settings::optimizer::Optimizer as SolcStandardJsonInputSettingsOptimizer;
 use crate::solc::standard_json::input::settings::selection::Selection as SolcStandardJsonInputSettingsSelection;
 use crate::solc::standard_json::input::Input as SolcStandardJsonInput;
 use crate::solc::standard_json::output::contract::evm::bytecode::Bytecode;
 use crate::solc::standard_json::output::contract::evm::bytecode::DeployedBytecode;
 use crate::solc::standard_json::output::Output as SolcStandardJsonOutput;
-use crate::solc::Compiler as SolcCompiler;
+use crate::solc::Compiler;
 use crate::warning::Warning;

 static PVM_BLOB_CACHE: Lazy<Mutex<HashMap<CachedBlob, Vec<u8>>>> = Lazy::new(Default::default);
@@ -24,6 +24,9 @@ static EVM_BLOB_CACHE: Lazy<Mutex<HashMap<CachedBlob, Vec<u8>>>> = Lazy::new(Def
 static EVM_RUNTIME_BLOB_CACHE: Lazy<Mutex<HashMap<CachedBlob, Vec<u8>>>> =
    Lazy::new(Default::default);

+const DEBUG_CONFIG: revive_llvm_context::DebugConfig =
+    revive_llvm_context::DebugConfig::new(None, true);
+
 #[derive(Hash, PartialEq, Eq)]
 struct CachedBlob {
    contract_name: String,
@@ -79,7 +82,8 @@ pub fn build_solidity_with_options(

    inkwell::support::enable_llvm_pretty_stack_trace();
    revive_llvm_context::initialize_target(revive_llvm_context::Target::PVM);
-    let _ = crate::process::EXECUTABLE.set(PathBuf::from(crate::r#const::DEFAULT_EXECUTABLE_NAME));
+    let _ = crate::process::native_process::EXECUTABLE
+        .set(PathBuf::from(crate::r#const::DEFAULT_EXECUTABLE_NAME));

    let mut solc = SolcCompiler::new(SolcCompiler::DEFAULT_EXECUTABLE_NAME.to_owned())?;
    let solc_version = solc.version()?;
@@ -103,14 +107,11 @@ pub fn build_solidity_with_options(

    let mut output = solc.standard_json(input, pipeline, None, vec![], None)?;

-    let project = output.try_to_project(sources, libraries, pipeline, &solc_version, None)?;
+    let project =
+        output.try_to_project(sources, libraries, pipeline, &solc_version, &DEBUG_CONFIG)?;

-    let build: crate::Build = project.compile(optimizer_settings, false, None)?;
-    build.write_to_standard_json(
-        &mut output,
-        &solc_version,
-        &semver::Version::from_str(env!("CARGO_PKG_VERSION"))?,
-    )?;
+    let build: crate::Build = project.compile(optimizer_settings, false, DEBUG_CONFIG)?;
+    build.write_to_standard_json(&mut output, &solc_version)?;

    Ok(output)
 }
@@ -127,7 +128,8 @@ pub fn build_solidity_with_options_evm(

    inkwell::support::enable_llvm_pretty_stack_trace();
    revive_llvm_context::initialize_target(revive_llvm_context::Target::PVM);
-    let _ = crate::process::EXECUTABLE.set(PathBuf::from(crate::r#const::DEFAULT_EXECUTABLE_NAME));
+    let _ = crate::process::native_process::EXECUTABLE
+        .set(PathBuf::from(crate::r#const::DEFAULT_EXECUTABLE_NAME));

    let mut solc = SolcCompiler::new(SolcCompiler::DEFAULT_EXECUTABLE_NAME.to_owned())?;
    let solc_version = solc.version()?;
@@ -180,7 +182,8 @@ pub fn build_solidity_and_detect_missing_libraries(

    inkwell::support::enable_llvm_pretty_stack_trace();
    revive_llvm_context::initialize_target(revive_llvm_context::Target::PVM);
-    let _ = crate::process::EXECUTABLE.set(PathBuf::from(crate::r#const::DEFAULT_EXECUTABLE_NAME));
+    let _ = crate::process::native_process::EXECUTABLE
+        .set(PathBuf::from(crate::r#const::DEFAULT_EXECUTABLE_NAME));

    let mut solc = SolcCompiler::new(SolcCompiler::DEFAULT_EXECUTABLE_NAME.to_owned())?;
    let solc_version = solc.version()?;
@@ -199,14 +202,11 @@ pub fn build_solidity_and_detect_missing_libraries(

    let mut output = solc.standard_json(input, pipeline, None, vec![], None)?;

-    let project = output.try_to_project(sources, libraries, pipeline, &solc_version, None)?;
+    let project =
+        output.try_to_project(sources, libraries, pipeline, &solc_version, &DEBUG_CONFIG)?;

    let missing_libraries = project.get_missing_libraries();
-    missing_libraries.write_to_standard_json(
-        &mut output,
-        &solc.version()?,
-        &semver::Version::from_str(env!("CARGO_PKG_VERSION"))?,
-    )?;
+    missing_libraries.write_to_standard_json(&mut output, &solc.version()?)?;

    Ok(output)
 }
@@ -219,9 +219,12 @@ pub fn build_yul(source_code: &str) -> anyhow::Result<()> {
    revive_llvm_context::initialize_target(revive_llvm_context::Target::PVM);
    let optimizer_settings = revive_llvm_context::OptimizerSettings::none();

-    let project =
-        Project::try_from_yul_string(PathBuf::from("test.yul").as_path(), source_code, None)?;
-    let _build = project.compile(optimizer_settings, false, None)?;
+    let project = Project::try_from_yul_string::<SolcCompiler>(
+        PathBuf::from("test.yul").as_path(),
+        source_code,
+        None,
+    )?;
+    let _build = project.compile(optimizer_settings, false, DEBUG_CONFIG)?;

    Ok(())
 }
@@ -232,14 +235,14 @@ pub fn check_solidity_warning(
    warning_substring: &str,
    libraries: BTreeMap<String, BTreeMap<String, String>>,
    pipeline: SolcPipeline,
-    skip_for_zkvm_edition: bool,
+    skip_for_revive_edition: bool,
    suppressed_warnings: Option<Vec<Warning>>,
 ) -> anyhow::Result<bool> {
    check_dependencies();

    let mut solc = SolcCompiler::new(SolcCompiler::DEFAULT_EXECUTABLE_NAME.to_owned())?;
    let solc_version = solc.version()?;
-    if skip_for_zkvm_edition && solc_version.l2_revision.is_some() {
+    if skip_for_revive_edition && solc_version.l2_revision.is_some() {
        return Ok(true);
    }

@@ -3,8 +3,11 @@ import * as path from 'path';
 const outputDir = 'artifacts';
 const binExtension = ':C.pvm';
 const asmExtension = ':C.pvmasm';
+const llvmExtension = '.ll';
 const contractSolFilename = 'contract.sol';
 const contractYulFilename = 'contract.yul';
+const contractOptimizedLLVMFilename = contractSolFilename + '.C.optimized';
+const contractUnoptimizedLLVMFilename = contractSolFilename + '.C.unoptimized';
 const pathToOutputDir = path.join(__dirname, '..', outputDir);
 const pathToContracts = path.join(__dirname, '..', 'src', 'contracts');
 const pathToBasicYulContract = path.join(pathToContracts, 'yul', contractYulFilename);
@@ -16,8 +19,11 @@ export const paths = {
  outputDir: outputDir,
  binExtension: binExtension,
  asmExtension: asmExtension,
+  llvmExtension: llvmExtension,
  contractSolFilename: contractSolFilename,
  contractYulFilename: contractYulFilename,
+  contractOptimizedLLVMFilename: contractOptimizedLLVMFilename,
+  contractUnoptimizedLLVMFilename: contractUnoptimizedLLVMFilename,
  pathToOutputDir: pathToOutputDir,
  pathToContracts: pathToContracts,
  pathToBasicSolContract: pathToBasicSolContract,
@@ -1,4 +1,4 @@
-import {executeCommand, isFolderExist, isFileExist, isFileEmpty} from "../src/helper";
+import { executeCommand, isFolderExist, isFileExist, isFileEmpty } from "../src/helper";
 import { paths } from '../src/entities';


@@ -76,3 +76,69 @@ describe("Default run a command from the help", () => {
        expect(result.output).not.toMatch(/([Ee]rror|[Ww]arning|[Ff]ail)/i);
    });
 });
+
+describe("Run resolc with source debug information", () => {
+    const commands = [
+        `resolc -g ${paths.pathToBasicSolContract}  --bin --asm --output-dir "${paths.pathToOutputDir}"`,
+        `resolc --disable-solc-optimizer -g ${paths.pathToBasicSolContract}  --bin --asm --output-dir "${paths.pathToOutputDir}"`
+    ]; // potential issue on resolc with full path on Windows cmd`;
+
+    for (var idx in commands) {
+        const command = commands[idx];
+        const result = executeCommand(command);
+
+        it("Compiler run successful", () => {
+            expect(result.output).toMatch(/(Compiler run successful.)/i);
+        });
+        it("Exit code = 0", () => {
+            expect(result.exitCode).toBe(0);
+        });
+        it("Output dir is created", () => {
+            expect(isFolderExist(paths.pathToOutputDir)).toBe(true);
+        });
+        it("Output files are created", () => { // a bug on windows
+            expect(isFileExist(paths.pathToOutputDir, paths.contractSolFilename, paths.binExtension)).toBe(true);
+            expect(isFileExist(paths.pathToOutputDir, paths.contractSolFilename, paths.asmExtension)).toBe(true);
+        });
+        it("the output files are not empty", () => {
+            expect(isFileEmpty(paths.pathToSolBinOutputFile)).toBe(false);
+            expect(isFileEmpty(paths.pathToSolAsmOutputFile)).toBe(false);
+        });
+        it("No 'Error'/'Fail' in the output", () => {
+            expect(result.output).not.toMatch(/([Ee]rror|[Ff]ail)/i);
+        });
+    }
+});
+
+describe("Run resolc with source debug information, check LLVM debug-info", () => {
+    const commands = [
+        `resolc -g ${paths.pathToBasicSolContract} --debug-output-dir="${paths.pathToOutputDir}"`,
+        `resolc -g --disable-solc-optimizer ${paths.pathToBasicSolContract} --debug-output-dir="${paths.pathToOutputDir}"`
+    ]; // potential issue on resolc with full path on Windows cmd`;
+
+    for (var idx in commands) {
+        const command = commands[idx];
+        const result = executeCommand(command);
+
+        it("Compiler run successful", () => {
+            expect(result.output).toMatch(/(Compiler run successful.)/i);
+        });
+        it("Exit code = 0", () => {
+            expect(result.exitCode).toBe(0);
+        });
+        it("Output dir is created", () => {
+            expect(isFolderExist(paths.pathToOutputDir)).toBe(true);
+        });
+        it("Output files are created", () => { // a bug on windows
+            expect(isFileExist(paths.pathToOutputDir, paths.contractOptimizedLLVMFilename, paths.llvmExtension)).toBe(true);
+            expect(isFileExist(paths.pathToOutputDir, paths.contractUnoptimizedLLVMFilename, paths.llvmExtension)).toBe(true);
+        });
+        it("the output files are not empty", () => {
+            expect(isFileEmpty(paths.pathToSolBinOutputFile)).toBe(false);
+            expect(isFileEmpty(paths.pathToSolAsmOutputFile)).toBe(false);
+        });
+        it("No 'Error'/'Fail' in the output", () => {
+            expect(result.output).not.toMatch(/([Ee]rror|[Ff]ail)/i);
+        });
+    }
+});
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Cyrill Leutwiler	952c5cc894	resolc-0.1.0-dev.7 (#143 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2024-12-20 14:33:08 +01:00
Cyrill Leutwiler	d8752ec6b5	the basefee opcode (#142 ) Signed-off-by: xermicus <cyrill@parity.io>	2024-12-19 18:59:10 +01:00
Cyrill Leutwiler	6ad846a285	the base fee opcode (#141 ) Signed-off-by: xermicus <cyrill@parity.io>	2024-12-19 12:44:15 +01:00
Cyrill Leutwiler	3f9771f838	update and fix the linker (#140 )	2024-12-18 23:11:06 +01:00
Cyrill Leutwiler	22070a824d	the gas limit opcode (#139 ) Signed-off-by: xermicus <cyrill@parity.io>	2024-12-18 20:31:42 +01:00
Cyrill Leutwiler	d299dd1a19	change getters to register version (#138 )	2024-12-18 17:56:37 +01:00
Cyrill Leutwiler	14a598e840	implement the gas opcode (#136 )	2024-12-18 17:19:32 +01:00
Cyrill Leutwiler	55ec0988e8	fix the CI runner version (#137 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2024-12-18 17:03:29 +01:00
Cyrill Leutwiler	909de515c4	Allow arbitrary call data size (#135 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2024-12-18 14:04:46 +01:00
Sebastian Miasojed	afe44ad21b	JS: Fix encoding conversion from utf16 to utf8 (#131 )	2024-12-11 09:23:02 +01:00
Cyrill Leutwiler	2cb8f82266	calls: supply max ref_time and proof_size limits (#133 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2024-12-10 16:31:44 +01:00
Cyrill Leutwiler	6f2f158ef1	fix new clippy lint (#132 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2024-12-10 15:24:25 +01:00
Cyrill Leutwiler	4e5482bad2	fix the commit sha in the version (#129 ) Signed-off-by: xermicus <cyrill@parity.io>	2024-12-03 12:34:17 +01:00
Cyrill Leutwiler	0110258d81	release 0.1.0 dev.6 (#128 )	2024-11-29 17:45:47 +01:00
Cyrill Leutwiler	f0d9d44dce	Implement the gasprice opcode (#127 )	2024-11-29 17:14:27 +01:00
Cyrill Leutwiler	3f6cd115ee	update warnings (#126 ) Signed-off-by: xermicus <cyrill@parity.io>	2024-11-29 16:23:36 +01:00
Cyrill Leutwiler	7c00bbb0fc	remove unneeded utils (#125 ) Signed-off-by: xermicus <cyrill@parity.io>	2024-11-29 16:21:24 +01:00
Cyrill Leutwiler	423a494621	Switch target to 64bit and enable the zbb feature (#120 )	2024-11-29 15:56:10 +01:00
Cyrill Leutwiler	08112e3449	Fix broken link in README.md	2024-11-29 10:39:42 +01:00
Jeeyong Um	db6ca1fcfa	Fix broken link to introduction in README.md (#124 )	2024-11-29 10:38:09 +01:00
Sebastian Miasojed	54d154a73c	Merge pull request #123 from smiasojed/web Add web worker compatibility	2024-11-29 10:22:59 +01:00
dependabot[bot]	93f1deb6a5	Bump rustls from 0.23.17 to 0.23.18 (#121 ) Bumps [rustls](https://github.com/rustls/rustls) from 0.23.17 to 0.23.18. - [Release notes](https://github.com/rustls/rustls/releases) - [Changelog](https://github.com/rustls/rustls/blob/main/CHANGELOG.md) - [Commits](https://github.com/rustls/rustls/compare/v/0.23.17...v/0.23.18) --- updated-dependencies: - dependency-name: rustls dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-11-29 09:50:29 +01:00
Sebastian Miasojed	9a150b13f3	Remove hardcoded soljson	2024-11-28 16:54:27 +01:00
Sebastian Miasojed	677cef9c0f	Remove comment	2024-11-27 15:30:49 +01:00
Sebastian Miasojed	d25be523c1	Update deps	2024-11-27 15:28:04 +01:00
Sebastian Miasojed	6a4fd1e991	Add web worker compatibility	2024-11-27 15:17:26 +01:00
Sebastian Miasojed	81915ddbcb	Merge pull request #122 from smiasojed/sync Remove async JS calls	2024-11-27 14:03:26 +01:00
Sebastian Miasojed	0f25bac4bd	Fix CI	2024-11-27 08:49:07 +01:00
Sebastian Miasojed	7d41495587	Fmt	2024-11-27 08:30:07 +01:00
Sebastian Miasojed	d6d5acfcce	Remove deps on solc	2024-11-26 22:35:18 +01:00
Sebastian Miasojed	130ac48bf0	Fix revive wasm CI	2024-11-26 22:11:26 +01:00
Sebastian Miasojed	b65fa2e42c	Remove async calls from revive	2024-11-26 22:03:57 +01:00
Sebastian Miasojed	1eb1083d40	Merge pull request #111 from smiasojed/resolc.js Add compilation to NodeJS module	2024-11-26 14:44:44 +01:00
Sebastian Miasojed	4c0c74f7f4	Fix npm build	2024-11-25 15:36:36 +01:00
Sebastian Miasojed	229c0d452d	Merge remote-tracking branch 'origin/main' into resolc.js	2024-11-25 10:54:44 +01:00
Sebastian Miasojed	4e024655a1	Add support for esm and cjs modules	2024-11-25 10:26:22 +01:00
Ermal Kaleci	01b5ed5ba3	Implement delegate_call (#80 )	2024-11-23 18:05:21 +01:00
Sebastian Miasojed	892c9b5fbe	Update clone-llvm.sh Co-authored-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2024-11-22 19:52:06 +01:00
xermicus	84d47fa738	fix missing semicolon Signed-off-by: xermicus <cyrill@parity.io>	2024-11-22 16:14:07 +01:00
Cyrill Leutwiler	dbb47fd13e	experimental: support for debug info (#118 ) Signed-off-by: wpt967 <matt.aw@parity.io> Signed-off-by: xermicus <cyrill@parity.io>	2024-11-22 08:56:09 +01:00
Cyrill Leutwiler	87f2bcefb3	dump the elf shared object into the debug output directory (#119 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2024-11-21 21:48:42 +01:00
Sebastian Miasojed	05925f25f1	Update comment	2024-11-21 13:57:00 +01:00
Sebastian Miasojed	8990b2a486	Update emscripten-build-llvm.sh Co-authored-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2024-11-21 12:49:23 +01:00
Cyrill Leutwiler	89ddfb28c8	CI: ignore the broken test (#116 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2024-11-21 12:22:15 +01:00
Sebastian Miasojed	32d4b2309c	Fix build script	2024-11-21 10:36:12 +01:00
Sebastian Miasojed	a772ff1354	Fix build path	2024-11-21 10:29:21 +01:00
Sebastian Miasojed	0a82addf02	Add directory arg support to clone-llvm	2024-11-20 17:15:55 +01:00
Sebastian Miasojed	491850760f	Update readme file	2024-11-20 12:57:41 +01:00
Sebastian Miasojed	fcbe00f4a9	Merge branch 'main' into resolc.js	2024-11-20 12:51:10 +01:00
Sebastian Miasojed	77406264ea	Improve description	2024-11-20 12:42:29 +01:00
Sebastian Miasojed	cdebf69fc0	Fix stdin support	2024-11-20 10:54:15 +01:00
Sebastian Miasojed	f36d62ca73	Add stdin support	2024-11-20 10:27:57 +01:00
Sebastian Miasojed	39e504703e	Add test with standard json args	2024-11-18 16:52:56 +01:00
Sebastian Miasojed	63da7212a1	Add worker code to resolc.js	2024-11-18 14:49:35 +01:00
Sebastian Miasojed	3072c03600	Fix parallel feature	2024-11-18 13:59:48 +01:00
Sebastian Miasojed	d88ddb25bd	Refactor soljson compiler	2024-11-18 12:19:36 +01:00
Sebastian Miasojed	87dd77b784	Remove libsolc crate	2024-11-18 11:07:45 +01:00
Sebastian Miasojed	cece20deb1	Cleanup	2024-11-18 10:18:21 +01:00
Sebastian Miasojed	f57ab96eed	Revert changes in llvm build	2024-11-15 16:08:36 +01:00
Cyrill Leutwiler	3232382d96	update dependencies (#115 ) Signed-off-by: xermicus <cyrill@parity.io>	2024-11-15 13:50:55 +01:00
Cyrill Leutwiler	6a120463c2	implement the blockhash opcode (#114 )	2024-11-15 13:11:04 +01:00
Sebastian Miasojed	881b88354c	Rename compiler to solc	2024-11-14 17:09:03 +01:00
Cyrill Leutwiler	c9dd347755	Add documentation portal (#99 )	2024-11-14 14:21:48 +01:00
Sebastian Miasojed	140545ea15	Fix CI	2024-11-14 11:49:20 +01:00
Sebastian Miasojed	010a2ed223	Fmt	2024-11-14 11:44:48 +01:00
Sebastian Miasojed	563864dd25	Fix CI	2024-11-14 11:26:20 +01:00
Sebastian Miasojed	ce8bf3d9ef	Apply suggestions from previous review	2024-11-14 11:20:33 +01:00
Cyrill Leutwiler	f947984671	update 64bit target flags (#113 )	2024-11-14 10:29:21 +01:00
Sebastian Miasojed	14991f40ac	Fix CI for wasm path	2024-11-13 15:34:41 +01:00
Sebastian Miasojed	6d16790f83	Update GHA	2024-11-12 17:22:15 +01:00
Sebastian Miasojed	64fefe76b5	Removed not needed libs from linking process	2024-11-12 16:07:21 +01:00
Sebastian Miasojed	f59b47df7b	Add ltinfo dep to GHA	2024-11-12 12:52:11 +01:00
Sebastian Miasojed	6e6fe20c71	Add Missing dep to GHA	2024-11-12 09:52:06 +01:00
Sebastian Miasojed	93d2f3b9d9	Log LLVM version in GHA	2024-11-12 09:47:43 +01:00
Sebastian Miasojed	8a225871ee	Fix deps in GHA	2024-11-08 15:53:27 +01:00
Sebastian Miasojed	677aedc6f3	Switch GHA to ubuntu	2024-11-08 15:45:52 +01:00
Sebastian Miasojed	90423ffb6b	Remove llvm-15 env from GHA	2024-11-08 15:36:00 +01:00
Sebastian Miasojed	255176978a	Remove old llvm-15 from GHA	2024-11-08 15:27:11 +01:00
Sebastian Miasojed	9a8003afbf	Install llvm in GHA	2024-11-08 15:10:42 +01:00
Sebastian Miasojed	7f3d0cecb2	Update cmake versions in GHA	2024-11-08 15:00:14 +01:00
Sebastian Miasojed	18376432f1	Fix GHA emsdk path	2024-11-08 14:01:18 +01:00
Sebastian Miasojed	007b79ee62	Use bash in GHA	2024-11-08 13:51:51 +01:00
Sebastian Miasojed	8c7d18aec7	Update GHA for wasm build	2024-11-08 13:46:00 +01:00
Sebastian Miasojed	c0a82ce6d2	Update wasm GHA	2024-11-08 13:38:26 +01:00
Sebastian Miasojed	c51d50bc88	Add GHA for wasm target	2024-11-08 13:28:45 +01:00
Sebastian Miasojed	94445bab93	Fix compilation for wasm target	2024-11-08 12:06:11 +01:00
Sebastian Miasojed	a934ec204e	Add temoprary wasm compilation output	2024-11-08 10:55:26 +01:00
Sebastian Miasojed	b6baf6cfd9	Make wasm version to compile	2024-11-08 09:54:10 +01:00
Sebastian Miasojed	b7b28efded	Update solc compiler version check	2024-11-07 15:30:00 +01:00
Sebastian Miasojed	d260472330	Fmt	2024-11-07 15:15:52 +01:00
Sebastian Miasojed	4f6debcbe3	Make native version to compaile again	2024-11-07 15:04:35 +01:00
Sebastian Miasojed	9b23e19479	Fix Cargo.toml	2024-11-07 09:43:44 +01:00
Sebastian Miasojed	88a888d138	Merge remote-tracking branch 'origin/main' into resolc.js	2024-11-06 15:04:34 +01:00
Cyrill Leutwiler	4cce4a729e	pre-release v0.1.0-dev.5 (#110 )	2024-10-31 15:22:34 +01:00
Cyrill Leutwiler	9267a2af02	use the long revive version string in the contract metadata (#109 )	2024-10-31 14:52:06 +01:00
Cyrill Leutwiler	173ace72cb	solidity: rename the revive metadata (#106 ) Rename the revive metadata fields and includes the commit hash and LLVM version in the revive version (similar to what solc does). Signed-off-by: xermicus <cyrill@parity.io>	2024-10-31 13:00:35 +01:00
Cyrill Leutwiler	37ab2b6782	declare immutable globals during in declare (#108 ) Signed-off-by: xermicus <cyrill@parity.io>	2024-10-31 12:07:39 +01:00
Cyrill Leutwiler	43d2ef3ce9	implement the code size opcodes (#107 )	2024-10-31 11:46:47 +01:00
Cyrill Leutwiler	68564f9866	display the git revision version information (#105 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2024-10-30 14:28:00 +01:00
Cyrill Leutwiler	36d9317831	update the polkadot-sdk and polkavm dependencies (#104 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2024-10-30 09:28:24 +01:00
Cyrill Leutwiler	5b3b90db83	support the origin opcode (#103 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2024-10-29 18:40:25 +01:00
Cyrill Leutwiler	a4043ecde7	update LLVM target features (#102 ) Signed-off-by: xermicus <cyrill@parity.io>	2024-10-29 18:17:29 +01:00
Cyrill Leutwiler	f985f42370	update polkadot-sdk and inkwell dependencies (#101 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2024-10-29 11:27:44 +01:00
Ermal Kaleci	aae25107a2	support full storage key space (#100 ) - The storage pointer values will no longer be truncated to the register size, allowing for the use of arbitrary storage keys - Failed storage value reads will now guarantee to return the zero value	2024-10-28 10:18:11 +01:00
Sebastian Miasojed	5ac67bdc0d	Initial wasm support	2024-08-29 17:28:31 +02:00