Merge branch 'main' into cl/optsize

- Add support for the YUL optimizer details in the standard json input
definition.
- Make optimizer settings optional. They can be omitted and solc will
pick default values ([see here for
reference](https://docs.soliditylang.org/en/latest/using-the-compiler.html#input-description)).

For example allows to use the
[`yul-phaser`](https://github.com/ethereum/solidity/blob/0917604a5ec7cff8bd40a1137f4fcb303fb90527/tools/yulPhaser/README.md?plain=1)
utility. I did a single search with slightly adjusted costs (just made
some educated guess) and after an hour or so this already found an
optimizer sequence
(`OESsShMxeoufcSTvlFxtelTfnfEvicdFxnsvopgCaIeLcnvsTtUrUgdVTUttaeUomccTTTuujsVVvVDvvueUrTjUOmjrrhuuTtj`)
which shrinks the size of the `EndpointV2.sol` from LayerZero by 10%.

---------

Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>
Signed-off-by: xermicus <cyrill@parity.io>

.github/scripts/json_generator.py

@@ -1,3 +1,13 @@
+#!/usr/bin/env python3
+"""
+This script generates JSON files for different platforms based on GitHub release data.
+It fetches release information from a specified GitHub repository and tag,
+parses the release assets, and generates JSON files for each platform with relevant metadata.
+It also handles checksum files and updates a list.json file for each platform.
+It requires the GITHUB_TOKEN environment variable to be set for authentication.
+Usage:
+    python json_generator.py <repo> <tag>
+"""
 import os
 import sys
 import json

.github/scripts/json_generator_nightly.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+This script generates JSON files for different platforms based on GitHub data.
+Requires the GITHUB_SHA, FIRST_SOLC_VERSION, LAST_SOLC_VERSION, TAG and FILEPATH environment variables to be set.
+Usage:
+    python json_generator_nightly.py
+"""
+import os
+import sys
+import json
+from datetime import datetime
+
+def validate_env_variables():
+    """Validate that environment variables are set."""
+    if "GITHUB_SHA" not in os.environ:
+        print("Error: GITHUB_SHA environment variable is not set.")
+        sys.exit(1)
+    if "FIRST_SOLC_VERSION" not in os.environ:
+        print("Error: FIRST_SOLC_VERSION environment variable is not set.")
+        sys.exit(1)
+    if "LAST_SOLC_VERSION" not in os.environ:
+        print("Error: LAST_SOLC_VERSION environment variable is not set.")
+        sys.exit(1)
+    if "TAG" not in os.environ:
+        print("Error: TAG environment variable is not set.")
+        sys.exit(1)
+    if "FILEPATH" not in os.environ:
+        print("Error: FILEPATH environment variable is not set.")
+        sys.exit(1)
+
+
+def fetch_data_file():
+    """
+    Fetch the data.json file with artifacts urls and sha256 checksums
+    and parse it into a single dictionary mapping artifact names to their URLs and SHAs.
+    """
+    # read data.json file
+    artifacts_data = {}
+    data_file_path = os.environ["FILEPATH"]
+    if not os.path.exists(data_file_path):
+        print("Error: data.json file not found.")
+        sys.exit(1)
+    with open(data_file_path, 'r') as f:
+        try:
+            artifacts_data = json.load(f)
+        except json.JSONDecodeError:
+            print("Error: data.json file is not a valid JSON.")
+            sys.exit(1)
+
+    result = {}
+
+    for item in artifacts_data:
+        for key, value in item.items():
+            if key.endswith('_url'):
+                base_key = key.rsplit('_url', 1)[0]
+                if base_key not in result:
+                    result[base_key] = {}
+                result[base_key]['url'] = value
+            elif key.endswith('_sha'):
+                base_key = key.rsplit('_sha', 1)[0]
+                if base_key not in result:
+                    result[base_key] = {}
+                result[base_key]['sha'] = value
+
+    return result
+
+
+
+
+
+def extract_build_hash():
+    """Extract the first 8 characters of the commit hash."""
+    sha = os.environ.get("GITHUB_SHA")
+    return f"commit.{sha[:8]}"
+
+def generate_asset_json_nightly(name, url, checksum):
+    """Generate JSON for a specific asset."""
+    # Date in format YYYY-MM-DD
+    date = datetime.now().strftime("%Y.%-m.%-d")
+    last_version = os.environ.get("TAG").replace('v','')
+    version = f"{last_version}-nightly.{date}"
+    SHA = os.environ.get("GITHUB_SHA", "")[:8]
+    build = f"commit.{SHA}"
+    long_version = f"{version}+{build}"
+
+    return {
+        "name": name,
+        "version": version,
+        "build": build,
+        "longVersion": long_version,
+        "url": url,
+        "sha256": checksum,
+        "firstSolcVersion": os.environ.get("FIRST_SOLC_VERSION"),
+        "lastSolcVersion": os.environ.get("LAST_SOLC_VERSION")
+    }
+
+def save_platform_json(platform_folder, asset_json):
+    """Save asset JSON and update list.json for a specific platform."""
+    # Create platform folder if it doesn't exist
+    os.makedirs(platform_folder, exist_ok=True)
+
+    # Update or create list.json
+    list_file_path = os.path.join(platform_folder, "list.json")
+
+    if os.path.exists(list_file_path):
+        with open(list_file_path, 'r') as f:
+            try:
+                list_data = json.load(f)
+            except json.JSONDecodeError:
+                list_data = {"builds": [], "releases": {}, "latestRelease": ""}
+    else:
+        list_data = {"builds": [], "releases": {}, "latestRelease": ""}
+
+    # Remove any existing entry with the same path
+    list_data['builds'] = [
+        build for build in list_data['builds']
+        if build['version'] != asset_json['version']
+    ]
+    # Add the new build
+    list_data['builds'].append(asset_json)
+
+    # Update releases
+    version = asset_json['version']
+    list_data['releases'][version] = f"{asset_json['name']}+{asset_json['longVersion']}"
+
+    # Update latest release
+    list_data['latestRelease'] = version
+
+    with open(list_file_path, 'w') as f:
+        json.dump(list_data, f, indent=4)
+
+def main():
+
+    validate_env_variables()
+    data = fetch_data_file()
+
+    # Mapping of asset names to platform folders
+    platform_mapping = {
+        'resolc-x86_64-unknown-linux-musl': 'linux',
+        'resolc-universal-apple-darwin': 'macos',
+        'resolc-x86_64-pc-windows-msvc': 'windows',
+        'resolc-web.js': 'wasm'
+    }
+
+    # Process each asset
+    for asset in data.keys():
+        platform_name = platform_mapping.get(asset)
+        if platform_name:
+            platform_folder = os.path.join(platform_name)
+            asset_json = generate_asset_json_nightly(asset, data[asset]['url'], data[asset]['sha'])
+            save_platform_json(platform_folder, asset_json)
+            print(f"Processed {asset} for {platform_name}")
+
+if __name__ == "__main__":
+    main()

.github/workflows/release-nightly.yml

@@ -0,0 +1,385 @@
+name: Nightly Release
+on:
+  schedule:
+    # Run every day at 01:00 UTC
+    - cron: "0 1 * * *"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+env:
+  CARGO_TERM_COLOR: always
+  RUST_MUSL_CROSS_IMAGE: messense/rust-musl-cross@sha256:c0154e992adb791c3b848dd008939d19862549204f8cb26f5ca7a00f629e6067
+
+jobs:
+  # check if there were commits yesterday
+  check_commits:
+    runs-on: ubuntu-latest
+    outputs:
+      has_commits: ${{ steps.check_commits.outputs.has_commits }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Fetch full history to check previous commits
+          ref: "main"
+
+      - name: Check for commits from yesterday
+        id: check_commits
+        run: |
+          # Get yesterday's date in YYYY-MM-DD format
+          YESTERDAY=$(date -d "yesterday" +%Y-%m-%d)
+          echo "Checking for commits from: $YESTERDAY"
+
+          # Check if there were any commits yesterday
+          COMMIT_COUNT=$(git log --oneline --since="$YESTERDAY 00:00:00" --until="$YESTERDAY 23:59:59" | wc -l)
+
+          echo "Found $COMMIT_COUNT commits from yesterday"
+
+          if [ $COMMIT_COUNT -gt 0 ]; then
+            echo "has_commits=true" >> $GITHUB_OUTPUT
+            echo "✅ Found $COMMIT_COUNT commits from yesterday - continuing workflow"
+          else
+            echo "has_commits=false" >> $GITHUB_OUTPUT
+            echo "❌ No commits found from yesterday - skipping remaining steps"
+            echo "::notice::❌ No commits found from yesterday - skipping remaining steps"
+          fi
+
+  build:
+    # github actions matrix jobs don't support multiple outputs
+    # ugly workaround from https://github.com/orgs/community/discussions/17245#discussioncomment-11222880
+    if: ${{ needs.check_commits.outputs.has_commits == 'true' }}
+    outputs:
+      resolc-x86_64-unknown-linux-musl_url: ${{ steps.set-output.outputs.resolc-x86_64-unknown-linux-musl_url }}
+      resolc-x86_64-unknown-linux-musl_sha: ${{ steps.set-output.outputs.resolc-x86_64-unknown-linux-musl_sha }}
+      resolc-aarch64-apple-darwin_url: ${{ steps.set-output.outputs.resolc-aarch64-apple-darwin_url }}
+      resolc-aarch64-apple-darwin_sha: ${{ steps.set-output.outputs.resolc-aarch64-apple-darwin_sha }}
+      resolc-x86_64-apple-darwin_url: ${{ steps.set-output.outputs.resolc-x86_64-apple-darwin_url }}
+      resolc-x86_64-apple-darwin_sha: ${{ steps.set-output.outputs.resolc-x86_64-apple-darwin_sha }}
+      resolc-x86_64-pc-windows-msvc_url: ${{ steps.set-output.outputs.resolc-x86_64-pc-windows-msvc_url }}
+      resolc-x86_64-pc-windows-msvc_sha: ${{ steps.set-output.outputs.resolc-x86_64-pc-windows-msvc_sha }}
+    strategy:
+      matrix:
+        target:
+          [
+            x86_64-unknown-linux-musl,
+            aarch64-apple-darwin,
+            x86_64-apple-darwin,
+            x86_64-pc-windows-msvc,
+          ]
+        include:
+          - target: x86_64-unknown-linux-musl
+            type: musl
+            runner: ubuntu-24.04
+          - target: aarch64-apple-darwin
+            type: native
+            runner: macos-14
+          - target: x86_64-apple-darwin
+            type: native
+            runner: macos-13
+          - target: x86_64-pc-windows-msvc
+            type: native
+            runner: windows-2022
+    runs-on: ${{ matrix.runner }}
+    needs: [check_commits]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          # without this it will override our rust flags
+          rustflags: ""
+          cache-key: ${{ matrix.target }}
+
+      - name: Download LLVM
+        uses: ./.github/actions/get-llvm
+        with:
+          target: ${{ matrix.target }}
+
+      - name: Build
+        if: ${{ matrix.type == 'native' }}
+        shell: bash
+        run: |
+          export LLVM_SYS_181_PREFIX=$PWD/llvm-${{ matrix.target }}
+          make install-bin
+          mv target/release/resolc resolc-${{ matrix.target }} || mv target/release/resolc.exe resolc-${{ matrix.target }}.exe
+
+      - name: Build
+        if: ${{ matrix.type == 'musl' }}
+        run: |
+          docker run -v $PWD:/opt/revive $RUST_MUSL_CROSS_IMAGE /bin/bash -c "
+           cd /opt/revive
+           chown -R root:root .
+           apt update && apt upgrade -y && apt install -y pkg-config
+           export LLVM_SYS_181_PREFIX=/opt/revive/llvm-${{ matrix.target }}
+           make install-bin
+           mv target/${{ matrix.target }}/release/resolc resolc-${{ matrix.target }}
+           "
+          sudo chown -R $(id -u):$(id -g) .
+
+      - name: Install Solc
+        uses: ./.github/actions/get-solc
+
+      - name: Basic Sanity Check
+        shell: bash
+        run: |
+          result=$(./resolc-${{ matrix.target }} --bin crates/integration/contracts/flipper.sol)
+          echo $result
+          if [[ $result == *'0x50564d'* ]]; then exit 0; else exit 1; fi
+
+      - name: Upload artifacts (nightly)
+        uses: actions/upload-artifact@v4
+        id: artifact-upload-step
+        with:
+          name: resolc-${{ matrix.target }}
+          path: resolc-${{ matrix.target }}*
+          retention-days: 40
+
+      - name: Set output variables (nightly)
+        id: set-output
+        shell: bash
+        run: |
+          echo "Artifact URL is ${{ steps.artifact-upload-step.outputs.artifact-url }}"
+          echo "Artifact SHA is ${{ steps.artifact-upload-step.outputs.artifact-digest }}"
+          echo "resolc-${{ matrix.target }}_url=${{ steps.artifact-upload-step.outputs.artifact-url }}"
+          echo "resolc-${{ matrix.target }}_url=${{ steps.artifact-upload-step.outputs.artifact-url }}" >> "$GITHUB_OUTPUT"
+          echo "resolc-${{ matrix.target }}_sha=${{ steps.artifact-upload-step.outputs.artifact-digest }}"
+          echo "resolc-${{ matrix.target }}_sha=${{ steps.artifact-upload-step.outputs.artifact-digest }}" >> "$GITHUB_OUTPUT"
+
+  build-wasm:
+    runs-on: ubuntu-24.04
+    needs: [check_commits]
+    if: ${{ needs.check_commits.outputs.has_commits == 'true' }}
+    outputs:
+      resolc-web.js_url: ${{ steps.set-output.outputs.resolc_web_js_url }}
+      resolc-web.js_sha: ${{ steps.set-output.outputs.resolc_web_js_sha }}
+    env:
+      RELEASE_RESOLC_WASM_URI: https://github.com/paritytech/revive/releases/download/${{ github.ref_name }}/resolc.wasm
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          target: wasm32-unknown-emscripten
+          # without this it will override our rust flags
+          rustflags: ""
+
+      - name: Download Host LLVM
+        uses: ./.github/actions/get-llvm
+        with:
+          target: x86_64-unknown-linux-gnu
+
+      - name: Download Wasm LLVM
+        uses: ./.github/actions/get-llvm
+        with:
+          target: wasm32-unknown-emscripten
+
+      - name: Download EMSDK
+        uses: ./.github/actions/get-emsdk
+
+      - name: Build
+        run: |
+          export LLVM_SYS_181_PREFIX=$PWD/llvm-x86_64-unknown-linux-gnu
+          export REVIVE_LLVM_TARGET_PREFIX=$PWD/llvm-wasm32-unknown-emscripten
+          source emsdk/emsdk_env.sh
+          make install-wasm
+          chmod -x ./target/wasm32-unknown-emscripten/release/resolc.wasm
+
+      - name: Set Up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "20"
+
+      - name: Basic Sanity Check
+        run: |
+          mkdir -p solc
+          curl -sSLo solc/soljson.js https://github.com/ethereum/solidity/releases/download/v0.8.30/soljson.js
+          node -e "
+          const soljson = require('solc/soljson');
+          const createRevive = require('./target/wasm32-unknown-emscripten/release/resolc.js');
+
+          const compiler = createRevive();
+          compiler.soljson = soljson;
+
+          const standardJsonInput =
+          {
+            language: 'Solidity',
+            sources: {
+              'MyContract.sol': {
+                content: 'pragma solidity ^0.8.0; contract MyContract { function greet() public pure returns (string memory) { return \'Hello\'; } }',
+              },
+            },
+            settings: { optimizer: { enabled: false } }
+          };
+
+          compiler.writeToStdin(JSON.stringify(standardJsonInput));
+          compiler.callMain(['--standard-json']);
+
+          // Collect output
+          const stdout = compiler.readFromStdout();
+          const stderr = compiler.readFromStderr();
+
+          if (stderr) { console.error(stderr); process.exit(1); }
+
+          let out = JSON.parse(stdout);
+          let bytecode = out.contracts['MyContract.sol']['MyContract'].evm.bytecode.object
+          console.log(bytecode);
+
+          if(!bytecode.startsWith('50564d')) { process.exit(1); }
+          "
+
+      - name: Compress Artifact
+        run: |
+          mkdir -p resolc-wasm32-unknown-emscripten
+          mv ./target/wasm32-unknown-emscripten/release/resolc.js ./resolc-wasm32-unknown-emscripten/
+          mv ./target/wasm32-unknown-emscripten/release/resolc.wasm ./resolc-wasm32-unknown-emscripten/
+          mv ./target/wasm32-unknown-emscripten/release/resolc_web.js ./resolc-wasm32-unknown-emscripten/
+
+      # There is no way to upload several files as several artifacts with a single upload-artifact step
+      # It's needed to have resolc_web.js separately for night builds for resolc-bin repo
+      # https://github.com/actions/upload-artifact/issues/331
+      - name: Upload artifact resolc.js (nightly)
+        uses: actions/upload-artifact@v4
+        with:
+          name: resolc.js
+          path: resolc-wasm32-unknown-emscripten/resolc.js
+          retention-days: 40
+
+      - name: Upload artifacts resolc.wasm (nightly)
+        uses: actions/upload-artifact@v4
+        with:
+          name: resolc.wasm
+          path: resolc-wasm32-unknown-emscripten/resolc.wasm
+          retention-days: 40
+
+      - name: Upload artifacts resolc_web.js (nightly)
+        uses: actions/upload-artifact@v4
+        id: artifact-upload-step
+        with:
+          name: resolc_web.js
+          path: resolc-wasm32-unknown-emscripten/resolc_web.js
+          retention-days: 40
+
+      - name: Set output variables
+        id: set-output
+        env:
+          TARGET: resolc_web_js
+        run: |
+          echo "Artifact URL is ${{ steps.artifact-upload-step.outputs.artifact-url }}"
+          echo "Artifact SHA is ${{ steps.artifact-upload-step.outputs.artifact-digest }}"
+          echo "${TARGET}_url=${{ steps.artifact-upload-step.outputs.artifact-url }}"
+          echo "${TARGET}_url=${{ steps.artifact-upload-step.outputs.artifact-url }}" >> "$GITHUB_OUTPUT"
+          echo "${TARGET}_sha=${{ steps.artifact-upload-step.outputs.artifact-digest }}""
+          echo "${TARGET}_sha=${{ steps.artifact-upload-step.outputs.artifact-digest }}"" >> "$GITHUB_OUTPUT"
+
+  create-macos-fat-binary:
+    if: ${{ needs.check_commits.outputs.has_commits == 'true' }}
+    needs: [build]
+    outputs:
+      resolc-universal-apple-darwin_url: ${{ steps.set-output.outputs.resolc-universal-apple-darwin_url }}
+      resolc-universal-apple-darwin_sha: ${{ steps.set-output.outputs.resolc-universal-apple-darwin_sha }}
+    runs-on: macos-14
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          merge-multiple: true
+
+      - name: Create macOS Fat Binary
+        run: |
+          lipo resolc-aarch64-apple-darwin resolc-x86_64-apple-darwin -create -output resolc-universal-apple-darwin
+
+      - name: Make Executable
+        run: |
+          chmod +x resolc-universal-apple-darwin
+
+      - uses: actions/upload-artifact@v4
+        id: artifact-upload-step
+        with:
+          name: resolc-universal-apple-darwin
+          path: resolc-universal-apple-darwin
+          retention-days: 40
+
+      - name: Set output variables
+        id: set-output
+        env:
+          TARGET: resolc-universal-apple-darwin
+        run: |
+          echo "Artifact URL is ${{ steps.artifact-upload-step.outputs.artifact-url }}"
+          echo "Artifact SHA is ${{ steps.artifact-upload-step.outputs.artifact-digest }}"
+          echo "${TARGET}_url=${{ steps.artifact-upload-step.outputs.artifact-url }}"
+          echo "${TARGET}_url=${{ steps.artifact-upload-step.outputs.artifact-url }}" >> "$GITHUB_OUTPUT"
+          echo "${TARGET}_sha=${{ steps.artifact-upload-step.outputs.artifact-digest }}""
+          echo "${TARGET}_sha=${{ steps.artifact-upload-step.outputs.artifact-digest }}"" >> "$GITHUB_OUTPUT"
+
+  generate-nightly-json:
+    runs-on: ubuntu-24.04
+    if: ${{ needs.check_commits.outputs.has_commits == 'true' }}
+    environment: tags
+    needs: [build-wasm, build, create-macos-fat-binary, check_commits]
+    steps:
+      - name: Checkout revive
+        uses: actions/checkout@v4
+        with:
+          path: revive
+
+      - name: Checkout resolc-bin
+        uses: actions/checkout@v4
+        with:
+          repository: paritytech/resolc-bin
+          path: resolc-bin
+
+      - name: Download Artifacts
+        uses: actions/download-artifact@v4
+        with:
+          merge-multiple: true
+          path: bins
+
+      - uses: actions/create-github-app-token@v1
+        id: app-token
+        with:
+          app-id: ${{ secrets.REVIVE_JSON_APP_ID }}
+          private-key: ${{ secrets.REVIVE_JSON_APP_KEY }}
+          owner: paritytech
+          repositories: resolc-bin
+
+      - name: Generate JSON
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TOKEN: ${{ steps.app-token.outputs.token }}
+          APP_NAME: "paritytech-revive-json"
+          Green: "\e[32m"
+          NC: "\e[0m"
+        run: |
+          echo '[' > data.json
+          echo '${{ toJSON(needs.build.outputs) }}' >> data.json
+          echo ',' >> data.json
+          echo '${{ toJSON(needs.build-wasm.outputs) }}' >> data.json
+          echo ',' >> data.json
+          echo '${{ toJSON(needs.create-macos-fat-binary.outputs) }}' >> data.json
+          echo ']' >> data.json
+          chmod +x bins/resolc-x86_64-unknown-linux-musl
+          export FIRST_SOLC_VERSION=$(./bins/resolc-x86_64-unknown-linux-musl --supported-solc-versions | cut -f 1 -d "," | tr -d ">=")
+          export LAST_SOLC_VERSION=$(./bins/resolc-x86_64-unknown-linux-musl --supported-solc-versions | cut -f 2 -d "," | tr -d "<=")
+          export FILEPATH=$(readlink -f data.json)
+          export TAG=$(cd revive;gh release list --json name,isLatest --jq '.[] | select(.isLatest)|.name')
+          cd resolc-bin
+          mkdir -p nightly
+          cd nightly
+          python3 ../../revive/.github/scripts/json_generator_nightly.py
+          cd ..
+          git status
+
+          echo "${Green}Add new remote with gh app token${NC}"
+          git remote set-url origin $(git config remote.origin.url | sed "s/github.com/${APP_NAME}:${TOKEN}@github.com/g")
+
+          echo "${Green}Remove http section that causes issues with gh app auth token${NC}"
+          sed -i.bak '/\[http/d' ./.git/config
+          sed -i.bak '/extraheader/d' ./.git/config
+
+          git config user.email "ci@parity.io"
+          git config user.name "${APP_NAME}"
+
+          git add nightly/
+          git commit -m "Update nightly json"
+          git push origin main
+
+          echo "::notice::nightly info.list files were successfully published to https://github.com/paritytech/resolc-bin"

.github/workflows/release.yml

@@ -14,6 +14,7 @@ concurrency:
 
 env:
   CARGO_TERM_COLOR: always
+  # if changed, dont forget to update the env var in release-nightly.yml
   RUST_MUSL_CROSS_IMAGE: messense/rust-musl-cross@sha256:c0154e992adb791c3b848dd008939d19862549204f8cb26f5ca7a00f629e6067
 
 jobs:

CHANGELOG.md

@@ -6,6 +6,19 @@ This is a development pre-release.
 
 Supported `polkadot-sdk` rev: `2503.0.1`
 
+## v0.4.0
+
+This is a development pre-release.
+
+Supported `polkadot-sdk` rev: `2503.0.1`
+
+### Added
+- Line debug information per YUL builtin and for `if` statements.
+- Support for the YUL optimizer details in the standard json input definition.
+
+### Fixed
+- The debug info source file matches the YUL path in `--debug-output-dir`, allowing tools to display the source line. 
+
 ## v0.3.0
 
 This is a development pre-release.

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

@@ -2,6 +2,7 @@
 
 pub mod ir_type;
 
+use std::path::Path;
 use std::path::PathBuf;
 
 use serde::Deserialize;
@@ -16,6 +17,14 @@ pub struct DebugConfig {
     pub output_directory: Option<PathBuf>,
     /// Whether debug info should be emitted.
     pub emit_debug_info: bool,
+    /// The YUL debug output file path.
+    ///
+    /// Is expected to be configured when running in YUL mode.
+    pub contract_path: Option<PathBuf>,
+    /// The YUL input file path.
+    ///
+    /// Is expected to be configured when not running in YUL mode.
+    pub yul_path: Option<PathBuf>,
 }
 
 impl DebugConfig {
@@ -24,15 +33,41 @@ impl DebugConfig {
         Self {
             output_directory,
             emit_debug_info,
+            contract_path: None,
+            yul_path: None,
         }
     }
 
+    /// Set the current YUL path.
+    pub fn set_yul_path(&mut self, yul_path: &Path) {
+        self.yul_path = yul_path.to_path_buf().into();
+    }
+
+    /// Set the current contract path.
+    pub fn set_contract_path(&mut self, contract_path: &str) {
+        self.contract_path = self.yul_source_path(contract_path);
+    }
+
+    /// Returns with the following precedence:
+    /// 1. The YUL source path if it was configured.
+    /// 2. The source YUL path from the debug output dir if it was configured.
+    /// 3. `None` if there is no debug output directory.
+    pub fn yul_source_path(&self, contract_path: &str) -> Option<PathBuf> {
+        if let Some(path) = self.yul_path.as_ref() {
+            return Some(path.clone());
+        }
+
+        self.output_directory.as_ref().map(|output_directory| {
+            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);
+            file_path
+        })
+    }
+
     /// Dumps the Yul IR.
     pub fn dump_yul(&self, contract_path: &str, code: &str) -> 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::Yul);
-            file_path.push(full_file_name);
+        if let Some(file_path) = self.yul_source_path(contract_path) {
             std::fs::write(file_path, code)?;
         }
 

crates/llvm-context/src/lib.rs

@@ -21,20 +21,9 @@ pub use self::polkavm::context::function::llvm_runtime::LLVMRuntime as PolkaVMLL
 pub use self::polkavm::context::function::r#return::Return as PolkaVMFunctionReturn;
 pub use self::polkavm::context::function::runtime::arithmetics::Addition as PolkaVMAdditionFunction;
 pub use self::polkavm::context::function::runtime::arithmetics::Division as PolkaVMDivisionFunction;
-pub use self::polkavm::context::function::runtime::arithmetics::Multiplication as PolkaVMMultiplicationFunction;
 pub use self::polkavm::context::function::runtime::arithmetics::Remainder as PolkaVMRemainderFunction;
 pub use self::polkavm::context::function::runtime::arithmetics::SignedDivision as PolkaVMSignedDivisionFunction;
 pub use self::polkavm::context::function::runtime::arithmetics::SignedRemainder as PolkaVMSignedRemainderFunction;
-pub use self::polkavm::context::function::runtime::arithmetics::Subtraction as PolkaVMSubstractionFunction;
-pub use self::polkavm::context::function::runtime::bitwise::And as PolkaVMAndFunction;
-pub use self::polkavm::context::function::runtime::bitwise::Byte as PolkaVMByteFunction;
-pub use self::polkavm::context::function::runtime::bitwise::Or as PolkaVMOrFunction;
-pub use self::polkavm::context::function::runtime::bitwise::Sar as PolkaVMSarFunction;
-pub use self::polkavm::context::function::runtime::bitwise::Shl as PolkaVMShlFunction;
-pub use self::polkavm::context::function::runtime::bitwise::Shr as PolkaVMShrFunction;
-pub use self::polkavm::context::function::runtime::bitwise::Xor as PolkaVMXorFunction;
-pub use self::polkavm::context::function::runtime::call::Call as PolkaVMCall;
-pub use self::polkavm::context::function::runtime::call::CallReentrancyProtector as PolkaVMCallReentrancyProtector;
 pub use self::polkavm::context::function::runtime::deploy_code::DeployCode as PolkaVMDeployCodeFunction;
 pub use self::polkavm::context::function::runtime::entry::Entry as PolkaVMEntryFunction;
 pub use self::polkavm::context::function::runtime::revive::Exit as PolkaVMExitFunction;

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

@@ -51,11 +51,20 @@ pub struct DebugInfo<'ctx> {
 
 impl<'ctx> DebugInfo<'ctx> {
     /// A shortcut constructor.
-    pub fn new(module: &inkwell::module::Module<'ctx>) -> Self {
+    pub fn new(
+        module: &inkwell::module::Module<'ctx>,
+        debug_config: &crate::debug_config::DebugConfig,
+    ) -> Self {
+        let module_name = module.get_name().to_string_lossy();
+        let yul_name = debug_config
+            .contract_path
+            .as_ref()
+            .map(|path| path.display().to_string());
+
         let (builder, compile_unit) = module.create_debug_info_builder(
             true,
             inkwell::debug_info::DWARFSourceLanguage::C,
-            module.get_name().to_string_lossy().as_ref(),
+            yul_name.as_deref().unwrap_or_else(|| module_name.as_ref()),
             "",
             "",
             false,

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

@@ -7,7 +7,7 @@ pub mod r#return;
 pub mod runtime;
 pub mod yul_data;
 
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 
 use inkwell::debug_info::AsDIScope;
 
@@ -29,6 +29,10 @@ pub struct Function<'ctx> {
     declaration: Declaration<'ctx>,
     /// The stack representation.
     stack: HashMap<String, Pointer<'ctx>>,
+    /// The stack variables buffer.
+    stack_variables: inkwell::values::GlobalValue<'ctx>,
+    /// The stack variable names to slot mapping.
+    stack_slots: BTreeMap<String, usize>,
     /// The return value entity.
     r#return: Return<'ctx>,
 
@@ -53,6 +57,7 @@ impl<'ctx> Function<'ctx> {
         name: String,
         declaration: Declaration<'ctx>,
         r#return: Return<'ctx>,
+        stack_variables: inkwell::values::GlobalValue<'ctx>,
 
         entry_block: inkwell::basic_block::BasicBlock<'ctx>,
         return_block: inkwell::basic_block::BasicBlock<'ctx>,
@@ -61,6 +66,8 @@ impl<'ctx> Function<'ctx> {
             name,
             declaration,
             stack: HashMap::with_capacity(Self::STACK_HASHMAP_INITIAL_CAPACITY),
+            stack_variables,
+            stack_slots: BTreeMap::new(),
             r#return,
 
             entry_block,
@@ -279,4 +286,45 @@ impl<'ctx> Function<'ctx> {
             .as_mut()
             .expect("The Yul data must have been initialized")
     }
+
+    /// Returns the stack variables global value.
+    pub fn stack_variables(&self) -> inkwell::values::GlobalValue<'ctx> {
+        self.stack_variables
+    }
+
+    /// Returns the slot for the given variable name.
+    pub fn stack_variable_slot(&mut self, name: String) -> usize {
+        let len = self.stack_slots.len();
+        *self.stack_slots.entry(name).or_insert_with(|| len)
+    }
+
+    /// References the stack variable `name`.
+    pub fn stack_variable_pointer<D: crate::PolkaVMDependency + Clone>(
+        &mut self,
+        name: String,
+        context: &mut super::Context<'ctx, D>,
+    ) -> Pointer<'ctx> {
+        if let Some(pointer) = self.get_stack_pointer(&name) {
+            return pointer;
+        }
+
+        let pointer_name = format!("var_{}", &name);
+        let slot = self.stack_variable_slot(name);
+        Pointer::new(
+            context.word_type(),
+            Default::default(),
+            unsafe {
+                context.builder().build_gep(
+                    context.word_type().array_type(0),
+                    self.stack_variables().as_pointer_value(),
+                    &[
+                        context.xlen_type().const_zero(),
+                        context.xlen_type().const_int(slot as u64, false),
+                    ],
+                    &pointer_name,
+                )
+            }
+            .unwrap(),
+        )
+    }
 }

crates/llvm-context/src/polkavm/context/function/runtime/arithmetics.rs

@@ -7,7 +7,7 @@ use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
 use crate::polkavm::WriteLLVM;
 
-/// Implements the ADD operator according to the EVM specification.
+/// Implements the division operator according to the EVM specification.
 pub struct Addition;
 
 impl<D> RuntimeFunction<D> for Addition
@@ -17,8 +17,12 @@ where
     const NAME: &'static str = "__revive_addition";
 
     fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
-        context.word_type().fn_type(
-            &[context.word_type().into(), context.word_type().into()],
+        context.void_type().fn_type(
+            &[
+                context.llvm().ptr_type(Default::default()).into(),
+                context.llvm().ptr_type(Default::default()).into(),
+                context.llvm().ptr_type(Default::default()).into(),
+            ],
             false,
         )
     }
@@ -27,15 +31,25 @@ where
         &self,
         context: &mut Context<'ctx, D>,
     ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
-        let operand_1 = Self::paramater(context, 0).into_int_value();
-        let operand_2 = Self::paramater(context, 1).into_int_value();
+        let result_pointer = Self::paramater(context, 0).into_pointer_value();
+        let operand_1 = Self::paramater(context, 1).into_pointer_value();
+        let operand_2 = Self::paramater(context, 2).into_pointer_value();
 
-        Ok(Some(
-            context
-                .builder()
-                .build_int_add(operand_1, operand_2, "ADD")
-                .map(Into::into)?,
-        ))
+        let operand_1 = context
+            .builder()
+            .build_load(context.word_type(), operand_1, "operand_1")?
+            .into_int_value();
+        let operand_2 = context
+            .builder()
+            .build_load(context.word_type(), operand_2, "operand_2")?
+            .into_int_value();
+        let result = context
+            .builder()
+            .build_int_add(operand_1, operand_2, "addition_result")?;
+
+        context.builder().build_store(result_pointer, result)?;
+
+        Ok(None)
     }
 }
 
@@ -52,96 +66,6 @@ where
     }
 }
 
-/// Implements the SUB operator according to the EVM specification.
-pub struct Subtraction;
-
-impl<D> RuntimeFunction<D> for Subtraction
-where
-    D: Dependency + Clone,
-{
-    const NAME: &'static str = "__revive_subtraction";
-
-    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
-        context.word_type().fn_type(
-            &[context.word_type().into(), context.word_type().into()],
-            false,
-        )
-    }
-
-    fn emit_body<'ctx>(
-        &self,
-        context: &mut Context<'ctx, D>,
-    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
-        let operand_1 = Self::paramater(context, 0).into_int_value();
-        let operand_2 = Self::paramater(context, 1).into_int_value();
-
-        Ok(Some(
-            context
-                .builder()
-                .build_int_sub(operand_1, operand_2, "SUB")
-                .map(Into::into)?,
-        ))
-    }
-}
-
-impl<D> WriteLLVM<D> for Subtraction
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::declare(self, context)
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::emit(&self, context)
-    }
-}
-
-/// Implements the MUL operator according to the EVM specification.
-pub struct Multiplication;
-
-impl<D> RuntimeFunction<D> for Multiplication
-where
-    D: Dependency + Clone,
-{
-    const NAME: &'static str = "__revive_multiplication";
-
-    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
-        context.word_type().fn_type(
-            &[context.word_type().into(), context.word_type().into()],
-            false,
-        )
-    }
-
-    fn emit_body<'ctx>(
-        &self,
-        context: &mut Context<'ctx, D>,
-    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
-        let operand_1 = Self::paramater(context, 0).into_int_value();
-        let operand_2 = Self::paramater(context, 1).into_int_value();
-
-        Ok(Some(
-            context
-                .builder()
-                .build_int_mul(operand_1, operand_2, "MUL")
-                .map(Into::into)?,
-        ))
-    }
-}
-
-impl<D> WriteLLVM<D> for Multiplication
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::declare(self, context)
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::emit(&self, context)
-    }
-}
-
 /// Implements the division operator according to the EVM specification.
 pub struct Division;
 

crates/llvm-context/src/polkavm/context/function/runtime/bitwise.rs

@@ -1,494 +0,0 @@
-//! Translates the arithmetic operations.
-
-use inkwell::values::BasicValue;
-
-use crate::polkavm::context::runtime::RuntimeFunction;
-use crate::polkavm::context::Context;
-use crate::polkavm::Dependency;
-use crate::polkavm::WriteLLVM;
-
-/// Implements the OR operator according to the EVM specification.
-pub struct Or;
-
-impl<D> RuntimeFunction<D> for Or
-where
-    D: Dependency + Clone,
-{
-    const NAME: &'static str = "__revive_or";
-
-    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
-        context.word_type().fn_type(
-            &[context.word_type().into(), context.word_type().into()],
-            false,
-        )
-    }
-
-    fn emit_body<'ctx>(
-        &self,
-        context: &mut Context<'ctx, D>,
-    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
-        let operand_1 = Self::paramater(context, 0).into_int_value();
-        let operand_2 = Self::paramater(context, 1).into_int_value();
-
-        Ok(Some(
-            context
-                .builder()
-                .build_or(operand_1, operand_2, "OR")
-                .map(Into::into)?,
-        ))
-    }
-}
-
-impl<D> WriteLLVM<D> for Or
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::declare(self, context)
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::emit(&self, context)
-    }
-}
-
-/// Implements the XOR operator according to the EVM specification.
-pub struct Xor;
-
-impl<D> RuntimeFunction<D> for Xor
-where
-    D: Dependency + Clone,
-{
-    const NAME: &'static str = "__revive_xor";
-
-    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
-        context.word_type().fn_type(
-            &[context.word_type().into(), context.word_type().into()],
-            false,
-        )
-    }
-
-    fn emit_body<'ctx>(
-        &self,
-        context: &mut Context<'ctx, D>,
-    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
-        let operand_1 = Self::paramater(context, 0).into_int_value();
-        let operand_2 = Self::paramater(context, 1).into_int_value();
-
-        Ok(Some(
-            context
-                .builder()
-                .build_xor(operand_1, operand_2, "XOR")
-                .map(Into::into)?,
-        ))
-    }
-}
-
-impl<D> WriteLLVM<D> for Xor
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::declare(self, context)
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::emit(&self, context)
-    }
-}
-
-/// Implements the AND operator according to the EVM specification.
-pub struct And;
-
-impl<D> RuntimeFunction<D> for And
-where
-    D: Dependency + Clone,
-{
-    const NAME: &'static str = "__revive_and";
-
-    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
-        context.word_type().fn_type(
-            &[context.word_type().into(), context.word_type().into()],
-            false,
-        )
-    }
-
-    fn emit_body<'ctx>(
-        &self,
-        context: &mut Context<'ctx, D>,
-    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
-        let operand_1 = Self::paramater(context, 0).into_int_value();
-        let operand_2 = Self::paramater(context, 1).into_int_value();
-
-        Ok(Some(
-            context
-                .builder()
-                .build_and(operand_1, operand_2, "AND")
-                .map(Into::into)?,
-        ))
-    }
-}
-
-impl<D> WriteLLVM<D> for And
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::declare(self, context)
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::emit(&self, context)
-    }
-}
-/// Implements the SHL operator according to the EVM specification.
-pub struct Shl;
-
-impl<D> RuntimeFunction<D> for Shl
-where
-    D: Dependency + Clone,
-{
-    const NAME: &'static str = "__revive_shl";
-
-    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
-        context.word_type().fn_type(
-            &[context.word_type().into(), context.word_type().into()],
-            false,
-        )
-    }
-
-    fn emit_body<'ctx>(
-        &self,
-        context: &mut Context<'ctx, D>,
-    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
-        let shift = Self::paramater(context, 0).into_int_value();
-        let value = Self::paramater(context, 1).into_int_value();
-
-        let overflow_block = context.append_basic_block("shift_left_overflow");
-        let non_overflow_block = context.append_basic_block("shift_left_non_overflow");
-        let join_block = context.append_basic_block("shift_left_join");
-
-        let condition_is_overflow = context.builder().build_int_compare(
-            inkwell::IntPredicate::UGT,
-            shift,
-            context.word_const((revive_common::BIT_LENGTH_WORD - 1) as u64),
-            "shift_left_is_overflow",
-        )?;
-        context.build_conditional_branch(
-            condition_is_overflow,
-            overflow_block,
-            non_overflow_block,
-        )?;
-
-        context.set_basic_block(overflow_block);
-        context.build_unconditional_branch(join_block);
-
-        context.set_basic_block(non_overflow_block);
-        let value =
-            context
-                .builder()
-                .build_left_shift(value, shift, "shift_left_non_overflow_result")?;
-        context.build_unconditional_branch(join_block);
-
-        context.set_basic_block(join_block);
-        let result = context
-            .builder()
-            .build_phi(context.word_type(), "shift_left_value")?;
-        result.add_incoming(&[
-            (&value, non_overflow_block),
-            (&context.word_const(0), overflow_block),
-        ]);
-        Ok(Some(result.as_basic_value()))
-    }
-}
-
-impl<D> WriteLLVM<D> for Shl
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::declare(self, context)
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::emit(&self, context)
-    }
-}
-
-/// Implements the SHR operator according to the EVM specification.
-pub struct Shr;
-
-impl<D> RuntimeFunction<D> for Shr
-where
-    D: Dependency + Clone,
-{
-    const NAME: &'static str = "__revive_shr";
-
-    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
-        context.word_type().fn_type(
-            &[context.word_type().into(), context.word_type().into()],
-            false,
-        )
-    }
-
-    fn emit_body<'ctx>(
-        &self,
-        context: &mut Context<'ctx, D>,
-    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
-        let shift = Self::paramater(context, 0).into_int_value();
-        let value = Self::paramater(context, 1).into_int_value();
-
-        let overflow_block = context.append_basic_block("shift_right_overflow");
-        let non_overflow_block = context.append_basic_block("shift_right_non_overflow");
-        let join_block = context.append_basic_block("shift_right_join");
-
-        let condition_is_overflow = context.builder().build_int_compare(
-            inkwell::IntPredicate::UGT,
-            shift,
-            context.word_const((revive_common::BIT_LENGTH_WORD - 1) as u64),
-            "shift_right_is_overflow",
-        )?;
-        context.build_conditional_branch(
-            condition_is_overflow,
-            overflow_block,
-            non_overflow_block,
-        )?;
-
-        context.set_basic_block(overflow_block);
-        context.build_unconditional_branch(join_block);
-
-        context.set_basic_block(non_overflow_block);
-        let value = context.builder().build_right_shift(
-            value,
-            shift,
-            false,
-            "shift_right_non_overflow_result",
-        )?;
-        context.build_unconditional_branch(join_block);
-
-        context.set_basic_block(join_block);
-        let result = context
-            .builder()
-            .build_phi(context.word_type(), "shift_right_value")?;
-        result.add_incoming(&[
-            (&value, non_overflow_block),
-            (&context.word_const(0), overflow_block),
-        ]);
-        Ok(Some(result.as_basic_value()))
-    }
-}
-
-impl<D> WriteLLVM<D> for Shr
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::declare(self, context)
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::emit(&self, context)
-    }
-}
-
-/// Implements the SAR operator according to the EVM specification.
-pub struct Sar;
-
-impl<D> RuntimeFunction<D> for Sar
-where
-    D: Dependency + Clone,
-{
-    const NAME: &'static str = "__revive_sar";
-
-    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
-        context.word_type().fn_type(
-            &[context.word_type().into(), context.word_type().into()],
-            false,
-        )
-    }
-
-    fn emit_body<'ctx>(
-        &self,
-        context: &mut Context<'ctx, D>,
-    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
-        let shift = Self::paramater(context, 0).into_int_value();
-        let value = Self::paramater(context, 1).into_int_value();
-
-        let overflow_block = context.append_basic_block("shift_right_arithmetic_overflow");
-        let overflow_positive_block =
-            context.append_basic_block("shift_right_arithmetic_overflow_positive");
-        let overflow_negative_block =
-            context.append_basic_block("shift_right_arithmetic_overflow_negative");
-        let non_overflow_block = context.append_basic_block("shift_right_arithmetic_non_overflow");
-        let join_block = context.append_basic_block("shift_right_arithmetic_join");
-
-        let condition_is_overflow = context.builder().build_int_compare(
-            inkwell::IntPredicate::UGT,
-            shift,
-            context.word_const((revive_common::BIT_LENGTH_WORD - 1) as u64),
-            "shift_right_arithmetic_is_overflow",
-        )?;
-        context.build_conditional_branch(
-            condition_is_overflow,
-            overflow_block,
-            non_overflow_block,
-        )?;
-
-        context.set_basic_block(overflow_block);
-        let sign_bit = context.builder().build_right_shift(
-            value,
-            context.word_const((revive_common::BIT_LENGTH_WORD - 1) as u64),
-            false,
-            "shift_right_arithmetic_sign_bit",
-        )?;
-        let condition_is_negative = context.builder().build_int_truncate_or_bit_cast(
-            sign_bit,
-            context.bool_type(),
-            "shift_right_arithmetic_sign_bit_truncated",
-        )?;
-        context.build_conditional_branch(
-            condition_is_negative,
-            overflow_negative_block,
-            overflow_positive_block,
-        )?;
-
-        context.set_basic_block(overflow_positive_block);
-        context.build_unconditional_branch(join_block);
-
-        context.set_basic_block(overflow_negative_block);
-        context.build_unconditional_branch(join_block);
-
-        context.set_basic_block(non_overflow_block);
-        let value = context.builder().build_right_shift(
-            value,
-            shift,
-            true,
-            "shift_right_arithmetic_non_overflow_result",
-        )?;
-        context.build_unconditional_branch(join_block);
-
-        context.set_basic_block(join_block);
-        let result = context
-            .builder()
-            .build_phi(context.word_type(), "shift_arithmetic_right_value")?;
-        result.add_incoming(&[
-            (&value, non_overflow_block),
-            (
-                &context.word_type().const_all_ones(),
-                overflow_negative_block,
-            ),
-            (&context.word_const(0), overflow_positive_block),
-        ]);
-        Ok(Some(result.as_basic_value()))
-    }
-}
-
-impl<D> WriteLLVM<D> for Sar
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::declare(self, context)
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::emit(&self, context)
-    }
-}
-/// Implements the BYTE operator according to the EVM specification.
-pub struct Byte;
-
-impl<D> RuntimeFunction<D> for Byte
-where
-    D: Dependency + Clone,
-{
-    const NAME: &'static str = "__revive_byte";
-
-    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
-        context.word_type().fn_type(
-            &[context.word_type().into(), context.word_type().into()],
-            false,
-        )
-    }
-
-    fn emit_body<'ctx>(
-        &self,
-        context: &mut Context<'ctx, D>,
-    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
-        let operand_1 = Self::paramater(context, 0).into_int_value();
-        let operand_2 = Self::paramater(context, 1).into_int_value();
-        const MAX_INDEX_BYTES: u64 = 31;
-
-        let is_overflow_bit = context.builder().build_int_compare(
-            inkwell::IntPredicate::ULE,
-            operand_1,
-            context.word_const(MAX_INDEX_BYTES),
-            "is_overflow_bit",
-        )?;
-        let is_overflow_byte = context.builder().build_int_z_extend(
-            is_overflow_bit,
-            context.byte_type(),
-            "is_overflow_byte",
-        )?;
-        let mask_byte = context.builder().build_int_mul(
-            context.byte_type().const_all_ones(),
-            is_overflow_byte,
-            "mask_byte",
-        )?;
-        let mask_byte_word = context.builder().build_int_z_extend(
-            mask_byte,
-            context.word_type(),
-            "mask_byte_word",
-        )?;
-
-        let index_truncated = context.builder().build_int_truncate(
-            operand_1,
-            context.byte_type(),
-            "index_truncated",
-        )?;
-        let index_in_bits = context.builder().build_int_mul(
-            index_truncated,
-            context
-                .byte_type()
-                .const_int(revive_common::BIT_LENGTH_BYTE as u64, false),
-            "index_in_bits",
-        )?;
-        let index_from_most_significant_bit = context.builder().build_int_sub(
-            context.byte_type().const_int(
-                MAX_INDEX_BYTES * revive_common::BIT_LENGTH_BYTE as u64,
-                false,
-            ),
-            index_in_bits,
-            "index_from_msb",
-        )?;
-        let index_extended = context.builder().build_int_z_extend(
-            index_from_most_significant_bit,
-            context.word_type(),
-            "index",
-        )?;
-
-        let mask = context
-            .builder()
-            .build_left_shift(mask_byte_word, index_extended, "mask")?;
-        let masked_value = context.builder().build_and(operand_2, mask, "masked")?;
-        let byte =
-            context
-                .builder()
-                .build_right_shift(masked_value, index_extended, false, "byte")?;
-
-        Ok(Some(byte.as_basic_value_enum()))
-    }
-}
-
-impl<D> WriteLLVM<D> for Byte
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::declare(self, context)
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::emit(&self, context)
-    }
-}

crates/llvm-context/src/polkavm/context/function/runtime/call.rs

@@ -1,257 +0,0 @@
-//! Translates the arithmetic operations.
-
-use inkwell::values::BasicValue;
-
-use crate::polkavm::context::runtime::RuntimeFunction;
-use crate::polkavm::context::Context;
-use crate::polkavm::context::Pointer;
-use crate::polkavm::Dependency;
-use crate::polkavm::WriteLLVM;
-
-const SOLIDITY_TRANSFER_GAS_STIPEND_THRESHOLD: u64 = 2300;
-
-/// The Solidity `address.transfer` and `address.send` call detection heuristic.
-///
-/// # Why
-/// This heuristic is an additional security feature to guard against re-entrancy attacks
-/// in case contract authors violate Solidity best practices and use `address.transfer` or
-/// `address.send`.
-/// While contract authors are supposed to never use `address.transfer` or `address.send`,
-/// for a small cost we can be extra defensive about it.
-///
-/// # How
-/// The gas stipend emitted by solc for `transfer` and `send` is not static, thus:
-/// - Dynamically allow re-entrancy only for calls considered not transfer or send.
-/// - Detected balance transfers will supply 0 deposit limit instead of `u256::MAX`.
-///
-/// Calls are considered transfer or send if:
-/// - (Input length | Output lenght) == 0;
-/// - Gas <= 2300;
-///
-/// # Arguments:
-/// - The deposit value pointer.
-/// - The gas value.
-/// - `input_length | output_length`.
-///
-///
-/// # Returns:
-/// The call flags xlen `IntValue`
-pub struct CallReentrancyProtector;
-
-impl<D> RuntimeFunction<D> for CallReentrancyProtector
-where
-    D: Dependency + Clone,
-{
-    const NAME: &'static str = "__revive_call_reentrancy_protector";
-
-    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
-        context.xlen_type().fn_type(
-            &[
-                context.llvm().ptr_type(Default::default()).into(),
-                context.word_type().into(),
-                context.xlen_type().into(),
-            ],
-            false,
-        )
-    }
-
-    fn emit_body<'ctx>(
-        &self,
-        context: &mut Context<'ctx, D>,
-    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
-        let deposit_pointer = Self::paramater(context, 0).into_pointer_value();
-        let gas = Self::paramater(context, 1).into_int_value();
-        let input_length_or_output_length = Self::paramater(context, 2).into_int_value();
-
-        // Branch-free SSA implementation: First derive the heuristic boolean (int1) value.
-        let is_no_input_no_output = context.builder().build_int_compare(
-            inkwell::IntPredicate::EQ,
-            context.xlen_type().const_zero(),
-            input_length_or_output_length,
-            "is_no_input_no_output",
-        )?;
-        let gas_stipend = context
-            .word_type()
-            .const_int(SOLIDITY_TRANSFER_GAS_STIPEND_THRESHOLD, false);
-        let is_gas_stipend_for_transfer_or_send = context.builder().build_int_compare(
-            inkwell::IntPredicate::ULE,
-            gas,
-            gas_stipend,
-            "is_gas_stipend_for_transfer_or_send",
-        )?;
-        let is_balance_transfer = context.builder().build_and(
-            is_no_input_no_output,
-            is_gas_stipend_for_transfer_or_send,
-            "is_balance_transfer",
-        )?;
-        let is_regular_call = context
-            .builder()
-            .build_not(is_balance_transfer, "is_balance_transfer_inverted")?;
-
-        // Call flag: Left shift the heuristic boolean value.
-        let is_regular_call_xlen = context.builder().build_int_z_extend(
-            is_regular_call,
-            context.xlen_type(),
-            "is_balance_transfer_xlen",
-        )?;
-        let call_flags = context.builder().build_left_shift(
-            is_regular_call_xlen,
-            context.xlen_type().const_int(3, false),
-            "flags",
-        )?;
-
-        // Deposit limit value: Sign-extended the heuristic boolean value.
-        let deposit_limit_value = context.builder().build_int_s_extend(
-            is_regular_call,
-            context.word_type(),
-            "deposit_limit_value",
-        )?;
-        context
-            .builder()
-            .build_store(deposit_pointer, deposit_limit_value)?;
-
-        Ok(Some(call_flags.into()))
-    }
-}
-
-impl<D> WriteLLVM<D> for CallReentrancyProtector
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::declare(self, context)
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::emit(&self, context)
-    }
-}
-
-/// Implements the CALL operator according to the EVM specification.
-///
-/// # Arguments:
-/// - The address value.
-/// - The value value.
-/// - The input offset.
-/// - The input length.
-/// - The output offset.
-/// - The output length.
-/// - The deposit limit pointer.
-/// - The call flags.
-///
-/// # Returns:
-/// - The success value (as xlen)
-pub struct Call;
-
-impl<D> RuntimeFunction<D> for Call
-where
-    D: Dependency + Clone,
-{
-    const NAME: &'static str = "__revive_call";
-
-    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
-        context.register_type().fn_type(
-            &[
-                context.word_type().into(),
-                context.word_type().into(),
-                context.xlen_type().into(),
-                context.xlen_type().into(),
-                context.xlen_type().into(),
-                context.xlen_type().into(),
-                context.llvm().ptr_type(Default::default()).into(),
-                context.xlen_type().into(),
-            ],
-            false,
-        )
-    }
-
-    fn emit_body<'ctx>(
-        &self,
-        context: &mut Context<'ctx, D>,
-    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
-        let address = Self::paramater(context, 0).into_int_value();
-        let value = Self::paramater(context, 1).into_int_value();
-        let input_offset = Self::paramater(context, 2).into_int_value();
-        let input_length = Self::paramater(context, 3).into_int_value();
-        let output_offset = Self::paramater(context, 4).into_int_value();
-        let output_length = Self::paramater(context, 5).into_int_value();
-        let depsit_limit_pointer = Self::paramater(context, 6).into_pointer_value();
-        let flags = Self::paramater(context, 7).into_int_value();
-
-        let address_pointer = context.build_address_argument_store(address)?;
-
-        let value_pointer = context.build_alloca_at_entry(context.word_type(), "value_pointer");
-        context.build_store(value_pointer, value)?;
-
-        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_and_callee = revive_runtime_api::calling_convention::pack_hi_lo_reg(
-            context.builder(),
-            context.llvm(),
-            flags,
-            address_pointer.to_int(context),
-            "address_and_callee",
-        )?;
-        let deposit_limit_pointer = Pointer::new(
-            context.word_type(),
-            Default::default(),
-            depsit_limit_pointer,
-        );
-        let deposit_and_value = revive_runtime_api::calling_convention::pack_hi_lo_reg(
-            context.builder(),
-            context.llvm(),
-            deposit_limit_pointer.to_int(context),
-            value_pointer.to_int(context),
-            "deposit_and_value",
-        )?;
-        let input_data = revive_runtime_api::calling_convention::pack_hi_lo_reg(
-            context.builder(),
-            context.llvm(),
-            input_length,
-            input_pointer.to_int(context),
-            "input_data",
-        )?;
-        let output_data = revive_runtime_api::calling_convention::pack_hi_lo_reg(
-            context.builder(),
-            context.llvm(),
-            output_length_pointer.to_int(context),
-            output_pointer.to_int(context),
-            "output_data",
-        )?;
-
-        let name = revive_runtime_api::polkavm_imports::CALL;
-        let success = context
-            .build_runtime_call(
-                name,
-                &[
-                    flags_and_callee.into(),
-                    context.register_type().const_all_ones().into(),
-                    context.register_type().const_all_ones().into(),
-                    deposit_and_value.into(),
-                    input_data.into(),
-                    output_data.into(),
-                ],
-            )
-            .unwrap_or_else(|| panic!("{name} should return a value"))
-            .into_int_value();
-        Ok(Some(success.into()))
-    }
-}
-
-impl<D> WriteLLVM<D> for Call
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::declare(self, context)
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        <Self as RuntimeFunction<_>>::emit(&self, context)
-    }
-}

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

@@ -1,8 +1,6 @@
 //! The front-end runtime functions.
 
 pub mod arithmetics;
-pub mod bitwise;
-pub mod call;
 pub mod deploy_code;
 pub mod entry;
 pub mod revive;

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

@@ -247,7 +247,7 @@ 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);
+            let debug_info = DebugInfo::new(&module, &debug_config);
             debug_info.initialize_module(llvm, &module);
             debug_info
         });
@@ -503,10 +503,17 @@ where
             }
         };
 
+        let stack_variables = format!("__vars_{name}");
+        self.declare_global(
+            &stack_variables,
+            self.word_type().array_type(0),
+            Default::default(),
+        );
         let function = Function::new(
             name.to_owned(),
             FunctionDeclaration::new(r#type, value),
             r#return,
+            self.get_global(&stack_variables).unwrap().value,
             entry_block,
             return_block,
         );
@@ -1271,6 +1278,20 @@ where
     where
         T: BasicType<'ctx>,
     {
+        let argument_types: Vec<inkwell::types::BasicMetadataTypeEnum> =
+            vec![self.llvm().ptr_type(Default::default()).into(); return_values_size]
+                .into_iter()
+                .chain(
+                    argument_types
+                        .as_slice()
+                        .iter()
+                        .map(T::as_basic_type_enum)
+                        .map(inkwell::types::BasicMetadataTypeEnum::from),
+                )
+                .collect();
+        self.void_type().fn_type(&argument_types.as_slice(), false)
+
+        /*
         let argument_types: Vec<inkwell::types::BasicMetadataTypeEnum> = argument_types
             .as_slice()
             .iter()
@@ -1287,6 +1308,7 @@ where
                 .structure_type(vec![self.word_type().as_basic_type_enum(); size].as_slice())
                 .fn_type(argument_types.as_slice(), false),
         }
+        */
     }
 
     /// Modifies the call site value, setting the default attributes.

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

@@ -8,6 +8,7 @@ use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
 
 pub mod heap;
+//pub mod stack;
 pub mod storage;
 
 /// The LLVM pointer.

crates/llvm-context/src/polkavm/context/pointer/stack.rs

@@ -0,0 +1,111 @@
+//! The revive simulated EVM stack variable functions.
+
+use inkwell::values::BasicValueEnum;
+
+use crate::polkavm::context::runtime::RuntimeFunction;
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+use crate::polkavm::WriteLLVM;
+
+/// Load a word size value from a heap pointer.
+pub struct DeclareVariable;
+
+impl<D> RuntimeFunction<D> for DeclareVariable
+where
+    D: Dependency + Clone,
+{
+    const NAME: &'static str = "__revive_declare_variable";
+
+    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
+        context
+            .llvm
+            .ptr_type(Default::default())
+            .fn_type(&[context.xlen_type().into()], false)
+    }
+
+    fn emit_body<'ctx>(
+        &self,
+        context: &mut Context<'ctx, D>,
+    ) -> anyhow::Result<Option<BasicValueEnum<'ctx>>> {
+        let offset = Self::paramater(context, 0).into_int_value();
+        let length = context
+            .xlen_type()
+            .const_int(revive_common::BYTE_LENGTH_WORD as u64, false);
+        let pointer = context.build_heap_gep(offset, length)?;
+        let value = context
+            .builder()
+            .build_load(context.word_type(), pointer.value, "value")?;
+        context
+            .basic_block()
+            .get_last_instruction()
+            .expect("Always exists")
+            .set_alignment(revive_common::BYTE_LENGTH_BYTE as u32)
+            .expect("Alignment is valid");
+
+        let swapped_value = context.build_byte_swap(value)?;
+        Ok(Some(swapped_value))
+    }
+}
+
+impl<D> WriteLLVM<D> for LoadWord
+where
+    D: Dependency + Clone,
+{
+    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::declare(self, context)
+    }
+
+    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::emit(&self, context)
+    }
+}
+
+/// Store a word size value through a heap pointer.
+pub struct StoreWord;
+
+impl<D> RuntimeFunction<D> for StoreWord
+where
+    D: Dependency + Clone,
+{
+    const NAME: &'static str = "__revive_store_heap_word";
+
+    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
+        context.void_type().fn_type(
+            &[context.xlen_type().into(), context.word_type().into()],
+            false,
+        )
+    }
+
+    fn emit_body<'ctx>(
+        &self,
+        context: &mut Context<'ctx, D>,
+    ) -> anyhow::Result<Option<BasicValueEnum<'ctx>>> {
+        let offset = Self::paramater(context, 0).into_int_value();
+        let length = context
+            .xlen_type()
+            .const_int(revive_common::BYTE_LENGTH_WORD as u64, false);
+        let pointer = context.build_heap_gep(offset, length)?;
+
+        let value = context.build_byte_swap(Self::paramater(context, 1))?;
+
+        context
+            .builder()
+            .build_store(pointer.value, value)?
+            .set_alignment(revive_common::BYTE_LENGTH_BYTE as u32)
+            .expect("Alignment is valid");
+        Ok(None)
+    }
+}
+
+impl<D> WriteLLVM<D> for StoreWord
+where
+    D: Dependency + Clone,
+{
+    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::declare(self, context)
+    }
+
+    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::emit(&self, context)
+    }
+}

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

@@ -1,30 +1,33 @@
 //! Translates the arithmetic operations.
 
+use inkwell::values::BasicValue;
+
 use crate::polkavm::context::runtime::RuntimeFunction;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
 use crate::PolkaVMAdditionFunction;
 use crate::PolkaVMDivisionFunction;
-use crate::PolkaVMMultiplicationFunction;
 use crate::PolkaVMRemainderFunction;
 use crate::PolkaVMSignedDivisionFunction;
 use crate::PolkaVMSignedRemainderFunction;
-use crate::PolkaVMSubstractionFunction;
 
 /// Translates the arithmetic addition.
 pub fn addition<'ctx, D>(
     context: &mut Context<'ctx, D>,
-    operand_1: inkwell::values::IntValue<'ctx>,
-    operand_2: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
+    binding: inkwell::values::PointerValue<'ctx>,
+    operand_1: inkwell::values::PointerValue<'ctx>,
+    operand_2: inkwell::values::PointerValue<'ctx>,
+) -> anyhow::Result<()>
 where
     D: Dependency + Clone,
 {
-    let name = <PolkaVMAdditionFunction as RuntimeFunction<D>>::NAME;
     let declaration = <PolkaVMAdditionFunction as RuntimeFunction<D>>::declaration(context);
-    Ok(context
-        .build_call(declaration, &[operand_1.into(), operand_2.into()], "SUB")
-        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value")))
+    context.build_call(
+        declaration,
+        &[binding.into(), operand_1.into(), operand_2.into()],
+        "add",
+    );
+    Ok(())
 }
 
 /// Translates the arithmetic subtraction.
@@ -36,11 +39,10 @@ pub fn subtraction<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let name = <PolkaVMSubstractionFunction as RuntimeFunction<D>>::NAME;
-    let declaration = <PolkaVMSubstractionFunction as RuntimeFunction<D>>::declaration(context);
     Ok(context
-        .build_call(declaration, &[operand_1.into(), operand_2.into()], "SUB")
-        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value")))
+        .builder()
+        .build_int_sub(operand_1, operand_2, "subtraction_result")?
+        .as_basic_value_enum())
 }
 
 /// Translates the arithmetic multiplication.
@@ -52,11 +54,10 @@ pub fn multiplication<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let name = <PolkaVMMultiplicationFunction as RuntimeFunction<D>>::NAME;
-    let declaration = <PolkaVMMultiplicationFunction as RuntimeFunction<D>>::declaration(context);
     Ok(context
-        .build_call(declaration, &[operand_1.into(), operand_2.into()], "MUL")
-        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value")))
+        .builder()
+        .build_int_mul(operand_1, operand_2, "multiplication_result")?
+        .as_basic_value_enum())
 }
 
 /// Translates the arithmetic division.

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

@@ -1,12 +1,9 @@
 //! Translates the bitwise operations.
 
-use crate::polkavm::context::runtime::RuntimeFunction;
+use inkwell::values::BasicValue;
+
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
-use crate::{
-    PolkaVMAndFunction, PolkaVMByteFunction, PolkaVMOrFunction, PolkaVMSarFunction,
-    PolkaVMShlFunction, PolkaVMShrFunction, PolkaVMXorFunction,
-};
 
 /// Translates the bitwise OR.
 pub fn or<'ctx, D>(
@@ -17,11 +14,10 @@ pub fn or<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let name = <PolkaVMOrFunction as RuntimeFunction<D>>::NAME;
-    let declaration = <PolkaVMOrFunction as RuntimeFunction<D>>::declaration(context);
     Ok(context
-        .build_call(declaration, &[operand_1.into(), operand_2.into()], "OR")
-        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value")))
+        .builder()
+        .build_or(operand_1, operand_2, "or_result")?
+        .as_basic_value_enum())
 }
 
 /// Translates the bitwise XOR.
@@ -33,11 +29,10 @@ pub fn xor<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let name = <PolkaVMXorFunction as RuntimeFunction<D>>::NAME;
-    let declaration = <PolkaVMXorFunction as RuntimeFunction<D>>::declaration(context);
     Ok(context
-        .build_call(declaration, &[operand_1.into(), operand_2.into()], "XOR")
-        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value")))
+        .builder()
+        .build_xor(operand_1, operand_2, "xor_result")?
+        .as_basic_value_enum())
 }
 
 /// Translates the bitwise AND.
@@ -49,11 +44,10 @@ pub fn and<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let name = <PolkaVMAndFunction as RuntimeFunction<D>>::NAME;
-    let declaration = <PolkaVMAndFunction as RuntimeFunction<D>>::declaration(context);
     Ok(context
-        .build_call(declaration, &[operand_1.into(), operand_2.into()], "AND")
-        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value")))
+        .builder()
+        .build_and(operand_1, operand_2, "and_result")?
+        .as_basic_value_enum())
 }
 
 /// Translates the bitwise shift left.
@@ -65,11 +59,37 @@ pub fn shift_left<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let name = <PolkaVMShlFunction as RuntimeFunction<D>>::NAME;
-    let declaration = <PolkaVMShlFunction as RuntimeFunction<D>>::declaration(context);
-    Ok(context
-        .build_call(declaration, &[shift.into(), value.into()], "SHL")
-        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value")))
+    let overflow_block = context.append_basic_block("shift_left_overflow");
+    let non_overflow_block = context.append_basic_block("shift_left_non_overflow");
+    let join_block = context.append_basic_block("shift_left_join");
+
+    let condition_is_overflow = context.builder().build_int_compare(
+        inkwell::IntPredicate::UGT,
+        shift,
+        context.word_const((revive_common::BIT_LENGTH_WORD - 1) as u64),
+        "shift_left_is_overflow",
+    )?;
+    context.build_conditional_branch(condition_is_overflow, overflow_block, non_overflow_block)?;
+
+    context.set_basic_block(overflow_block);
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(non_overflow_block);
+    let value =
+        context
+            .builder()
+            .build_left_shift(value, shift, "shift_left_non_overflow_result")?;
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(join_block);
+    let result = context
+        .builder()
+        .build_phi(context.word_type(), "shift_left_value")?;
+    result.add_incoming(&[
+        (&value, non_overflow_block),
+        (&context.word_const(0), overflow_block),
+    ]);
+    Ok(result.as_basic_value())
 }
 
 /// Translates the bitwise shift right.
@@ -81,11 +101,39 @@ pub fn shift_right<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let name = <PolkaVMShrFunction as RuntimeFunction<D>>::NAME;
-    let declaration = <PolkaVMShrFunction as RuntimeFunction<D>>::declaration(context);
-    Ok(context
-        .build_call(declaration, &[shift.into(), value.into()], "SHR")
-        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value")))
+    let overflow_block = context.append_basic_block("shift_right_overflow");
+    let non_overflow_block = context.append_basic_block("shift_right_non_overflow");
+    let join_block = context.append_basic_block("shift_right_join");
+
+    let condition_is_overflow = context.builder().build_int_compare(
+        inkwell::IntPredicate::UGT,
+        shift,
+        context.word_const((revive_common::BIT_LENGTH_WORD - 1) as u64),
+        "shift_right_is_overflow",
+    )?;
+    context.build_conditional_branch(condition_is_overflow, overflow_block, non_overflow_block)?;
+
+    context.set_basic_block(overflow_block);
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(non_overflow_block);
+    let value = context.builder().build_right_shift(
+        value,
+        shift,
+        false,
+        "shift_right_non_overflow_result",
+    )?;
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(join_block);
+    let result = context
+        .builder()
+        .build_phi(context.word_type(), "shift_right_value")?;
+    result.add_incoming(&[
+        (&value, non_overflow_block),
+        (&context.word_const(0), overflow_block),
+    ]);
+    Ok(result.as_basic_value())
 }
 
 /// Translates the arithmetic bitwise shift right.
@@ -97,11 +145,68 @@ pub fn shift_right_arithmetic<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let name = <PolkaVMSarFunction as RuntimeFunction<D>>::NAME;
-    let declaration = <PolkaVMSarFunction as RuntimeFunction<D>>::declaration(context);
-    Ok(context
-        .build_call(declaration, &[shift.into(), value.into()], "SHR")
-        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value")))
+    let overflow_block = context.append_basic_block("shift_right_arithmetic_overflow");
+    let overflow_positive_block =
+        context.append_basic_block("shift_right_arithmetic_overflow_positive");
+    let overflow_negative_block =
+        context.append_basic_block("shift_right_arithmetic_overflow_negative");
+    let non_overflow_block = context.append_basic_block("shift_right_arithmetic_non_overflow");
+    let join_block = context.append_basic_block("shift_right_arithmetic_join");
+
+    let condition_is_overflow = context.builder().build_int_compare(
+        inkwell::IntPredicate::UGT,
+        shift,
+        context.word_const((revive_common::BIT_LENGTH_WORD - 1) as u64),
+        "shift_right_arithmetic_is_overflow",
+    )?;
+    context.build_conditional_branch(condition_is_overflow, overflow_block, non_overflow_block)?;
+
+    context.set_basic_block(overflow_block);
+    let sign_bit = context.builder().build_right_shift(
+        value,
+        context.word_const((revive_common::BIT_LENGTH_WORD - 1) as u64),
+        false,
+        "shift_right_arithmetic_sign_bit",
+    )?;
+    let condition_is_negative = context.builder().build_int_truncate_or_bit_cast(
+        sign_bit,
+        context.bool_type(),
+        "shift_right_arithmetic_sign_bit_truncated",
+    )?;
+    context.build_conditional_branch(
+        condition_is_negative,
+        overflow_negative_block,
+        overflow_positive_block,
+    )?;
+
+    context.set_basic_block(overflow_positive_block);
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(overflow_negative_block);
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(non_overflow_block);
+    let value = context.builder().build_right_shift(
+        value,
+        shift,
+        true,
+        "shift_right_arithmetic_non_overflow_result",
+    )?;
+    context.build_unconditional_branch(join_block);
+
+    context.set_basic_block(join_block);
+    let result = context
+        .builder()
+        .build_phi(context.word_type(), "shift_arithmetic_right_value")?;
+    result.add_incoming(&[
+        (&value, non_overflow_block),
+        (
+            &context.word_type().const_all_ones(),
+            overflow_negative_block,
+        ),
+        (&context.word_const(0), overflow_positive_block),
+    ]);
+    Ok(result.as_basic_value())
 }
 
 /// Translates the `byte` instruction, extracting the byte of `operand_2`
@@ -120,9 +225,61 @@ pub fn byte<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let name = <PolkaVMByteFunction as RuntimeFunction<D>>::NAME;
-    let declaration = <PolkaVMByteFunction as RuntimeFunction<D>>::declaration(context);
-    Ok(context
-        .build_call(declaration, &[operand_1.into(), operand_2.into()], "BYTE")
-        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value")))
+    const MAX_INDEX_BYTES: u64 = 31;
+
+    let is_overflow_bit = context.builder().build_int_compare(
+        inkwell::IntPredicate::ULE,
+        operand_1,
+        context.word_const(MAX_INDEX_BYTES),
+        "is_overflow_bit",
+    )?;
+    let is_overflow_byte = context.builder().build_int_z_extend(
+        is_overflow_bit,
+        context.byte_type(),
+        "is_overflow_byte",
+    )?;
+    let mask_byte = context.builder().build_int_mul(
+        context.byte_type().const_all_ones(),
+        is_overflow_byte,
+        "mask_byte",
+    )?;
+    let mask_byte_word =
+        context
+            .builder()
+            .build_int_z_extend(mask_byte, context.word_type(), "mask_byte_word")?;
+
+    let index_truncated =
+        context
+            .builder()
+            .build_int_truncate(operand_1, context.byte_type(), "index_truncated")?;
+    let index_in_bits = context.builder().build_int_mul(
+        index_truncated,
+        context
+            .byte_type()
+            .const_int(revive_common::BIT_LENGTH_BYTE as u64, false),
+        "index_in_bits",
+    )?;
+    let index_from_most_significant_bit = context.builder().build_int_sub(
+        context.byte_type().const_int(
+            MAX_INDEX_BYTES * revive_common::BIT_LENGTH_BYTE as u64,
+            false,
+        ),
+        index_in_bits,
+        "index_from_msb",
+    )?;
+    let index_extended = context.builder().build_int_z_extend(
+        index_from_most_significant_bit,
+        context.word_type(),
+        "index",
+    )?;
+
+    let mask = context
+        .builder()
+        .build_left_shift(mask_byte_word, index_extended, "mask")?;
+    let masked_value = context.builder().build_and(operand_2, mask, "masked")?;
+    let byte = context
+        .builder()
+        .build_right_shift(masked_value, index_extended, false, "byte")?;
+
+    Ok(byte.as_basic_value_enum())
 }

crates/llvm-context/src/polkavm/evm/call.rs

@@ -3,13 +3,12 @@
 use inkwell::values::BasicValue;
 
 use crate::polkavm::context::argument::Argument;
-use crate::polkavm::context::runtime::RuntimeFunction;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
-use crate::{PolkaVMCall, PolkaVMCallReentrancyProtector};
 
 const STATIC_CALL_FLAG: u32 = 0b0001_0000;
 const REENTRANT_CALL_FLAG: u32 = 0b0000_1000;
+const SOLIDITY_TRANSFER_GAS_STIPEND_THRESHOLD: u64 = 2300;
 
 /// Translates a contract call.
 #[allow(clippy::too_many_arguments)]
@@ -28,45 +27,79 @@ pub fn call<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let input_offset = context.safe_truncate_int_to_xlen(input_offset)?;
-    let output_offset = context.safe_truncate_int_to_xlen(output_offset)?;
-
-    let input_length = context.safe_truncate_int_to_xlen(input_length)?;
-    let output_length = context.safe_truncate_int_to_xlen(output_length)?;
-
-    let deposit_limit_pointer =
-        context.build_alloca_at_entry(context.word_type(), "deposit_pointer");
-    let flags = if static_call {
-        let flags = REENTRANT_CALL_FLAG | STATIC_CALL_FLAG;
-        context.build_store(deposit_limit_pointer, context.word_type().const_zero())?;
-        context.xlen_type().const_int(flags as u64, false)
-    } else {
-        call_reentrancy_heuristic(
-            context,
-            deposit_limit_pointer.value,
-            gas,
-            input_length,
-            output_length,
-        )?
-    };
+    let address_pointer = context.build_address_argument_store(address)?;
 
     let value = value.unwrap_or_else(|| context.word_const(0));
+    let value_pointer = context.build_alloca_at_entry(context.word_type(), "value_pointer");
+    context.build_store(value_pointer, value)?;
 
-    let name = <PolkaVMCall as RuntimeFunction<D>>::NAME;
-    let declaration = <PolkaVMCall as RuntimeFunction<D>>::declaration(context);
-    let arguments = &[
-        address.into(),
-        value.into(),
-        input_offset.into(),
-        input_length.into(),
-        output_offset.into(),
-        output_length.into(),
-        deposit_limit_pointer.value.into(),
-        flags.into(),
-    ];
+    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)?;
+
+    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, deposit_limit_value) = if static_call {
+        let flags = REENTRANT_CALL_FLAG | STATIC_CALL_FLAG;
+        (
+            context.xlen_type().const_int(flags as u64, false),
+            context.word_type().const_zero(),
+        )
+    } else {
+        call_reentrancy_heuristic(context, gas, input_length, output_length)?
+    };
+
+    let deposit_pointer = context.build_alloca_at_entry(context.word_type(), "deposit_pointer");
+    context.build_store(deposit_pointer, deposit_limit_value)?;
+
+    let flags_and_callee = revive_runtime_api::calling_convention::pack_hi_lo_reg(
+        context.builder(),
+        context.llvm(),
+        flags,
+        address_pointer.to_int(context),
+        "address_and_callee",
+    )?;
+    let deposit_and_value = revive_runtime_api::calling_convention::pack_hi_lo_reg(
+        context.builder(),
+        context.llvm(),
+        deposit_pointer.to_int(context),
+        value_pointer.to_int(context),
+        "deposit_and_value",
+    )?;
+    let input_data = revive_runtime_api::calling_convention::pack_hi_lo_reg(
+        context.builder(),
+        context.llvm(),
+        input_length,
+        input_pointer.to_int(context),
+        "input_data",
+    )?;
+    let output_data = revive_runtime_api::calling_convention::pack_hi_lo_reg(
+        context.builder(),
+        context.llvm(),
+        output_length_pointer.to_int(context),
+        output_pointer.to_int(context),
+        "output_data",
+    )?;
+
+    let name = revive_runtime_api::polkavm_imports::CALL;
     let success = context
-        .build_call(declaration, arguments, "call")
-        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value"))
+        .build_runtime_call(
+            name,
+            &[
+                flags_and_callee.into(),
+                context.register_type().const_all_ones().into(),
+                context.register_type().const_all_ones().into(),
+                deposit_and_value.into(),
+                input_data.into(),
+                output_data.into(),
+            ],
+        )
+        .unwrap_or_else(|| panic!("{name} should return a value"))
         .into_int_value();
 
     let is_success = context.builder().build_int_compare(
@@ -183,28 +216,85 @@ where
         .as_basic_value_enum())
 }
 
+/// The Solidity `address.transfer` and `address.send` call detection heuristic.
+///
+/// # Why
+/// This heuristic is an additional security feature to guard against re-entrancy attacks
+/// in case contract authors violate Solidity best practices and use `address.transfer` or
+/// `address.send`.
+/// While contract authors are supposed to never use `address.transfer` or `address.send`,
+/// for a small cost we can be extra defensive about it.
+///
+/// # How
+/// The gas stipend emitted by solc for `transfer` and `send` is not static, thus:
+/// - Dynamically allow re-entrancy only for calls considered not transfer or send.
+/// - Detected balance transfers will supply 0 deposit limit instead of `u256::MAX`.
+///
+/// Calls are considered transfer or send if:
+/// - (Input length | Output lenght) == 0;
+/// - Gas <= 2300;
+///
+/// # Returns
+/// The call flags xlen `IntValue` and the deposit limit word `IntValue`.
 fn call_reentrancy_heuristic<'ctx, D>(
     context: &mut Context<'ctx, D>,
-    deposit_limit_pointer: inkwell::values::PointerValue<'ctx>,
     gas: inkwell::values::IntValue<'ctx>,
     input_length: inkwell::values::IntValue<'ctx>,
     output_length: inkwell::values::IntValue<'ctx>,
-) -> anyhow::Result<inkwell::values::IntValue<'ctx>>
+) -> anyhow::Result<(
+    inkwell::values::IntValue<'ctx>,
+    inkwell::values::IntValue<'ctx>,
+)>
 where
     D: Dependency + Clone,
 {
-    let name = <PolkaVMCallReentrancyProtector as RuntimeFunction<D>>::NAME;
-    let declaration = <PolkaVMCallReentrancyProtector as RuntimeFunction<D>>::declaration(context);
-    let arguments = &[
-        deposit_limit_pointer.into(),
-        gas.into(),
+    // Branch-free SSA implementation: First derive the heuristic boolean (int1) value.
+    let input_length_or_output_length =
         context
             .builder()
-            .build_or(input_length, output_length, "input_length_or_output_length")?
-            .into(),
-    ];
-    Ok(context
-        .build_call(declaration, arguments, "call_flags")
-        .unwrap_or_else(|| panic!("revive runtime function {name} should return a value"))
-        .into_int_value())
+            .build_or(input_length, output_length, "input_length_or_output_length")?;
+    let is_no_input_no_output = context.builder().build_int_compare(
+        inkwell::IntPredicate::EQ,
+        context.xlen_type().const_zero(),
+        input_length_or_output_length,
+        "is_no_input_no_output",
+    )?;
+    let gas_stipend = context
+        .word_type()
+        .const_int(SOLIDITY_TRANSFER_GAS_STIPEND_THRESHOLD, false);
+    let is_gas_stipend_for_transfer_or_send = context.builder().build_int_compare(
+        inkwell::IntPredicate::ULE,
+        gas,
+        gas_stipend,
+        "is_gas_stipend_for_transfer_or_send",
+    )?;
+    let is_balance_transfer = context.builder().build_and(
+        is_no_input_no_output,
+        is_gas_stipend_for_transfer_or_send,
+        "is_balance_transfer",
+    )?;
+    let is_regular_call = context
+        .builder()
+        .build_not(is_balance_transfer, "is_balance_transfer_inverted")?;
+
+    // Call flag: Left shift the heuristic boolean value.
+    let is_regular_call_xlen = context.builder().build_int_z_extend(
+        is_regular_call,
+        context.xlen_type(),
+        "is_balance_transfer_xlen",
+    )?;
+    let call_flags = context.builder().build_left_shift(
+        is_regular_call_xlen,
+        context.xlen_type().const_int(3, false),
+        "flags",
+    )?;
+
+    // Deposit limit value: Sign-extended the heuristic boolean value.
+    let deposit_limit_value = context.builder().build_int_s_extend(
+        is_regular_call,
+        context.word_type(),
+        "deposit_limit_value",
+    )?;
+
+    Ok((call_flags, deposit_limit_value))
 }

crates/resolc/src/lib.rs

@@ -54,7 +54,7 @@ pub fn yul<T: Compiler>(
     solc: &mut T,
     optimizer_settings: revive_llvm_context::OptimizerSettings,
     include_metadata_hash: bool,
-    debug_config: revive_llvm_context::DebugConfig,
+    mut debug_config: revive_llvm_context::DebugConfig,
     llvm_arguments: &[String],
     memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
 ) -> anyhow::Result<Build> {
@@ -77,6 +77,7 @@ pub fn yul<T: Compiler>(
     let solc_validator = Some(&*solc);
     let project = Project::try_from_yul_path(path, solc_validator)?;
 
+    debug_config.set_yul_path(path);
     let build = project.compile(
         optimizer_settings,
         include_metadata_hash,

crates/resolc/src/project/contract/mod.rs

@@ -77,7 +77,7 @@ impl Contract {
         project: Project,
         optimizer_settings: revive_llvm_context::OptimizerSettings,
         include_metadata_hash: bool,
-        debug_config: revive_llvm_context::DebugConfig,
+        mut debug_config: revive_llvm_context::DebugConfig,
         llvm_arguments: &[String],
         memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
     ) -> anyhow::Result<ContractBuild> {
@@ -117,6 +117,7 @@ impl Contract {
             _ => llvm.create_module(self.path.as_str()),
         };
 
+        debug_config.set_contract_path(&self.path);
         let mut context = revive_llvm_context::PolkaVMContext::new(
             &llvm,
             module,

crates/resolc/src/solc/solc_compiler.rs

@@ -45,8 +45,6 @@ impl Compiler for SolcCompiler {
         include_paths: Vec<String>,
         allow_paths: Option<String>,
     ) -> anyhow::Result<SolcStandardJsonOutput> {
-        let version = self.version()?.validate(&include_paths)?.default;
-
         let mut command = std::process::Command::new(self.executable.as_str());
         command.stdin(std::process::Stdio::piped());
         command.stdout(std::process::Stdio::piped());
@@ -65,7 +63,7 @@ impl Compiler for SolcCompiler {
             command.arg(allow_paths);
         }
 
-        input.normalize(&version);
+        input.normalize();
 
         let suppressed_warnings = input.suppressed_warnings.take().unwrap_or_default();
 

crates/resolc/src/solc/soljson_compiler.rs

@@ -40,8 +40,7 @@ impl Compiler for SoljsonCompiler {
             anyhow::bail!("configuring allow paths is not supported with solJson")
         }
 
-        let version = self.version()?.validate(&include_paths)?.default;
-        input.normalize(&version);
+        input.normalize();
 
         let suppressed_warnings = input.suppressed_warnings.take().unwrap_or_default();
 

crates/solc-json-interface/src/lib.rs

@@ -7,6 +7,7 @@ pub use self::combined_json::contract::Contract as CombinedJsonContract;
 pub use self::standard_json::input::language::Language as SolcStandardJsonInputLanguage;
 pub use self::standard_json::input::settings::metadata::Metadata as SolcStandardJsonInputSettingsMetadata;
 pub use self::standard_json::input::settings::metadata_hash::MetadataHash as SolcStandardJsonInputSettingsMetadataHash;
+pub use self::standard_json::input::settings::optimizer::yul_details::YulDetails as SolcStandardJsonInputSettingsYulOptimizerDetails;
 pub use self::standard_json::input::settings::optimizer::Optimizer as SolcStandardJsonInputSettingsOptimizer;
 pub use self::standard_json::input::settings::polkavm::memory::MemoryConfig as SolcStandardJsonInputSettingsPolkaVMMemory;
 pub use self::standard_json::input::settings::polkavm::memory::DEFAULT_HEAP_SIZE as PolkaVMDefaultHeapMemorySize;

crates/solc-json-interface/src/standard_json/input/mod.rs

@@ -140,7 +140,7 @@ impl Input {
     }
 
     /// Sets the necessary defaults.
-    pub fn normalize(&mut self, version: &semver::Version) {
-        self.settings.normalize(version);
+    pub fn normalize(&mut self) {
+        self.settings.normalize();
     }
 }

crates/solc-json-interface/src/standard_json/input/settings/mod.rs

@@ -74,9 +74,9 @@ impl Settings {
     }
 
     /// Sets the necessary defaults.
-    pub fn normalize(&mut self, version: &semver::Version) {
+    pub fn normalize(&mut self) {
         self.polkavm = None;
-        self.optimizer.normalize(version);
+        self.optimizer.normalize();
     }
 
     /// Parses the library list and returns their double hashmap with path and name as keys.

crates/solc-json-interface/src/standard_json/input/settings/optimizer/details.rs

@@ -3,37 +3,54 @@
 use serde::Deserialize;
 use serde::Serialize;
 
+use crate::standard_json::input::settings::optimizer::yul_details::YulDetails;
+
 /// The `solc --standard-json` input settings optimizer details.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Details {
     /// Whether the pass is enabled.
-    pub peephole: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub peephole: Option<bool>,
     /// Whether the pass is enabled.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub inliner: Option<bool>,
     /// Whether the pass is enabled.
-    pub jumpdest_remover: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub jumpdest_remover: Option<bool>,
     /// Whether the pass is enabled.
-    pub order_literals: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub order_literals: Option<bool>,
     /// Whether the pass is enabled.
-    pub deduplicate: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub deduplicate: Option<bool>,
     /// Whether the pass is enabled.
-    pub cse: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cse: Option<bool>,
     /// Whether the pass is enabled.
-    pub constant_optimizer: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub constant_optimizer: Option<bool>,
+    /// Whether the YUL optimizer is enabled.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub yul: Option<bool>,
+    /// The YUL optimizer configuration.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub yul_details: Option<YulDetails>,
 }
 
 impl Details {
     /// A shortcut constructor.
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
-        peephole: bool,
+        peephole: Option<bool>,
         inliner: Option<bool>,
-        jumpdest_remover: bool,
-        order_literals: bool,
-        deduplicate: bool,
-        cse: bool,
-        constant_optimizer: bool,
+        jumpdest_remover: Option<bool>,
+        order_literals: Option<bool>,
+        deduplicate: Option<bool>,
+        cse: Option<bool>,
+        constant_optimizer: Option<bool>,
+        yul: Option<bool>,
+        yul_details: Option<YulDetails>,
     ) -> Self {
         Self {
             peephole,
@@ -43,10 +60,11 @@ impl Details {
             deduplicate,
             cse,
             constant_optimizer,
+            yul,
+            yul_details,
         }
     }
 
-    /// Creates a set of disabled optimizations.
     pub fn disabled(version: &semver::Version) -> Self {
         let inliner = if version >= &semver::Version::new(0, 8, 5) {
             Some(false)
@@ -54,6 +72,16 @@ impl Details {
             None
         };
 
-        Self::new(false, inliner, false, false, false, false, false)
+        Self::new(
+            Some(false),
+            inliner,
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false),
+            None,
+            None,
+        )
     }
 }

crates/solc-json-interface/src/standard_json/input/settings/optimizer/mod.rs

@@ -1,6 +1,7 @@
 //! The `solc --standard-json` input settings optimizer.
 
 pub mod details;
+pub mod yul_details;
 
 use serde::Deserialize;
 use serde::Serialize;
@@ -41,13 +42,8 @@ impl Optimizer {
     }
 
     /// Sets the necessary defaults.
-    pub fn normalize(&mut self, version: &semver::Version) {
+    pub fn normalize(&mut self) {
         self.mode = None;
         self.fallback_to_optimizing_for_size = None;
-        self.details = if version >= &semver::Version::new(0, 5, 5) {
-            Some(Details::disabled(version))
-        } else {
-            None
-        };
     }
 }

crates/solc-json-interface/src/standard_json/input/settings/optimizer/yul_details.rs

@@ -0,0 +1,26 @@
+//! The `solc --standard-json` input settings YUL optimizer details.
+
+use serde::Deserialize;
+use serde::Serialize;
+
+/// The `solc --standard-json` input settings optimizer YUL details.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct YulDetails {
+    /// Whether the stack allocation pass is enabled.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stack_allocation: Option<bool>,
+    /// The optimization step sequence string.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub optimizer_steps: Option<String>,
+}
+
+impl YulDetails {
+    /// A shortcut constructor.
+    pub fn new(stack_allocation: Option<bool>, optimizer_steps: Option<String>) -> Self {
+        Self {
+            stack_allocation,
+            optimizer_steps,
+        }
+    }
+}

crates/yul/src/parser/statement/assignment.rs

@@ -115,13 +115,29 @@ impl<D> revive_llvm_context::PolkaVMWriteLLVM<D> for Assignment
 where
     D: revive_llvm_context::PolkaVMDependency + Clone,
 {
-    fn into_llvm(
+    fn into_llvm<'ctx>(
         mut self,
-        context: &mut revive_llvm_context::PolkaVMContext<D>,
+        context: &mut revive_llvm_context::PolkaVMContext<'ctx, D>,
     ) -> anyhow::Result<()> {
         context.set_debug_location(self.location.line, 0, None)?;
 
-        let value = match self.initializer.into_llvm(context)? {
+        let bindings: Vec<(String, revive_llvm_context::PolkaVMPointer<'ctx>)> = self
+            .bindings
+            .into_iter()
+            .map(|binding| {
+                (
+                    binding.inner.clone(),
+                    context
+                        .current_function()
+                        .borrow_mut()
+                        .stack_variable_pointer(binding.inner, context),
+                )
+            })
+            .collect();
+
+        self.initializer.into_llvm(bindings.as_slice(), context)?;
+        /*
+        let value = match self.initializer.into_llvm(bindings.as_slice(), context)? {
             Some(value) => value,
             None => return Ok(()),
         };
@@ -181,6 +197,8 @@ where
             context.build_store(binding_pointer, value)?;
         }
 
+        */
+
         Ok(())
     }
 }

crates/yul/src/parser/statement/block.rs

@@ -184,7 +184,7 @@ where
                     block.into_llvm(context)?;
                 }
                 Statement::Expression(expression) => {
-                    expression.into_llvm(context)?;
+                    expression.into_llvm(&[], context)?;
                 }
                 Statement::VariableDeclaration(statement) => statement.into_llvm(context)?,
                 Statement::Assignment(statement) => statement.into_llvm(context)?,

crates/yul/src/parser/statement/expression/function_call/mod.rs

@@ -117,24 +117,37 @@ impl FunctionCall {
     /// Converts the function call into an LLVM value.
     pub fn into_llvm<'ctx, D>(
         mut self,
+        bindings: &[(String, revive_llvm_context::PolkaVMPointer<'ctx>)],
         context: &mut revive_llvm_context::PolkaVMContext<'ctx, D>,
-    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>>
+    ) -> anyhow::Result<()>
     where
         D: revive_llvm_context::PolkaVMDependency + Clone,
     {
         let location = self.location;
+        context.set_debug_location(location.line, 0, None)?;
 
         match self.name {
             Name::UserDefined(name) => {
-                let mut values = Vec::with_capacity(self.arguments.len());
-                for argument in self.arguments.into_iter().rev() {
+                let mut values = Vec::with_capacity(bindings.len() + self.arguments.len());
+                for (n, argument) in self.arguments.into_iter().rev().enumerate() {
+                    let id = format!("arg_{n}");
+                    let binding_pointer = context.build_alloca(context.word_type(), &id);
                     let value = argument
-                        .into_llvm(context)?
+                        .into_llvm(&[(id, binding_pointer)], context)?
                         .expect("Always exists")
-                        .access(context)?;
+                        .as_pointer(context)?
+                        .value
+                        .as_basic_value_enum();
                     values.push(value);
                 }
                 values.reverse();
+
+                let values = bindings
+                    .into_iter()
+                    .map(|(_, pointer)| pointer.value.as_basic_value_enum())
+                    .chain(values.into_iter())
+                    .collect::<Vec<_>>();
+
                 let function = context.get_function(name.as_str()).ok_or_else(|| {
                     anyhow::anyhow!("{} Undeclared function `{}`", location, name)
                 })?;
@@ -151,23 +164,24 @@ impl FunctionCall {
                     );
                 }
 
-                let return_value = context.build_call(
+                let _return_value = context.build_call(
                     function.borrow().declaration(),
                     values.as_slice(),
                     format!("{name}_call").as_str(),
                 );
 
-                Ok(return_value)
+                Ok(())
             }
 
             Name::Add => {
                 let arguments = self.pop_arguments_llvm::<D, 2>(context)?;
                 revive_llvm_context::polkavm_evm_arithmetic::addition(
                     context,
-                    arguments[0].into_int_value(),
-                    arguments[1].into_int_value(),
-                )
-                .map(Some)
+                    bindings,
+                    arguments[0].into_pointer_value(),
+                    arguments[1].into_pointer_value(),
+                )?;
+                Ok(())
             }
             Name::Sub => {
                 let arguments = self.pop_arguments_llvm::<D, 2>(context)?;
@@ -986,10 +1000,12 @@ impl FunctionCall {
         D: revive_llvm_context::PolkaVMDependency + Clone,
     {
         let mut arguments = Vec::with_capacity(N);
-        for expression in self.arguments.drain(0..N).rev() {
+        for (index, expression) in self.arguments.drain(0..N).rev().enumerate() {
+            let name = format!("arg_{index}");
+            let pointer = context.build_alloca(context.word_type(), &name);
             arguments.push(
                 expression
-                    .into_llvm(context)?
+                    .into_llvm(&[(name, pointer)], context)?
                     .expect("Always exists")
                     .access(context)?,
             );
@@ -1008,8 +1024,14 @@ impl FunctionCall {
         D: revive_llvm_context::PolkaVMDependency + Clone,
     {
         let mut arguments = Vec::with_capacity(N);
-        for expression in self.arguments.drain(0..N).rev() {
-            arguments.push(expression.into_llvm(context)?.expect("Always exists"));
+        for (index, expression) in self.arguments.drain(0..N).rev().enumerate() {
+            let name = format!("arg_{index}");
+            let pointer = context.build_alloca(context.word_type(), &name);
+            arguments.push(
+                expression
+                    .into_llvm(&[(name, pointer)], context)?
+                    .expect("Always exists"),
+            );
         }
         arguments.reverse();
 

crates/yul/src/parser/statement/expression/literal.rs

@@ -72,6 +72,7 @@ impl Literal {
     /// Converts the literal into its LLVM.
     pub fn into_llvm<'ctx, D>(
         self,
+        binding: Option<(String, revive_llvm_context::PolkaVMPointer<'ctx>)>,
         context: &revive_llvm_context::PolkaVMContext<'ctx, D>,
     ) -> anyhow::Result<revive_llvm_context::PolkaVMArgument<'ctx>>
     where
@@ -97,7 +98,17 @@ impl Literal {
                     BooleanLiteral::True => num::BigUint::one(),
                 };
 
-                Ok(revive_llvm_context::PolkaVMArgument::value(value).with_constant(constant))
+                match binding {
+                    Some((id, pointer)) => {
+                        context.build_store(pointer, value)?;
+                        Ok(revive_llvm_context::PolkaVMArgument::pointer(pointer, id)
+                            .with_constant(constant))
+                    }
+                    None => {
+                        Ok(revive_llvm_context::PolkaVMArgument::value(value)
+                            .with_constant(constant))
+                    }
+                }
             }
             LexicalLiteral::Integer(inner) => {
                 let r#type = self.yul_type.unwrap_or_default().into_llvm(context);
@@ -125,7 +136,17 @@ impl Literal {
                 }
                 .expect("Always valid");
 
-                Ok(revive_llvm_context::PolkaVMArgument::value(value).with_constant(constant))
+                match binding {
+                    Some((id, pointer)) => {
+                        context.build_store(pointer, value)?;
+                        Ok(revive_llvm_context::PolkaVMArgument::pointer(pointer, id)
+                            .with_constant(constant))
+                    }
+                    None => {
+                        Ok(revive_llvm_context::PolkaVMArgument::value(value)
+                            .with_constant(constant))
+                    }
+                }
             }
             LexicalLiteral::String(inner) => {
                 let string = inner.inner;
@@ -216,7 +237,16 @@ impl Literal {
                     )
                     .expect("The value is valid")
                     .as_basic_value_enum();
-                Ok(revive_llvm_context::PolkaVMArgument::value(value).with_original(string))
+                match binding {
+                    Some((id, pointer)) => {
+                        context.build_store(pointer, value)?;
+                        Ok(revive_llvm_context::PolkaVMArgument::pointer(pointer, id)
+                            .with_original(string))
+                    }
+                    None => Ok(
+                        revive_llvm_context::PolkaVMArgument::value(value).with_original(string)
+                    ),
+                }
             }
         }
     }

crates/yul/src/parser/statement/expression/mod.rs

@@ -100,6 +100,7 @@ impl Expression {
     /// Converts the expression into an LLVM value.
     pub fn into_llvm<'ctx, D>(
         self,
+        bindings: &[(String, revive_llvm_context::PolkaVMPointer<'ctx>)],
         context: &mut revive_llvm_context::PolkaVMContext<'ctx, D>,
     ) -> anyhow::Result<Option<revive_llvm_context::PolkaVMArgument<'ctx>>>
     where
@@ -108,7 +109,13 @@ impl Expression {
         match self {
             Self::Literal(literal) => literal
                 .clone()
-                .into_llvm(context)
+                .into_llvm(
+                    bindings
+                        .first()
+                        .to_owned()
+                        .map(|(id, binding)| (id.to_string(), *binding)),
+                    context,
+                )
                 .map_err(|error| {
                     anyhow::anyhow!(
                         "{} Invalid literal `{}`: {}",
@@ -138,9 +145,10 @@ impl Expression {
                     _ => argument,
                 }))
             }
-            Self::FunctionCall(call) => Ok(call
-                .into_llvm(context)?
-                .map(revive_llvm_context::PolkaVMArgument::value)),
+            Self::FunctionCall(call) => {
+                call.into_llvm(bindings, context)?;
+                Ok(None)
+            }
         }
     }
 }

crates/yul/src/parser/statement/for_loop.rs

@@ -74,9 +74,10 @@ where
 
         context.build_unconditional_branch(condition_block);
         context.set_basic_block(condition_block);
+        let binding_pointer = context.build_alloca(context.word_type(), "if_condition");
         let condition = self
             .condition
-            .into_llvm(context)?
+            .into_llvm(&[("todo".to_string(), binding_pointer)], context)?
             .expect("Always exists")
             .access(context)?
             .into_int_value();

crates/yul/src/parser/statement/function_definition.rs

@@ -231,8 +231,80 @@ where
         context: &mut revive_llvm_context::PolkaVMContext<D>,
     ) -> anyhow::Result<()> {
         context.set_current_function(self.identifier.as_str(), Some(self.location.line))?;
+
         context.set_basic_block(context.current_function().borrow().entry_block());
 
+        let return_types: Vec<_> = self
+            .arguments
+            .iter()
+            .map(|argument| {
+                let yul_type = argument.r#type.to_owned().unwrap_or_default();
+                yul_type.into_llvm(context)
+            })
+            .collect();
+        for (index, argument) in self.result.iter().enumerate() {
+            let pointer = context
+                .current_function()
+                .borrow()
+                .get_nth_param(index)
+                .into_pointer_value();
+            let pointer = revive_llvm_context::PolkaVMPointer::new(
+                return_types[index],
+                Default::default(),
+                pointer,
+            );
+            context.build_store(pointer, pointer.r#type.const_zero())?;
+            context
+                .current_function()
+                .borrow_mut()
+                .insert_stack_pointer(argument.inner.clone(), pointer);
+        }
+
+        let argument_types: Vec<_> = self
+            .arguments
+            .iter()
+            .map(|argument| {
+                let yul_type = argument.r#type.to_owned().unwrap_or_default();
+                yul_type.into_llvm(context)
+            })
+            .collect();
+        for (index, argument) in self.arguments.iter().enumerate() {
+            let pointer = context
+                .current_function()
+                .borrow()
+                .get_nth_param(index + self.result.len())
+                .into_pointer_value();
+            let pointer = revive_llvm_context::PolkaVMPointer::new(
+                argument_types[index],
+                Default::default(),
+                pointer,
+            );
+            context
+                .current_function()
+                .borrow_mut()
+                .insert_stack_pointer(argument.inner.clone(), pointer);
+        }
+
+        self.body.into_llvm(context)?;
+        context.set_debug_location(self.location.line, 0, None)?;
+
+        match context
+            .basic_block()
+            .get_last_instruction()
+            .map(|instruction| instruction.get_opcode())
+        {
+            Some(inkwell::values::InstructionOpcode::Br) => {}
+            Some(inkwell::values::InstructionOpcode::Switch) => {}
+            _ => context
+                .build_unconditional_branch(context.current_function().borrow().return_block()),
+        }
+
+        context.set_basic_block(context.current_function().borrow().return_block());
+        context.build_return(None);
+
+        context.pop_debug_scope();
+
+        /*
         let r#return = context.current_function().borrow().r#return();
         match r#return {
             revive_llvm_context::PolkaVMFunctionReturn::None => {}
@@ -319,6 +391,7 @@ where
         }
 
         context.pop_debug_scope();
+        */
 
         Ok(())
     }

crates/yul/src/parser/statement/if_conditional.rs

@@ -53,9 +53,11 @@ where
     D: revive_llvm_context::PolkaVMDependency + Clone,
 {
     fn into_llvm(self, context: &mut revive_llvm_context::PolkaVMContext<D>) -> anyhow::Result<()> {
+        let binding_pointer = context.build_alloca(context.word_type(), "if_condition");
+        context.set_debug_location(self.location.line, 0, None)?;
         let condition = self
             .condition
-            .into_llvm(context)?
+            .into_llvm(&[("todo".to_string(), binding_pointer)], context)?
             .expect("Always exists")
             .access(context)?
             .into_int_value();

crates/yul/src/parser/statement/object.rs

@@ -205,24 +205,11 @@ where
         revive_llvm_context::PolkaVMEventLogFunction::<4>.declare(context)?;
 
         revive_llvm_context::PolkaVMAdditionFunction.declare(context)?;
-        revive_llvm_context::PolkaVMSubstractionFunction.declare(context)?;
-        revive_llvm_context::PolkaVMMultiplicationFunction.declare(context)?;
         revive_llvm_context::PolkaVMDivisionFunction.declare(context)?;
         revive_llvm_context::PolkaVMSignedDivisionFunction.declare(context)?;
         revive_llvm_context::PolkaVMRemainderFunction.declare(context)?;
         revive_llvm_context::PolkaVMSignedRemainderFunction.declare(context)?;
 
-        revive_llvm_context::PolkaVMOrFunction.declare(context)?;
-        revive_llvm_context::PolkaVMXorFunction.declare(context)?;
-        revive_llvm_context::PolkaVMAndFunction.declare(context)?;
-        revive_llvm_context::PolkaVMShlFunction.declare(context)?;
-        revive_llvm_context::PolkaVMShrFunction.declare(context)?;
-        revive_llvm_context::PolkaVMSarFunction.declare(context)?;
-        revive_llvm_context::PolkaVMByteFunction.declare(context)?;
-
-        revive_llvm_context::PolkaVMCall.declare(context)?;
-        revive_llvm_context::PolkaVMCallReentrancyProtector.declare(context)?;
-
         revive_llvm_context::PolkaVMSbrkFunction.declare(context)?;
 
         let mut entry = revive_llvm_context::PolkaVMEntryFunction::default();
@@ -273,24 +260,11 @@ where
         revive_llvm_context::PolkaVMEventLogFunction::<4>.into_llvm(context)?;
 
         revive_llvm_context::PolkaVMAdditionFunction.into_llvm(context)?;
-        revive_llvm_context::PolkaVMSubstractionFunction.into_llvm(context)?;
-        revive_llvm_context::PolkaVMMultiplicationFunction.into_llvm(context)?;
         revive_llvm_context::PolkaVMDivisionFunction.into_llvm(context)?;
         revive_llvm_context::PolkaVMSignedDivisionFunction.into_llvm(context)?;
         revive_llvm_context::PolkaVMRemainderFunction.into_llvm(context)?;
         revive_llvm_context::PolkaVMSignedRemainderFunction.into_llvm(context)?;
 
-        revive_llvm_context::PolkaVMOrFunction.into_llvm(context)?;
-        revive_llvm_context::PolkaVMXorFunction.into_llvm(context)?;
-        revive_llvm_context::PolkaVMAndFunction.into_llvm(context)?;
-        revive_llvm_context::PolkaVMShlFunction.into_llvm(context)?;
-        revive_llvm_context::PolkaVMShrFunction.into_llvm(context)?;
-        revive_llvm_context::PolkaVMSarFunction.into_llvm(context)?;
-        revive_llvm_context::PolkaVMByteFunction.into_llvm(context)?;
-
-        revive_llvm_context::PolkaVMCall.into_llvm(context)?;
-        revive_llvm_context::PolkaVMCallReentrancyProtector.into_llvm(context)?;
-
         revive_llvm_context::PolkaVMSbrkFunction.into_llvm(context)?;
 
         Ok(())

crates/yul/src/parser/statement/switch/mod.rs

@@ -123,7 +123,7 @@ where
     D: revive_llvm_context::PolkaVMDependency + Clone,
 {
     fn into_llvm(self, context: &mut revive_llvm_context::PolkaVMContext<D>) -> anyhow::Result<()> {
-        let scrutinee = self.expression.into_llvm(context)?;
+        let scrutinee = self.expression.into_llvm(&[], context)?;
 
         if self.cases.is_empty() {
             if let Some(block) = self.default {
@@ -137,7 +137,7 @@ where
 
         let mut branches = Vec::with_capacity(self.cases.len());
         for (index, case) in self.cases.into_iter().enumerate() {
-            let constant = case.literal.into_llvm(context)?.access(context)?;
+            let constant = case.literal.into_llvm(None, context)?.access(context)?;
 
             let expression_block = context
                 .append_basic_block(format!("switch_case_branch_{}_block", index + 1).as_str());

crates/yul/src/parser/statement/variable_declaration.rs

@@ -99,6 +99,25 @@ where
         mut self,
         context: &mut revive_llvm_context::PolkaVMContext<'ctx, D>,
     ) -> anyhow::Result<()> {
+        let bindings: Vec<(String, revive_llvm_context::PolkaVMPointer<'ctx>)> = self
+            .bindings
+            .into_iter()
+            .map(|binding| {
+                (
+                    binding.inner.clone(),
+                    context
+                        .current_function()
+                        .borrow_mut()
+                        .stack_variable_pointer(binding.inner, context),
+                )
+            })
+            .collect();
+
+        if let Some(expression) = self.expression {
+            expression.into_llvm(&bindings, context)?;
+        }
+
+        /*
         if self.bindings.len() == 1 {
             let identifier = self.bindings.remove(0);
             context.set_debug_location(self.location.line, 0, None)?;
@@ -213,6 +232,7 @@ where
                 })?;
             context.build_store(pointer, value)?;
         }
+        */
 
         Ok(())
     }

crates/yul/src/parser/type.rs

@@ -70,10 +70,11 @@ impl Type {
         D: revive_llvm_context::PolkaVMDependency + Clone,
     {
         match self {
-            Self::Bool => context.integer_type(revive_common::BIT_LENGTH_BOOLEAN),
-            Self::Int(bitlength) => context.integer_type(bitlength),
+            //Self::Bool => context.integer_type(revive_common::BIT_LENGTH_BOOLEAN),
+            //Self::Int(bitlength) => context.integer_type(bitlength),
             Self::UInt(bitlength) => context.integer_type(bitlength),
-            Self::Custom(_) => context.word_type(),
+            //Self::Custom(_) => context.word_type(),
+            _ => panic!("oh no"),
         }
     }
 }