mirror of
https://github.com/pezkuwichain/revive.git
synced 2026-06-14 21:31:05 +00:00
Compare commits
35 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 xermicus
|
ad3315346c | ||
|
dependabot[bot]
|
516f79ee0f | ||
|
Alexander Samusev
|
9f5443b6d6 | ||
|
Alexander Samusev
|
0dafc779ce | ||
|
xermicus
|
7d8fa75a0f | ||
|
dependabot[bot]
|
80f94b5c76 | ||
|
xermicus
|
dab29bc89b | ||
|
xermicus
|
313c033261 | ||
|
xermicus
|
87c1d7a8be | ||
|
xermicus
|
8a98346a9c | ||
|
Alexander Samusev
|
1b4d2c6bb8 | ||
|
xermicus
|
004b8ac16c | ||
|
xermicus
|
497dae2494 | ||
|
Pavlo Khrystenko
|
36ea69b50f | ||
|
xermicus
|
2bbc5d713d | ||
|
xermicus
|
4a9b651235 | ||
|
Alexander Theißen
|
66f9a4d64f | ||
|
xermicus
|
76f4cf71d6 | ||
|
xermicus
|
77e0344d80 | ||
|
Alexander Theißen
|
2fb8beee62 | ||
|
xermicus
|
93788e72e9 | ||
|
xermicus
|
296a226d0b | ||
|
xermicus
|
84deb3a29d | ||
|
Evgeny Snitko
|
ee064671e0 | ||
|
xermicus
|
63dfd046e5 | ||
|
xermicus
|
08f341ccc1 | ||
|
xermicus
|
a07968205b | ||
|
Evgeny Snitko
|
7ffe64ed7c | ||
|
Yuri Volkov
|
f1bce4fe3f | ||
|
xermicus
|
9efbb4c0b4 | ||
|
xermicus
|
bcc8fa892c | ||
|
Pavlo Khrystenko
|
89ec25da65 | ||
|
xermicus
|
75a83af4da | ||
|
xermicus
|
9c330ef8fc | ||
|
Yuri Volkov
|
687cec31ef |
@@ -0,0 +1,19 @@
|
||||
name: "Get Emscripten SDK"
|
||||
inputs:
|
||||
version:
|
||||
description: ""
|
||||
required: false
|
||||
default: "3.1.64"
|
||||
|
||||
|
||||
runs:
|
||||
using: "composite"
|
||||
steps:
|
||||
- name: install emsdk
|
||||
shell: bash
|
||||
run: |
|
||||
git clone https://github.com/emscripten-core/emsdk.git ./emsdk/
|
||||
cd emsdk
|
||||
git checkout tags/${{ inputs.version }}
|
||||
./emsdk install ${{ inputs.version }}
|
||||
./emsdk activate ${{ inputs.version }}
|
||||
@@ -0,0 +1,70 @@
|
||||
# example:
|
||||
# - uses: ./.github/actions/get-llvm
|
||||
# with:
|
||||
# target: x86_64-unknown-linux-gnu
|
||||
|
||||
name: "Download LLVM"
|
||||
inputs:
|
||||
target:
|
||||
required: true
|
||||
|
||||
runs:
|
||||
using: "composite"
|
||||
steps:
|
||||
- name: find asset
|
||||
id: find
|
||||
uses: actions/github-script@v7
|
||||
env:
|
||||
target: ${{ inputs.target }}
|
||||
with:
|
||||
result-encoding: string
|
||||
script: |
|
||||
let page = 1;
|
||||
let releases = [];
|
||||
|
||||
let releasePrefix = "llvm-"
|
||||
let target = process.env.target
|
||||
|
||||
do {
|
||||
const res = await github.rest.repos.listReleases({
|
||||
owner: context.repo.owner,
|
||||
repo: context.repo.repo,
|
||||
per_page: 50,
|
||||
page,
|
||||
});
|
||||
|
||||
releases = res.data
|
||||
releases.sort((a, b) => {
|
||||
return (a.published_at < b.published_at) ? 1 : ((a.published_at > b.published_at) ? -1 : 0);
|
||||
});
|
||||
|
||||
let llvmLatestRelease = releases.find(release => {
|
||||
return release.tag_name.startsWith(releasePrefix);
|
||||
});
|
||||
if (llvmLatestRelease){
|
||||
let asset = llvmLatestRelease.assets.find(asset =>{
|
||||
return asset.name.includes(target);
|
||||
});
|
||||
if (!asset){
|
||||
core.setFailed(`Artifact for '${target}' not found in release ${llvmLatestRelease.tag_name} (${llvmLatestRelease.html_url})`);
|
||||
process.exit();
|
||||
}
|
||||
return asset.browser_download_url;
|
||||
}
|
||||
|
||||
page++;
|
||||
} while(releases.length > 0);
|
||||
|
||||
core.setFailed(`No LLVM releases with '${releasePrefix}' atifacts found! Please release LLVM before running this workflow.`);
|
||||
process.exit();
|
||||
|
||||
- name: download
|
||||
shell: bash
|
||||
run: |
|
||||
curl -sSLo llvm.tar.gz ${{ steps.find.outputs.result }}
|
||||
|
||||
- name: unpack
|
||||
shell: bash
|
||||
run: |
|
||||
tar -xf llvm.tar.gz
|
||||
rm llvm.tar.gz
|
||||
@@ -0,0 +1,36 @@
|
||||
name: "Install Solidity Compiler"
|
||||
description: "Installs the Ethereum solc Solidity compiler frontend executable"
|
||||
|
||||
runs:
|
||||
using: "composite"
|
||||
steps:
|
||||
- name: Figure out Solc Download URL
|
||||
shell: bash
|
||||
run: |
|
||||
if [[ "${{ runner.os }}" == "Linux" ]]; then
|
||||
echo "SOLC_NAME=solc-static-linux" >> $GITHUB_ENV
|
||||
elif [[ "${{ runner.os }}" == "Windows" ]]; then
|
||||
echo "SOLC_NAME=solc-windows.exe" >> $GITHUB_ENV
|
||||
else
|
||||
echo "SOLC_NAME=solc-macos" >> $GITHUB_ENV
|
||||
fi
|
||||
|
||||
- name: Download Solc
|
||||
shell: bash
|
||||
run: |
|
||||
mkdir -p solc
|
||||
curl -sSL --output solc/solc https://github.com/ethereum/solidity/releases/download/v0.8.29/${SOLC_NAME}
|
||||
|
||||
- name: Make Solc Executable
|
||||
if: ${{ runner.os == 'Windows' }}
|
||||
shell: bash
|
||||
run: |
|
||||
echo "$(pwd -W)\\solc" >> $GITHUB_PATH
|
||||
mv solc/solc solc/solc.exe
|
||||
|
||||
- name: Make Solc Executable
|
||||
if: ${{ runner.os != 'Windows' }}
|
||||
shell: bash
|
||||
run: |
|
||||
echo "$(pwd)/solc" >> $GITHUB_PATH
|
||||
chmod +x solc/solc
|
||||
@@ -0,0 +1,165 @@
|
||||
import os
|
||||
import sys
|
||||
import json
|
||||
import requests
|
||||
|
||||
def validate_github_token():
|
||||
"""Validate that GITHUB_TOKEN environment variable is set."""
|
||||
if 'GITHUB_TOKEN' not in os.environ:
|
||||
print("Error: GITHUB_TOKEN environment variable is not set.")
|
||||
sys.exit(1)
|
||||
|
||||
def fetch_release_data(repo, tag):
|
||||
"""Fetch release data from GitHub API."""
|
||||
url = f"https://api.github.com/repos/{repo}/releases/tags/{tag}"
|
||||
headers = {
|
||||
'Authorization': f"Bearer {os.environ['GITHUB_TOKEN']}",
|
||||
'Accept': 'application/vnd.github+json',
|
||||
'X-GitHub-Api-Version': '2022-11-28'
|
||||
}
|
||||
|
||||
try:
|
||||
response = requests.get(url, headers=headers)
|
||||
response.raise_for_status()
|
||||
return response.json()
|
||||
except requests.RequestException as e:
|
||||
print(f"Error fetching release data: {e}")
|
||||
sys.exit(1)
|
||||
|
||||
def fetch_checksum_file(release_data):
|
||||
"""
|
||||
Fetch the checksum.txt file from the release assets
|
||||
and parse it into a dictionary mapping file names to their SHA256 checksums.
|
||||
"""
|
||||
checksums = {}
|
||||
|
||||
# Find the checksum.txt asset URL
|
||||
checksum_asset = None
|
||||
for asset in release_data['assets']:
|
||||
if asset['name'] == 'checksums.txt':
|
||||
checksum_asset = asset
|
||||
break
|
||||
|
||||
if not checksum_asset:
|
||||
print("Warning: checksum.txt file not found in release assets.")
|
||||
return checksums
|
||||
|
||||
# Download the checksum file
|
||||
headers = {
|
||||
'Authorization': f"Bearer {os.environ['GITHUB_TOKEN']}",
|
||||
'Accept': 'application/octet-stream'
|
||||
}
|
||||
|
||||
try:
|
||||
response = requests.get(checksum_asset['browser_download_url'], headers=headers)
|
||||
response.raise_for_status()
|
||||
|
||||
# Parse checksum file
|
||||
for line in response.text.splitlines():
|
||||
if line.strip():
|
||||
checksum, filename = line.strip().split(None, 1)
|
||||
checksums[filename] = checksum
|
||||
|
||||
return checksums
|
||||
except requests.RequestException as e:
|
||||
print(f"Error fetching checksum file: {e}")
|
||||
return checksums
|
||||
except Exception as e:
|
||||
print(f"Error parsing checksum file: {e}")
|
||||
return checksums
|
||||
|
||||
def extract_build_hash(target_commitish):
|
||||
"""Extract the first 8 characters of the commit hash."""
|
||||
return f"commit.{target_commitish[:8]}"
|
||||
|
||||
def generate_asset_json(release_data, asset, checksums):
|
||||
"""Generate JSON for a specific asset."""
|
||||
version = release_data['tag_name'].lstrip('v')
|
||||
build = extract_build_hash(release_data['target_commitish'])
|
||||
long_version = f"{version}+{build}"
|
||||
|
||||
# Get SHA256 checksum if available
|
||||
sha256 = checksums.get(asset['name'], "")
|
||||
|
||||
return {
|
||||
"name": asset['name'],
|
||||
"version": version,
|
||||
"build": build,
|
||||
"longVersion": long_version,
|
||||
"url": asset['browser_download_url'],
|
||||
"sha256": sha256,
|
||||
"firstSolcVersion": os.environ.get("FIRST_SOLC_VERSION", ""),
|
||||
"lastSolcVersion": os.environ.get("LAST_SOLC_VERSION", "")
|
||||
}
|
||||
|
||||
def save_platform_json(platform_folder, asset_json, tag):
|
||||
"""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 arguments
|
||||
if len(sys.argv) != 3:
|
||||
print("Usage: python script.py <repo> <tag>")
|
||||
sys.exit(1)
|
||||
|
||||
repo, tag = sys.argv[1], sys.argv[2]
|
||||
|
||||
# Validate GitHub token
|
||||
validate_github_token()
|
||||
|
||||
# Fetch release data
|
||||
release_data = fetch_release_data(repo, tag)
|
||||
|
||||
# Fetch checksums
|
||||
checksums = fetch_checksum_file(release_data)
|
||||
|
||||
# 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.exe': 'windows',
|
||||
'resolc_web.js': 'wasm'
|
||||
}
|
||||
|
||||
# Process each asset
|
||||
for asset in release_data['assets']:
|
||||
platform_name = platform_mapping.get(asset['name'])
|
||||
if platform_name:
|
||||
platform_folder = os.path.join(platform_name)
|
||||
asset_json = generate_asset_json(release_data, asset, checksums)
|
||||
save_platform_json(platform_folder, asset_json, tag)
|
||||
print(f"Processed {asset['name']} for {platform_name}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,127 +0,0 @@
|
||||
name: Build revive-wasm
|
||||
on:
|
||||
push:
|
||||
branches: ["main"]
|
||||
pull_request:
|
||||
branches: ["main"]
|
||||
workflow_dispatch:
|
||||
|
||||
env:
|
||||
CARGO_TERM_COLOR: always
|
||||
REVIVE_WASM_INSTALL_DIR: ${{ github.workspace }}/target/wasm32-unknown-emscripten/release
|
||||
|
||||
jobs:
|
||||
build-revive-wasm:
|
||||
runs-on: parity-large
|
||||
defaults:
|
||||
run:
|
||||
shell: bash
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Cache LLVM build
|
||||
id: cache-llvm
|
||||
uses: actions/cache@v3
|
||||
with:
|
||||
path: |
|
||||
target-llvm/emscripten/target-final
|
||||
target-llvm/gnu/target-final
|
||||
# Use a unique key based on LLVM version or configuration files to avoid cache invalidation
|
||||
key: llvm-build-${{ runner.os }}-${{ hashFiles('LLVM.lock', 'Cargo.toml', 'Cargo.lock', 'crates/llvm-builder/**', '.github/workflows/build-revive-wasm.yml') }}
|
||||
|
||||
- name: Install system dependencies
|
||||
run: |
|
||||
sudo apt-get update && sudo apt-get install -y cmake ninja-build curl git libssl-dev pkg-config clang lld
|
||||
|
||||
- name: Install Rust stable toolchain
|
||||
uses: actions-rs/toolchain@v1
|
||||
with:
|
||||
profile: minimal
|
||||
toolchain: stable
|
||||
components: rust-src
|
||||
target: wasm32-unknown-emscripten
|
||||
|
||||
- name: Install LLVM build dependencies
|
||||
run: |
|
||||
make install-llvm-builder
|
||||
revive-llvm --target-env emscripten clone
|
||||
|
||||
- name: Setup revive environment variables
|
||||
run: |
|
||||
echo "LLVM_SYS_181_PREFIX=$(pwd)/target-llvm/gnu/target-final" >> $GITHUB_ENV
|
||||
echo "REVIVE_LLVM_TARGET_PREFIX=$(pwd)/target-llvm/emscripten/target-final" >> $GITHUB_ENV
|
||||
|
||||
- name: Build host LLVM
|
||||
if: steps.cache-llvm.outputs.cache-hit != 'true'
|
||||
run: |
|
||||
revive-llvm build --llvm-projects lld --llvm-projects clang
|
||||
|
||||
- name: Build target LLVM
|
||||
if: steps.cache-llvm.outputs.cache-hit != 'true'
|
||||
run: |
|
||||
source emsdk/emsdk_env.sh
|
||||
revive-llvm --target-env emscripten build --llvm-projects lld
|
||||
|
||||
- run: |
|
||||
rustup show
|
||||
cargo --version
|
||||
rustup +nightly show
|
||||
cargo +nightly --version
|
||||
cmake --version
|
||||
bash --version
|
||||
|
||||
- name: Use Cached LLVM
|
||||
if: steps.cache-llvm.outputs.cache-hit == 'true'
|
||||
run: |
|
||||
echo "Using cached LLVM"
|
||||
|
||||
- name: Build revive
|
||||
run: |
|
||||
source emsdk/emsdk_env.sh
|
||||
make install-wasm
|
||||
|
||||
- uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: revive-wasm
|
||||
path: |
|
||||
${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc.js
|
||||
${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc.wasm
|
||||
${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc_web.js
|
||||
retention-days: 1
|
||||
|
||||
test-revive-wasm:
|
||||
needs: build-revive-wasm
|
||||
strategy:
|
||||
matrix:
|
||||
os: ["ubuntu-24.04", "macos-14", "windows-2022"]
|
||||
runs-on: ${{ matrix.os }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Create Target Directory
|
||||
run: mkdir -p ${{ env.REVIVE_WASM_INSTALL_DIR }}
|
||||
|
||||
- name: Download Artifact
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: revive-wasm
|
||||
path: ${{ env.REVIVE_WASM_INSTALL_DIR }}
|
||||
|
||||
- name: Set Up Node.js
|
||||
uses: actions/setup-node@v3
|
||||
with:
|
||||
node-version: "20"
|
||||
|
||||
- name: Install packages
|
||||
run: npm install
|
||||
|
||||
- name: Run Playwright tests
|
||||
run: |
|
||||
cd js
|
||||
npx playwright install --with-deps
|
||||
npx playwright test
|
||||
|
||||
- name: Test revive
|
||||
run: |
|
||||
echo "Running tests for ${{ matrix.os }}"
|
||||
npm run test:wasm
|
||||
@@ -0,0 +1,64 @@
|
||||
name: Generate JSON for resolc-bin
|
||||
on:
|
||||
release:
|
||||
types: [published]
|
||||
|
||||
jobs:
|
||||
generateJson:
|
||||
runs-on: ubuntu-latest
|
||||
if: contains(github.event.release.tag_name, 'llvm') == false
|
||||
environment: tags
|
||||
env:
|
||||
# the token is needed for json_generator.py
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
with:
|
||||
path: tmp
|
||||
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
with:
|
||||
repository: paritytech/resolc-bin
|
||||
path: resolc-bin
|
||||
|
||||
- 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 and push
|
||||
env:
|
||||
TOKEN: ${{ steps.app-token.outputs.token }}
|
||||
APP_NAME: "paritytech-revive-json"
|
||||
Green: "\e[32m"
|
||||
NC: "\e[0m"
|
||||
run: |
|
||||
sudo apt-get update && sudo apt-get install -y wget
|
||||
wget https://github.com/${GITHUB_REPOSITORY}/releases/download/${GITHUB_REF_NAME}/resolc-x86_64-unknown-linux-musl
|
||||
chmod +x resolc-x86_64-unknown-linux-musl
|
||||
export FIRST_SOLC_VERSION=$(./resolc-x86_64-unknown-linux-musl --supported-solc-versions | cut -f 1 -d "," | tr -d ">=")
|
||||
export LAST_SOLC_VERSION=$(./resolc-x86_64-unknown-linux-musl --supported-solc-versions | cut -f 2 -d "," | tr -d "<=")
|
||||
|
||||
cd resolc-bin
|
||||
python ../tmp/.github/scripts/json_generator.py ${GITHUB_REPOSITORY} ${{ github.event.release.tag_name }}
|
||||
|
||||
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 .
|
||||
git commit -m "Update json"
|
||||
git push origin main
|
||||
|
||||
echo "::notice::info.list files were successfully published to https://github.com/paritytech/resolc-bin"
|
||||
@@ -1,5 +1,4 @@
|
||||
name: Release LLVM
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
@@ -8,12 +7,16 @@ on:
|
||||
required: true
|
||||
description: llvm version in "x.x.x" format, e.g. "18.1.8"
|
||||
|
||||
concurrency:
|
||||
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
env:
|
||||
CARGO_TERM_COLOR: always
|
||||
|
||||
jobs:
|
||||
create-release:
|
||||
runs-on: ubuntu-latest
|
||||
create-release-draft:
|
||||
runs-on: ubuntu-24.04
|
||||
permissions:
|
||||
contents: write
|
||||
outputs:
|
||||
@@ -23,145 +26,107 @@ jobs:
|
||||
run: |
|
||||
echo "version=llvm-${{ inputs.llvm_version }}-revive.${GITHUB_SHA:0:7}" >> $GITHUB_OUTPUT
|
||||
|
||||
- name: create release
|
||||
- name: Create Release
|
||||
uses: softprops/action-gh-release@v2
|
||||
with:
|
||||
name: "LLVM binaries release: ${{ steps.resolve-version.outputs.version }}"
|
||||
body: "This release includes binaries of LLVM, used to compile revive itself"
|
||||
make_latest: "false"
|
||||
name: ${{ steps.resolve-version.outputs.version }}
|
||||
body: "LLVM is a dependency of revive. The LLVM releases are used by our CI to build revive."
|
||||
draft: true
|
||||
tag_name: ${{ steps.resolve-version.outputs.version }}
|
||||
|
||||
build-macos:
|
||||
build:
|
||||
strategy:
|
||||
matrix:
|
||||
os: [macos-14, macos-13]
|
||||
target: [x86_64-unknown-linux-gnu, x86_64-unknown-linux-musl, wasm32-unknown-emscripten, aarch64-apple-darwin, x86_64-apple-darwin, x86_64-pc-windows-msvc]
|
||||
include:
|
||||
- os: macos-13
|
||||
arch: x64
|
||||
- os: macos-14
|
||||
arch: arm64
|
||||
needs: create-release
|
||||
runs-on: ${{ matrix.os }}
|
||||
name: "build-macos-${{ matrix.arch }}"
|
||||
- target: x86_64-unknown-linux-gnu
|
||||
builder-arg: gnu
|
||||
host: linux
|
||||
runner: parity-large
|
||||
- target: x86_64-unknown-linux-musl
|
||||
builder-arg: musl
|
||||
host: linux
|
||||
runner: parity-large
|
||||
- target: wasm32-unknown-emscripten
|
||||
builder-arg: emscripten
|
||||
host: linux
|
||||
runner: parity-large
|
||||
- target: aarch64-apple-darwin
|
||||
builder-arg: gnu
|
||||
host: macos
|
||||
runner: macos-14
|
||||
- target: x86_64-apple-darwin
|
||||
builder-arg: gnu
|
||||
host: macos
|
||||
runner: macos-13
|
||||
- target: x86_64-pc-windows-msvc
|
||||
builder-arg: gnu
|
||||
host: windows
|
||||
runner: windows-2022
|
||||
needs: create-release-draft
|
||||
runs-on: ${{ matrix.runner }}
|
||||
env:
|
||||
RUST_LOG: trace
|
||||
permissions:
|
||||
contents: write # for uploading assets to release
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: install macos deps
|
||||
run: |
|
||||
brew install ninja
|
||||
|
||||
- name: versions
|
||||
run: |
|
||||
rustup show
|
||||
cargo --version
|
||||
cmake --version
|
||||
echo "bash:" && bash --version
|
||||
echo "ninja:" && ninja --version
|
||||
echo "clang:" && clang --version
|
||||
|
||||
- name: Build LLVM
|
||||
run: |
|
||||
make install-llvm
|
||||
|
||||
- name: clean
|
||||
# check removed files
|
||||
run: |
|
||||
cd target-llvm/gnu/target-final/bin/
|
||||
rm diagtool llvm-libtool-darwin llvm-lipo llvm-pdbutil llvm-dwarfdump llvm-nm llvm-readobj llvm-cfi-verify \
|
||||
sancov llvm-debuginfo-analyzer llvm-objdump llvm-profgen llvm-extract llvm-jitlink llvm-c-test llvm-gsymutil llvm-dwp \
|
||||
dsymutil llvm-dwarfutil llvm-exegesis lli clang-rename bugpoint clang-extdef-mapping clang-refactor c-index-test \
|
||||
llvm-reduce llvm-lto clang-linker-wrapper llc llvm-lto2
|
||||
|
||||
- name: package artifacts
|
||||
run: |
|
||||
tar -czf "${{ needs.create-release.outputs.version }}-macos-${{ matrix.arch }}.tar.gz" target-llvm/gnu/target-final
|
||||
|
||||
- name: upload archive to release
|
||||
uses: softprops/action-gh-release@v2
|
||||
- uses: actions-rust-lang/setup-rust-toolchain@v1
|
||||
with:
|
||||
make_latest: "false"
|
||||
tag_name: ${{ needs.create-release.outputs.version }}
|
||||
files: |
|
||||
${{ needs.create-release.outputs.version }}-macos-${{ matrix.arch }}.tar.gz
|
||||
# without this it will override our rust flags
|
||||
rustflags: ""
|
||||
cache-key: ${{ matrix.target }}
|
||||
|
||||
|
||||
build-linux-all:
|
||||
needs: create-release
|
||||
runs-on: parity-large
|
||||
env:
|
||||
RUST_LOG: trace
|
||||
permissions:
|
||||
contents: write # for uploading assets to release
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: install linux deps
|
||||
- name: Install Dependencies
|
||||
if: ${{ matrix.host == 'linux' }}
|
||||
run: |
|
||||
sudo apt-get update && sudo apt-get install -y cmake ninja-build curl git libssl-dev pkg-config clang lld musl
|
||||
|
||||
- uses: actions-rust-lang/setup-rust-toolchain@v1
|
||||
with:
|
||||
toolchain: stable
|
||||
components: rust-src
|
||||
target: wasm32-unknown-emscripten
|
||||
rustflags: ""
|
||||
|
||||
- name: versions
|
||||
- name: Install Dependencies
|
||||
if: ${{ matrix.host == 'macos' }}
|
||||
run: |
|
||||
rustup show
|
||||
cargo --version
|
||||
cmake --version
|
||||
echo "bash:" && bash --version
|
||||
echo "ninja:" && ninja --version
|
||||
echo "clang:" && clang --version
|
||||
brew install ninja
|
||||
|
||||
- name: Build host LLVM
|
||||
- name: Install LLVM Builder
|
||||
run: |
|
||||
make install-llvm
|
||||
cargo install --path crates/llvm-builder
|
||||
|
||||
- name: Build gnu LLVM
|
||||
- name: Clone LLVM
|
||||
run: |
|
||||
revive-llvm clone
|
||||
revive-llvm build --llvm-projects lld --llvm-projects clang
|
||||
revive-llvm --target-env ${{ matrix.builder-arg }} clone
|
||||
|
||||
- name: Build musl LLVM
|
||||
- name: Build LLVM
|
||||
if: ${{ matrix.target != 'wasm32-unknown-emscripten' }}
|
||||
run: |
|
||||
revive-llvm --target-env musl build --llvm-projects lld --llvm-projects clang
|
||||
revive-llvm --target-env ${{ matrix.builder-arg }} build --llvm-projects lld --llvm-projects clang
|
||||
|
||||
- name: Build emscripten LLVM
|
||||
- name: Build LLVM
|
||||
if: ${{ matrix.target == 'wasm32-unknown-emscripten' }}
|
||||
run: |
|
||||
revive-llvm --target-env emscripten clone
|
||||
source emsdk/emsdk_env.sh
|
||||
revive-llvm --target-env emscripten build --llvm-projects lld
|
||||
revive-llvm --target-env ${{ matrix.builder-arg }} build --llvm-projects lld
|
||||
|
||||
- name: clean
|
||||
# check removed files
|
||||
- name: Remove Unnecessary Binaries
|
||||
shell: bash
|
||||
run: |
|
||||
for target in gnu emscripten musl; do
|
||||
cd target-llvm/${target}/target-final/bin/
|
||||
rm -rf diagtool llvm-libtool-darwin llvm-lipo llvm-pdbutil llvm-dwarfdump llvm-nm llvm-readobj llvm-cfi-verify \
|
||||
sancov llvm-debuginfo-analyzer llvm-objdump llvm-profgen llvm-extract llvm-jitlink llvm-c-test llvm-gsymutil llvm-dwp \
|
||||
dsymutil llvm-dwarfutil llvm-exegesis lli clang-rename bugpoint clang-extdef-mapping clang-refactor c-index-test \
|
||||
llvm-reduce llvm-lto clang-linker-wrapper llc llvm-lto2 llvm-otool llvm-readelf
|
||||
cd -
|
||||
done
|
||||
cd target-llvm/${{ matrix.builder-arg }}/target-final/bin/
|
||||
rm -f diagtool* llvm-libtool-darwin* llvm-lipo* llvm-pdbutil* llvm-dwarfdump* llvm-nm* llvm-readobj* llvm-cfi-verify* \
|
||||
sancov* llvm-debuginfo-analyzer* llvm-objdump* llvm-profgen* llvm-extract* llvm-jitlink* llvm-c-test* llvm-gsymutil* llvm-dwp* \
|
||||
dsymutil* llvm-dwarfutil* llvm-exegesis* lli clang-rename* bugpoint* clang-extdef-mapping* clang-refactor* c-index-test* \
|
||||
llvm-reduce* llvm-lto* clang-linker-wrapper* llc* llvm-lto2* llvm-otool* llvm-readelf* \
|
||||
clang-repl* clang-check* clang-scan-deps*
|
||||
cd -
|
||||
|
||||
- name: package artifacts
|
||||
- name: Package Artifact
|
||||
shell: bash
|
||||
run: |
|
||||
tar -czf "${{ needs.create-release.outputs.version }}-x86_64-linux-gnu-linux.tar.gz" target-llvm/gnu/target-final
|
||||
tar -czf "${{ needs.create-release.outputs.version }}-x86_64-linux-musl.tar.gz" target-llvm/musl/target-final
|
||||
tar -czf "${{ needs.create-release.outputs.version }}-wasm32-unknown-emscripten.tar.gz" target-llvm/emscripten/target-final
|
||||
mv target-llvm/${{ matrix.builder-arg }}/target-final/ llvm-${{ matrix.target }}
|
||||
tar -czf "${{ needs.create-release-draft.outputs.version }}-${{ matrix.target }}.tar.gz" llvm-${{ matrix.target }}
|
||||
|
||||
- name: upload archive to release
|
||||
- name: Add Artifact to Release
|
||||
uses: softprops/action-gh-release@v2
|
||||
with:
|
||||
make_latest: "false"
|
||||
tag_name: ${{ needs.create-release.outputs.version }}
|
||||
tag_name: ${{ needs.create-release-draft.outputs.version }}
|
||||
draft: true
|
||||
files: |
|
||||
${{ needs.create-release.outputs.version }}-x86_64-linux-gnu-linux.tar.gz
|
||||
${{ needs.create-release.outputs.version }}-x86_64-linux-musl.tar.gz
|
||||
${{ needs.create-release.outputs.version }}-wasm32-unknown-emscripten.tar.gz
|
||||
${{ needs.create-release-draft.outputs.version }}-${{ matrix.target }}.tar.gz
|
||||
|
||||
+288
-347
@@ -1,347 +1,288 @@
|
||||
name: Release
|
||||
run-name: Release ${{ github.ref_name }}
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- 'main'
|
||||
|
||||
concurrency:
|
||||
group: ${{ github.ref }}-${{ github.workflow }}
|
||||
cancel-in-progress: true
|
||||
|
||||
env:
|
||||
#rust-musl-cross:x86_64-musl
|
||||
RUST_MUSL_CROSS_IMAGE: messense/rust-musl-cross@sha256:68b86bc7cb2867259e6b233415a665ff4469c28b57763e78c3bfea1c68091561
|
||||
|
||||
jobs:
|
||||
|
||||
#
|
||||
#
|
||||
#
|
||||
tag:
|
||||
runs-on: ubuntu-24.04
|
||||
permissions:
|
||||
contents: write
|
||||
outputs:
|
||||
TAG: ${{ steps.versions.outputs.TAG }}
|
||||
PKG_VER: ${{ steps.versions.outputs.PKG_VER }}
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-tags: 'true'
|
||||
fetch-depth: 0
|
||||
|
||||
- name: Versions
|
||||
id: versions
|
||||
run: |
|
||||
export CURRENT_TAG=$(git describe --tags --abbrev=0 --exclude "llvm-*")
|
||||
export PKG_VER=v$(cat Cargo.toml | grep -A 5 package] | grep version | cut -d '=' -f 2 | tr -d '"' | tr -d " ")
|
||||
echo "Current tag $CURRENT_TAG"
|
||||
echo "Package version $PKG_VER"
|
||||
#
|
||||
echo "PKG_VER=$PKG_VER" >> $GITHUB_OUTPUT
|
||||
if [ $CURRENT_TAG == $PKG_VER ];
|
||||
then
|
||||
echo "Tag is up to date. Nothing to do.";
|
||||
export TAG=old;
|
||||
else
|
||||
echo "Tag was updated.";
|
||||
export TAG=new;
|
||||
fi
|
||||
echo "TAG=$TAG" >> $GITHUB_OUTPUT
|
||||
|
||||
#
|
||||
#
|
||||
#
|
||||
build-linux-all:
|
||||
if: ${{ needs.tag.outputs.TAG == 'new' }}
|
||||
runs-on: parity-large
|
||||
needs: [tag]
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: install linux deps
|
||||
run: |
|
||||
sudo apt-get update && sudo apt-get install -y cmake ninja-build \
|
||||
curl git libssl-dev pkg-config clang lld musl
|
||||
|
||||
- name: Install Rust stable toolchain
|
||||
uses: actions-rs/toolchain@v1
|
||||
with:
|
||||
profile: minimal
|
||||
toolchain: stable
|
||||
components: rust-src
|
||||
target: wasm32-unknown-emscripten
|
||||
|
||||
- name: versions
|
||||
run: |
|
||||
rustup show
|
||||
cargo --version
|
||||
cmake --version
|
||||
echo "bash:" && bash --version
|
||||
echo "ninja:" && ninja --version
|
||||
echo "clang:" && clang --version
|
||||
|
||||
- name: build revive-llvm
|
||||
run: make install-llvm-builder
|
||||
|
||||
# musl LLVM
|
||||
|
||||
- name: llvm-musl-cache restore
|
||||
id: llvm-musl-cache
|
||||
uses: actions/cache/restore@v4
|
||||
with:
|
||||
path: target-llvm/musl/target-final
|
||||
key: llvm-linux-musl-${{ hashFiles('crates/solidity/**') }}
|
||||
|
||||
- name: Build musl LLVM
|
||||
if: steps.llvm-musl-cache.outputs.cache-hit != 'true'
|
||||
run: |
|
||||
revive-llvm --target-env musl clone
|
||||
revive-llvm --target-env musl build --llvm-projects lld --llvm-projects clang
|
||||
|
||||
- name: llvm-musl-cache save
|
||||
if: steps.llvm-musl-cache.outputs.cache-hit != 'true'
|
||||
uses: actions/cache/save@v4
|
||||
with:
|
||||
path: target-llvm/musl/target-final
|
||||
key: llvm-linux-musl-${{ hashFiles('crates/solidity/**') }}
|
||||
|
||||
# emscripten LLVM
|
||||
|
||||
- name: llvm-emscripten-cache restore
|
||||
id: llvm-emscripten-cache
|
||||
uses: actions/cache/restore@v4
|
||||
with:
|
||||
path: |
|
||||
target-llvm/emscripten/target-final
|
||||
emsdk
|
||||
key: llvm-linux-emscripten-${{ hashFiles('crates/solidity/**') }}
|
||||
|
||||
- name: Build emscripten LLVM
|
||||
if: steps.llvm-emscripten-cache.outputs.cache-hit != 'true'
|
||||
run: |
|
||||
revive-llvm --target-env emscripten clone
|
||||
source emsdk/emsdk_env.sh
|
||||
revive-llvm --target-env emscripten build --llvm-projects lld
|
||||
|
||||
- name: llvm-emscripten-cache save
|
||||
if: steps.llvm-emscripten-cache.outputs.cache-hit != 'true'
|
||||
uses: actions/cache/save@v4
|
||||
with:
|
||||
path: |
|
||||
target-llvm/emscripten/target-final
|
||||
emsdk
|
||||
key: llvm-linux-emscripten-${{ hashFiles('crates/solidity/**') }}
|
||||
|
||||
# Build revive
|
||||
|
||||
- name: build musl
|
||||
run: |
|
||||
mkdir resolc-out
|
||||
docker run -v $PWD:/opt/revive $RUST_MUSL_CROSS_IMAGE /bin/bash -c "
|
||||
cd /opt/revive
|
||||
apt update && apt upgrade -y && apt install -y pkg-config
|
||||
export LLVM_SYS_181_PREFIX=/opt/revive/target-llvm/musl/target-final
|
||||
make install-bin
|
||||
cp /root/.cargo/bin/resolc /opt/revive/resolc-out/resolc
|
||||
"
|
||||
|
||||
- name: check musl
|
||||
run: |
|
||||
mkdir solc
|
||||
curl -sSLo solc/solc https://github.com/ethereum/solidity/releases/download/v0.8.28/solc-static-linux
|
||||
chmod +x solc/solc
|
||||
PATH=$PWD/solc:$PATH
|
||||
result=$(./resolc-out/resolc --bin crates/integration/contracts/flipper.sol)
|
||||
echo $result
|
||||
if [[ $result == *'0x50564d'* ]]; then exit 0; else exit 1; fi
|
||||
|
||||
- name: Set Up Node.js
|
||||
uses: actions/setup-node@v3
|
||||
with:
|
||||
node-version: "20"
|
||||
|
||||
- name: build wasm
|
||||
run: |
|
||||
export LLVM_SYS_181_PREFIX=$PWD/target-llvm/musl/target-final
|
||||
export REVIVE_LLVM_TARGET_PREFIX=$PWD/target-llvm/emscripten/target-final
|
||||
source emsdk/emsdk_env.sh
|
||||
rustup target add wasm32-unknown-emscripten
|
||||
make install-wasm
|
||||
|
||||
- name: check wasm
|
||||
run: |
|
||||
curl -sSLo solc/soljson.js https://github.com/ethereum/solidity/releases/download/v0.8.28/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); }
|
||||
"
|
||||
|
||||
- uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: revive-wasm
|
||||
path: |
|
||||
./target/wasm32-unknown-emscripten/release/resolc.js
|
||||
./target/wasm32-unknown-emscripten/release/resolc.wasm
|
||||
./target/wasm32-unknown-emscripten/release/resolc_web.js
|
||||
retention-days: 1
|
||||
|
||||
- uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: revive-linux
|
||||
path: |
|
||||
./resolc-out/resolc
|
||||
retention-days: 1
|
||||
|
||||
#
|
||||
#
|
||||
#
|
||||
create-release:
|
||||
needs: [tag, build-linux-all]
|
||||
runs-on: ubuntu-24.04
|
||||
permissions:
|
||||
contents: write
|
||||
outputs:
|
||||
upload_url: ${{ steps.create_release.outputs.result }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Create/update tag
|
||||
id: tag
|
||||
uses: actions/github-script@v7
|
||||
with:
|
||||
result-encoding: string
|
||||
script: |
|
||||
await github.rest.git.createRef({
|
||||
owner: context.repo.owner,
|
||||
repo: context.repo.repo,
|
||||
ref: 'refs/tags/${{ needs.tag.outputs.PKG_VER }}',
|
||||
sha: context.sha
|
||||
})
|
||||
|
||||
- name: get relese notes
|
||||
id: get-notes
|
||||
run: |
|
||||
{
|
||||
echo 'releaseNotes<<EOF'
|
||||
sed '/^## ${{ needs.tag.outputs.PKG_VER }}/,/^## v/!d' CHANGELOG.md | sed -e '1d' -e '$d'
|
||||
echo EOF
|
||||
} >> "$GITHUB_OUTPUT"
|
||||
|
||||
|
||||
- name: Create release
|
||||
id: create_release
|
||||
env:
|
||||
releaseNotes: ${{ steps.get-notes.outputs.releaseNotes }}
|
||||
version: ${{ needs.tag.outputs.PKG_VER }}
|
||||
uses: actions/github-script@v7
|
||||
with:
|
||||
result-encoding: string
|
||||
script: |
|
||||
let response = await github.rest.repos.createRelease({
|
||||
owner: context.repo.owner,
|
||||
repo: context.repo.repo,
|
||||
tag_name: process.env.version,
|
||||
name: process.env.version,
|
||||
body: process.env.releaseNotes,
|
||||
draft: true,
|
||||
prerelease: true
|
||||
});
|
||||
console.log(response);
|
||||
return response.data.upload_url;
|
||||
|
||||
- name: Log
|
||||
run: |
|
||||
echo "tag result: ${{ needs.tag.outputs.TAG }}"
|
||||
echo "pkg version: ${{ needs.tag.outputs.PKG_VER }}"
|
||||
|
||||
#
|
||||
#
|
||||
#
|
||||
upload-assets:
|
||||
runs-on: ubuntu-24.04
|
||||
needs: [create-release]
|
||||
steps:
|
||||
|
||||
- name: Download Artifact
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: revive-wasm
|
||||
path: resolc/
|
||||
|
||||
- name: Download Artifact
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: revive-linux
|
||||
path: resolc/
|
||||
|
||||
- name: upload resolc
|
||||
uses: actions/upload-release-asset@v1
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
with:
|
||||
upload_url: ${{ needs.create-release.outputs.upload_url }}
|
||||
asset_path: ./resolc/resolc
|
||||
asset_name: resolc-static-linux
|
||||
asset_content_type: application/octet-stream
|
||||
|
||||
- name: upload resolc.js
|
||||
uses: actions/upload-release-asset@v1
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
with:
|
||||
upload_url: ${{ needs.create-release.outputs.upload_url }}
|
||||
asset_path: ./resolc/resolc.js
|
||||
asset_name: resolc.js
|
||||
asset_content_type: application/octet-stream
|
||||
|
||||
- name: upload resolc.wasm
|
||||
uses: actions/upload-release-asset@v1
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
with:
|
||||
upload_url: ${{ needs.create-release.outputs.upload_url }}
|
||||
asset_path: ./resolc/resolc.wasm
|
||||
asset_name: resolc.wasm
|
||||
asset_content_type: application/octet-stream
|
||||
|
||||
- name: upload resolc_web.js
|
||||
uses: actions/upload-release-asset@v1
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
with:
|
||||
upload_url: ${{ needs.create-release.outputs.upload_url }}
|
||||
asset_path: ./resolc/resolc_web.js
|
||||
asset_name: resolc_web.js
|
||||
asset_content_type: application/octet-stream
|
||||
name: Build & Release
|
||||
on:
|
||||
push:
|
||||
branches: ["main"]
|
||||
tags:
|
||||
- "v*"
|
||||
pull_request:
|
||||
branches: ["main"]
|
||||
types: [opened, synchronize, labeled, unlabeled]
|
||||
|
||||
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:68b86bc7cb2867259e6b233415a665ff4469c28b57763e78c3bfea1c68091561
|
||||
|
||||
jobs:
|
||||
check-version-changed:
|
||||
runs-on: ubuntu-24.04
|
||||
permissions:
|
||||
contents: write
|
||||
env:
|
||||
CURRENT_TAG: ${{ github.ref_name }}
|
||||
outputs:
|
||||
RELEASE_NOTES: ${{ steps.versions.outputs.RELEASE_NOTES }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
# Check that tag and version in Cargo.toml match
|
||||
- name: Check versions
|
||||
id: versions
|
||||
run: |
|
||||
if [[ $CURRENT_TAG == 'main' ]];
|
||||
then
|
||||
echo "::notice::Tag $CURRENT_TAG is not a release tag, skipping the check in the main branch";
|
||||
exit 0
|
||||
fi
|
||||
|
||||
if [[ $CURRENT_TAG != "v"* ]];
|
||||
then
|
||||
echo "::notice::Tag $CURRENT_TAG is not a release tag, skipping the check in a PR";
|
||||
exit 0
|
||||
fi
|
||||
|
||||
export PKG_VER=v$(cat Cargo.toml | grep -A 5 package] | grep version | cut -d '=' -f 2 | tr -d '"' | tr -d " ")
|
||||
echo "Current tag $CURRENT_TAG"
|
||||
echo "Package version $PKG_VER"
|
||||
#
|
||||
if [[ $CURRENT_TAG != $PKG_VER ]];
|
||||
then
|
||||
echo "::error::Tag $CURRENT_TAG doesn't match package version $PKG_VER in Cargo.toml, please fix";
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Generating release notes early, in order to avoid checkout at the last step
|
||||
export RELEASE_NOTES="$(sed '/^## '${CURRENT_TAG}'/,/^## v/!d' CHANGELOG.md | sed -e '1d' -e '$d')"
|
||||
|
||||
echo "Release notes:"
|
||||
echo "$RELEASE_NOTES"
|
||||
|
||||
echo 'RELEASE_NOTES<<EOF' >> $GITHUB_OUTPUT
|
||||
echo "$RELEASE_NOTES" >> $GITHUB_OUTPUT
|
||||
echo 'EOF' >> $GITHUB_OUTPUT
|
||||
|
||||
build:
|
||||
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-version-changed]
|
||||
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
|
||||
|
||||
- uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: resolc-${{ matrix.target }}
|
||||
path: resolc-${{ matrix.target }}*
|
||||
retention-days: 1
|
||||
|
||||
build-wasm:
|
||||
runs-on: ubuntu-24.04
|
||||
needs: [check-version-changed]
|
||||
env:
|
||||
RELEASE_RESOLC_WASM_URI: https://github.com/paritytech/revive-workflow-test/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.29/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/
|
||||
|
||||
- uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: resolc-wasm32-unknown-emscripten
|
||||
path: resolc-wasm32-unknown-emscripten/*
|
||||
retention-days: 1
|
||||
|
||||
create-release:
|
||||
if: startsWith(github.ref_name, 'v')
|
||||
needs: [check-version-changed, build-wasm]
|
||||
runs-on: macos-14
|
||||
environment: tags
|
||||
steps:
|
||||
- name: Download Artifacts
|
||||
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-x86_64-unknown-linux-musl
|
||||
chmod +x resolc-universal-apple-darwin
|
||||
|
||||
- name: Create sha-256 checksum
|
||||
run: |
|
||||
shasum -a 256 resolc-x86_64-unknown-linux-musl > checksums.txt
|
||||
shasum -a 256 resolc-universal-apple-darwin >> checksums.txt
|
||||
shasum -a 256 resolc-x86_64-pc-windows-msvc.exe >> checksums.txt
|
||||
shasum -a 256 resolc.js >> checksums.txt
|
||||
shasum -a 256 resolc.wasm >> checksums.txt
|
||||
shasum -a 256 resolc_web.js >> checksums.txt
|
||||
|
||||
- uses: actions/create-github-app-token@v1
|
||||
id: app-token
|
||||
with:
|
||||
app-id: ${{ secrets.REVIVE_RELEASE_APP_ID }}
|
||||
private-key: ${{ secrets.REVIVE_RELEASE_APP_KEY }}
|
||||
|
||||
- name: create-release
|
||||
uses: softprops/action-gh-release@v2
|
||||
with:
|
||||
body: |
|
||||
## Changelog
|
||||
${{ needs.check-version-changed.outputs.RELEASE_NOTES }}
|
||||
|
||||
## Note for macOS Users
|
||||
The macOS binary is unsigned and it needs to be made runnable using `xattr -c resolc-universal-apple-darwin`.
|
||||
tag_name: ${{ github.ref_name }}
|
||||
name: ${{ github.ref_name }}
|
||||
prerelease: true
|
||||
token: ${{ steps.app-token.outputs.token }}
|
||||
target_commitish: ${{ github.sha }}
|
||||
files: |
|
||||
resolc-x86_64-unknown-linux-musl
|
||||
resolc-universal-apple-darwin
|
||||
resolc-x86_64-pc-windows-msvc.exe
|
||||
resolc.js
|
||||
resolc.wasm
|
||||
resolc_web.js
|
||||
checksums.txt
|
||||
|
||||
@@ -1,58 +0,0 @@
|
||||
name: Build
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: ["main"]
|
||||
pull_request:
|
||||
branches: ["main"]
|
||||
|
||||
env:
|
||||
CARGO_TERM_COLOR: always
|
||||
|
||||
jobs:
|
||||
build-ubuntu-x86:
|
||||
runs-on: ubuntu-24.04
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install solc
|
||||
run: |
|
||||
mkdir -p solc
|
||||
curl -sSL --output solc/solc https://github.com/ethereum/solidity/releases/download/v0.8.28/solc-static-linux
|
||||
chmod +x solc/solc
|
||||
echo "$(pwd)/solc/" >> $GITHUB_PATH
|
||||
|
||||
- name: Install LLVM
|
||||
run: |
|
||||
curl -sSL --output llvm.tar.xz https://github.com/paritytech/revive/releases/download/v0.1.0-dev.7/clang+llvm-18.1.8-x86_64-linux-gnu-ubuntu-24.04.tar.xz
|
||||
mkdir llvm18
|
||||
tar Jxf llvm.tar.xz -C llvm18/
|
||||
echo "LLVM_SYS_181_PREFIX=$(pwd)/llvm18" >> $GITHUB_ENV
|
||||
|
||||
- name: Install geth
|
||||
run: |
|
||||
sudo add-apt-repository -y ppa:ethereum/ethereum
|
||||
sudo apt update
|
||||
sudo apt install -y ethereum
|
||||
|
||||
- name: Machete
|
||||
uses: bnjbvr/cargo-machete@main
|
||||
|
||||
- name: Format
|
||||
run: make format
|
||||
|
||||
- name: Clippy
|
||||
run: make clippy
|
||||
|
||||
- name: Test cargo workspace
|
||||
run: make test-workspace
|
||||
|
||||
- name: Test CLI
|
||||
run: make test-cli
|
||||
|
||||
- uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: ${{ github.job }}-resolc
|
||||
path: ./target/release/resolc
|
||||
retention-days: 1
|
||||
@@ -0,0 +1,45 @@
|
||||
name: Test LLVM Builder
|
||||
on:
|
||||
pull_request:
|
||||
branches: ["main"]
|
||||
types: [opened, synchronize]
|
||||
paths:
|
||||
- 'LLVM.lock'
|
||||
- 'crates/llvm-builder/**'
|
||||
- '.github/workflows/test-llvm-builder.yml'
|
||||
|
||||
concurrency:
|
||||
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
env:
|
||||
CARGO_TERM_COLOR: always
|
||||
|
||||
jobs:
|
||||
test:
|
||||
strategy:
|
||||
matrix:
|
||||
runner: [parity-large, macos-14, windows-2022]
|
||||
runs-on: ${{ matrix.runner }}
|
||||
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.runner }}
|
||||
|
||||
- name: Install Dependencies
|
||||
if: matrix.runner == 'parity-large'
|
||||
run: |
|
||||
sudo apt update && sudo apt-get install -y cmake ninja-build curl git libssl-dev pkg-config clang lld musl
|
||||
|
||||
- name: Install Dependencies
|
||||
if: matrix.runner == 'macos-14'
|
||||
run: |
|
||||
brew install ninja
|
||||
|
||||
- name: Test
|
||||
run: make test-llvm-builder
|
||||
env:
|
||||
RUST_LOG: trace
|
||||
@@ -0,0 +1,98 @@
|
||||
name: Test Wasm Version
|
||||
on:
|
||||
push:
|
||||
branches: ["main"]
|
||||
pull_request:
|
||||
branches: ["main"]
|
||||
types: [opened, synchronize]
|
||||
|
||||
concurrency:
|
||||
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
env:
|
||||
CARGO_TERM_COLOR: always
|
||||
REVIVE_WASM_INSTALL_DIR: ${{ github.workspace }}/target/wasm32-unknown-emscripten/release
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ubuntu-24.04
|
||||
defaults:
|
||||
run:
|
||||
shell: bash
|
||||
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: Install emsdk
|
||||
uses: ./.github/actions/get-emsdk
|
||||
|
||||
- name: Set LLVM Environment Variables
|
||||
run: |
|
||||
echo "LLVM_SYS_181_PREFIX=$(pwd)/llvm-x86_64-unknown-linux-gnu" >> $GITHUB_ENV
|
||||
echo "REVIVE_LLVM_TARGET_PREFIX=$(pwd)/llvm-wasm32-unknown-emscripten" >> $GITHUB_ENV
|
||||
|
||||
- name: Build Revive
|
||||
run: |
|
||||
source emsdk/emsdk_env.sh
|
||||
make install-wasm
|
||||
|
||||
- uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: revive-wasm
|
||||
path: |
|
||||
${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc.js
|
||||
${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc.wasm
|
||||
${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc_web.js
|
||||
retention-days: 1
|
||||
|
||||
test:
|
||||
needs: build
|
||||
strategy:
|
||||
matrix:
|
||||
os: ["ubuntu-24.04", "macos-14", "windows-2022"]
|
||||
runs-on: ${{ matrix.os }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Create Target Directory
|
||||
run: mkdir -p ${{ env.REVIVE_WASM_INSTALL_DIR }}
|
||||
|
||||
- name: Download Artifact
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: revive-wasm
|
||||
path: ${{ env.REVIVE_WASM_INSTALL_DIR }}
|
||||
|
||||
- name: Set Up Node.js
|
||||
uses: actions/setup-node@v3
|
||||
with:
|
||||
node-version: "20"
|
||||
|
||||
- name: Install Node Packages
|
||||
run: npm install
|
||||
|
||||
- name: Run Playwright tests
|
||||
run: |
|
||||
cd js
|
||||
npx playwright install --with-deps
|
||||
npx playwright test
|
||||
|
||||
- name: Test revive
|
||||
run: |
|
||||
echo "Running tests for ${{ matrix.os }}"
|
||||
npm run test:wasm
|
||||
@@ -0,0 +1,57 @@
|
||||
name: Test
|
||||
on:
|
||||
push:
|
||||
branches: ["main"]
|
||||
pull_request:
|
||||
branches: ["main"]
|
||||
types: [opened, synchronize]
|
||||
|
||||
concurrency:
|
||||
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
env:
|
||||
CARGO_TERM_COLOR: always
|
||||
|
||||
jobs:
|
||||
test:
|
||||
runs-on: ubuntu-24.04
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions-rust-lang/setup-rust-toolchain@v1
|
||||
with:
|
||||
# without this it will override our rust flags
|
||||
rustflags: ""
|
||||
|
||||
- name: Install Solc
|
||||
uses: ./.github/actions/get-solc
|
||||
|
||||
- name: Download LLVM
|
||||
uses: ./.github/actions/get-llvm
|
||||
with:
|
||||
target: x86_64-unknown-linux-gnu
|
||||
|
||||
- name: Set LLVM Environment Variables
|
||||
run: |
|
||||
echo "LLVM_SYS_181_PREFIX=$(pwd)/llvm-x86_64-unknown-linux-gnu" >> $GITHUB_ENV
|
||||
|
||||
- name: Install Geth
|
||||
run: |
|
||||
sudo add-apt-repository -y ppa:ethereum/ethereum
|
||||
sudo apt update
|
||||
sudo apt install -y ethereum
|
||||
|
||||
- name: Machete
|
||||
uses: bnjbvr/cargo-machete@v0.7.1
|
||||
|
||||
- name: Format
|
||||
run: make format
|
||||
|
||||
- name: Clippy
|
||||
run: make clippy
|
||||
|
||||
- name: Test cargo workspace
|
||||
run: make test-workspace
|
||||
|
||||
- name: Test CLI
|
||||
run: make test-cli
|
||||
+38
-6
@@ -4,7 +4,39 @@
|
||||
|
||||
This is a development pre-release.
|
||||
|
||||
Supported `polkadot-sdk` rev: `274a781e8ca1a9432c7ec87593bd93214abbff50`
|
||||
## v0.1.0-dev.13
|
||||
|
||||
This is a development pre-release.
|
||||
|
||||
Supported `polkadot-sdk` rev:`c29e72a8628835e34deb6aa7db9a78a2e4eabcee`
|
||||
|
||||
### Added
|
||||
- Support for solc v0.8.29
|
||||
- Decouples the solc JSON-input-output type definitions from the Solidity fronted and expose them via a dedicated crate.
|
||||
- `--supported-solc-versions` for `resolc` binary to return a `semver` range of supported `solc` versions.
|
||||
- Support for passing LLVM command line options via the prcoess input or providing one or more `--llvm-arg='..'` resolc CLI flag. This allows more fine-grained control over the LLVM backend configuration.
|
||||
|
||||
### Changed
|
||||
- Storage keys and values are big endian. This was a pre-mature optimization because for the contract itself it this is a no-op and thus not observable. However we should consider the storage layout as part of the contract ABI. The endianness of transient storage values are still kept as-is.
|
||||
- Running `resolc` using webkit is no longer supported.
|
||||
|
||||
### Fixed
|
||||
- A missing byte swap for the create2 salt value.
|
||||
|
||||
## v0.1.0-dev.12
|
||||
|
||||
This is a development pre-release.
|
||||
|
||||
Supported `polkadot-sdk` rev: `21f6f0705e53c15aa2b8a5706b208200447774a9`
|
||||
|
||||
### Added
|
||||
- Per file output selection for `--standard-json` mode.
|
||||
- The `ir` output selection option for `--standard-json` mode.
|
||||
|
||||
### Changed
|
||||
- Improved code size: Large contracts compile to smaller code blobs when enabling aggressive size optimizations (`-Oz`).
|
||||
|
||||
### Fixed
|
||||
|
||||
## v0.1.0-dev.11
|
||||
|
||||
@@ -14,7 +46,7 @@ Supported `polkadot-sdk` rev: `274a781e8ca1a9432c7ec87593bd93214abbff50`
|
||||
|
||||
### Added
|
||||
|
||||
### Changed
|
||||
### Changed
|
||||
|
||||
### Fixed
|
||||
- A bug causing incorrect loads from the emulated EVM linear memory.
|
||||
@@ -30,7 +62,7 @@ Supported `polkadot-sdk` rev: `274a781e8ca1a9432c7ec87593bd93214abbff50`
|
||||
- Support for the `coinbase` opcode.
|
||||
- The resolc web JS version.
|
||||
|
||||
### Changed
|
||||
### Changed
|
||||
- Missing the `--overwrite` flag emits an error instead of a warning.
|
||||
- The `resolc` executable prints the help by default.
|
||||
- Removed support for legacy EVM assembly (EVMLA) translation.
|
||||
@@ -52,7 +84,7 @@ This is a development pre-release.
|
||||
|
||||
### Added
|
||||
|
||||
### Changed
|
||||
### Changed
|
||||
- Syscalls with more than 6 arguments now pack them into registers.
|
||||
|
||||
### Fixed
|
||||
@@ -92,9 +124,9 @@ This is a development pre-release.
|
||||
- Calls forward maximum weight limits instead of 0, anticipating a change in polkadot-sdk where weight limits of 0 no longer interprets as uncapped limit.
|
||||
|
||||
### Fixed
|
||||
- A linker bug which was preventing certain contracts from linking with the PVM linker.
|
||||
- A linker bug which was preventing certain contracts from linking with the PVM linker.
|
||||
- JS: Fix encoding conversion from JS string (UTF-16) to UTF-8.
|
||||
- The git commit hash slug is always displayed in the version string.
|
||||
- The git commit hash slug is always displayed in the version string.
|
||||
|
||||
## v0.1.0-dev.6
|
||||
|
||||
|
||||
Generated
+644
-722
File diff suppressed because it is too large
Load Diff
+16
-15
@@ -3,7 +3,7 @@ resolver = "2"
|
||||
members = ["crates/*"]
|
||||
|
||||
[workspace.package]
|
||||
version = "0.1.0-dev.11"
|
||||
version = "0.1.0-dev.13"
|
||||
authors = [
|
||||
"Cyrill Leutwiler <cyrill@parity.io>",
|
||||
"Parity Technologies <admin@parity.io>",
|
||||
@@ -14,19 +14,20 @@ repository = "https://github.com/paritytech/revive"
|
||||
rust-version = "1.81.0"
|
||||
|
||||
[workspace.dependencies]
|
||||
revive-benchmarks = { version = "0.1.0-dev.11", path = "crates/benchmarks" }
|
||||
revive-builtins = { version = "0.1.0-dev.11", path = "crates/builtins" }
|
||||
revive-common = { version = "0.1.0-dev.11", path = "crates/common" }
|
||||
revive-differential = { version = "0.1.0-dev.11", path = "crates/differential" }
|
||||
revive-integration = { version = "0.1.0-dev.11", path = "crates/integration" }
|
||||
revive-linker = { version = "0.1.0-dev.11", path = "crates/linker" }
|
||||
lld-sys = { version = "0.1.0-dev.11", path = "crates/lld-sys" }
|
||||
revive-llvm-context = { version = "0.1.0-dev.11", path = "crates/llvm-context" }
|
||||
revive-runtime-api = { version = "0.1.0-dev.11", path = "crates/runtime-api" }
|
||||
revive-runner = { version = "0.1.0-dev.11", path = "crates/runner" }
|
||||
revive-solidity = { version = "0.1.0-dev.11", path = "crates/solidity" }
|
||||
revive-stdlib = { version = "0.1.0-dev.11", path = "crates/stdlib" }
|
||||
revive-build-utils = { version = "0.1.0-dev.11", path = "crates/build-utils" }
|
||||
revive-benchmarks = { version = "0.1.0-dev.13", path = "crates/benchmarks" }
|
||||
revive-builtins = { version = "0.1.0-dev.13", path = "crates/builtins" }
|
||||
revive-common = { version = "0.1.0-dev.13", path = "crates/common" }
|
||||
revive-differential = { version = "0.1.0-dev.13", path = "crates/differential" }
|
||||
revive-integration = { version = "0.1.0-dev.13", path = "crates/integration" }
|
||||
revive-linker = { version = "0.1.0-dev.13", path = "crates/linker" }
|
||||
lld-sys = { version = "0.1.0-dev.13", path = "crates/lld-sys" }
|
||||
revive-llvm-context = { version = "0.1.0-dev.13", path = "crates/llvm-context" }
|
||||
revive-runtime-api = { version = "0.1.0-dev.13", path = "crates/runtime-api" }
|
||||
revive-runner = { version = "0.1.0-dev.13", path = "crates/runner" }
|
||||
revive-solc-json-interface = { version = "0.1.0-dev.13", path = "crates/solc-json-interface" }
|
||||
revive-solidity = { version = "0.1.0-dev.13", path = "crates/solidity" }
|
||||
revive-stdlib = { version = "0.1.0-dev.13", path = "crates/stdlib" }
|
||||
revive-build-utils = { version = "0.1.0-dev.13", path = "crates/build-utils" }
|
||||
|
||||
hex = "0.4.3"
|
||||
cc = "1.2"
|
||||
@@ -72,7 +73,7 @@ assert_fs = "1.1"
|
||||
# polkadot-sdk and friends
|
||||
codec = { version = "3.6.12", default-features = false, package = "parity-scale-codec" }
|
||||
scale-info = { version = "2.11.6", default-features = false }
|
||||
polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk", rev = "274a781e8ca1a9432c7ec87593bd93214abbff50" }
|
||||
polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk", rev = "c29e72a8628835e34deb6aa7db9a78a2e4eabcee" }
|
||||
|
||||
# llvm
|
||||
[workspace.dependencies.inkwell]
|
||||
|
||||
+1
-1
@@ -11,7 +11,7 @@ RUN make install-llvm-builder
|
||||
RUN revive-llvm --target-env musl clone
|
||||
RUN revive-llvm --target-env musl build --llvm-projects lld --llvm-projects clang
|
||||
|
||||
FROM messense/rust-musl-cross:x86_64-musl AS resolc-builder
|
||||
FROM messense/rust-musl-cross@sha256:68b86bc7cb2867259e6b233415a665ff4469c28b57763e78c3bfea1c68091561 AS resolc-builder
|
||||
WORKDIR /opt/revive
|
||||
|
||||
RUN apt update && \
|
||||
|
||||
@@ -23,7 +23,7 @@
|
||||
install: install-bin install-npm
|
||||
|
||||
install-bin:
|
||||
cargo install --path crates/solidity
|
||||
cargo install --locked --path crates/solidity
|
||||
|
||||
install-npm:
|
||||
npm install && npm fund
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
|
||||
|
||||
[](https://contracts.polkadot.io/revive_compiler/)
|
||||
|
||||
# revive
|
||||
|
||||
+8
-4
@@ -4,10 +4,14 @@ Prior to the first stable release we neither have formal release processes nor d
|
||||
|
||||
To create a new pre-release:
|
||||
|
||||
1. Merge a release PR which updates the `-dev.X` versions in the workspace `Cargo.toml` and updates the `CHANGELOG.md` accordingly. The release workflow will attempt to build and publish a new release whenever the latest git tag does not match the cargo package version.
|
||||
2. Wait for the `Release` workflow to finish. If the workflow fails after the `build-linux-all` step, check if a tag has been created and delete it before restarting or pushing updates. Note: It's more convenient to debug the release workflow in a fork (the fork has to be under the `paritytech` org to access `parity-large` runners).
|
||||
3. Check draft release on [Releases page](https://github.com/paritytech/revive/releases) and publish (should contain `resolc.js`, `resolc.wasm`, `resolc-web.js`, and `resolc-static-linux` release assets)
|
||||
4. Update the [contract-docs](https://github.com/paritytech/contract-docs/) accordingly
|
||||
1. Create a release PR which updates the `-dev.X` versions in the workspace `Cargo.toml` and updates the `CHANGELOG.md` accordingly.
|
||||
2. If the CI passes, merge the release PR.
|
||||
3. Push a tag that has the same `-dev.X` version as in `Cargo.toml`
|
||||
4. The release workflow will attempt to build and publish a new pre-release if the latest tag does match the cargo package version.
|
||||
5. Wait for the `Release` workflow to finish. It should create the pre-release with the same `-dev.X` name.
|
||||
6. Check that pre-release was created on the [Releases page](https://github.com/paritytech/revive/releases) with all artifacts.
|
||||
7. After the release is published, another workflow should start automatically and update json files in https://github.com/paritytech/resolc-bin. Check the changes.
|
||||
8. Update the [contract-docs](https://github.com/paritytech/contract-docs/) accordingly
|
||||
|
||||
# LLVM release
|
||||
|
||||
|
||||
@@ -15,6 +15,7 @@ serde_json = { workspace = true }
|
||||
|
||||
revive-solidity = { workspace = true }
|
||||
revive-runner = { workspace = true }
|
||||
revive-llvm-context = { workspace = true }
|
||||
|
||||
[dev-dependencies]
|
||||
sha1 = { workspace = true }
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
{
|
||||
"Baseline": 1110,
|
||||
"Computation": 2389,
|
||||
"DivisionArithmetics": 14822,
|
||||
"ERC20": 23973,
|
||||
"Events": 1605,
|
||||
"FibonacciIterative": 2023,
|
||||
"Flipper": 1989,
|
||||
"SHA1": 17026
|
||||
"Baseline": 1443,
|
||||
"Computation": 2788,
|
||||
"DivisionArithmetics": 9748,
|
||||
"ERC20": 19150,
|
||||
"Events": 2201,
|
||||
"FibonacciIterative": 2041,
|
||||
"Flipper": 2691,
|
||||
"SHA1": 8997
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
pragma solidity ^0.8.28;
|
||||
|
||||
contract Predicted {
|
||||
uint public salt;
|
||||
|
||||
constructor(uint _salt) {
|
||||
salt = _salt;
|
||||
}
|
||||
}
|
||||
|
||||
contract AddressPredictor {
|
||||
constructor(uint _salt, bytes memory _bytecode) payable {
|
||||
address deployed = address(new Predicted{salt: bytes32(_salt)}(_salt));
|
||||
address predicted = predictAddress(_salt, _bytecode);
|
||||
assert(deployed == predicted);
|
||||
}
|
||||
|
||||
function predictAddress(
|
||||
uint _foo,
|
||||
bytes memory _bytecode
|
||||
) public view returns (address predicted) {
|
||||
bytes32 addr = keccak256(
|
||||
abi.encodePacked(
|
||||
bytes1(0xff),
|
||||
address(this),
|
||||
bytes32(_foo),
|
||||
keccak256(abi.encodePacked(_bytecode, abi.encode(_foo)))
|
||||
)
|
||||
);
|
||||
predicted = address(uint160(uint(addr)));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
pragma solidity ^0.8.28;
|
||||
|
||||
/* runner.json
|
||||
{
|
||||
"differential": true,
|
||||
"actions": [
|
||||
{
|
||||
"Instantiate": {
|
||||
"code": {
|
||||
"Solidity": {
|
||||
"contract": "DelegateCaller"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"Call": {
|
||||
"dest": {
|
||||
"Instantiated": 0
|
||||
},
|
||||
"data": "e466c6c9"
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
*/
|
||||
|
||||
contract DelegateCaller {
|
||||
function delegateNoContract() external returns (bool) {
|
||||
address testAddress = 0x0000000000000000000000000000000000000000;
|
||||
(bool success, ) = testAddress.delegatecall(
|
||||
abi.encodeWithSignature("test()")
|
||||
);
|
||||
return success;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
pragma solidity ^0.8.28;
|
||||
|
||||
/* runner.json
|
||||
{
|
||||
"differential": true,
|
||||
"actions": [
|
||||
{
|
||||
"Instantiate": {
|
||||
"code": {
|
||||
"Solidity": {
|
||||
"contract": "FunctionType"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"Call": {
|
||||
"dest": {
|
||||
"Instantiated": 0
|
||||
},
|
||||
"data": "b8c9d365"
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
*/
|
||||
|
||||
contract FunctionType {
|
||||
uint public immutable x = 42;
|
||||
|
||||
function h() public view returns (function() external view returns (uint)) {
|
||||
return this.x;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
pragma solidity ^0.8.29;
|
||||
|
||||
/* runner.json
|
||||
{
|
||||
"differential": true,
|
||||
"actions": [
|
||||
{
|
||||
"Instantiate": {
|
||||
"code": {
|
||||
"Solidity": {
|
||||
"contract": "LayoutAt"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"Call": {
|
||||
"dest": {
|
||||
"Instantiated": 0
|
||||
},
|
||||
"data": "a7a0d537"
|
||||
}
|
||||
},
|
||||
{
|
||||
"Call": {
|
||||
"dest": {
|
||||
"Instantiated": 0
|
||||
},
|
||||
"data": "15393349"
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
*/
|
||||
|
||||
contract LayoutAt layout at 0xDEADBEEF + 0xCAFEBABE {
|
||||
uint[3] public something;
|
||||
|
||||
constructor() payable {
|
||||
something[0] = 1337;
|
||||
something[1] = 42;
|
||||
something[2] = 69;
|
||||
}
|
||||
|
||||
function slotOfSomething() public pure returns (uint ret) {
|
||||
assembly {
|
||||
ret := something.slot
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
pragma solidity ^0.8;
|
||||
|
||||
/* runner.json
|
||||
{
|
||||
"differential": true,
|
||||
"actions": [
|
||||
{
|
||||
"Instantiate": {
|
||||
"code": {
|
||||
"Solidity": {
|
||||
"contract": "MCopyOverlap"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"Call": {
|
||||
"dest": {
|
||||
"Instantiated": 0
|
||||
},
|
||||
"data": "afdce848"
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
*/
|
||||
|
||||
function copy(
|
||||
uint dstOffset,
|
||||
uint srcOffset,
|
||||
uint length
|
||||
) pure returns (bytes memory out) {
|
||||
out = hex"2222222222222222333333333333333344444444444444445555555555555555"
|
||||
hex"6666666666666666777777777777777788888888888888889999999999999999"
|
||||
hex"aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccccccccccccccccdddddddddddddddd";
|
||||
assembly {
|
||||
mcopy(
|
||||
add(add(out, 0x20), dstOffset),
|
||||
add(add(out, 0x20), srcOffset),
|
||||
length
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
contract MCopyOverlap {
|
||||
function mcopy_to_right_overlap() public pure returns (bytes memory) {
|
||||
return copy(0x20, 0x10, 0x30);
|
||||
}
|
||||
}
|
||||
@@ -15,7 +15,7 @@ pragma solidity ^0.8;
|
||||
"Instantiated": 0
|
||||
},
|
||||
"key": "0000000000000000000000000000000000000000000000000000000000000000",
|
||||
"expected": "0100000000000000000000000000000000000000000000000000000000000000"
|
||||
"expected": "0000000000000000000000000000000000000000000000000000000000000001"
|
||||
}
|
||||
},
|
||||
{
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
use alloy_primitives::{Address, Bytes, I256, U256};
|
||||
use alloy_sol_types::{sol, SolCall, SolConstructor};
|
||||
|
||||
use revive_llvm_context::OptimizerSettings;
|
||||
use revive_solidity::test_utils::*;
|
||||
|
||||
#[derive(Clone)]
|
||||
@@ -249,8 +250,19 @@ sol!(
|
||||
);
|
||||
case!("Storage.sol", Storage, transientCall, storage_transient, value: U256);
|
||||
|
||||
sol!(
|
||||
contract Predicted {
|
||||
constructor(uint _foo);
|
||||
}
|
||||
contract AddressPredictor {
|
||||
constructor(uint _foo, bytes memory _bytecode) payable;
|
||||
}
|
||||
);
|
||||
case!("AddressPredictor.sol", Predicted, constructorCall, predicted_constructor, salt: U256);
|
||||
case!("AddressPredictor.sol", AddressPredictor, constructorCall, address_predictor_constructor, salt: U256, bytecode: Bytes);
|
||||
|
||||
impl Contract {
|
||||
fn build(calldata: Vec<u8>, name: &'static str, code: &str) -> Self {
|
||||
pub fn build(calldata: Vec<u8>, name: &'static str, code: &str) -> Self {
|
||||
Self {
|
||||
name,
|
||||
evm_runtime: compile_evm_bin_runtime(name, code),
|
||||
@@ -258,11 +270,19 @@ impl Contract {
|
||||
calldata,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn build_size_opt(calldata: Vec<u8>, name: &'static str, code: &str) -> Self {
|
||||
Self {
|
||||
name,
|
||||
evm_runtime: compile_evm_bin_runtime(name, code),
|
||||
pvm_runtime: compile_blob_with_options(name, code, true, OptimizerSettings::size()),
|
||||
calldata,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use alloy_primitives::{Bytes, U256};
|
||||
use rayon::iter::{IntoParallelIterator, ParallelIterator};
|
||||
use serde::{de::Deserialize, Serialize};
|
||||
use std::{collections::BTreeMap, fs::File};
|
||||
@@ -302,14 +322,47 @@ mod tests {
|
||||
};
|
||||
|
||||
[
|
||||
Contract::baseline as fn() -> Contract,
|
||||
Contract::flipper as fn() -> Contract,
|
||||
(|| Contract::odd_product(0)) as fn() -> Contract,
|
||||
(|| Contract::fib_iterative(U256::ZERO)) as fn() -> Contract,
|
||||
Contract::erc20 as fn() -> Contract,
|
||||
(|| Contract::sha1(Bytes::new())) as fn() -> Contract,
|
||||
(|| Contract::division_arithmetics_div(U256::ZERO, U256::ZERO)) as fn() -> Contract,
|
||||
(|| Contract::event(U256::ZERO)) as fn() -> Contract,
|
||||
(|| {
|
||||
Contract::build_size_opt(
|
||||
vec![],
|
||||
"Baseline",
|
||||
include_str!("../contracts/Baseline.sol"),
|
||||
)
|
||||
}) as _,
|
||||
(|| {
|
||||
Contract::build_size_opt(
|
||||
vec![],
|
||||
"Flipper",
|
||||
include_str!("../contracts/flipper.sol"),
|
||||
)
|
||||
}) as _,
|
||||
(|| {
|
||||
Contract::build_size_opt(
|
||||
vec![],
|
||||
"Computation",
|
||||
include_str!("../contracts/Computation.sol"),
|
||||
)
|
||||
}) as _,
|
||||
(|| {
|
||||
Contract::build_size_opt(
|
||||
vec![],
|
||||
"FibonacciIterative",
|
||||
include_str!("../contracts/Fibonacci.sol"),
|
||||
)
|
||||
}) as _,
|
||||
(|| Contract::build_size_opt(vec![], "ERC20", include_str!("../contracts/ERC20.sol")))
|
||||
as _,
|
||||
(|| Contract::build_size_opt(vec![], "SHA1", include_str!("../contracts/SHA1.sol")))
|
||||
as _,
|
||||
(|| {
|
||||
Contract::build_size_opt(
|
||||
vec![],
|
||||
"DivisionArithmetics",
|
||||
include_str!("../contracts/DivisionArithmetics.sol"),
|
||||
)
|
||||
}) as _,
|
||||
(|| Contract::build_size_opt(vec![], "Events", include_str!("../contracts/Events.sol")))
|
||||
as _,
|
||||
]
|
||||
.into_par_iter()
|
||||
.map(extract_code_size)
|
||||
|
||||
@@ -33,6 +33,7 @@ test_spec!(msize, "MSize", "MSize.sol");
|
||||
test_spec!(sha1, "SHA1", "SHA1.sol");
|
||||
test_spec!(block, "Block", "Block.sol");
|
||||
test_spec!(mcopy, "MCopy", "MCopy.sol");
|
||||
test_spec!(mcopy_overlap, "MCopyOverlap", "MCopyOverlap.sol");
|
||||
test_spec!(events, "Events", "Events.sol");
|
||||
test_spec!(storage, "Storage", "Storage.sol");
|
||||
test_spec!(mstore8, "MStore8", "MStore8.sol");
|
||||
@@ -56,6 +57,9 @@ test_spec!(transfer, "Transfer", "Transfer.sol");
|
||||
test_spec!(send, "Send", "Send.sol");
|
||||
test_spec!(function_pointer, "FunctionPointer", "FunctionPointer.sol");
|
||||
test_spec!(mload, "MLoad", "MLoad.sol");
|
||||
test_spec!(delegate_no_contract, "DelegateCaller", "DelegateCaller.sol");
|
||||
test_spec!(function_type, "FunctionType", "FunctionType.sol");
|
||||
test_spec!(layout_at, "LayoutAt", "LayoutAt.sol");
|
||||
|
||||
fn instantiate(path: &str, contract: &str) -> Vec<SpecsAction> {
|
||||
vec![Instantiate {
|
||||
@@ -482,3 +486,31 @@ fn transfer_denies_reentrancy() {
|
||||
}
|
||||
.run();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn create2_salt() {
|
||||
let salt = U256::from(777);
|
||||
let predicted = Contract::predicted_constructor(salt).pvm_runtime;
|
||||
let predictor = Contract::address_predictor_constructor(salt, predicted.clone().into());
|
||||
Specs {
|
||||
actions: vec![
|
||||
Upload {
|
||||
origin: TestAddress::Alice,
|
||||
code: Code::Bytes(predicted),
|
||||
storage_deposit_limit: None,
|
||||
},
|
||||
Instantiate {
|
||||
origin: TestAddress::Alice,
|
||||
value: 0,
|
||||
gas_limit: Some(GAS_LIMIT),
|
||||
storage_deposit_limit: None,
|
||||
code: Code::Bytes(predictor.pvm_runtime),
|
||||
data: predictor.calldata,
|
||||
salt: OptionalHex::default(),
|
||||
},
|
||||
],
|
||||
differential: false,
|
||||
..Default::default()
|
||||
}
|
||||
.run();
|
||||
}
|
||||
|
||||
@@ -52,7 +52,6 @@ pub fn link<T: AsRef<[u8]>>(input: T) -> anyhow::Result<Vec<u8>> {
|
||||
|
||||
let ld_args = [
|
||||
"ld.lld",
|
||||
"--lto=full",
|
||||
"--error-limit=0",
|
||||
"--relocatable",
|
||||
"--emit-relocs",
|
||||
|
||||
@@ -96,7 +96,7 @@ fn main() {
|
||||
revive_build_utils::llvm_cxx_flags()
|
||||
.split_whitespace()
|
||||
.fold(&mut cc::Build::new(), |builder, flag| builder.flag(flag))
|
||||
.flag("-Wno-unused-parameter")
|
||||
.warnings(false)
|
||||
.cpp(true)
|
||||
.file("src/linker.cpp")
|
||||
.compile("liblinker.a");
|
||||
|
||||
@@ -32,6 +32,7 @@ tar = { workspace = true }
|
||||
flate2 = { workspace = true }
|
||||
env_logger = { workspace = true }
|
||||
log = { workspace = true }
|
||||
which = { workspace = true }
|
||||
|
||||
[dev-dependencies]
|
||||
assert_cmd = { workspace = true }
|
||||
|
||||
@@ -1,5 +1,8 @@
|
||||
//! Utilities for compiling the LLVM compiler-rt builtins.
|
||||
|
||||
use crate::utils::path_windows_to_unix as to_unix;
|
||||
use std::{env::consts::EXE_EXTENSION, process::Command};
|
||||
|
||||
/// Static CFLAGS variable passed to the compiler building the compiler-rt builtins.
|
||||
const C_FLAGS: [&str; 6] = [
|
||||
"--target=riscv64",
|
||||
@@ -44,24 +47,31 @@ fn cmake_dynamic_args(
|
||||
|
||||
let mut clang_path = llvm_target_host.to_path_buf();
|
||||
clang_path.push("bin/clang");
|
||||
clang_path.set_extension(EXE_EXTENSION);
|
||||
|
||||
let mut clangxx_path = llvm_target_host.to_path_buf();
|
||||
clangxx_path.push("bin/clang++");
|
||||
clangxx_path.set_extension(EXE_EXTENSION);
|
||||
|
||||
let mut llvm_config_path = llvm_target_host.to_path_buf();
|
||||
llvm_config_path.push("bin/llvm-config");
|
||||
llvm_config_path.set_extension(EXE_EXTENSION);
|
||||
|
||||
let mut ar_path = llvm_target_host.to_path_buf();
|
||||
ar_path.push("bin/llvm-ar");
|
||||
ar_path.set_extension(EXE_EXTENSION);
|
||||
|
||||
let mut nm_path = llvm_target_host.to_path_buf();
|
||||
nm_path.push("bin/llvm-nm");
|
||||
nm_path.set_extension(EXE_EXTENSION);
|
||||
|
||||
let mut ranlib_path = llvm_target_host.to_path_buf();
|
||||
ranlib_path.push("bin/llvm-ranlib");
|
||||
ranlib_path.set_extension(EXE_EXTENSION);
|
||||
|
||||
let mut linker_path = llvm_target_host.to_path_buf();
|
||||
linker_path.push("bin/ld.lld");
|
||||
linker_path.set_extension(EXE_EXTENSION);
|
||||
|
||||
Ok([
|
||||
format!(
|
||||
@@ -76,12 +86,18 @@ fn cmake_dynamic_args(
|
||||
format!("-DCMAKE_C_FLAGS='{}'", C_FLAGS.join(" ")),
|
||||
format!("-DCMAKE_ASM_FLAGS='{}'", C_FLAGS.join(" ")),
|
||||
format!("-DCMAKE_CXX_FLAGS='{}'", C_FLAGS.join(" ")),
|
||||
format!("-DCMAKE_C_COMPILER='{}'", clang_path.to_string_lossy()),
|
||||
format!("-DCMAKE_ASM_COMPILER='{}'", clang_path.to_string_lossy()),
|
||||
format!("-DCMAKE_CXX_COMPILER='{}'", clangxx_path.to_string_lossy()),
|
||||
format!("-DCMAKE_AR='{}'", ar_path.to_string_lossy()),
|
||||
format!("-DCMAKE_NM='{}'", nm_path.to_string_lossy()),
|
||||
format!("-DCMAKE_RANLIB='{}'", ranlib_path.to_string_lossy()),
|
||||
format!(
|
||||
"-DCMAKE_C_COMPILER='{}'",
|
||||
to_unix(clang_path.clone())?.display()
|
||||
),
|
||||
format!("-DCMAKE_ASM_COMPILER='{}'", to_unix(clang_path)?.display()),
|
||||
format!(
|
||||
"-DCMAKE_CXX_COMPILER='{}'",
|
||||
to_unix(clangxx_path)?.display()
|
||||
),
|
||||
format!("-DCMAKE_AR='{}'", to_unix(ar_path)?.display()),
|
||||
format!("-DCMAKE_NM='{}'", to_unix(nm_path)?.display()),
|
||||
format!("-DCMAKE_RANLIB='{}'", to_unix(ranlib_path)?.display()),
|
||||
format!(
|
||||
"-DLLVM_CONFIG_PATH='{}'",
|
||||
llvm_config_path.to_string_lossy()
|
||||
@@ -101,7 +117,13 @@ pub fn build(
|
||||
log::info!("building compiler-rt for rv64emac");
|
||||
|
||||
crate::utils::check_presence("cmake")?;
|
||||
crate::utils::check_presence("ninja")?;
|
||||
|
||||
let generator = if cfg!(target_os = "windows") {
|
||||
"Visual Studio 17 2022"
|
||||
} else {
|
||||
crate::utils::check_presence("ninja")?;
|
||||
"Ninja"
|
||||
};
|
||||
|
||||
let llvm_module_compiler_rt = crate::LLVMPath::llvm_module_compiler_rt()?;
|
||||
let llvm_compiler_rt_build = crate::LLVMPath::llvm_build_compiler_rt()?;
|
||||
@@ -114,7 +136,7 @@ pub fn build(
|
||||
"-B",
|
||||
llvm_compiler_rt_build.to_string_lossy().as_ref(),
|
||||
"-G",
|
||||
"Ninja",
|
||||
generator,
|
||||
])
|
||||
.args(CMAKE_STATIC_ARGS)
|
||||
.args(cmake_dynamic_args(build_type, target_env)?)
|
||||
@@ -131,7 +153,17 @@ pub fn build(
|
||||
"LLVM compiler-rt building cmake",
|
||||
)?;
|
||||
|
||||
crate::utils::ninja(&llvm_compiler_rt_build)?;
|
||||
crate::utils::command(
|
||||
Command::new("cmake").args([
|
||||
"--build",
|
||||
llvm_compiler_rt_build.to_string_lossy().as_ref(),
|
||||
"--target",
|
||||
"install",
|
||||
"--config",
|
||||
build_type.to_string().as_str(),
|
||||
]),
|
||||
"Building",
|
||||
)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -214,7 +214,7 @@ pub fn build(
|
||||
sanitizer,
|
||||
)?;
|
||||
} else if cfg!(target_os = "windows") {
|
||||
platforms::x86_64_windows_gnu::build(
|
||||
platforms::x86_64_windows_msvc::build(
|
||||
build_type,
|
||||
targets,
|
||||
llvm_projects,
|
||||
|
||||
@@ -8,7 +8,7 @@ pub mod wasm32_emscripten;
|
||||
pub mod x86_64_linux_gnu;
|
||||
pub mod x86_64_linux_musl;
|
||||
pub mod x86_64_macos;
|
||||
pub mod x86_64_windows_gnu;
|
||||
pub mod x86_64_windows_msvc;
|
||||
|
||||
use std::str::FromStr;
|
||||
|
||||
|
||||
@@ -8,7 +8,7 @@ use std::path::Path;
|
||||
use std::process::Command;
|
||||
|
||||
/// The build options shared by all platforms.
|
||||
pub const SHARED_BUILD_OPTS: [&str; 19] = [
|
||||
pub const SHARED_BUILD_OPTS: [&str; 21] = [
|
||||
"-DPACKAGE_VENDOR='Parity Technologies'",
|
||||
"-DCMAKE_BUILD_WITH_INSTALL_RPATH=1",
|
||||
"-DLLVM_BUILD_DOCS='Off'",
|
||||
@@ -28,6 +28,8 @@ pub const SHARED_BUILD_OPTS: [&str; 19] = [
|
||||
"-DCMAKE_EXPORT_COMPILE_COMMANDS='On'",
|
||||
"-DPython3_FIND_REGISTRY='LAST'", // Use Python version from $PATH, not from registry
|
||||
"-DBUG_REPORT_URL='https://github.com/paritytech/contract-issues/issues/'",
|
||||
"-DCLANG_ENABLE_ARCMT='Off'",
|
||||
"-DCLANG_ENABLE_STATIC_ANALYZER='Off'",
|
||||
];
|
||||
|
||||
/// The build options shared by all platforms except MUSL.
|
||||
|
||||
+12
-24
@@ -1,7 +1,6 @@
|
||||
//! The revive LLVM amd64 `windows-gnu` builder.
|
||||
|
||||
use std::collections::HashSet;
|
||||
use std::path::PathBuf;
|
||||
use std::process::Command;
|
||||
|
||||
use crate::build_type::BuildType;
|
||||
@@ -28,10 +27,6 @@ pub fn build(
|
||||
sanitizer: Option<Sanitizer>,
|
||||
) -> anyhow::Result<()> {
|
||||
crate::utils::check_presence("cmake")?;
|
||||
crate::utils::check_presence("clang")?;
|
||||
crate::utils::check_presence("clang++")?;
|
||||
crate::utils::check_presence("lld")?;
|
||||
crate::utils::check_presence("ninja")?;
|
||||
|
||||
let llvm_module_llvm =
|
||||
LLVMPath::llvm_module_llvm().and_then(crate::utils::path_windows_to_unix)?;
|
||||
@@ -48,15 +43,12 @@ pub fn build(
|
||||
"-B",
|
||||
llvm_build_final.to_string_lossy().as_ref(),
|
||||
"-G",
|
||||
"Ninja",
|
||||
"Visual Studio 17 2022",
|
||||
format!(
|
||||
"-DCMAKE_INSTALL_PREFIX='{}'",
|
||||
llvm_target_final.to_string_lossy().as_ref(),
|
||||
)
|
||||
.as_str(),
|
||||
format!("-DCMAKE_BUILD_TYPE='{build_type}'").as_str(),
|
||||
"-DCMAKE_C_COMPILER='clang'",
|
||||
"-DCMAKE_CXX_COMPILER='clang++'",
|
||||
format!(
|
||||
"-DLLVM_TARGETS_TO_BUILD='{}'",
|
||||
targets
|
||||
@@ -75,7 +67,7 @@ pub fn build(
|
||||
.join(";")
|
||||
)
|
||||
.as_str(),
|
||||
"-DLLVM_USE_LINKER='lld'",
|
||||
"-DLLVM_BUILD_LLVM_C_DYLIB=Off",
|
||||
])
|
||||
.args(crate::platforms::shared::shared_build_opts_default_target(
|
||||
default_target,
|
||||
@@ -107,20 +99,16 @@ pub fn build(
|
||||
"LLVM building cmake",
|
||||
)?;
|
||||
|
||||
crate::utils::ninja(llvm_build_final.as_ref())?;
|
||||
|
||||
let libstdcpp_source_path = match std::env::var("LIBSTDCPP_SOURCE_PATH") {
|
||||
Ok(libstdcpp_source_path) => PathBuf::from(libstdcpp_source_path),
|
||||
Err(error) => anyhow::bail!(
|
||||
"The `LIBSTDCPP_SOURCE_PATH` must be set to the path to the libstdc++.a static library: {}", error
|
||||
),
|
||||
};
|
||||
let mut libstdcpp_destination_path = llvm_target_final;
|
||||
libstdcpp_destination_path.push("./lib/libstdc++.a");
|
||||
fs_extra::file::copy(
|
||||
crate::utils::path_windows_to_unix(libstdcpp_source_path)?,
|
||||
crate::utils::path_windows_to_unix(libstdcpp_destination_path)?,
|
||||
&fs_extra::file::CopyOptions::default(),
|
||||
crate::utils::command(
|
||||
Command::new("cmake").args([
|
||||
"--build",
|
||||
llvm_build_final.to_string_lossy().as_ref(),
|
||||
"--target",
|
||||
"install",
|
||||
"--config",
|
||||
build_type.to_string().as_str(),
|
||||
]),
|
||||
"Building with msbuild",
|
||||
)?;
|
||||
|
||||
Ok(())
|
||||
@@ -7,6 +7,7 @@ use std::process::Command;
|
||||
use std::process::Stdio;
|
||||
use std::time::Duration;
|
||||
|
||||
use anyhow::Context;
|
||||
use path_slash::PathBufExt;
|
||||
|
||||
/// The LLVM host repository URL.
|
||||
@@ -131,11 +132,8 @@ pub fn path_windows_to_unix<P: AsRef<Path> + PathBufExt>(path: P) -> anyhow::Res
|
||||
|
||||
/// Checks if the tool exists in the system.
|
||||
pub fn check_presence(name: &str) -> anyhow::Result<()> {
|
||||
let description = &format!("checking the `{name}` executable");
|
||||
log::info!("{description}");
|
||||
|
||||
command(Command::new("which").arg(name), description)
|
||||
.map_err(|_| anyhow::anyhow!("Tool `{}` is missing. Please install", name))
|
||||
which::which(name).with_context(|| format!("Tool `{name}` is missing. Please install"))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Identify XCode version using `pkgutil`.
|
||||
|
||||
@@ -53,6 +53,16 @@ fn clone_build_and_clean_musl() -> anyhow::Result<()> {
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
Command::cargo_bin(common::REVIVE_LLVM)?
|
||||
.current_dir(test_dir.path())
|
||||
.arg("build")
|
||||
.arg("--llvm-projects")
|
||||
.arg("clang")
|
||||
.arg("--llvm-projects")
|
||||
.arg("lld")
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
Command::cargo_bin(common::REVIVE_LLVM)?
|
||||
.arg("--target-env")
|
||||
.arg("musl")
|
||||
@@ -65,12 +75,6 @@ fn clone_build_and_clean_musl() -> anyhow::Result<()> {
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
Command::cargo_bin(common::REVIVE_LLVM)?
|
||||
.current_dir(test_dir.path())
|
||||
.arg("builtins")
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
Command::cargo_bin(common::REVIVE_LLVM)?
|
||||
.current_dir(test_dir.path())
|
||||
.arg("clean")
|
||||
@@ -83,6 +87,7 @@ fn clone_build_and_clean_musl() -> anyhow::Result<()> {
|
||||
/// This test verifies that the LLVM repository can be successfully cloned and built in debug mode
|
||||
/// with tests and coverage enabled.
|
||||
#[test]
|
||||
#[cfg(target_os = "linux")]
|
||||
fn debug_build_with_tests_coverage() -> anyhow::Result<()> {
|
||||
let test_dir = common::TestDir::with_lockfile(None)?;
|
||||
|
||||
@@ -99,6 +104,10 @@ fn debug_build_with_tests_coverage() -> anyhow::Result<()> {
|
||||
.arg("--enable-tests")
|
||||
.arg("--build-type")
|
||||
.arg("Debug")
|
||||
.arg("--llvm-projects")
|
||||
.arg("clang")
|
||||
.arg("--llvm-projects")
|
||||
.arg("lld")
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
@@ -107,6 +116,7 @@ fn debug_build_with_tests_coverage() -> anyhow::Result<()> {
|
||||
|
||||
/// This test verifies that the LLVM repository can be successfully built with address sanitizer.
|
||||
#[test]
|
||||
#[cfg(target_os = "linux")]
|
||||
fn build_with_sanitizers() -> anyhow::Result<()> {
|
||||
let test_dir = common::TestDir::with_lockfile(None)?;
|
||||
|
||||
@@ -121,6 +131,10 @@ fn build_with_sanitizers() -> anyhow::Result<()> {
|
||||
.arg("build")
|
||||
.arg("--sanitizer")
|
||||
.arg("Address")
|
||||
.arg("--llvm-projects")
|
||||
.arg("lld")
|
||||
.arg("--llvm-projects")
|
||||
.arg("clang")
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
@@ -129,15 +143,36 @@ fn build_with_sanitizers() -> anyhow::Result<()> {
|
||||
|
||||
/// Tests the clone, build, and clean process of the LLVM repository for the emscripten target.
|
||||
#[test]
|
||||
#[cfg(any(target_os = "linux", target_os = "macos"))]
|
||||
#[cfg(target_os = "linux")]
|
||||
fn clone_build_and_clean_emscripten() -> anyhow::Result<()> {
|
||||
let test_dir = common::TestDir::with_lockfile(None)?;
|
||||
let command = Command::cargo_bin(common::REVIVE_LLVM)?;
|
||||
let program = command.get_program().to_string_lossy();
|
||||
|
||||
Command::cargo_bin(common::REVIVE_LLVM)?
|
||||
.current_dir(test_dir.path())
|
||||
.arg("clone")
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
Command::cargo_bin(common::REVIVE_LLVM)?
|
||||
.current_dir(test_dir.path())
|
||||
.arg("build")
|
||||
.arg("--llvm-projects")
|
||||
.arg("lld")
|
||||
.arg("--llvm-projects")
|
||||
.arg("clang")
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
// Two little shell-dependent things here:
|
||||
// Doing `. ./emsdk_env.sh` instead of `source`, as `source` might be missing in some shells
|
||||
// `cd {} && . ./emsdk_env.sh && cd ..` helps the script to locate `emsdk.py`
|
||||
// @see https://github.com/emscripten-core/emsdk/blob/9dbdc4b3437750b85d16931c7c801bb71a782122/emsdk_env.sh#L61-L69
|
||||
let emsdk_wrapped_build_command = format!(
|
||||
"{program} --target-env emscripten clone && \
|
||||
source {}emsdk_env.sh && \
|
||||
{program} --target-env emscripten build --llvm-projects clang --llvm-projects lld",
|
||||
cd {} && . ./emsdk_env.sh && cd .. && \
|
||||
{program} --target-env emscripten build --llvm-projects lld",
|
||||
revive_llvm_builder::LLVMPath::DIRECTORY_EMSDK_SOURCE,
|
||||
);
|
||||
|
||||
|
||||
@@ -22,6 +22,7 @@ num = { workspace = true }
|
||||
hex = { workspace = true }
|
||||
sha3 = { workspace = true }
|
||||
inkwell = { workspace = true }
|
||||
libc = { workspace = true }
|
||||
polkavm-disassembler = { workspace = true }
|
||||
polkavm-common = { workspace = true }
|
||||
|
||||
@@ -29,3 +30,4 @@ revive-common = { workspace = true }
|
||||
revive-runtime-api = { workspace = true }
|
||||
revive-linker = { workspace = true }
|
||||
revive-stdlib = { workspace = true }
|
||||
revive-solc-json-interface = { workspace = true }
|
||||
|
||||
@@ -1,9 +1,7 @@
|
||||
//! The LLVM context library.
|
||||
|
||||
pub(crate) mod debug_config;
|
||||
pub(crate) mod optimizer;
|
||||
pub(crate) mod polkavm;
|
||||
pub(crate) mod target_machine;
|
||||
use std::ffi::CString;
|
||||
use std::sync::OnceLock;
|
||||
|
||||
pub use self::debug_config::ir_type::IRType as DebugConfigIR;
|
||||
pub use self::debug_config::DebugConfig;
|
||||
@@ -21,17 +19,27 @@ pub use self::polkavm::context::function::declaration::Declaration as PolkaVMFun
|
||||
pub use self::polkavm::context::function::intrinsics::Intrinsics as PolkaVMIntrinsicFunction;
|
||||
pub use self::polkavm::context::function::llvm_runtime::LLVMRuntime as PolkaVMLLVMRuntime;
|
||||
pub use self::polkavm::context::function::r#return::Return as PolkaVMFunctionReturn;
|
||||
pub use self::polkavm::context::function::runtime::arithmetics::Division as PolkaVMDivisionFunction;
|
||||
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::deploy_code::DeployCode as PolkaVMDeployCodeFunction;
|
||||
pub use self::polkavm::context::function::runtime::entry::Entry as PolkaVMEntryFunction;
|
||||
pub use self::polkavm::context::function::runtime::immutable_data_load::ImmutableDataLoad as PolkaVMImmutableDataLoadFunction;
|
||||
pub use self::polkavm::context::function::runtime::revive::Exit as PolkaVMExitFunction;
|
||||
pub use self::polkavm::context::function::runtime::revive::WordToPointer as PolkaVMWordToPointerFunction;
|
||||
pub use self::polkavm::context::function::runtime::runtime_code::RuntimeCode as PolkaVMRuntimeCodeFunction;
|
||||
pub use self::polkavm::context::function::runtime::FUNCTION_DEPLOY_CODE as PolkaVMFunctionDeployCode;
|
||||
pub use self::polkavm::context::function::runtime::FUNCTION_ENTRY as PolkaVMFunctionEntry;
|
||||
pub use self::polkavm::context::function::runtime::FUNCTION_LOAD_IMMUTABLE_DATA as PolkaVMFunctionImmutableDataLoad;
|
||||
pub use self::polkavm::context::function::runtime::FUNCTION_RUNTIME_CODE as PolkaVMFunctionRuntimeCode;
|
||||
pub use self::polkavm::context::function::yul_data::YulData as PolkaVMFunctionYulData;
|
||||
pub use self::polkavm::context::function::Function as PolkaVMFunction;
|
||||
pub use self::polkavm::context::global::Global as PolkaVMGlobal;
|
||||
pub use self::polkavm::context::pointer::heap::LoadWord as PolkaVMLoadHeapWordFunction;
|
||||
pub use self::polkavm::context::pointer::heap::StoreWord as PolkaVMStoreHeapWordFunction;
|
||||
pub use self::polkavm::context::pointer::storage::LoadTransientWord as PolkaVMLoadTransientStorageWordFunction;
|
||||
pub use self::polkavm::context::pointer::storage::LoadWord as PolkaVMLoadStorageWordFunction;
|
||||
pub use self::polkavm::context::pointer::storage::StoreTransientWord as PolkaVMStoreTransientStorageWordFunction;
|
||||
pub use self::polkavm::context::pointer::storage::StoreWord as PolkaVMStoreStorageWordFunction;
|
||||
pub use self::polkavm::context::pointer::Pointer as PolkaVMPointer;
|
||||
pub use self::polkavm::context::r#loop::Loop as PolkaVMLoop;
|
||||
pub use self::polkavm::context::solidity_data::SolidityData as PolkaVMContextSolidityData;
|
||||
@@ -47,14 +55,17 @@ pub use self::polkavm::evm::create as polkavm_evm_create;
|
||||
pub use self::polkavm::evm::crypto as polkavm_evm_crypto;
|
||||
pub use self::polkavm::evm::ether_gas as polkavm_evm_ether_gas;
|
||||
pub use self::polkavm::evm::event as polkavm_evm_event;
|
||||
pub use self::polkavm::evm::event::EventLog as PolkaVMEventLogFunction;
|
||||
pub use self::polkavm::evm::ext_code as polkavm_evm_ext_code;
|
||||
pub use self::polkavm::evm::immutable as polkavm_evm_immutable;
|
||||
pub use self::polkavm::evm::immutable::Load as PolkaVMLoadImmutableDataFunction;
|
||||
pub use self::polkavm::evm::immutable::Store as PolkaVMStoreImmutableDataFunction;
|
||||
|
||||
pub use self::polkavm::evm::math as polkavm_evm_math;
|
||||
pub use self::polkavm::evm::memory as polkavm_evm_memory;
|
||||
pub use self::polkavm::evm::r#return as polkavm_evm_return;
|
||||
pub use self::polkavm::evm::return_data as polkavm_evm_return_data;
|
||||
pub use self::polkavm::evm::storage as polkavm_evm_storage;
|
||||
pub use self::polkavm::metadata_hash::MetadataHash as PolkaVMMetadataHash;
|
||||
pub use self::polkavm::r#const as polkavm_const;
|
||||
pub use self::polkavm::Dependency as PolkaVMDependency;
|
||||
pub use self::polkavm::DummyDependency as PolkaVMDummyDependency;
|
||||
@@ -63,9 +74,41 @@ pub use self::polkavm::WriteLLVM as PolkaVMWriteLLVM;
|
||||
pub use self::target_machine::target::Target;
|
||||
pub use self::target_machine::TargetMachine;
|
||||
|
||||
/// Initializes the target machine.
|
||||
pub fn initialize_target(target: Target) {
|
||||
pub(crate) mod debug_config;
|
||||
pub(crate) mod optimizer;
|
||||
pub(crate) mod polkavm;
|
||||
pub(crate) mod target_machine;
|
||||
|
||||
static DID_INITIALIZE: OnceLock<()> = OnceLock::new();
|
||||
|
||||
/// Initializes the LLVM compiler backend.
|
||||
///
|
||||
/// This is a no-op if called subsequentially.
|
||||
///
|
||||
/// `llvm_arguments` are passed as-is to the LLVM CL options parser.
|
||||
pub fn initialize_llvm(target: Target, name: &str, llvm_arguments: &[String]) {
|
||||
let Ok(_) = DID_INITIALIZE.set(()) else {
|
||||
return; // Tests don't go through a recursive process
|
||||
};
|
||||
|
||||
let argv = [name.to_string()]
|
||||
.iter()
|
||||
.chain(llvm_arguments)
|
||||
.map(|arg| CString::new(arg.as_bytes()).unwrap())
|
||||
.collect::<Vec<_>>();
|
||||
let argv: Vec<*const libc::c_char> = argv.iter().map(|arg| arg.as_ptr()).collect();
|
||||
let overview = CString::new("").unwrap();
|
||||
unsafe {
|
||||
inkwell::llvm_sys::support::LLVMParseCommandLineOptions(
|
||||
argv.len() as i32,
|
||||
argv.as_ptr(),
|
||||
overview.as_ptr(),
|
||||
);
|
||||
}
|
||||
|
||||
inkwell::support::enable_llvm_pretty_stack_trace();
|
||||
|
||||
match target {
|
||||
Target::PVM => self::polkavm::initialize_target(),
|
||||
Target::PVM => inkwell::targets::Target::initialize_riscv(&Default::default()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
|
||||
pub mod size_level;
|
||||
|
||||
use revive_solc_json_interface::SolcStandardJsonInputSettingsOptimizer;
|
||||
use serde::Deserialize;
|
||||
use serde::Serialize;
|
||||
|
||||
@@ -226,3 +227,18 @@ impl std::fmt::Display for Settings {
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl TryFrom<&SolcStandardJsonInputSettingsOptimizer> for Settings {
|
||||
type Error = anyhow::Error;
|
||||
|
||||
fn try_from(value: &SolcStandardJsonInputSettingsOptimizer) -> Result<Self, Self::Error> {
|
||||
let mut result = match value.mode {
|
||||
Some(mode) => Self::try_from_cli(mode)?,
|
||||
None => Self::cycles(),
|
||||
};
|
||||
if value.fallback_to_optimizing_for_size.unwrap_or_default() {
|
||||
result.enable_fallback_to_size();
|
||||
}
|
||||
Ok(result)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,10 +8,6 @@ pub enum AddressSpace {
|
||||
Stack,
|
||||
/// The heap memory.
|
||||
Heap,
|
||||
/// The generic memory page.
|
||||
Storage,
|
||||
/// The transient storage.
|
||||
TransientStorage,
|
||||
}
|
||||
|
||||
impl From<AddressSpace> for inkwell::AddressSpace {
|
||||
@@ -19,8 +15,6 @@ impl From<AddressSpace> for inkwell::AddressSpace {
|
||||
match value {
|
||||
AddressSpace::Stack => Self::from(0),
|
||||
AddressSpace::Heap => Self::from(1),
|
||||
AddressSpace::Storage => Self::from(5),
|
||||
AddressSpace::TransientStorage => Self::from(6),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
//! The LLVM runtime functions.
|
||||
|
||||
use inkwell::types::BasicType;
|
||||
|
||||
use crate::optimizer::Optimizer;
|
||||
use crate::polkavm::context::address_space::AddressSpace;
|
||||
use crate::polkavm::context::function::declaration::Declaration as FunctionDeclaration;
|
||||
use crate::polkavm::context::function::Function;
|
||||
|
||||
@@ -19,9 +16,6 @@ pub struct LLVMRuntime<'ctx> {
|
||||
pub exp: FunctionDeclaration<'ctx>,
|
||||
/// The corresponding LLVM runtime function.
|
||||
pub sign_extend: FunctionDeclaration<'ctx>,
|
||||
|
||||
/// The corresponding LLVM runtime function.
|
||||
pub sha3: FunctionDeclaration<'ctx>,
|
||||
}
|
||||
|
||||
impl<'ctx> LLVMRuntime<'ctx> {
|
||||
@@ -37,9 +31,6 @@ impl<'ctx> LLVMRuntime<'ctx> {
|
||||
/// The corresponding runtime function name.
|
||||
pub const FUNCTION_SIGNEXTEND: &'static str = "__signextend";
|
||||
|
||||
/// The corresponding runtime function name.
|
||||
pub const FUNCTION_SHA3: &'static str = "__sha3";
|
||||
|
||||
/// A shortcut constructor.
|
||||
pub fn new(
|
||||
llvm: &'ctx inkwell::context::Context,
|
||||
@@ -65,43 +56,11 @@ impl<'ctx> LLVMRuntime<'ctx> {
|
||||
Function::set_default_attributes(llvm, sign_extend, optimizer);
|
||||
Function::set_pure_function_attributes(llvm, sign_extend);
|
||||
|
||||
let sha3 = Self::declare(
|
||||
module,
|
||||
Self::FUNCTION_SHA3,
|
||||
llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
|
||||
.fn_type(
|
||||
vec![
|
||||
llvm.ptr_type(AddressSpace::Heap.into())
|
||||
.as_basic_type_enum()
|
||||
.into(),
|
||||
llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
|
||||
.as_basic_type_enum()
|
||||
.into(),
|
||||
llvm.custom_width_int_type(revive_common::BIT_LENGTH_BOOLEAN as u32)
|
||||
.as_basic_type_enum()
|
||||
.into(),
|
||||
]
|
||||
.as_slice(),
|
||||
false,
|
||||
),
|
||||
Some(inkwell::module::Linkage::External),
|
||||
);
|
||||
Function::set_default_attributes(llvm, sha3, optimizer);
|
||||
Function::set_attributes(
|
||||
llvm,
|
||||
sha3,
|
||||
//vec![Attribute::ArgMemOnly, Attribute::ReadOnly],
|
||||
vec![],
|
||||
false,
|
||||
);
|
||||
|
||||
Self {
|
||||
add_mod,
|
||||
mul_mod,
|
||||
exp,
|
||||
sign_extend,
|
||||
|
||||
sha3,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -81,8 +81,7 @@ impl<'ctx> Function<'ctx> {
|
||||
|| (name.starts_with("__")
|
||||
&& name != self::runtime::FUNCTION_ENTRY
|
||||
&& name != self::runtime::FUNCTION_DEPLOY_CODE
|
||||
&& name != self::runtime::FUNCTION_RUNTIME_CODE
|
||||
&& name != self::runtime::FUNCTION_LOAD_IMMUTABLE_DATA)
|
||||
&& name != self::runtime::FUNCTION_RUNTIME_CODE)
|
||||
}
|
||||
|
||||
/// Returns the LLVM function declaration.
|
||||
@@ -110,30 +109,21 @@ impl<'ctx> Function<'ctx> {
|
||||
pub fn set_attributes(
|
||||
llvm: &'ctx inkwell::context::Context,
|
||||
declaration: Declaration<'ctx>,
|
||||
attributes: Vec<Attribute>,
|
||||
attributes: &[Attribute],
|
||||
force: bool,
|
||||
) {
|
||||
for attribute_kind in attributes.into_iter() {
|
||||
for attribute_kind in attributes {
|
||||
match attribute_kind {
|
||||
Attribute::Memory => unimplemented!("`memory` attributes are not implemented"),
|
||||
attribute_kind @ Attribute::AlwaysInline if force => {
|
||||
let is_optimize_none_set = declaration
|
||||
.value
|
||||
.get_enum_attribute(
|
||||
inkwell::attributes::AttributeLoc::Function,
|
||||
Attribute::OptimizeNone as u32,
|
||||
)
|
||||
.is_some();
|
||||
if !is_optimize_none_set {
|
||||
declaration.value.remove_enum_attribute(
|
||||
inkwell::attributes::AttributeLoc::Function,
|
||||
Attribute::NoInline as u32,
|
||||
);
|
||||
declaration.value.add_attribute(
|
||||
inkwell::attributes::AttributeLoc::Function,
|
||||
llvm.create_enum_attribute(attribute_kind as u32, 0),
|
||||
);
|
||||
}
|
||||
declaration.value.remove_enum_attribute(
|
||||
inkwell::attributes::AttributeLoc::Function,
|
||||
Attribute::NoInline as u32,
|
||||
);
|
||||
declaration.value.add_attribute(
|
||||
inkwell::attributes::AttributeLoc::Function,
|
||||
llvm.create_enum_attribute(*attribute_kind as u32, 0),
|
||||
);
|
||||
}
|
||||
attribute_kind @ Attribute::NoInline if force => {
|
||||
declaration.value.remove_enum_attribute(
|
||||
@@ -142,12 +132,12 @@ impl<'ctx> Function<'ctx> {
|
||||
);
|
||||
declaration.value.add_attribute(
|
||||
inkwell::attributes::AttributeLoc::Function,
|
||||
llvm.create_enum_attribute(attribute_kind as u32, 0),
|
||||
llvm.create_enum_attribute(*attribute_kind as u32, 0),
|
||||
);
|
||||
}
|
||||
attribute_kind => declaration.value.add_attribute(
|
||||
inkwell::attributes::AttributeLoc::Function,
|
||||
llvm.create_enum_attribute(attribute_kind as u32, 0),
|
||||
llvm.create_enum_attribute(*attribute_kind as u32, 0),
|
||||
),
|
||||
}
|
||||
}
|
||||
@@ -178,27 +168,16 @@ impl<'ctx> Function<'ctx> {
|
||||
declaration: Declaration<'ctx>,
|
||||
optimizer: &Optimizer,
|
||||
) {
|
||||
if optimizer.settings().level_middle_end == inkwell::OptimizationLevel::None {
|
||||
Self::remove_attributes(
|
||||
declaration,
|
||||
&[Attribute::OptimizeForSize, Attribute::AlwaysInline],
|
||||
);
|
||||
if optimizer.settings().level_middle_end_size == SizeLevel::Z {
|
||||
Self::set_attributes(
|
||||
llvm,
|
||||
declaration,
|
||||
vec![Attribute::OptimizeNone, Attribute::NoInline],
|
||||
false,
|
||||
);
|
||||
} else if optimizer.settings().level_middle_end_size == SizeLevel::Z {
|
||||
Self::set_attributes(
|
||||
llvm,
|
||||
declaration,
|
||||
vec![Attribute::OptimizeForSize, Attribute::MinSize],
|
||||
&[Attribute::OptimizeForSize, Attribute::MinSize],
|
||||
false,
|
||||
);
|
||||
}
|
||||
|
||||
Self::set_attributes(llvm, declaration, vec![Attribute::NoFree], false);
|
||||
Self::set_attributes(llvm, declaration, &[Attribute::NoFree], false);
|
||||
}
|
||||
|
||||
/// Sets the front-end runtime attributes.
|
||||
@@ -208,7 +187,7 @@ impl<'ctx> Function<'ctx> {
|
||||
optimizer: &Optimizer,
|
||||
) {
|
||||
if optimizer.settings().level_middle_end_size == SizeLevel::Z {
|
||||
Self::set_attributes(llvm, declaration, vec![Attribute::NoInline], false);
|
||||
Self::set_attributes(llvm, declaration, &[Attribute::NoInline], false);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -220,7 +199,7 @@ impl<'ctx> Function<'ctx> {
|
||||
Self::set_attributes(
|
||||
llvm,
|
||||
declaration,
|
||||
vec![
|
||||
&[
|
||||
Attribute::MustProgress,
|
||||
Attribute::NoUnwind,
|
||||
Attribute::WillReturn,
|
||||
|
||||
@@ -0,0 +1,269 @@
|
||||
//! 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 division operator according to the EVM specification.
|
||||
pub struct Division;
|
||||
|
||||
impl<D> RuntimeFunction<D> for Division
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = "__revive_division";
|
||||
|
||||
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();
|
||||
|
||||
wrapped_division(context, operand_2, || {
|
||||
Ok(context
|
||||
.builder()
|
||||
.build_int_unsigned_div(operand_1, operand_2, "DIV")?)
|
||||
})
|
||||
.map(Into::into)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for Division
|
||||
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 signed division operator according to the EVM specification.
|
||||
pub struct SignedDivision;
|
||||
|
||||
impl<D> RuntimeFunction<D> for SignedDivision
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = "__revive_signed_division";
|
||||
|
||||
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();
|
||||
|
||||
let block_calculate = context.append_basic_block("calculate");
|
||||
let block_overflow = context.append_basic_block("overflow");
|
||||
let block_select = context.append_basic_block("select_result");
|
||||
let block_origin = context.basic_block();
|
||||
context.builder().build_switch(
|
||||
operand_2,
|
||||
block_calculate,
|
||||
&[
|
||||
(context.word_type().const_zero(), block_select),
|
||||
(context.word_type().const_all_ones(), block_overflow),
|
||||
],
|
||||
)?;
|
||||
|
||||
context.set_basic_block(block_calculate);
|
||||
let quotient = context
|
||||
.builder()
|
||||
.build_int_signed_div(operand_1, operand_2, "SDIV")?;
|
||||
context.build_unconditional_branch(block_select);
|
||||
|
||||
context.set_basic_block(block_overflow);
|
||||
let max_uint = context.builder().build_int_z_extend(
|
||||
context
|
||||
.integer_type(revive_common::BIT_LENGTH_WORD - 1)
|
||||
.const_all_ones(),
|
||||
context.word_type(),
|
||||
"max_uint",
|
||||
)?;
|
||||
let is_operand_1_overflow = context.builder().build_int_compare(
|
||||
inkwell::IntPredicate::EQ,
|
||||
operand_1,
|
||||
context.builder().build_int_neg(max_uint, "min_uint")?,
|
||||
"is_operand_1_overflow",
|
||||
)?;
|
||||
context.build_conditional_branch(is_operand_1_overflow, block_select, block_calculate)?;
|
||||
|
||||
context.set_basic_block(block_select);
|
||||
let result = context.builder().build_phi(context.word_type(), "result")?;
|
||||
result.add_incoming(&[
|
||||
(&operand_1, block_overflow),
|
||||
(&context.word_const(0), block_origin),
|
||||
("ient.as_basic_value_enum(), block_calculate),
|
||||
]);
|
||||
Ok(Some(result.as_basic_value()))
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for SignedDivision
|
||||
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 remainder operator according to the EVM specification.
|
||||
pub struct Remainder;
|
||||
|
||||
impl<D> RuntimeFunction<D> for Remainder
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = "__revive_remainder";
|
||||
|
||||
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();
|
||||
|
||||
wrapped_division(context, operand_2, || {
|
||||
Ok(context
|
||||
.builder()
|
||||
.build_int_unsigned_rem(operand_1, operand_2, "MOD")?)
|
||||
})
|
||||
.map(Into::into)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for Remainder
|
||||
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 signed remainder operator according to the EVM specification.
|
||||
pub struct SignedRemainder;
|
||||
|
||||
impl<D> RuntimeFunction<D> for SignedRemainder
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = "__revive_signed_remainder";
|
||||
|
||||
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();
|
||||
|
||||
wrapped_division(context, operand_2, || {
|
||||
Ok(context
|
||||
.builder()
|
||||
.build_int_signed_rem(operand_1, operand_2, "SMOD")?)
|
||||
})
|
||||
.map(Into::into)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for SignedRemainder
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
/// Wrap division operations so that zero will be returned if the
|
||||
/// denominator is zero (see also Ethereum YP Appendix H.2).
|
||||
///
|
||||
/// The closure is expected to calculate and return the quotient.
|
||||
///
|
||||
/// The result is either the calculated quotient or zero,
|
||||
/// selected at runtime.
|
||||
fn wrapped_division<'ctx, D, F, T>(
|
||||
context: &Context<'ctx, D>,
|
||||
denominator: inkwell::values::IntValue<'ctx>,
|
||||
f: F,
|
||||
) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
F: FnOnce() -> anyhow::Result<T>,
|
||||
T: inkwell::values::IntMathValue<'ctx>,
|
||||
{
|
||||
assert_eq!(
|
||||
denominator.get_type().get_bit_width(),
|
||||
revive_common::BIT_LENGTH_WORD as u32
|
||||
);
|
||||
|
||||
let block_calculate = context.append_basic_block("calculate");
|
||||
let block_select = context.append_basic_block("select");
|
||||
let block_origin = context.basic_block();
|
||||
context.builder().build_switch(
|
||||
denominator,
|
||||
block_calculate,
|
||||
&[(context.word_const(0), block_select)],
|
||||
)?;
|
||||
|
||||
context.set_basic_block(block_calculate);
|
||||
let calculated_value = f()?.as_basic_value_enum();
|
||||
context.build_unconditional_branch(block_select);
|
||||
|
||||
context.set_basic_block(block_select);
|
||||
let result = context.builder().build_phi(context.word_type(), "result")?;
|
||||
result.add_incoming(&[
|
||||
(&context.word_const(0), block_origin),
|
||||
(&calculated_value, block_calculate),
|
||||
]);
|
||||
Ok(result.as_basic_value())
|
||||
}
|
||||
@@ -145,7 +145,7 @@ where
|
||||
crate::PolkaVMFunction::set_attributes(
|
||||
context.llvm(),
|
||||
entry,
|
||||
vec![crate::PolkaVMAttribute::NoReturn],
|
||||
&[crate::PolkaVMAttribute::NoReturn],
|
||||
true,
|
||||
);
|
||||
|
||||
|
||||
@@ -1,118 +0,0 @@
|
||||
//! The immutable data runtime function.
|
||||
|
||||
use crate::polkavm::context::address_space::AddressSpace;
|
||||
use crate::polkavm::context::function::runtime;
|
||||
use crate::polkavm::context::pointer::Pointer;
|
||||
use crate::polkavm::context::Context;
|
||||
use crate::polkavm::Dependency;
|
||||
use crate::polkavm::WriteLLVM;
|
||||
|
||||
/// A function for requesting the immutable data from the runtime.
|
||||
/// This is a special function that is only used by the front-end generated code.
|
||||
///
|
||||
/// The runtime API is called lazily and subsequent calls are no-ops.
|
||||
///
|
||||
/// The bytes written is asserted to match the expected length.
|
||||
/// This should never fail; the length is known.
|
||||
/// However, this is a one time assertion, hence worth it.
|
||||
#[derive(Debug)]
|
||||
pub struct ImmutableDataLoad;
|
||||
|
||||
impl<D> WriteLLVM<D> for ImmutableDataLoad
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
|
||||
context.add_function(
|
||||
runtime::FUNCTION_LOAD_IMMUTABLE_DATA,
|
||||
context.void_type().fn_type(Default::default(), false),
|
||||
0,
|
||||
Some(inkwell::module::Linkage::External),
|
||||
)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
|
||||
context.set_current_function(runtime::FUNCTION_LOAD_IMMUTABLE_DATA, None)?;
|
||||
context.set_basic_block(context.current_function().borrow().entry_block());
|
||||
|
||||
let immutable_data_size_pointer = context
|
||||
.get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE)?
|
||||
.value
|
||||
.as_pointer_value();
|
||||
let immutable_data_size = context.build_load(
|
||||
Pointer::new(
|
||||
context.xlen_type(),
|
||||
AddressSpace::Stack,
|
||||
immutable_data_size_pointer,
|
||||
),
|
||||
"immutable_data_size_load",
|
||||
)?;
|
||||
|
||||
let load_immutable_data_block = context.append_basic_block("load_immutables_block");
|
||||
let return_block = context.current_function().borrow().return_block();
|
||||
let immutable_data_size_is_zero = context.builder().build_int_compare(
|
||||
inkwell::IntPredicate::EQ,
|
||||
context.xlen_type().const_zero(),
|
||||
immutable_data_size.into_int_value(),
|
||||
"immutable_data_size_is_zero",
|
||||
)?;
|
||||
context.build_conditional_branch(
|
||||
immutable_data_size_is_zero,
|
||||
return_block,
|
||||
load_immutable_data_block,
|
||||
)?;
|
||||
|
||||
context.set_basic_block(load_immutable_data_block);
|
||||
let output_pointer = context
|
||||
.get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER)?
|
||||
.value
|
||||
.as_pointer_value();
|
||||
context.build_runtime_call(
|
||||
revive_runtime_api::polkavm_imports::GET_IMMUTABLE_DATA,
|
||||
&[
|
||||
context
|
||||
.builder()
|
||||
.build_ptr_to_int(output_pointer, context.xlen_type(), "ptr_to_xlen")?
|
||||
.into(),
|
||||
context
|
||||
.builder()
|
||||
.build_ptr_to_int(
|
||||
immutable_data_size_pointer,
|
||||
context.xlen_type(),
|
||||
"ptr_to_xlen",
|
||||
)?
|
||||
.into(),
|
||||
],
|
||||
);
|
||||
let bytes_written = context.builder().build_load(
|
||||
context.xlen_type(),
|
||||
immutable_data_size_pointer,
|
||||
"bytes_written",
|
||||
)?;
|
||||
context.builder().build_store(
|
||||
immutable_data_size_pointer,
|
||||
context.xlen_type().const_zero(),
|
||||
)?;
|
||||
let overflow_block = context.append_basic_block("immutable_data_overflow");
|
||||
let is_overflow = context.builder().build_int_compare(
|
||||
inkwell::IntPredicate::UGT,
|
||||
immutable_data_size.into_int_value(),
|
||||
bytes_written.into_int_value(),
|
||||
"is_overflow",
|
||||
)?;
|
||||
context.build_conditional_branch(is_overflow, overflow_block, return_block)?;
|
||||
|
||||
context.set_basic_block(overflow_block);
|
||||
context.build_call(context.intrinsics().trap, &[], "invalid_trap");
|
||||
context.build_unreachable();
|
||||
|
||||
context.set_basic_block(return_block);
|
||||
context.build_return(None);
|
||||
|
||||
context.pop_debug_scope();
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -1,8 +1,9 @@
|
||||
//! The front-end runtime functions.
|
||||
|
||||
pub mod arithmetics;
|
||||
pub mod deploy_code;
|
||||
pub mod entry;
|
||||
pub mod immutable_data_load;
|
||||
pub mod revive;
|
||||
pub mod runtime_code;
|
||||
|
||||
/// The main entry function name.
|
||||
@@ -13,6 +14,3 @@ pub const FUNCTION_DEPLOY_CODE: &str = "__deploy";
|
||||
|
||||
/// The runtime code function name.
|
||||
pub const FUNCTION_RUNTIME_CODE: &str = "__runtime";
|
||||
|
||||
/// The immutable data load function name.
|
||||
pub const FUNCTION_LOAD_IMMUTABLE_DATA: &str = "__immutable_data_load";
|
||||
|
||||
@@ -0,0 +1,147 @@
|
||||
//! The revive compiler runtime functions.
|
||||
|
||||
use inkwell::values::BasicValue;
|
||||
|
||||
use crate::polkavm::context::function::Attribute;
|
||||
use crate::polkavm::context::runtime::RuntimeFunction;
|
||||
use crate::polkavm::context::Context;
|
||||
use crate::polkavm::Dependency;
|
||||
use crate::polkavm::WriteLLVM;
|
||||
|
||||
/// Pointers are represented as opaque 256 bit integer values in EVM.
|
||||
/// In practice, they should never exceed a register sized bit value.
|
||||
/// However, we still protect against this possibility here: Heap index
|
||||
/// offsets are generally untrusted and potentially represent valid
|
||||
/// (but wrong) pointers when truncated.
|
||||
pub struct WordToPointer;
|
||||
|
||||
impl<D> RuntimeFunction<D> for WordToPointer
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = "__revive_int_truncate";
|
||||
|
||||
const ATTRIBUTES: &'static [Attribute] = &[
|
||||
Attribute::WillReturn,
|
||||
Attribute::NoFree,
|
||||
Attribute::AlwaysInline,
|
||||
];
|
||||
|
||||
fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
|
||||
context
|
||||
.xlen_type()
|
||||
.fn_type(&[context.word_type().into()], false)
|
||||
}
|
||||
|
||||
fn emit_body<'ctx>(
|
||||
&self,
|
||||
context: &mut Context<'ctx, D>,
|
||||
) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
|
||||
let value = Self::paramater(context, 0).into_int_value();
|
||||
let truncated =
|
||||
context
|
||||
.builder()
|
||||
.build_int_truncate(value, context.xlen_type(), "offset_truncated")?;
|
||||
let extended = context.builder().build_int_z_extend(
|
||||
truncated,
|
||||
context.word_type(),
|
||||
"offset_extended",
|
||||
)?;
|
||||
let is_overflow = context.builder().build_int_compare(
|
||||
inkwell::IntPredicate::NE,
|
||||
value,
|
||||
extended,
|
||||
"compare_truncated_extended",
|
||||
)?;
|
||||
|
||||
let block_continue = context.append_basic_block("offset_pointer_ok");
|
||||
let block_trap = context.append_basic_block("offset_pointer_overflow");
|
||||
context.build_conditional_branch(is_overflow, block_trap, block_continue)?;
|
||||
|
||||
context.set_basic_block(block_trap);
|
||||
context.build_call(context.intrinsics().trap, &[], "invalid_trap");
|
||||
context.build_unreachable();
|
||||
|
||||
context.set_basic_block(block_continue);
|
||||
Ok(Some(truncated.as_basic_value_enum()))
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for WordToPointer
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
/// The revive runtime exit function.
|
||||
pub struct Exit;
|
||||
|
||||
impl<D> RuntimeFunction<D> for Exit
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = "__revive_exit";
|
||||
|
||||
const ATTRIBUTES: &'static [Attribute] = &[
|
||||
Attribute::NoReturn,
|
||||
Attribute::NoFree,
|
||||
Attribute::AlwaysInline,
|
||||
];
|
||||
|
||||
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(),
|
||||
context.word_type().into(),
|
||||
],
|
||||
false,
|
||||
)
|
||||
}
|
||||
|
||||
fn emit_body<'ctx>(
|
||||
&self,
|
||||
context: &mut Context<'ctx, D>,
|
||||
) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
|
||||
let flags = Self::paramater(context, 0).into_int_value();
|
||||
let offset = Self::paramater(context, 1).into_int_value();
|
||||
let length = Self::paramater(context, 2).into_int_value();
|
||||
|
||||
let offset_truncated = context.safe_truncate_int_to_xlen(offset)?;
|
||||
let length_truncated = context.safe_truncate_int_to_xlen(length)?;
|
||||
let heap_pointer = context.build_heap_gep(offset_truncated, length_truncated)?;
|
||||
let offset_pointer = context.builder().build_ptr_to_int(
|
||||
heap_pointer.value,
|
||||
context.xlen_type(),
|
||||
"return_data_ptr_to_int",
|
||||
)?;
|
||||
|
||||
context.build_runtime_call(
|
||||
revive_runtime_api::polkavm_imports::RETURN,
|
||||
&[flags.into(), offset_pointer.into(), length_truncated.into()],
|
||||
);
|
||||
context.build_unreachable();
|
||||
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for Exit
|
||||
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)
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@ pub mod function;
|
||||
pub mod global;
|
||||
pub mod r#loop;
|
||||
pub mod pointer;
|
||||
pub mod runtime;
|
||||
pub mod solidity_data;
|
||||
pub mod yul_data;
|
||||
|
||||
@@ -31,6 +32,8 @@ use crate::polkavm::DebugConfig;
|
||||
use crate::polkavm::Dependency;
|
||||
use crate::target_machine::target::Target;
|
||||
use crate::target_machine::TargetMachine;
|
||||
use crate::PolkaVMLoadHeapWordFunction;
|
||||
use crate::PolkaVMStoreHeapWordFunction;
|
||||
|
||||
use self::address_space::AddressSpace;
|
||||
use self::attribute::Attribute;
|
||||
@@ -41,10 +44,13 @@ use self::function::declaration::Declaration as FunctionDeclaration;
|
||||
use self::function::intrinsics::Intrinsics;
|
||||
use self::function::llvm_runtime::LLVMRuntime;
|
||||
use self::function::r#return::Return as FunctionReturn;
|
||||
use self::function::runtime::revive::Exit;
|
||||
use self::function::runtime::revive::WordToPointer;
|
||||
use self::function::Function;
|
||||
use self::global::Global;
|
||||
use self::pointer::Pointer;
|
||||
use self::r#loop::Loop;
|
||||
use self::runtime::RuntimeFunction;
|
||||
use self::solidity_data::SolidityData;
|
||||
use self::yul_data::YulData;
|
||||
|
||||
@@ -77,6 +83,8 @@ where
|
||||
current_function: Option<Rc<RefCell<Function<'ctx>>>>,
|
||||
/// The loop context stack.
|
||||
loop_stack: Vec<Loop<'ctx>>,
|
||||
/// The extra LLVM arguments that were used during target initialization.
|
||||
llvm_arguments: &'ctx [String],
|
||||
|
||||
/// The project dependency manager. It can be any entity implementing the trait.
|
||||
/// The manager is used to get information about contracts and their dependencies during
|
||||
@@ -217,6 +225,7 @@ where
|
||||
dependency_manager: Option<D>,
|
||||
include_metadata_hash: bool,
|
||||
debug_config: DebugConfig,
|
||||
llvm_arguments: &'ctx [String],
|
||||
) -> Self {
|
||||
Self::set_data_layout(llvm, &module);
|
||||
Self::link_stdlib_module(llvm, &module);
|
||||
@@ -244,6 +253,7 @@ where
|
||||
functions: HashMap::with_capacity(Self::FUNCTIONS_HASHMAP_INITIAL_CAPACITY),
|
||||
current_function: None,
|
||||
loop_stack: Vec::with_capacity(Self::LOOP_STACK_INITIAL_CAPACITY),
|
||||
llvm_arguments,
|
||||
|
||||
dependency_manager,
|
||||
include_metadata_hash,
|
||||
@@ -633,6 +643,7 @@ where
|
||||
self.optimizer.settings().to_owned(),
|
||||
self.include_metadata_hash,
|
||||
self.debug_config.clone(),
|
||||
self.llvm_arguments,
|
||||
)
|
||||
})
|
||||
}
|
||||
@@ -721,6 +732,7 @@ where
|
||||
name: &str,
|
||||
) -> Pointer<'ctx> {
|
||||
let pointer = self.builder.build_alloca(r#type, name).unwrap();
|
||||
|
||||
pointer
|
||||
.as_instruction()
|
||||
.unwrap()
|
||||
@@ -768,60 +780,18 @@ where
|
||||
) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>> {
|
||||
match pointer.address_space {
|
||||
AddressSpace::Heap => {
|
||||
let heap_pointer = self.build_heap_gep(
|
||||
self.builder().build_ptr_to_int(
|
||||
pointer.value,
|
||||
self.xlen_type(),
|
||||
"offset_ptrtoint",
|
||||
)?,
|
||||
pointer
|
||||
.r#type
|
||||
.size_of()
|
||||
.expect("should be IntValue")
|
||||
.const_truncate(self.xlen_type()),
|
||||
)?;
|
||||
|
||||
let value = self
|
||||
let name = <PolkaVMLoadHeapWordFunction as RuntimeFunction<D>>::NAME;
|
||||
let declaration =
|
||||
<PolkaVMLoadHeapWordFunction as RuntimeFunction<D>>::declaration(self);
|
||||
let arguments = [self
|
||||
.builder()
|
||||
.build_load(pointer.r#type, heap_pointer.value, name)?;
|
||||
self.basic_block()
|
||||
.get_last_instruction()
|
||||
.expect("Always exists")
|
||||
.set_alignment(revive_common::BYTE_LENGTH_BYTE as u32)
|
||||
.expect("Alignment is valid");
|
||||
|
||||
self.build_byte_swap(value)
|
||||
}
|
||||
AddressSpace::Storage | AddressSpace::TransientStorage => {
|
||||
let storage_value_pointer =
|
||||
self.build_alloca(self.word_type(), "storage_value_pointer");
|
||||
self.build_store(storage_value_pointer, self.word_const(0))?;
|
||||
|
||||
let storage_value_length_pointer =
|
||||
self.build_alloca(self.xlen_type(), "storage_value_length_pointer");
|
||||
self.build_store(
|
||||
storage_value_length_pointer,
|
||||
self.word_const(revive_common::BIT_LENGTH_WORD as u64),
|
||||
)?;
|
||||
|
||||
let transient = pointer.address_space == AddressSpace::TransientStorage;
|
||||
|
||||
self.build_runtime_call(
|
||||
revive_runtime_api::polkavm_imports::GET_STORAGE,
|
||||
&[
|
||||
self.xlen_type().const_int(transient as u64, false).into(),
|
||||
pointer.to_int(self).into(),
|
||||
self.xlen_type().const_all_ones().into(),
|
||||
storage_value_pointer.to_int(self).into(),
|
||||
storage_value_length_pointer.to_int(self).into(),
|
||||
],
|
||||
);
|
||||
|
||||
// We do not to check the return value.
|
||||
// Solidity assumes infallible SLOAD.
|
||||
// If a key doesn't exist the "zero" value is returned.
|
||||
|
||||
self.build_load(storage_value_pointer, "storage_value_load")
|
||||
.build_ptr_to_int(pointer.value, self.xlen_type(), "offset_ptrtoint")?
|
||||
.as_basic_value_enum()];
|
||||
Ok(self
|
||||
.build_call(declaration, &arguments, "heap_load")
|
||||
.unwrap_or_else(|| {
|
||||
panic!("revive runtime function {name} should return a value")
|
||||
}))
|
||||
}
|
||||
AddressSpace::Stack => {
|
||||
let value = self
|
||||
@@ -847,60 +817,13 @@ where
|
||||
{
|
||||
match pointer.address_space {
|
||||
AddressSpace::Heap => {
|
||||
let heap_pointer = self.build_heap_gep(
|
||||
self.builder().build_ptr_to_int(
|
||||
pointer.value,
|
||||
self.xlen_type(),
|
||||
"offset_ptrtoint",
|
||||
)?,
|
||||
value
|
||||
.as_basic_value_enum()
|
||||
.get_type()
|
||||
.size_of()
|
||||
.expect("should be IntValue")
|
||||
.const_truncate(self.xlen_type()),
|
||||
)?;
|
||||
|
||||
let value = value.as_basic_value_enum();
|
||||
let value = match value.get_type().into_int_type().get_bit_width() as usize {
|
||||
revive_common::BIT_LENGTH_WORD => self.build_byte_swap(value)?,
|
||||
revive_common::BIT_LENGTH_BYTE => value,
|
||||
_ => unreachable!("Only word and byte sized values can be stored on EVM heap"),
|
||||
};
|
||||
|
||||
self.builder
|
||||
.build_store(heap_pointer.value, value)?
|
||||
.set_alignment(revive_common::BYTE_LENGTH_BYTE as u32)
|
||||
.expect("Alignment is valid");
|
||||
}
|
||||
AddressSpace::Storage | AddressSpace::TransientStorage => {
|
||||
assert_eq!(
|
||||
value.as_basic_value_enum().get_type(),
|
||||
self.word_type().as_basic_type_enum()
|
||||
);
|
||||
|
||||
let storage_value_pointer = self.build_alloca(self.word_type(), "storage_value");
|
||||
let storage_value_pointer_casted = self.builder().build_ptr_to_int(
|
||||
storage_value_pointer.value,
|
||||
self.xlen_type(),
|
||||
"storage_value_pointer_casted",
|
||||
)?;
|
||||
|
||||
self.builder()
|
||||
.build_store(storage_value_pointer.value, value)?;
|
||||
|
||||
let transient = pointer.address_space == AddressSpace::TransientStorage;
|
||||
|
||||
self.build_runtime_call(
|
||||
revive_runtime_api::polkavm_imports::SET_STORAGE,
|
||||
&[
|
||||
self.xlen_type().const_int(transient as u64, false).into(),
|
||||
pointer.to_int(self).into(),
|
||||
self.xlen_type().const_all_ones().into(),
|
||||
storage_value_pointer_casted.into(),
|
||||
self.integer_const(crate::polkavm::XLEN, 32).into(),
|
||||
],
|
||||
);
|
||||
let declaration =
|
||||
<PolkaVMStoreHeapWordFunction as RuntimeFunction<D>>::declaration(self);
|
||||
let arguments = [
|
||||
pointer.to_int(self).as_basic_value_enum(),
|
||||
value.as_basic_value_enum(),
|
||||
];
|
||||
self.build_call(declaration, &arguments, "heap_store");
|
||||
}
|
||||
AddressSpace::Stack => {
|
||||
let instruction = self.builder.build_store(pointer.value, value).unwrap();
|
||||
@@ -946,9 +869,6 @@ where
|
||||
where
|
||||
T: BasicType<'ctx>,
|
||||
{
|
||||
assert_ne!(pointer.address_space, AddressSpace::Storage);
|
||||
assert_ne!(pointer.address_space, AddressSpace::TransientStorage);
|
||||
|
||||
let value = unsafe {
|
||||
self.builder
|
||||
.build_gep(pointer.r#type, pointer.value, indexes, name)
|
||||
@@ -1115,38 +1035,16 @@ where
|
||||
offset: inkwell::values::IntValue<'ctx>,
|
||||
length: inkwell::values::IntValue<'ctx>,
|
||||
) -> anyhow::Result<()> {
|
||||
let offset_truncated = self.safe_truncate_int_to_xlen(offset)?;
|
||||
let length_truncated = self.safe_truncate_int_to_xlen(length)?;
|
||||
let offset_into_heap = self.build_heap_gep(offset_truncated, length_truncated)?;
|
||||
|
||||
let length_pointer = self.safe_truncate_int_to_xlen(length)?;
|
||||
let offset_pointer = self.builder().build_ptr_to_int(
|
||||
offset_into_heap.value,
|
||||
self.xlen_type(),
|
||||
"return_data_ptr_to_int",
|
||||
)?;
|
||||
|
||||
self.build_runtime_call(
|
||||
revive_runtime_api::polkavm_imports::RETURN,
|
||||
&[flags.into(), offset_pointer.into(), length_pointer.into()],
|
||||
self.build_call(
|
||||
<Exit as RuntimeFunction<D>>::declaration(self),
|
||||
&[flags.into(), offset.into(), length.into()],
|
||||
"exit",
|
||||
);
|
||||
self.build_unreachable();
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Truncate a memory offset to register size, trapping if it doesn't fit.
|
||||
/// Pointers are represented as opaque 256 bit integer values in EVM.
|
||||
/// In practice, they should never exceed a register sized bit value.
|
||||
/// However, we still protect against this possibility here. Heap index
|
||||
/// offsets are generally untrusted and potentially represent valid
|
||||
/// (but wrong) pointers when truncated.
|
||||
///
|
||||
/// TODO: Splitting up into a dedicated function
|
||||
/// could potentially decrease code sizes (LLVM can still decide to inline).
|
||||
/// However, passing i256 parameters is counter productive and
|
||||
/// I've found that splitting it up actualy increases code size.
|
||||
/// Should be reviewed after 64bit support.
|
||||
pub fn safe_truncate_int_to_xlen(
|
||||
&self,
|
||||
value: inkwell::values::IntValue<'ctx>,
|
||||
@@ -1160,29 +1058,19 @@ where
|
||||
"expected XLEN or WORD sized int type for memory offset",
|
||||
);
|
||||
|
||||
let truncated =
|
||||
self.builder()
|
||||
.build_int_truncate(value, self.xlen_type(), "offset_truncated")?;
|
||||
let extended =
|
||||
self.builder()
|
||||
.build_int_z_extend(truncated, self.word_type(), "offset_extended")?;
|
||||
let is_overflow = self.builder().build_int_compare(
|
||||
inkwell::IntPredicate::NE,
|
||||
value,
|
||||
extended,
|
||||
"compare_truncated_extended",
|
||||
)?;
|
||||
|
||||
let block_continue = self.append_basic_block("offset_pointer_ok");
|
||||
let block_trap = self.append_basic_block("offset_pointer_overflow");
|
||||
self.build_conditional_branch(is_overflow, block_trap, block_continue)?;
|
||||
|
||||
self.set_basic_block(block_trap);
|
||||
self.build_call(self.intrinsics().trap, &[], "invalid_trap");
|
||||
self.build_unreachable();
|
||||
|
||||
self.set_basic_block(block_continue);
|
||||
Ok(truncated)
|
||||
Ok(self
|
||||
.build_call(
|
||||
<WordToPointer as RuntimeFunction<D>>::declaration(self),
|
||||
&[value.into()],
|
||||
"word_to_pointer",
|
||||
)
|
||||
.unwrap_or_else(|| {
|
||||
panic!(
|
||||
"revive runtime function {} should return a value",
|
||||
<WordToPointer as RuntimeFunction<D>>::NAME,
|
||||
)
|
||||
})
|
||||
.into_int_value())
|
||||
}
|
||||
|
||||
/// Build a call to PolkaVM `sbrk` for extending the heap from offset by `size`.
|
||||
@@ -1222,34 +1110,6 @@ where
|
||||
Ok(memory_size_value.into_int_value())
|
||||
}
|
||||
|
||||
/// Call PolkaVM `sbrk` for extending the heap by `offset` + `size`,
|
||||
/// trapping the contract if the call failed.
|
||||
pub fn build_heap_alloc(
|
||||
&self,
|
||||
offset: inkwell::values::IntValue<'ctx>,
|
||||
size: inkwell::values::IntValue<'ctx>,
|
||||
) -> anyhow::Result<()> {
|
||||
let end_of_memory = self.build_sbrk(offset, size)?;
|
||||
let return_is_nil = self.builder().build_int_compare(
|
||||
inkwell::IntPredicate::EQ,
|
||||
end_of_memory,
|
||||
self.llvm().ptr_type(Default::default()).const_null(),
|
||||
"compare_end_of_memory_nil",
|
||||
)?;
|
||||
|
||||
let continue_block = self.append_basic_block("sbrk_not_nil");
|
||||
let trap_block = self.append_basic_block("sbrk_nil");
|
||||
self.build_conditional_branch(return_is_nil, trap_block, continue_block)?;
|
||||
|
||||
self.set_basic_block(trap_block);
|
||||
self.build_call(self.intrinsics().trap, &[], "invalid_trap");
|
||||
self.build_unreachable();
|
||||
|
||||
self.set_basic_block(continue_block);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Returns a pointer to `offset` into the heap, allocating
|
||||
/// enough memory if `offset + length` would be out of bounds.
|
||||
/// # Panics
|
||||
@@ -1262,19 +1122,8 @@ where
|
||||
assert_eq!(offset.get_type(), self.xlen_type());
|
||||
assert_eq!(length.get_type(), self.xlen_type());
|
||||
|
||||
self.build_heap_alloc(offset, length)?;
|
||||
|
||||
let heap_start = self
|
||||
.module()
|
||||
.get_global(revive_runtime_api::polkavm_imports::MEMORY)
|
||||
.expect("the memory symbol should have been declared")
|
||||
.as_pointer_value();
|
||||
Ok(self.build_gep(
|
||||
Pointer::new(self.byte_type(), AddressSpace::Stack, heap_start),
|
||||
&[offset],
|
||||
self.byte_type(),
|
||||
"heap_offset_via_gep",
|
||||
))
|
||||
let pointer = self.build_sbrk(offset, length)?;
|
||||
Ok(Pointer::new(self.byte_type(), AddressSpace::Stack, pointer))
|
||||
}
|
||||
|
||||
/// Returns a boolean type constant.
|
||||
@@ -1445,13 +1294,6 @@ where
|
||||
inkwell::attributes::AttributeLoc::Param(index as u32),
|
||||
self.llvm.create_enum_attribute(Attribute::NoFree as u32, 0),
|
||||
);
|
||||
if function == self.llvm_runtime().sha3 {
|
||||
call_site_value.add_attribute(
|
||||
inkwell::attributes::AttributeLoc::Param(index as u32),
|
||||
self.llvm
|
||||
.create_enum_attribute(Attribute::ReadOnly as u32, 0),
|
||||
);
|
||||
}
|
||||
if Some(argument.get_type()) == function.r#type.get_return_type() {
|
||||
if function
|
||||
.r#type
|
||||
@@ -1580,4 +1422,8 @@ where
|
||||
anyhow::bail!("The immutable size data is not available");
|
||||
}
|
||||
}
|
||||
|
||||
pub fn optimizer_settings(&self) -> &OptimizerSettings {
|
||||
self.optimizer.settings()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,110 @@
|
||||
//! The revive simulated EVM linear memory pointer 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 LoadWord;
|
||||
|
||||
impl<D> RuntimeFunction<D> for LoadWord
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = "__revive_load_heap_word";
|
||||
|
||||
fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
|
||||
context
|
||||
.word_type()
|
||||
.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)
|
||||
}
|
||||
}
|
||||
+3
@@ -7,6 +7,9 @@ use crate::polkavm::context::global::Global;
|
||||
use crate::polkavm::context::Context;
|
||||
use crate::polkavm::Dependency;
|
||||
|
||||
pub mod heap;
|
||||
pub mod storage;
|
||||
|
||||
/// The LLVM pointer.
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct Pointer<'ctx> {
|
||||
@@ -0,0 +1,247 @@
|
||||
//! The revive storage pointer 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 storage pointer.
|
||||
pub struct LoadWord;
|
||||
|
||||
impl<D> RuntimeFunction<D> for LoadWord
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = "__revive_load_storage_word";
|
||||
|
||||
fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
|
||||
context
|
||||
.word_type()
|
||||
.fn_type(&[context.word_type().into()], false)
|
||||
}
|
||||
|
||||
fn emit_body<'ctx>(
|
||||
&self,
|
||||
context: &mut Context<'ctx, D>,
|
||||
) -> anyhow::Result<Option<BasicValueEnum<'ctx>>> {
|
||||
Ok(Some(emit_load(
|
||||
context,
|
||||
Self::paramater(context, 0),
|
||||
false,
|
||||
)?))
|
||||
}
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
/// Load a word size value from a transient storage pointer.
|
||||
pub struct LoadTransientWord;
|
||||
|
||||
impl<D> RuntimeFunction<D> for LoadTransientWord
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = "__revive_load_transient_storage_word";
|
||||
|
||||
fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
|
||||
context
|
||||
.word_type()
|
||||
.fn_type(&[context.word_type().into()], false)
|
||||
}
|
||||
|
||||
fn emit_body<'ctx>(
|
||||
&self,
|
||||
context: &mut Context<'ctx, D>,
|
||||
) -> anyhow::Result<Option<BasicValueEnum<'ctx>>> {
|
||||
Ok(Some(emit_load(context, Self::paramater(context, 0), true)?))
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for LoadTransientWord
|
||||
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 storage pointer.
|
||||
pub struct StoreWord;
|
||||
|
||||
impl<D> RuntimeFunction<D> for StoreWord
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = "__revive_store_storage_word";
|
||||
|
||||
fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
|
||||
context.void_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<BasicValueEnum<'ctx>>> {
|
||||
emit_store(
|
||||
context,
|
||||
Self::paramater(context, 0),
|
||||
Self::paramater(context, 1),
|
||||
false,
|
||||
)?;
|
||||
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
/// Store a word size value through a transient storage pointer.
|
||||
pub struct StoreTransientWord;
|
||||
|
||||
impl<D> RuntimeFunction<D> for StoreTransientWord
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = "__revive_store_transient_storage_word";
|
||||
|
||||
fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
|
||||
context.void_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<BasicValueEnum<'ctx>>> {
|
||||
emit_store(
|
||||
context,
|
||||
Self::paramater(context, 0),
|
||||
Self::paramater(context, 1),
|
||||
true,
|
||||
)?;
|
||||
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for StoreTransientWord
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_load<'ctx, D: Dependency + Clone>(
|
||||
context: &mut Context<'ctx, D>,
|
||||
mut key: BasicValueEnum<'ctx>,
|
||||
transient: bool,
|
||||
) -> anyhow::Result<BasicValueEnum<'ctx>> {
|
||||
if !transient {
|
||||
key = context.build_byte_swap(key)?;
|
||||
}
|
||||
|
||||
let key_pointer = context.build_alloca_at_entry(context.word_type(), "key_pointer");
|
||||
let value_pointer = context.build_alloca_at_entry(context.word_type(), "value_pointer");
|
||||
let length_pointer = context.build_alloca_at_entry(context.xlen_type(), "length_pointer");
|
||||
|
||||
context.builder().build_store(key_pointer.value, key)?;
|
||||
context.build_store(value_pointer, context.word_const(0))?;
|
||||
context.build_store(
|
||||
length_pointer,
|
||||
context
|
||||
.xlen_type()
|
||||
.const_int(revive_common::BYTE_LENGTH_WORD as u64, false),
|
||||
)?;
|
||||
|
||||
let is_transient = context.xlen_type().const_int(transient as u64, false);
|
||||
|
||||
let arguments = [
|
||||
is_transient.into(),
|
||||
key_pointer.to_int(context).into(),
|
||||
context.xlen_type().const_all_ones().into(),
|
||||
value_pointer.to_int(context).into(),
|
||||
length_pointer.to_int(context).into(),
|
||||
];
|
||||
context.build_runtime_call(revive_runtime_api::polkavm_imports::GET_STORAGE, &arguments);
|
||||
|
||||
// We do not to check the return value: Solidity assumes infallible loads.
|
||||
// If a key doesn't exist the "zero" value is returned (ensured by above write).
|
||||
|
||||
let value = context.build_load(value_pointer, "storage_value")?;
|
||||
Ok(if transient {
|
||||
value
|
||||
} else {
|
||||
context.build_byte_swap(value)?
|
||||
})
|
||||
}
|
||||
|
||||
fn emit_store<'ctx, D: Dependency + Clone>(
|
||||
context: &mut Context<'ctx, D>,
|
||||
mut key: BasicValueEnum<'ctx>,
|
||||
mut value: BasicValueEnum<'ctx>,
|
||||
transient: bool,
|
||||
) -> anyhow::Result<()> {
|
||||
if !transient {
|
||||
key = context.build_byte_swap(key)?;
|
||||
value = context.build_byte_swap(value)?;
|
||||
}
|
||||
|
||||
let key_pointer = context.build_alloca_at_entry(context.word_type(), "key_pointer");
|
||||
let value_pointer = context.build_alloca_at_entry(context.word_type(), "value_pointer");
|
||||
|
||||
context.build_store(key_pointer, key)?;
|
||||
context.build_store(value_pointer, value)?;
|
||||
|
||||
let is_transient = context.xlen_type().const_int(transient as u64, false);
|
||||
|
||||
let arguments = [
|
||||
is_transient.into(),
|
||||
key_pointer.to_int(context).into(),
|
||||
context.xlen_type().const_all_ones().into(),
|
||||
value_pointer.to_int(context).into(),
|
||||
context.integer_const(crate::polkavm::XLEN, 32).into(),
|
||||
];
|
||||
context.build_runtime_call(revive_runtime_api::polkavm_imports::SET_STORAGE, &arguments);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
//! The revive compiler runtime function interface definition.
|
||||
//!
|
||||
//! Common routines should not be inlined but extracted into smaller functions.
|
||||
//! This benefits contract code size.
|
||||
|
||||
use crate::optimizer::settings::size_level::SizeLevel;
|
||||
use crate::polkavm::context::function::declaration::Declaration;
|
||||
use crate::polkavm::context::function::Function;
|
||||
use crate::polkavm::context::Attribute;
|
||||
use crate::polkavm::context::Context;
|
||||
use crate::polkavm::Dependency;
|
||||
|
||||
/// The revive runtime function interface simplifies declaring runtime functions
|
||||
/// and code emitting by providing helpful default implementations.
|
||||
pub trait RuntimeFunction<D>
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
/// The function name.
|
||||
const NAME: &'static str;
|
||||
|
||||
const ATTRIBUTES: &'static [Attribute] = &[
|
||||
Attribute::NoFree,
|
||||
Attribute::NoRecurse,
|
||||
Attribute::WillReturn,
|
||||
];
|
||||
|
||||
/// The function type.
|
||||
fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx>;
|
||||
|
||||
/// Declare the function.
|
||||
fn declare(&self, context: &mut Context<D>) -> anyhow::Result<()> {
|
||||
let function = context.add_function(
|
||||
Self::NAME,
|
||||
Self::r#type(context),
|
||||
0,
|
||||
Some(inkwell::module::Linkage::External),
|
||||
)?;
|
||||
|
||||
let mut attributes = Self::ATTRIBUTES.to_vec();
|
||||
attributes.extend_from_slice(match context.optimizer_settings().level_middle_end_size {
|
||||
SizeLevel::Zero => &[],
|
||||
_ => &[Attribute::OptimizeForSize, Attribute::MinSize],
|
||||
});
|
||||
Function::set_attributes(
|
||||
context.llvm(),
|
||||
function.borrow().declaration(),
|
||||
&attributes,
|
||||
true,
|
||||
);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Get the function declaration.
|
||||
fn declaration<'ctx>(context: &Context<'ctx, D>) -> Declaration<'ctx> {
|
||||
context
|
||||
.get_function(Self::NAME)
|
||||
.unwrap_or_else(|| panic!("runtime function {} should be declared", Self::NAME))
|
||||
.borrow()
|
||||
.declaration()
|
||||
}
|
||||
|
||||
/// Emit the function.
|
||||
fn emit(&self, context: &mut Context<D>) -> anyhow::Result<()> {
|
||||
context.set_current_function(Self::NAME, None)?;
|
||||
context.set_basic_block(context.current_function().borrow().entry_block());
|
||||
|
||||
let return_value = self.emit_body(context)?;
|
||||
self.emit_epilogue(context, return_value);
|
||||
|
||||
context.pop_debug_scope();
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Emit the function body.
|
||||
fn emit_body<'ctx>(
|
||||
&self,
|
||||
context: &mut Context<'ctx, D>,
|
||||
) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>>;
|
||||
|
||||
/// Emit the function return instructions.
|
||||
fn emit_epilogue<'ctx>(
|
||||
&self,
|
||||
context: &mut Context<'ctx, D>,
|
||||
return_value: Option<inkwell::values::BasicValueEnum<'ctx>>,
|
||||
) {
|
||||
let return_block = context.current_function().borrow().return_block();
|
||||
context.build_unconditional_branch(return_block);
|
||||
context.set_basic_block(return_block);
|
||||
match return_value {
|
||||
Some(value) => context.build_return(Some(&value)),
|
||||
None => context.build_return(None),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the nth function paramater.
|
||||
fn paramater<'ctx>(
|
||||
context: &Context<'ctx, D>,
|
||||
index: usize,
|
||||
) -> inkwell::values::BasicValueEnum<'ctx> {
|
||||
let name = Self::NAME;
|
||||
context
|
||||
.get_function(name)
|
||||
.unwrap_or_else(|| panic!("runtime function {name} should be declared"))
|
||||
.borrow()
|
||||
.declaration()
|
||||
.function_value()
|
||||
.get_nth_param(index as u32)
|
||||
.unwrap_or_else(|| panic!("runtime function {name} should have parameter #{index}"))
|
||||
}
|
||||
}
|
||||
@@ -10,12 +10,20 @@ pub fn create_context(
|
||||
llvm: &inkwell::context::Context,
|
||||
optimizer_settings: OptimizerSettings,
|
||||
) -> Context<DummyDependency> {
|
||||
crate::polkavm::initialize_target();
|
||||
crate::initialize_llvm(crate::Target::PVM, "resolc", Default::default());
|
||||
|
||||
let module = llvm.create_module("test");
|
||||
let optimizer = Optimizer::new(optimizer_settings);
|
||||
|
||||
Context::<DummyDependency>::new(llvm, module, optimizer, None, true, Default::default())
|
||||
Context::<DummyDependency>::new(
|
||||
llvm,
|
||||
module,
|
||||
optimizer,
|
||||
None,
|
||||
true,
|
||||
Default::default(),
|
||||
Default::default(),
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -2,8 +2,13 @@
|
||||
|
||||
use inkwell::values::BasicValue;
|
||||
|
||||
use crate::polkavm::context::runtime::RuntimeFunction;
|
||||
use crate::polkavm::context::Context;
|
||||
use crate::polkavm::Dependency;
|
||||
use crate::PolkaVMDivisionFunction;
|
||||
use crate::PolkaVMRemainderFunction;
|
||||
use crate::PolkaVMSignedDivisionFunction;
|
||||
use crate::PolkaVMSignedRemainderFunction;
|
||||
|
||||
/// Translates the arithmetic addition.
|
||||
pub fn addition<'ctx, D>(
|
||||
@@ -59,11 +64,11 @@ pub fn division<'ctx, D>(
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
wrapped_division(context, operand_2, || {
|
||||
Ok(context
|
||||
.builder()
|
||||
.build_int_unsigned_div(operand_1, operand_2, "DIV")?)
|
||||
})
|
||||
let name = <PolkaVMDivisionFunction as RuntimeFunction<D>>::NAME;
|
||||
let declaration = <PolkaVMDivisionFunction as RuntimeFunction<D>>::declaration(context);
|
||||
Ok(context
|
||||
.build_call(declaration, &[operand_1.into(), operand_2.into()], "div")
|
||||
.unwrap_or_else(|| panic!("revive runtime function {name} should return a value",)))
|
||||
}
|
||||
|
||||
/// Translates the arithmetic remainder.
|
||||
@@ -75,11 +80,11 @@ pub fn remainder<'ctx, D>(
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
wrapped_division(context, operand_2, || {
|
||||
Ok(context
|
||||
.builder()
|
||||
.build_int_unsigned_rem(operand_1, operand_2, "MOD")?)
|
||||
})
|
||||
let name = <PolkaVMRemainderFunction as RuntimeFunction<D>>::NAME;
|
||||
let declaration = <PolkaVMRemainderFunction as RuntimeFunction<D>>::declaration(context);
|
||||
Ok(context
|
||||
.build_call(declaration, &[operand_1.into(), operand_2.into()], "rem")
|
||||
.unwrap_or_else(|| panic!("revive runtime function {name} should return a value",)))
|
||||
}
|
||||
|
||||
/// Translates the signed arithmetic division.
|
||||
@@ -94,54 +99,11 @@ pub fn division_signed<'ctx, D>(
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
assert_eq!(
|
||||
operand_2.get_type().get_bit_width(),
|
||||
revive_common::BIT_LENGTH_WORD as u32
|
||||
);
|
||||
|
||||
let block_calculate = context.append_basic_block("calculate");
|
||||
let block_overflow = context.append_basic_block("overflow");
|
||||
let block_select = context.append_basic_block("select_result");
|
||||
let block_origin = context.basic_block();
|
||||
context.builder().build_switch(
|
||||
operand_2,
|
||||
block_calculate,
|
||||
&[
|
||||
(context.word_type().const_zero(), block_select),
|
||||
(context.word_type().const_all_ones(), block_overflow),
|
||||
],
|
||||
)?;
|
||||
|
||||
context.set_basic_block(block_calculate);
|
||||
let quotient = context
|
||||
.builder()
|
||||
.build_int_signed_div(operand_1, operand_2, "SDIV")?;
|
||||
context.build_unconditional_branch(block_select);
|
||||
|
||||
context.set_basic_block(block_overflow);
|
||||
let max_uint = context.builder().build_int_z_extend(
|
||||
context
|
||||
.integer_type(revive_common::BIT_LENGTH_WORD - 1)
|
||||
.const_all_ones(),
|
||||
context.word_type(),
|
||||
"max_uint",
|
||||
)?;
|
||||
let is_operand_1_overflow = context.builder().build_int_compare(
|
||||
inkwell::IntPredicate::EQ,
|
||||
operand_1,
|
||||
context.builder().build_int_neg(max_uint, "min_uint")?,
|
||||
"is_operand_1_overflow",
|
||||
)?;
|
||||
context.build_conditional_branch(is_operand_1_overflow, block_select, block_calculate)?;
|
||||
|
||||
context.set_basic_block(block_select);
|
||||
let result = context.builder().build_phi(context.word_type(), "result")?;
|
||||
result.add_incoming(&[
|
||||
(&operand_1, block_overflow),
|
||||
(&context.word_const(0), block_origin),
|
||||
("ient.as_basic_value_enum(), block_calculate),
|
||||
]);
|
||||
Ok(result.as_basic_value())
|
||||
let name = <PolkaVMSignedDivisionFunction as RuntimeFunction<D>>::NAME;
|
||||
let declaration = <PolkaVMSignedDivisionFunction as RuntimeFunction<D>>::declaration(context);
|
||||
Ok(context
|
||||
.build_call(declaration, &[operand_1.into(), operand_2.into()], "sdiv")
|
||||
.unwrap_or_else(|| panic!("revive runtime function {name} should return a value",)))
|
||||
}
|
||||
|
||||
/// Translates the signed arithmetic remainder.
|
||||
@@ -153,53 +115,9 @@ pub fn remainder_signed<'ctx, D>(
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
wrapped_division(context, operand_2, || {
|
||||
Ok(context
|
||||
.builder()
|
||||
.build_int_signed_rem(operand_1, operand_2, "SMOD")?)
|
||||
})
|
||||
}
|
||||
|
||||
/// Wrap division operations so that zero will be returned if the
|
||||
/// denominator is zero (see also Ethereum YP Appendix H.2).
|
||||
///
|
||||
/// The closure is expected to calculate and return the quotient.
|
||||
///
|
||||
/// The result is either the calculated quotient or zero,
|
||||
/// selected at runtime.
|
||||
fn wrapped_division<'ctx, D, F, T>(
|
||||
context: &Context<'ctx, D>,
|
||||
denominator: inkwell::values::IntValue<'ctx>,
|
||||
f: F,
|
||||
) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
F: FnOnce() -> anyhow::Result<T>,
|
||||
T: inkwell::values::IntMathValue<'ctx>,
|
||||
{
|
||||
assert_eq!(
|
||||
denominator.get_type().get_bit_width(),
|
||||
revive_common::BIT_LENGTH_WORD as u32
|
||||
);
|
||||
|
||||
let block_calculate = context.append_basic_block("calculate");
|
||||
let block_select = context.append_basic_block("select");
|
||||
let block_origin = context.basic_block();
|
||||
context.builder().build_switch(
|
||||
denominator,
|
||||
block_calculate,
|
||||
&[(context.word_const(0), block_select)],
|
||||
)?;
|
||||
|
||||
context.set_basic_block(block_calculate);
|
||||
let calculated_value = f()?.as_basic_value_enum();
|
||||
context.build_unconditional_branch(block_select);
|
||||
|
||||
context.set_basic_block(block_select);
|
||||
let result = context.builder().build_phi(context.word_type(), "result")?;
|
||||
result.add_incoming(&[
|
||||
(&context.word_const(0), block_origin),
|
||||
(&calculated_value, block_calculate),
|
||||
]);
|
||||
Ok(result.as_basic_value())
|
||||
let name = <PolkaVMSignedRemainderFunction as RuntimeFunction<D>>::NAME;
|
||||
let declaration = <PolkaVMSignedRemainderFunction as RuntimeFunction<D>>::declaration(context);
|
||||
Ok(context
|
||||
.build_call(declaration, &[operand_1.into(), operand_2.into()], "srem")
|
||||
.unwrap_or_else(|| panic!("revive runtime function {name} should return a value",)))
|
||||
}
|
||||
|
||||
@@ -32,6 +32,7 @@ where
|
||||
let salt_pointer = match salt {
|
||||
Some(salt) => {
|
||||
let salt_pointer = context.build_alloca_at_entry(context.word_type(), "salt_pointer");
|
||||
let salt = context.build_byte_swap(salt.into())?;
|
||||
context.build_store(salt_pointer, salt)?;
|
||||
salt_pointer
|
||||
}
|
||||
|
||||
@@ -2,84 +2,183 @@
|
||||
|
||||
use inkwell::values::BasicValue;
|
||||
|
||||
use crate::polkavm::context::runtime::RuntimeFunction;
|
||||
use crate::polkavm::context::Context;
|
||||
use crate::polkavm::Dependency;
|
||||
use crate::polkavm::WriteLLVM;
|
||||
|
||||
/// A function for emitting EVM event logs from contract code.
|
||||
pub struct EventLog<const N: usize>;
|
||||
|
||||
impl<D, const N: usize> RuntimeFunction<D> for EventLog<N>
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = match N {
|
||||
0 => "__revive_log_0",
|
||||
1 => "__revive_log_1",
|
||||
2 => "__revive_log_2",
|
||||
3 => "__revive_log_3",
|
||||
4 => "__revive_log_4",
|
||||
_ => unreachable!(),
|
||||
};
|
||||
|
||||
fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
|
||||
let mut parameter_types = vec![context.xlen_type().into(), context.xlen_type().into()];
|
||||
parameter_types.extend_from_slice(&[context.word_type().into(); N]);
|
||||
context.void_type().fn_type(¶meter_types, false)
|
||||
}
|
||||
|
||||
fn emit_body<'ctx>(
|
||||
&self,
|
||||
context: &mut Context<'ctx, D>,
|
||||
) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
|
||||
let input_offset = Self::paramater(context, 0).into_int_value();
|
||||
let input_length = Self::paramater(context, 1).into_int_value();
|
||||
let input_pointer = context.builder().build_ptr_to_int(
|
||||
context.build_heap_gep(input_offset, input_length)?.value,
|
||||
context.xlen_type(),
|
||||
"event_input_offset",
|
||||
)?;
|
||||
|
||||
let arguments = if N == 0 {
|
||||
[
|
||||
context.xlen_type().const_zero().as_basic_value_enum(),
|
||||
context.xlen_type().const_zero().as_basic_value_enum(),
|
||||
input_pointer.as_basic_value_enum(),
|
||||
input_length.as_basic_value_enum(),
|
||||
]
|
||||
} else {
|
||||
let topics_buffer_size = N * revive_common::BYTE_LENGTH_WORD;
|
||||
let topics_buffer_pointer = context.build_alloca_at_entry(
|
||||
context.byte_type().array_type(topics_buffer_size as u32),
|
||||
"topics_buffer",
|
||||
);
|
||||
|
||||
for n in 0..N {
|
||||
let topic = Self::paramater(context, n + 2);
|
||||
let topic_buffer_offset = context
|
||||
.xlen_type()
|
||||
.const_int((n * revive_common::BYTE_LENGTH_WORD) as u64, false);
|
||||
context.build_store(
|
||||
context.build_gep(
|
||||
topics_buffer_pointer,
|
||||
&[context.xlen_type().const_zero(), topic_buffer_offset],
|
||||
context.byte_type(),
|
||||
&format!("topic_buffer_{N}_gep"),
|
||||
),
|
||||
context.build_byte_swap(topic.as_basic_value_enum())?,
|
||||
)?;
|
||||
}
|
||||
|
||||
[
|
||||
context
|
||||
.builder()
|
||||
.build_ptr_to_int(
|
||||
topics_buffer_pointer.value,
|
||||
context.xlen_type(),
|
||||
"event_topics_offset",
|
||||
)?
|
||||
.as_basic_value_enum(),
|
||||
context
|
||||
.xlen_type()
|
||||
.const_int(N as u64, false)
|
||||
.as_basic_value_enum(),
|
||||
input_pointer.as_basic_value_enum(),
|
||||
input_length.as_basic_value_enum(),
|
||||
]
|
||||
};
|
||||
|
||||
context.build_runtime_call(
|
||||
revive_runtime_api::polkavm_imports::DEPOSIT_EVENT,
|
||||
&arguments,
|
||||
);
|
||||
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for EventLog<0>
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for EventLog<1>
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for EventLog<2>
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for EventLog<3>
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for EventLog<4>
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
/// Translates a log or event call.
|
||||
///
|
||||
/// TODO: Splitting up into dedicated functions (log0..log4)
|
||||
/// could potentially decrease code sizes (LLVM can still decide to inline).
|
||||
/// However, passing i256 parameters is counter productive and
|
||||
/// I've found that splitting it up actualy increases code size.
|
||||
/// Should be reviewed after 64bit support.
|
||||
pub fn log<'ctx, D>(
|
||||
pub fn log<'ctx, D, const N: usize>(
|
||||
context: &mut Context<'ctx, D>,
|
||||
input_offset: inkwell::values::IntValue<'ctx>,
|
||||
input_length: inkwell::values::IntValue<'ctx>,
|
||||
topics: Vec<inkwell::values::IntValue<'ctx>>,
|
||||
topics: [inkwell::values::BasicValueEnum<'ctx>; N],
|
||||
) -> anyhow::Result<()>
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
let input_offset = context.safe_truncate_int_to_xlen(input_offset)?;
|
||||
let input_length = context.safe_truncate_int_to_xlen(input_length)?;
|
||||
let input_pointer = context.builder().build_ptr_to_int(
|
||||
context.build_heap_gep(input_offset, input_length)?.value,
|
||||
context.xlen_type(),
|
||||
"event_input_offset",
|
||||
)?;
|
||||
|
||||
let arguments = if topics.is_empty() {
|
||||
[
|
||||
context.xlen_type().const_zero().as_basic_value_enum(),
|
||||
context.xlen_type().const_zero().as_basic_value_enum(),
|
||||
input_pointer.as_basic_value_enum(),
|
||||
input_length.as_basic_value_enum(),
|
||||
]
|
||||
} else {
|
||||
let topics_buffer_size = topics.len() * revive_common::BYTE_LENGTH_WORD;
|
||||
let topics_buffer_pointer = context.build_alloca(
|
||||
context.byte_type().array_type(topics_buffer_size as u32),
|
||||
"topics_buffer",
|
||||
);
|
||||
|
||||
for (n, topic) in topics.iter().enumerate() {
|
||||
let topic_buffer_offset = context
|
||||
.xlen_type()
|
||||
.const_int((n * revive_common::BYTE_LENGTH_WORD) as u64, false);
|
||||
context.build_store(
|
||||
context.build_gep(
|
||||
topics_buffer_pointer,
|
||||
&[context.xlen_type().const_zero(), topic_buffer_offset],
|
||||
context.byte_type(),
|
||||
"topic_buffer_gep",
|
||||
),
|
||||
context.build_byte_swap(topic.as_basic_value_enum())?,
|
||||
)?;
|
||||
}
|
||||
|
||||
[
|
||||
context
|
||||
.builder()
|
||||
.build_ptr_to_int(
|
||||
topics_buffer_pointer.value,
|
||||
context.xlen_type(),
|
||||
"event_topics_offset",
|
||||
)?
|
||||
.as_basic_value_enum(),
|
||||
context
|
||||
.xlen_type()
|
||||
.const_int(topics.len() as u64, false)
|
||||
.as_basic_value_enum(),
|
||||
input_pointer.as_basic_value_enum(),
|
||||
input_length.as_basic_value_enum(),
|
||||
]
|
||||
};
|
||||
|
||||
let _ = context.build_runtime_call(
|
||||
revive_runtime_api::polkavm_imports::DEPOSIT_EVENT,
|
||||
&arguments,
|
||||
);
|
||||
|
||||
let declaration = <EventLog<N> as RuntimeFunction<D>>::declaration(context);
|
||||
let mut arguments = vec![
|
||||
context.safe_truncate_int_to_xlen(input_offset)?.into(),
|
||||
context.safe_truncate_int_to_xlen(input_length)?.into(),
|
||||
];
|
||||
arguments.extend_from_slice(&topics);
|
||||
context.build_call(declaration, &arguments, "log");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -4,10 +4,206 @@ use inkwell::types::BasicType;
|
||||
|
||||
use crate::polkavm::context::address_space::AddressSpace;
|
||||
use crate::polkavm::context::code_type::CodeType;
|
||||
use crate::polkavm::context::function::runtime;
|
||||
use crate::polkavm::context::pointer::Pointer;
|
||||
use crate::polkavm::context::runtime::RuntimeFunction;
|
||||
use crate::polkavm::context::Context;
|
||||
use crate::polkavm::Dependency;
|
||||
use crate::polkavm::WriteLLVM;
|
||||
|
||||
/// A function for requesting the immutable data from the runtime.
|
||||
/// This is a special function that is only used by the front-end generated code.
|
||||
///
|
||||
/// The runtime API is called lazily and subsequent calls are no-ops.
|
||||
///
|
||||
/// The bytes written is asserted to match the expected length.
|
||||
/// This should never fail; the length is known.
|
||||
/// However, this is a one time assertion, hence worth it.
|
||||
pub struct Load;
|
||||
|
||||
impl<D> RuntimeFunction<D> for Load
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = "__revive_load_immutable_data";
|
||||
|
||||
fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
|
||||
context.void_type().fn_type(Default::default(), false)
|
||||
}
|
||||
|
||||
fn emit_body<'ctx>(
|
||||
&self,
|
||||
context: &mut Context<'ctx, D>,
|
||||
) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
|
||||
let immutable_data_size_pointer = context
|
||||
.get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE)?
|
||||
.value
|
||||
.as_pointer_value();
|
||||
let immutable_data_size = context.build_load(
|
||||
Pointer::new(
|
||||
context.xlen_type(),
|
||||
AddressSpace::Stack,
|
||||
immutable_data_size_pointer,
|
||||
),
|
||||
"immutable_data_size_load",
|
||||
)?;
|
||||
|
||||
let load_immutable_data_block = context.append_basic_block("load_immutables_block");
|
||||
let return_block = context.current_function().borrow().return_block();
|
||||
let immutable_data_size_is_zero = context.builder().build_int_compare(
|
||||
inkwell::IntPredicate::EQ,
|
||||
context.xlen_type().const_zero(),
|
||||
immutable_data_size.into_int_value(),
|
||||
"immutable_data_size_is_zero",
|
||||
)?;
|
||||
context.build_conditional_branch(
|
||||
immutable_data_size_is_zero,
|
||||
return_block,
|
||||
load_immutable_data_block,
|
||||
)?;
|
||||
|
||||
context.set_basic_block(load_immutable_data_block);
|
||||
let output_pointer = context
|
||||
.get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER)?
|
||||
.value
|
||||
.as_pointer_value();
|
||||
context.build_runtime_call(
|
||||
revive_runtime_api::polkavm_imports::GET_IMMUTABLE_DATA,
|
||||
&[
|
||||
context
|
||||
.builder()
|
||||
.build_ptr_to_int(output_pointer, context.xlen_type(), "ptr_to_xlen")?
|
||||
.into(),
|
||||
context
|
||||
.builder()
|
||||
.build_ptr_to_int(
|
||||
immutable_data_size_pointer,
|
||||
context.xlen_type(),
|
||||
"ptr_to_xlen",
|
||||
)?
|
||||
.into(),
|
||||
],
|
||||
);
|
||||
let bytes_written = context.builder().build_load(
|
||||
context.xlen_type(),
|
||||
immutable_data_size_pointer,
|
||||
"bytes_written",
|
||||
)?;
|
||||
context.builder().build_store(
|
||||
immutable_data_size_pointer,
|
||||
context.xlen_type().const_zero(),
|
||||
)?;
|
||||
let overflow_block = context.append_basic_block("immutable_data_overflow");
|
||||
let is_overflow = context.builder().build_int_compare(
|
||||
inkwell::IntPredicate::UGT,
|
||||
immutable_data_size.into_int_value(),
|
||||
bytes_written.into_int_value(),
|
||||
"is_overflow",
|
||||
)?;
|
||||
context.build_conditional_branch(is_overflow, overflow_block, return_block)?;
|
||||
|
||||
context.set_basic_block(overflow_block);
|
||||
context.build_call(context.intrinsics().trap, &[], "invalid_trap");
|
||||
context.build_unreachable();
|
||||
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for Load
|
||||
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 the immutable data from the constructor code.
|
||||
pub struct Store;
|
||||
|
||||
impl<D> RuntimeFunction<D> for Store
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
const NAME: &'static str = "__revive_store_immutable_data";
|
||||
|
||||
fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
|
||||
context.void_type().fn_type(Default::default(), false)
|
||||
}
|
||||
|
||||
fn emit_body<'ctx>(
|
||||
&self,
|
||||
context: &mut Context<'ctx, D>,
|
||||
) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
|
||||
let immutable_data_size_pointer = context
|
||||
.get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE)?
|
||||
.value
|
||||
.as_pointer_value();
|
||||
let immutable_data_size = context.build_load(
|
||||
Pointer::new(
|
||||
context.xlen_type(),
|
||||
AddressSpace::Stack,
|
||||
immutable_data_size_pointer,
|
||||
),
|
||||
"immutable_data_size_load",
|
||||
)?;
|
||||
|
||||
let write_immutable_data_block = context.append_basic_block("write_immutables_block");
|
||||
let join_return_block = context.append_basic_block("join_return_block");
|
||||
let immutable_data_size_is_zero = context.builder().build_int_compare(
|
||||
inkwell::IntPredicate::EQ,
|
||||
context.xlen_type().const_zero(),
|
||||
immutable_data_size.into_int_value(),
|
||||
"immutable_data_size_is_zero",
|
||||
)?;
|
||||
context.build_conditional_branch(
|
||||
immutable_data_size_is_zero,
|
||||
join_return_block,
|
||||
write_immutable_data_block,
|
||||
)?;
|
||||
|
||||
context.set_basic_block(write_immutable_data_block);
|
||||
let immutable_data_pointer = context
|
||||
.get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER)?
|
||||
.value
|
||||
.as_pointer_value();
|
||||
context.build_runtime_call(
|
||||
revive_runtime_api::polkavm_imports::SET_IMMUTABLE_DATA,
|
||||
&[
|
||||
context
|
||||
.builder()
|
||||
.build_ptr_to_int(
|
||||
immutable_data_pointer,
|
||||
context.xlen_type(),
|
||||
"immutable_data_pointer_to_xlen",
|
||||
)?
|
||||
.into(),
|
||||
immutable_data_size,
|
||||
],
|
||||
);
|
||||
context.build_unconditional_branch(join_return_block);
|
||||
|
||||
context.set_basic_block(join_return_block);
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
impl<D> WriteLLVM<D> for Store
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
/// Translates the contract immutable load.
|
||||
///
|
||||
@@ -27,14 +223,15 @@ where
|
||||
}
|
||||
Some(CodeType::Deploy) => load_from_memory(context, index),
|
||||
Some(CodeType::Runtime) => {
|
||||
let name = <Load as RuntimeFunction<D>>::NAME;
|
||||
context.build_call(
|
||||
context
|
||||
.get_function(runtime::FUNCTION_LOAD_IMMUTABLE_DATA)
|
||||
.get_function(name)
|
||||
.expect("is always declared for runtime code")
|
||||
.borrow()
|
||||
.declaration(),
|
||||
&[],
|
||||
runtime::FUNCTION_LOAD_IMMUTABLE_DATA,
|
||||
name,
|
||||
);
|
||||
load_from_memory(context, index)
|
||||
}
|
||||
|
||||
@@ -85,5 +85,14 @@ where
|
||||
offset,
|
||||
"mstore8_destination",
|
||||
);
|
||||
context.build_store(pointer, value)
|
||||
let pointer = context.build_sbrk(
|
||||
pointer.to_int(context),
|
||||
context.xlen_type().const_int(1, false),
|
||||
)?;
|
||||
context
|
||||
.builder()
|
||||
.build_store(pointer, value)?
|
||||
.set_alignment(revive_common::BYTE_LENGTH_BYTE as u32)
|
||||
.expect("Alignment is valid");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
//! Translates the transaction return operations.
|
||||
|
||||
use crate::polkavm::context::address_space::AddressSpace;
|
||||
use crate::polkavm::context::code_type::CodeType;
|
||||
use crate::polkavm::context::pointer::Pointer;
|
||||
use crate::polkavm::context::runtime::RuntimeFunction;
|
||||
use crate::polkavm::context::Context;
|
||||
use crate::polkavm::evm::immutable::Store;
|
||||
use crate::polkavm::Dependency;
|
||||
|
||||
/// Translates the `return` instruction.
|
||||
@@ -18,55 +18,11 @@ where
|
||||
match context.code_type() {
|
||||
None => anyhow::bail!("Return is not available if the contract part is undefined"),
|
||||
Some(CodeType::Deploy) => {
|
||||
let immutable_data_size_pointer = context
|
||||
.get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE)?
|
||||
.value
|
||||
.as_pointer_value();
|
||||
let immutable_data_size = context.build_load(
|
||||
Pointer::new(
|
||||
context.xlen_type(),
|
||||
AddressSpace::Stack,
|
||||
immutable_data_size_pointer,
|
||||
),
|
||||
"immutable_data_size_load",
|
||||
)?;
|
||||
|
||||
let write_immutable_data_block = context.append_basic_block("write_immutables_block");
|
||||
let join_return_block = context.append_basic_block("join_return_block");
|
||||
let immutable_data_size_is_zero = context.builder().build_int_compare(
|
||||
inkwell::IntPredicate::EQ,
|
||||
context.xlen_type().const_zero(),
|
||||
immutable_data_size.into_int_value(),
|
||||
"immutable_data_size_is_zero",
|
||||
)?;
|
||||
context.build_conditional_branch(
|
||||
immutable_data_size_is_zero,
|
||||
join_return_block,
|
||||
write_immutable_data_block,
|
||||
)?;
|
||||
|
||||
context.set_basic_block(write_immutable_data_block);
|
||||
let immutable_data_pointer = context
|
||||
.get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER)?
|
||||
.value
|
||||
.as_pointer_value();
|
||||
context.build_runtime_call(
|
||||
revive_runtime_api::polkavm_imports::SET_IMMUTABLE_DATA,
|
||||
&[
|
||||
context
|
||||
.builder()
|
||||
.build_ptr_to_int(
|
||||
immutable_data_pointer,
|
||||
context.xlen_type(),
|
||||
"immutable_data_pointer_to_xlen",
|
||||
)?
|
||||
.into(),
|
||||
immutable_data_size,
|
||||
],
|
||||
context.build_call(
|
||||
<Store as RuntimeFunction<D>>::declaration(context),
|
||||
Default::default(),
|
||||
"store_immutable_data",
|
||||
);
|
||||
context.build_unconditional_branch(join_return_block);
|
||||
|
||||
context.set_basic_block(join_return_block);
|
||||
}
|
||||
Some(CodeType::Runtime) => {}
|
||||
}
|
||||
@@ -100,11 +56,7 @@ pub fn stop<D>(context: &mut Context<D>) -> anyhow::Result<()>
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
r#return(
|
||||
context,
|
||||
context.integer_const(crate::polkavm::XLEN, 0),
|
||||
context.integer_const(crate::polkavm::XLEN, 0),
|
||||
)
|
||||
r#return(context, context.word_const(0), context.word_const(0))
|
||||
}
|
||||
|
||||
/// Translates the `invalid` instruction.
|
||||
|
||||
@@ -1,8 +1,12 @@
|
||||
//! Translates the storage operations.
|
||||
|
||||
use crate::polkavm::context::address_space::AddressSpace;
|
||||
use crate::polkavm::context::runtime::RuntimeFunction;
|
||||
use crate::polkavm::context::Context;
|
||||
use crate::polkavm::Dependency;
|
||||
use crate::PolkaVMLoadStorageWordFunction;
|
||||
use crate::PolkaVMLoadTransientStorageWordFunction;
|
||||
use crate::PolkaVMStoreStorageWordFunction;
|
||||
use crate::PolkaVMStoreTransientStorageWordFunction;
|
||||
|
||||
/// Translates the storage load.
|
||||
pub fn load<'ctx, D>(
|
||||
@@ -12,10 +16,12 @@ pub fn load<'ctx, D>(
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
|
||||
slot_ptr.address_space = AddressSpace::Storage;
|
||||
context.builder().build_store(slot_ptr.value, position)?;
|
||||
context.build_load(slot_ptr, "storage_load_value")
|
||||
let name = <PolkaVMLoadStorageWordFunction as RuntimeFunction<D>>::NAME;
|
||||
let declaration = <PolkaVMLoadStorageWordFunction as RuntimeFunction<D>>::declaration(context);
|
||||
let arguments = [position.into()];
|
||||
Ok(context
|
||||
.build_call(declaration, &arguments, "storage_load")
|
||||
.unwrap_or_else(|| panic!("runtime function {name} should return a value")))
|
||||
}
|
||||
|
||||
/// Translates the storage store.
|
||||
@@ -27,10 +33,9 @@ pub fn store<'ctx, D>(
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
|
||||
slot_ptr.address_space = AddressSpace::Storage;
|
||||
context.builder().build_store(slot_ptr.value, position)?;
|
||||
context.build_store(slot_ptr, value)?;
|
||||
let declaration = <PolkaVMStoreStorageWordFunction as RuntimeFunction<D>>::declaration(context);
|
||||
let arguments = [position.into(), value.into()];
|
||||
context.build_call(declaration, &arguments, "storage_store");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -42,10 +47,13 @@ pub fn transient_load<'ctx, D>(
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
|
||||
slot_ptr.address_space = AddressSpace::TransientStorage;
|
||||
context.builder().build_store(slot_ptr.value, position)?;
|
||||
context.build_load(slot_ptr, "transient_storage_load_value")
|
||||
let name = <PolkaVMLoadTransientStorageWordFunction as RuntimeFunction<D>>::NAME;
|
||||
let arguments = [position.into()];
|
||||
let declaration =
|
||||
<PolkaVMLoadTransientStorageWordFunction as RuntimeFunction<D>>::declaration(context);
|
||||
Ok(context
|
||||
.build_call(declaration, &arguments, "transient_storage_load")
|
||||
.unwrap_or_else(|| panic!("runtime function {name} should return a value")))
|
||||
}
|
||||
|
||||
/// Translates the transient storage store.
|
||||
@@ -57,9 +65,9 @@ pub fn transient_store<'ctx, D>(
|
||||
where
|
||||
D: Dependency + Clone,
|
||||
{
|
||||
let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
|
||||
slot_ptr.address_space = AddressSpace::TransientStorage;
|
||||
context.builder().build_store(slot_ptr.value, position)?;
|
||||
context.build_store(slot_ptr, value)?;
|
||||
let declaration =
|
||||
<PolkaVMStoreTransientStorageWordFunction as RuntimeFunction<D>>::declaration(context);
|
||||
let arguments = [position.into(), value.into()];
|
||||
context.build_call(declaration, &arguments, "transient_storage_store");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -3,7 +3,6 @@
|
||||
pub mod r#const;
|
||||
pub mod context;
|
||||
pub mod evm;
|
||||
pub mod metadata_hash;
|
||||
|
||||
pub use self::r#const::*;
|
||||
|
||||
@@ -18,11 +17,6 @@ use sha3::Digest;
|
||||
use self::context::build::Build;
|
||||
use self::context::Context;
|
||||
|
||||
/// Initializes the PolkaVM target machine.
|
||||
pub fn initialize_target() {
|
||||
inkwell::targets::Target::initialize_riscv(&Default::default());
|
||||
}
|
||||
|
||||
/// Builds PolkaVM assembly text.
|
||||
pub fn build_assembly_text(
|
||||
contract_path: &str,
|
||||
@@ -95,6 +89,7 @@ pub trait Dependency {
|
||||
optimizer_settings: OptimizerSettings,
|
||||
include_metadata_hash: bool,
|
||||
debug_config: DebugConfig,
|
||||
llvm_arguments: &[String],
|
||||
) -> anyhow::Result<String>;
|
||||
|
||||
/// Resolves a full contract path.
|
||||
@@ -115,6 +110,7 @@ impl Dependency for DummyDependency {
|
||||
_optimizer_settings: OptimizerSettings,
|
||||
_include_metadata_hash: bool,
|
||||
_debug_config: DebugConfig,
|
||||
_llvm_arguments: &[String],
|
||||
) -> anyhow::Result<String> {
|
||||
Ok(String::new())
|
||||
}
|
||||
|
||||
@@ -34,3 +34,4 @@ polkadot-sdk.features = [
|
||||
|
||||
revive-solidity = { workspace = true, optional = true }
|
||||
revive-differential = { workspace = true, optional = true }
|
||||
revive-llvm-context = { workspace = true }
|
||||
|
||||
@@ -274,6 +274,7 @@ impl From<Code> for pallet_revive::Code {
|
||||
&contract,
|
||||
&source_code,
|
||||
solc_optimizer.unwrap_or(true),
|
||||
revive_llvm_context::OptimizerSettings::cycles(),
|
||||
))
|
||||
}
|
||||
Code::Path(path) => pallet_revive::Code::Upload(std::fs::read(path).unwrap()),
|
||||
|
||||
@@ -106,14 +106,10 @@ impl SpecsAction {
|
||||
};
|
||||
|
||||
for (key, expected) in storage {
|
||||
let mut key = **key;
|
||||
let mut expected = **expected;
|
||||
key.reverse();
|
||||
expected.reverse();
|
||||
actions.push(Self::VerifyStorage {
|
||||
contract: account_pvm.clone(),
|
||||
key,
|
||||
expected,
|
||||
key: **key,
|
||||
expected: **expected,
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -13,18 +13,18 @@ uint32_t __memory_size = 0;
|
||||
|
||||
void * __sbrk_internal(uint32_t offset, uint32_t size) {
|
||||
if (offset >= MAX_MEMORY_SIZE || size > MAX_MEMORY_SIZE) {
|
||||
return NULL;
|
||||
POLKAVM_TRAP();
|
||||
}
|
||||
|
||||
uint32_t new_size = ALIGN(offset + size);
|
||||
if (new_size > MAX_MEMORY_SIZE) {
|
||||
return NULL;
|
||||
POLKAVM_TRAP();
|
||||
}
|
||||
if (new_size > __memory_size) {
|
||||
__memory_size = new_size;
|
||||
}
|
||||
|
||||
return (void *)&__memory[__memory_size];
|
||||
return (void *)&__memory[offset];
|
||||
}
|
||||
|
||||
void * memset(void *b, int c, size_t len) {
|
||||
|
||||
@@ -0,0 +1,23 @@
|
||||
[package]
|
||||
name = "revive-solc-json-interface"
|
||||
version.workspace = true
|
||||
authors.workspace = true
|
||||
license.workspace = true
|
||||
edition.workspace = true
|
||||
repository.workspace = true
|
||||
rust-version.workspace = true
|
||||
description = "Rust bindings for the solc standard JSON and combined JSON interface"
|
||||
|
||||
[features]
|
||||
default = ["parallel"]
|
||||
parallel = ["rayon"]
|
||||
resolc = [] # The resolc binary adds a bunch of custom fields to the format
|
||||
|
||||
[dependencies]
|
||||
revive-common = { workspace = true }
|
||||
|
||||
anyhow = { workspace = true }
|
||||
rayon = { workspace = true, optional = true }
|
||||
semver = { workspace = true }
|
||||
serde = { workspace = true }
|
||||
serde_json = { workspace = true }
|
||||
@@ -0,0 +1,27 @@
|
||||
//! This crates provides (de)serializable Rust types for interacting
|
||||
//! `solc` via the [JSON-input-output][0] interface.
|
||||
//!
|
||||
//! [0]: https://docs.soliditylang.org/en/latest/using-the-compiler.html#compiler-input-and-output-json-description
|
||||
|
||||
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::Optimizer as SolcStandardJsonInputSettingsOptimizer;
|
||||
pub use self::standard_json::input::settings::selection::file::flag::Flag as SolcStandardJsonInputSettingsSelectionFileFlag;
|
||||
pub use self::standard_json::input::settings::selection::file::File as SolcStandardJsonInputSettingsSelectionFile;
|
||||
pub use self::standard_json::input::settings::selection::Selection as SolcStandardJsonInputSettingsSelection;
|
||||
pub use self::standard_json::input::settings::Settings as SolcStandardJsonInputSettings;
|
||||
pub use self::standard_json::input::source::Source as SolcStandardJsonInputSource;
|
||||
pub use self::standard_json::input::Input as SolcStandardJsonInput;
|
||||
pub use self::standard_json::output::contract::evm::bytecode::Bytecode as SolcStandardJsonOutputContractEVMBytecode;
|
||||
pub use self::standard_json::output::contract::evm::EVM as SolcStandardJsonOutputContractEVM;
|
||||
pub use self::standard_json::output::contract::Contract as SolcStandardJsonOutputContract;
|
||||
pub use self::standard_json::output::Output as SolcStandardJsonOutput;
|
||||
#[cfg(feature = "resolc")]
|
||||
pub use self::warning::Warning as ResolcWarning;
|
||||
|
||||
pub mod combined_json;
|
||||
pub mod standard_json;
|
||||
#[cfg(feature = "resolc")]
|
||||
pub mod warning;
|
||||
+9
-5
@@ -8,14 +8,15 @@ use std::collections::BTreeMap;
|
||||
use std::collections::BTreeSet;
|
||||
use std::path::PathBuf;
|
||||
|
||||
#[cfg(feature = "parallel")]
|
||||
#[cfg(all(feature = "parallel", feature = "resolc"))]
|
||||
use rayon::iter::{IntoParallelIterator, ParallelIterator};
|
||||
use serde::Deserialize;
|
||||
use serde::Serialize;
|
||||
|
||||
use crate::solc::standard_json::input::settings::metadata::Metadata as SolcStandardJsonInputSettingsMetadata;
|
||||
use crate::solc::standard_json::input::settings::optimizer::Optimizer as SolcStandardJsonInputSettingsOptimizer;
|
||||
use crate::solc::standard_json::input::settings::selection::Selection as SolcStandardJsonInputSettingsSelection;
|
||||
use crate::standard_json::input::settings::metadata::Metadata as SolcStandardJsonInputSettingsMetadata;
|
||||
use crate::standard_json::input::settings::optimizer::Optimizer as SolcStandardJsonInputSettingsOptimizer;
|
||||
use crate::standard_json::input::settings::selection::Selection as SolcStandardJsonInputSettingsSelection;
|
||||
#[cfg(feature = "resolc")]
|
||||
use crate::warning::Warning;
|
||||
|
||||
use self::language::Language;
|
||||
@@ -33,6 +34,7 @@ pub struct Input {
|
||||
/// The compiler settings.
|
||||
pub settings: Settings,
|
||||
/// The suppressed warnings.
|
||||
#[cfg(feature = "resolc")]
|
||||
#[serde(skip_serializing)]
|
||||
pub suppressed_warnings: Option<Vec<Warning>>,
|
||||
}
|
||||
@@ -60,7 +62,7 @@ impl Input {
|
||||
output_selection: SolcStandardJsonInputSettingsSelection,
|
||||
optimizer: SolcStandardJsonInputSettingsOptimizer,
|
||||
metadata: Option<SolcStandardJsonInputSettingsMetadata>,
|
||||
suppressed_warnings: Option<Vec<Warning>>,
|
||||
#[cfg(feature = "resolc")] suppressed_warnings: Option<Vec<Warning>>,
|
||||
) -> anyhow::Result<Self> {
|
||||
let mut paths: BTreeSet<PathBuf> = paths.iter().cloned().collect();
|
||||
let libraries = Settings::parse_libraries(library_map)?;
|
||||
@@ -89,12 +91,14 @@ impl Input {
|
||||
optimizer,
|
||||
metadata,
|
||||
),
|
||||
#[cfg(feature = "resolc")]
|
||||
suppressed_warnings,
|
||||
})
|
||||
}
|
||||
|
||||
/// A shortcut constructor from source code.
|
||||
/// Only for the integration test purposes.
|
||||
#[cfg(feature = "resolc")]
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn try_from_sources(
|
||||
evm_version: Option<revive_common::EVMVersion>,
|
||||
+4
-2
@@ -3,18 +3,20 @@
|
||||
use serde::Deserialize;
|
||||
use serde::Serialize;
|
||||
|
||||
use crate::standard_json::input::settings::metadata_hash::MetadataHash;
|
||||
|
||||
/// The `solc --standard-json` input settings metadata.
|
||||
#[derive(Debug, Default, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct Metadata {
|
||||
/// The bytecode hash mode.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub bytecode_hash: Option<revive_llvm_context::PolkaVMMetadataHash>,
|
||||
pub bytecode_hash: Option<MetadataHash>,
|
||||
}
|
||||
|
||||
impl Metadata {
|
||||
/// A shortcut constructor.
|
||||
pub fn new(bytecode_hash: revive_llvm_context::PolkaVMMetadataHash) -> Self {
|
||||
pub fn new(bytecode_hash: MetadataHash) -> Self {
|
||||
Self {
|
||||
bytecode_hash: Some(bytecode_hash),
|
||||
}
|
||||
+1
@@ -1,6 +1,7 @@
|
||||
//! The `solc --standard-json` input settings.
|
||||
|
||||
pub mod metadata;
|
||||
pub mod metadata_hash;
|
||||
pub mod optimizer;
|
||||
pub mod selection;
|
||||
|
||||
-15
@@ -49,18 +49,3 @@ impl Optimizer {
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
impl TryFrom<&Optimizer> for revive_llvm_context::OptimizerSettings {
|
||||
type Error = anyhow::Error;
|
||||
|
||||
fn try_from(value: &Optimizer) -> Result<Self, Self::Error> {
|
||||
let mut result = match value.mode {
|
||||
Some(mode) => Self::try_from_cli(mode)?,
|
||||
None => Self::cycles(),
|
||||
};
|
||||
if value.fallback_to_optimizing_for_size.unwrap_or_default() {
|
||||
result.enable_fallback_to_size();
|
||||
}
|
||||
Ok(result)
|
||||
}
|
||||
}
|
||||
+4
@@ -40,6 +40,9 @@ pub enum Flag {
|
||||
/// The assembly code
|
||||
#[serde(rename = "evm.assembly")]
|
||||
Assembly,
|
||||
/// The Ir
|
||||
#[serde(rename = "ir")]
|
||||
Ir,
|
||||
}
|
||||
|
||||
impl std::fmt::Display for Flag {
|
||||
@@ -57,6 +60,7 @@ impl std::fmt::Display for Flag {
|
||||
Self::EVMBC => write!(f, "evm.bytecode"),
|
||||
Self::EVMDBC => write!(f, "evm.deployedBytecode"),
|
||||
Self::Assembly => write!(f, "evm.assembly"),
|
||||
Self::Ir => write!(f, "ir"),
|
||||
}
|
||||
}
|
||||
}
|
||||
+2
-1
@@ -10,7 +10,7 @@ use serde::Serialize;
|
||||
use self::flag::Flag as SelectionFlag;
|
||||
|
||||
/// The `solc --standard-json` output file selection.
|
||||
#[derive(Debug, Default, Serialize, Deserialize)]
|
||||
#[derive(Debug, Default, Serialize, Deserialize, PartialEq)]
|
||||
pub struct File {
|
||||
/// The per-file output selections.
|
||||
#[serde(rename = "", skip_serializing_if = "Option::is_none")]
|
||||
@@ -45,6 +45,7 @@ impl File {
|
||||
self.per_contract
|
||||
.get_or_insert_with(HashSet::default)
|
||||
.extend(required.per_contract.unwrap_or_default());
|
||||
|
||||
self
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
//! The `solc --standard-json` output selection.
|
||||
|
||||
pub mod file;
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use serde::Deserialize;
|
||||
use serde::Serialize;
|
||||
|
||||
use self::file::File as FileSelection;
|
||||
|
||||
/// The `solc --standard-json` output selection.
|
||||
#[derive(Debug, Serialize, Deserialize, Default, PartialEq)]
|
||||
pub struct Selection {
|
||||
/// Only the 'all' wildcard is available for robustness reasons.
|
||||
#[serde(rename = "*", skip_serializing_if = "Option::is_none")]
|
||||
all: Option<FileSelection>,
|
||||
|
||||
#[serde(skip_serializing_if = "BTreeMap::is_empty", flatten)]
|
||||
pub files: BTreeMap<String, FileSelection>,
|
||||
}
|
||||
|
||||
impl Selection {
|
||||
/// Creates the selection required by our compilation process.
|
||||
pub fn new_required() -> Self {
|
||||
Self {
|
||||
all: Some(FileSelection::new_required()),
|
||||
files: BTreeMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Extends the user's output selection with flag required by our compilation process.
|
||||
pub fn extend_with_required(&mut self) -> &mut Self {
|
||||
self.all
|
||||
.get_or_insert_with(FileSelection::new_required)
|
||||
.extend_with_required();
|
||||
for (_, v) in self.files.iter_mut() {
|
||||
v.extend_with_required();
|
||||
}
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use crate::SolcStandardJsonInputSettingsSelectionFile;
|
||||
|
||||
use super::Selection;
|
||||
|
||||
#[test]
|
||||
fn per_file() {
|
||||
let init = Selection {
|
||||
all: None,
|
||||
files: BTreeMap::from([(
|
||||
"Test".to_owned(),
|
||||
SolcStandardJsonInputSettingsSelectionFile::new_required(),
|
||||
)]),
|
||||
};
|
||||
|
||||
let deser = serde_json::to_string(&init)
|
||||
.and_then(|string| serde_json::from_str(&string))
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(init, deser)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn all() {
|
||||
let init = Selection {
|
||||
all: Some(SolcStandardJsonInputSettingsSelectionFile::new_required()),
|
||||
files: BTreeMap::new(),
|
||||
};
|
||||
|
||||
let deser = serde_json::to_string(&init)
|
||||
.and_then(|string| serde_json::from_str(&string))
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(init, deser)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn all_and_override() {
|
||||
let init = Selection {
|
||||
all: Some(SolcStandardJsonInputSettingsSelectionFile::new_required()),
|
||||
files: BTreeMap::from([(
|
||||
"Test".to_owned(),
|
||||
SolcStandardJsonInputSettingsSelectionFile::new_required(),
|
||||
)]),
|
||||
};
|
||||
|
||||
let deser = serde_json::to_string(&init)
|
||||
.and_then(|string| serde_json::from_str(&string))
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(init, deser)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
//! The `solc <input>.sol --standard-json` interface input and output.
|
||||
|
||||
pub mod input;
|
||||
pub mod output;
|
||||
+3
@@ -32,6 +32,9 @@ pub struct Contract {
|
||||
/// Contract's bytecode and related objects
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub evm: Option<EVM>,
|
||||
/// The contract IR code.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub ir: Option<String>,
|
||||
/// The contract optimized IR code.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub ir_optimized: Option<String>,
|
||||
@@ -0,0 +1,71 @@
|
||||
//! The `solc --standard-json` output.
|
||||
|
||||
pub mod contract;
|
||||
pub mod error;
|
||||
pub mod source;
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use serde::Deserialize;
|
||||
use serde::Serialize;
|
||||
|
||||
#[cfg(feature = "resolc")]
|
||||
use crate::warning::Warning;
|
||||
|
||||
use self::contract::Contract;
|
||||
use self::error::Error as SolcStandardJsonOutputError;
|
||||
use self::source::Source;
|
||||
|
||||
/// The `solc --standard-json` output.
|
||||
#[derive(Debug, Serialize, Deserialize, Clone, Default)]
|
||||
pub struct Output {
|
||||
/// The file-contract hashmap.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub contracts: Option<BTreeMap<String, BTreeMap<String, Contract>>>,
|
||||
/// The source code mapping data.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub sources: Option<BTreeMap<String, Source>>,
|
||||
/// The compilation errors and warnings.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub errors: Option<Vec<SolcStandardJsonOutputError>>,
|
||||
/// The `solc` compiler version.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub version: Option<String>,
|
||||
/// The `solc` compiler long version.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub long_version: Option<String>,
|
||||
/// The `resolc` compiler version.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub revive_version: Option<String>,
|
||||
}
|
||||
|
||||
impl Output {
|
||||
/// Traverses the AST and returns the list of additional errors and warnings.
|
||||
#[cfg(feature = "resolc")]
|
||||
pub fn preprocess_ast(&mut self, suppressed_warnings: &[Warning]) -> anyhow::Result<()> {
|
||||
let sources = match self.sources.as_ref() {
|
||||
Some(sources) => sources,
|
||||
None => return Ok(()),
|
||||
};
|
||||
|
||||
let mut messages = Vec::new();
|
||||
for (path, source) in sources.iter() {
|
||||
if let Some(ast) = source.ast.as_ref() {
|
||||
let mut polkavm_messages = Source::get_messages(ast, suppressed_warnings);
|
||||
for message in polkavm_messages.iter_mut() {
|
||||
message.push_contract_path(path.as_str());
|
||||
}
|
||||
messages.extend(polkavm_messages);
|
||||
}
|
||||
}
|
||||
self.errors = match self.errors.take() {
|
||||
Some(mut errors) => {
|
||||
errors.extend(messages);
|
||||
Some(errors)
|
||||
}
|
||||
None => Some(messages),
|
||||
};
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
+4
-2
@@ -3,7 +3,8 @@
|
||||
use serde::Deserialize;
|
||||
use serde::Serialize;
|
||||
|
||||
use crate::solc::standard_json::output::error::Error as SolcStandardJsonOutputError;
|
||||
use crate::standard_json::output::error::Error as SolcStandardJsonOutputError;
|
||||
#[cfg(feature = "resolc")]
|
||||
use crate::warning::Warning;
|
||||
|
||||
/// The `solc --standard-json` output source.
|
||||
@@ -131,6 +132,7 @@ impl Source {
|
||||
}
|
||||
|
||||
/// Returns the list of messages for some specific parts of the AST.
|
||||
#[cfg(feature = "resolc")]
|
||||
pub fn get_messages(
|
||||
ast: &serde_json::Value,
|
||||
suppressed_warnings: &[Warning],
|
||||
@@ -194,7 +196,7 @@ impl Source {
|
||||
_ => None,
|
||||
},
|
||||
)
|
||||
.last()
|
||||
.next_back()
|
||||
.ok_or_else(|| anyhow::anyhow!("The last contract not found in the AST"))
|
||||
}
|
||||
}
|
||||
@@ -1,26 +1,22 @@
|
||||
//! The compiler warning.
|
||||
//! `resolc` custom compiler warnings.
|
||||
//!
|
||||
//! The revive compiler adds warnings only applicable when compilng
|
||||
//! to the revive stack on Polkadot to the output.
|
||||
|
||||
use std::str::FromStr;
|
||||
|
||||
use serde::Deserialize;
|
||||
use serde::Serialize;
|
||||
|
||||
/// The compiler warning.
|
||||
// The `resolc` custom compiler warning.
|
||||
#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub enum Warning {
|
||||
/// The warning for eponymous feature.
|
||||
EcRecover,
|
||||
/// The warning for eponymous feature.
|
||||
SendTransfer,
|
||||
/// The warning for eponymous feature.
|
||||
ExtCodeSize,
|
||||
/// The warning for eponymous feature.
|
||||
TxOrigin,
|
||||
/// The warning for eponymous feature.
|
||||
BlockTimestamp,
|
||||
/// The warning for eponymous feature.
|
||||
BlockNumber,
|
||||
/// The warning for eponymous feature.
|
||||
BlockHash,
|
||||
}
|
||||
|
||||
@@ -37,6 +37,7 @@ inkwell = { workspace = true }
|
||||
|
||||
revive-common = { workspace = true }
|
||||
revive-llvm-context = { workspace = true }
|
||||
revive-solc-json-interface = { workspace = true, features = ["resolc"] }
|
||||
|
||||
[target.'cfg(target_env = "musl")'.dependencies]
|
||||
mimalloc = { version = "*", default-features = false }
|
||||
|
||||
@@ -5,12 +5,11 @@ use std::fs::File;
|
||||
use std::io::Write;
|
||||
use std::path::Path;
|
||||
|
||||
use revive_solc_json_interface::CombinedJsonContract;
|
||||
use revive_solc_json_interface::SolcStandardJsonOutputContract;
|
||||
use serde::Deserialize;
|
||||
use serde::Serialize;
|
||||
|
||||
use crate::solc::combined_json::contract::Contract as CombinedJsonContract;
|
||||
use crate::solc::standard_json::output::contract::Contract as StandardJsonOutputContract;
|
||||
|
||||
/// The Solidity contract build.
|
||||
#[derive(Debug, Serialize, Deserialize)]
|
||||
pub struct Contract {
|
||||
@@ -131,7 +130,7 @@ impl Contract {
|
||||
/// Writes the contract text assembly and bytecode to the standard JSON.
|
||||
pub fn write_to_standard_json(
|
||||
self,
|
||||
standard_json_contract: &mut StandardJsonOutputContract,
|
||||
standard_json_contract: &mut SolcStandardJsonOutputContract,
|
||||
) -> anyhow::Result<()> {
|
||||
standard_json_contract.metadata = Some(self.metadata_json);
|
||||
|
||||
|
||||
@@ -5,8 +5,9 @@ pub mod contract;
|
||||
use std::collections::BTreeMap;
|
||||
use std::path::Path;
|
||||
|
||||
use crate::solc::combined_json::CombinedJson;
|
||||
use crate::solc::standard_json::output::Output as StandardJsonOutput;
|
||||
use revive_solc_json_interface::combined_json::CombinedJson;
|
||||
use revive_solc_json_interface::SolcStandardJsonOutput;
|
||||
|
||||
use crate::solc::version::Version as SolcVersion;
|
||||
use crate::ResolcVersion;
|
||||
|
||||
@@ -66,7 +67,7 @@ impl Build {
|
||||
/// Writes all contracts assembly and bytecode to the standard JSON.
|
||||
pub fn write_to_standard_json(
|
||||
mut self,
|
||||
standard_json: &mut StandardJsonOutput,
|
||||
standard_json: &mut SolcStandardJsonOutput,
|
||||
solc_version: &SolcVersion,
|
||||
) -> anyhow::Result<()> {
|
||||
let contracts = match standard_json.contracts.as_mut() {
|
||||
|
||||
+58
-31
@@ -7,7 +7,6 @@ pub(crate) mod process;
|
||||
pub(crate) mod project;
|
||||
pub(crate) mod solc;
|
||||
pub(crate) mod version;
|
||||
pub(crate) mod warning;
|
||||
pub(crate) mod yul;
|
||||
|
||||
pub use self::build::contract::Contract as ContractBuild;
|
||||
@@ -23,29 +22,16 @@ pub use self::process::Process;
|
||||
pub use self::project::contract::Contract as ProjectContract;
|
||||
pub use self::project::Project;
|
||||
pub use self::r#const::*;
|
||||
pub use self::solc::combined_json::contract::Contract as SolcCombinedJsonContract;
|
||||
pub use self::solc::combined_json::CombinedJson as SolcCombinedJson;
|
||||
#[cfg(not(target_os = "emscripten"))]
|
||||
pub use self::solc::solc_compiler::SolcCompiler;
|
||||
#[cfg(target_os = "emscripten")]
|
||||
pub use self::solc::soljson_compiler::SoljsonCompiler;
|
||||
pub use self::solc::standard_json::input::language::Language as SolcStandardJsonInputLanguage;
|
||||
pub use self::solc::standard_json::input::settings::metadata::Metadata as SolcStandardJsonInputSettingsMetadata;
|
||||
pub use self::solc::standard_json::input::settings::optimizer::Optimizer as SolcStandardJsonInputSettingsOptimizer;
|
||||
pub use self::solc::standard_json::input::settings::selection::file::flag::Flag as SolcStandardJsonInputSettingsSelectionFileFlag;
|
||||
pub use self::solc::standard_json::input::settings::selection::file::File as SolcStandardJsonInputSettingsSelectionFile;
|
||||
pub use self::solc::standard_json::input::settings::selection::Selection as SolcStandardJsonInputSettingsSelection;
|
||||
pub use self::solc::standard_json::input::settings::Settings as SolcStandardJsonInputSettings;
|
||||
pub use self::solc::standard_json::input::source::Source as SolcStandardJsonInputSource;
|
||||
pub use self::solc::standard_json::input::Input as SolcStandardJsonInput;
|
||||
pub use self::solc::standard_json::output::contract::evm::bytecode::Bytecode as SolcStandardJsonOutputContractEVMBytecode;
|
||||
pub use self::solc::standard_json::output::contract::evm::EVM as SolcStandardJsonOutputContractEVM;
|
||||
pub use self::solc::standard_json::output::contract::Contract as SolcStandardJsonOutputContract;
|
||||
pub use self::solc::standard_json::output::Output as SolcStandardJsonOutput;
|
||||
pub use self::solc::version::Version as SolcVersion;
|
||||
pub use self::solc::Compiler;
|
||||
pub use self::solc::FIRST_SUPPORTED_VERSION as SolcFirstSupportedVersion;
|
||||
pub use self::solc::LAST_SUPPORTED_VERSION as SolcLastSupportedVersion;
|
||||
pub use self::version::Version as ResolcVersion;
|
||||
pub use self::warning::Warning;
|
||||
|
||||
#[cfg(not(target_os = "emscripten"))]
|
||||
pub mod test_utils;
|
||||
pub mod tests;
|
||||
@@ -54,6 +40,13 @@ use std::collections::BTreeSet;
|
||||
use std::io::Write;
|
||||
use std::path::PathBuf;
|
||||
|
||||
use revive_solc_json_interface::standard_json::input::settings::metadata_hash::MetadataHash;
|
||||
use revive_solc_json_interface::ResolcWarning;
|
||||
use revive_solc_json_interface::SolcStandardJsonInput;
|
||||
use revive_solc_json_interface::SolcStandardJsonInputLanguage;
|
||||
use revive_solc_json_interface::SolcStandardJsonInputSettingsOptimizer;
|
||||
use revive_solc_json_interface::SolcStandardJsonInputSettingsSelection;
|
||||
|
||||
/// Runs the Yul mode.
|
||||
pub fn yul<T: Compiler>(
|
||||
input_files: &[PathBuf],
|
||||
@@ -61,6 +54,7 @@ pub fn yul<T: Compiler>(
|
||||
optimizer_settings: revive_llvm_context::OptimizerSettings,
|
||||
include_metadata_hash: bool,
|
||||
debug_config: revive_llvm_context::DebugConfig,
|
||||
llvm_arguments: &[String],
|
||||
) -> anyhow::Result<Build> {
|
||||
let path = match input_files.len() {
|
||||
1 => input_files.first().expect("Always exists"),
|
||||
@@ -81,7 +75,12 @@ pub fn yul<T: Compiler>(
|
||||
let solc_validator = Some(&*solc);
|
||||
let project = Project::try_from_yul_path(path, solc_validator)?;
|
||||
|
||||
let build = project.compile(optimizer_settings, include_metadata_hash, debug_config)?;
|
||||
let build = project.compile(
|
||||
optimizer_settings,
|
||||
include_metadata_hash,
|
||||
debug_config,
|
||||
llvm_arguments,
|
||||
)?;
|
||||
|
||||
Ok(build)
|
||||
}
|
||||
@@ -92,6 +91,7 @@ pub fn llvm_ir(
|
||||
optimizer_settings: revive_llvm_context::OptimizerSettings,
|
||||
include_metadata_hash: bool,
|
||||
debug_config: revive_llvm_context::DebugConfig,
|
||||
llvm_arguments: &[String],
|
||||
) -> anyhow::Result<Build> {
|
||||
let path = match input_files.len() {
|
||||
1 => input_files.first().expect("Always exists"),
|
||||
@@ -104,7 +104,12 @@ pub fn llvm_ir(
|
||||
|
||||
let project = Project::try_from_llvm_ir_path(path)?;
|
||||
|
||||
let build = project.compile(optimizer_settings, include_metadata_hash, debug_config)?;
|
||||
let build = project.compile(
|
||||
optimizer_settings,
|
||||
include_metadata_hash,
|
||||
debug_config,
|
||||
llvm_arguments,
|
||||
)?;
|
||||
|
||||
Ok(build)
|
||||
}
|
||||
@@ -123,8 +128,9 @@ pub fn standard_output<T: Compiler>(
|
||||
include_paths: Vec<String>,
|
||||
allow_paths: Option<String>,
|
||||
remappings: Option<BTreeSet<String>>,
|
||||
suppressed_warnings: Option<Vec<Warning>>,
|
||||
suppressed_warnings: Option<Vec<ResolcWarning>>,
|
||||
debug_config: revive_llvm_context::DebugConfig,
|
||||
llvm_arguments: &[String],
|
||||
) -> anyhow::Result<Build> {
|
||||
let solc_version = solc.version()?;
|
||||
|
||||
@@ -152,7 +158,7 @@ pub fn standard_output<T: Compiler>(
|
||||
.collect();
|
||||
|
||||
let libraries = solc_input.settings.libraries.clone().unwrap_or_default();
|
||||
let mut solc_output = solc.standard_json(solc_input, base_path, include_paths, allow_paths)?;
|
||||
let solc_output = solc.standard_json(solc_input, base_path, include_paths, allow_paths)?;
|
||||
|
||||
if let Some(errors) = solc_output.errors.as_deref() {
|
||||
let mut has_errors = false;
|
||||
@@ -170,10 +176,20 @@ pub fn standard_output<T: Compiler>(
|
||||
}
|
||||
}
|
||||
|
||||
let project =
|
||||
solc_output.try_to_project(source_code_files, libraries, &solc_version, &debug_config)?;
|
||||
let project = Project::try_from_standard_json_output(
|
||||
&solc_output,
|
||||
source_code_files,
|
||||
libraries,
|
||||
&solc_version,
|
||||
&debug_config,
|
||||
)?;
|
||||
|
||||
let build = project.compile(optimizer_settings, include_metadata_hash, debug_config)?;
|
||||
let build = project.compile(
|
||||
optimizer_settings,
|
||||
include_metadata_hash,
|
||||
debug_config,
|
||||
llvm_arguments,
|
||||
)?;
|
||||
|
||||
Ok(build)
|
||||
}
|
||||
@@ -186,6 +202,7 @@ pub fn standard_json<T: Compiler>(
|
||||
include_paths: Vec<String>,
|
||||
allow_paths: Option<String>,
|
||||
debug_config: revive_llvm_context::DebugConfig,
|
||||
llvm_arguments: &[String],
|
||||
) -> anyhow::Result<()> {
|
||||
let solc_version = solc.version()?;
|
||||
|
||||
@@ -200,9 +217,7 @@ pub fn standard_json<T: Compiler>(
|
||||
revive_llvm_context::OptimizerSettings::try_from(&solc_input.settings.optimizer)?;
|
||||
|
||||
let include_metadata_hash = match solc_input.settings.metadata {
|
||||
Some(ref metadata) => {
|
||||
metadata.bytecode_hash != Some(revive_llvm_context::PolkaVMMetadataHash::None)
|
||||
}
|
||||
Some(ref metadata) => metadata.bytecode_hash != Some(MetadataHash::None),
|
||||
None => true,
|
||||
};
|
||||
|
||||
@@ -218,14 +233,24 @@ pub fn standard_json<T: Compiler>(
|
||||
}
|
||||
}
|
||||
|
||||
let project =
|
||||
solc_output.try_to_project(source_code_files, libraries, &solc_version, &debug_config)?;
|
||||
let project = Project::try_from_standard_json_output(
|
||||
&solc_output,
|
||||
source_code_files,
|
||||
libraries,
|
||||
&solc_version,
|
||||
&debug_config,
|
||||
)?;
|
||||
|
||||
if detect_missing_libraries {
|
||||
let missing_libraries = project.get_missing_libraries();
|
||||
missing_libraries.write_to_standard_json(&mut solc_output, &solc_version)?;
|
||||
} else {
|
||||
let build = project.compile(optimizer_settings, include_metadata_hash, debug_config)?;
|
||||
let build = project.compile(
|
||||
optimizer_settings,
|
||||
include_metadata_hash,
|
||||
debug_config,
|
||||
llvm_arguments,
|
||||
)?;
|
||||
build.write_to_standard_json(&mut solc_output, &solc_version)?;
|
||||
}
|
||||
serde_json::to_writer(std::io::stdout(), &solc_output)?;
|
||||
@@ -247,10 +272,11 @@ pub fn combined_json<T: Compiler>(
|
||||
include_paths: Vec<String>,
|
||||
allow_paths: Option<String>,
|
||||
remappings: Option<BTreeSet<String>>,
|
||||
suppressed_warnings: Option<Vec<Warning>>,
|
||||
suppressed_warnings: Option<Vec<ResolcWarning>>,
|
||||
debug_config: revive_llvm_context::DebugConfig,
|
||||
output_directory: Option<PathBuf>,
|
||||
overwrite: bool,
|
||||
llvm_arguments: &[String],
|
||||
) -> anyhow::Result<()> {
|
||||
let build = standard_output(
|
||||
input_files,
|
||||
@@ -266,6 +292,7 @@ pub fn combined_json<T: Compiler>(
|
||||
remappings,
|
||||
suppressed_warnings,
|
||||
debug_config,
|
||||
llvm_arguments,
|
||||
)?;
|
||||
|
||||
let mut combined_json = solc.combined_json(input_files, format.as_str())?;
|
||||
|
||||
@@ -3,7 +3,8 @@
|
||||
use std::collections::BTreeMap;
|
||||
use std::collections::HashSet;
|
||||
|
||||
use crate::solc::standard_json::output::Output as StandardJsonOutput;
|
||||
use revive_solc_json_interface::SolcStandardJsonOutput;
|
||||
|
||||
use crate::solc::version::Version as SolcVersion;
|
||||
use crate::ResolcVersion;
|
||||
|
||||
@@ -22,7 +23,7 @@ impl MissingLibraries {
|
||||
/// Writes the missing libraries to the standard JSON.
|
||||
pub fn write_to_standard_json(
|
||||
mut self,
|
||||
standard_json: &mut StandardJsonOutput,
|
||||
standard_json: &mut SolcStandardJsonOutput,
|
||||
solc_version: &SolcVersion,
|
||||
) -> anyhow::Result<()> {
|
||||
let contracts = match standard_json.contracts.as_mut() {
|
||||
|
||||
@@ -20,6 +20,8 @@ pub struct Input {
|
||||
pub optimizer_settings: revive_llvm_context::OptimizerSettings,
|
||||
/// The debug output config.
|
||||
pub debug_config: revive_llvm_context::DebugConfig,
|
||||
/// The extra LLVM arguments give used for manual control.
|
||||
pub llvm_arguments: Vec<String>,
|
||||
}
|
||||
|
||||
impl Input {
|
||||
@@ -30,6 +32,7 @@ impl Input {
|
||||
include_metadata_hash: bool,
|
||||
optimizer_settings: revive_llvm_context::OptimizerSettings,
|
||||
debug_config: revive_llvm_context::DebugConfig,
|
||||
llvm_arguments: Vec<String>,
|
||||
) -> Self {
|
||||
Self {
|
||||
contract,
|
||||
@@ -37,6 +40,7 @@ impl Input {
|
||||
include_metadata_hash,
|
||||
optimizer_settings,
|
||||
debug_config,
|
||||
llvm_arguments,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -37,11 +37,19 @@ pub trait Process {
|
||||
}
|
||||
|
||||
let input: Input = revive_common::deserialize_from_slice(buffer.as_slice())?;
|
||||
|
||||
revive_llvm_context::initialize_llvm(
|
||||
revive_llvm_context::Target::PVM,
|
||||
crate::DEFAULT_EXECUTABLE_NAME,
|
||||
&input.llvm_arguments,
|
||||
);
|
||||
|
||||
let result = input.contract.compile(
|
||||
input.project,
|
||||
input.optimizer_settings,
|
||||
input.include_metadata_hash,
|
||||
input.debug_config,
|
||||
&input.llvm_arguments,
|
||||
);
|
||||
|
||||
match result {
|
||||
|
||||
@@ -18,6 +18,8 @@ pub struct Metadata {
|
||||
pub revive_version: String,
|
||||
/// The PolkaVM compiler optimizer settings.
|
||||
pub optimizer_settings: revive_llvm_context::OptimizerSettings,
|
||||
/// The extra LLVM arguments give used for manual control.
|
||||
pub llvm_arguments: Vec<String>,
|
||||
}
|
||||
|
||||
impl Metadata {
|
||||
@@ -27,6 +29,7 @@ impl Metadata {
|
||||
solc_version: String,
|
||||
revive_pallet_version: Option<semver::Version>,
|
||||
optimizer_settings: revive_llvm_context::OptimizerSettings,
|
||||
llvm_arguments: Vec<String>,
|
||||
) -> Self {
|
||||
Self {
|
||||
solc_metadata,
|
||||
@@ -34,6 +37,7 @@ impl Metadata {
|
||||
revive_pallet_version,
|
||||
revive_version: ResolcVersion::default().long,
|
||||
optimizer_settings,
|
||||
llvm_arguments,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user