mirror of
https://github.com/pezkuwichain/revive.git
synced 2026-06-14 15:41:04 +00:00
Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 alvicsam
|
f6dcd23e90 |
@@ -1,38 +0,0 @@
|
|||||||
name: Build revive-debian
|
|
||||||
on:
|
|
||||||
workflow_dispatch:
|
|
||||||
|
|
||||||
env:
|
|
||||||
REVIVE_DEBIAN_PACKAGE: revive-debian-x86
|
|
||||||
DEBIAN_CONTAINER: revive-builder-debian-x86
|
|
||||||
DEBIAN_CONTAINER_BUILDER: build-debian-builder.sh
|
|
||||||
DEBIAN_CONTAINER_RUNNER: run-debian-builder.sh
|
|
||||||
REVIVE_DEBIAN_INSTALL: ${{ github.workspace }}/target/release
|
|
||||||
REVIVE_DEBIAN_BINARY: resolc
|
|
||||||
RUST_VERSION: "1.80"
|
|
||||||
|
|
||||||
jobs:
|
|
||||||
build-revive-debian-x86:
|
|
||||||
name: debian-container-x86
|
|
||||||
runs-on: ubuntu-latest
|
|
||||||
steps:
|
|
||||||
- uses: actions/checkout@v4
|
|
||||||
|
|
||||||
- name: build-container
|
|
||||||
run: |
|
|
||||||
(cd utils && ./${{ env.DEBIAN_CONTAINER_BUILDER}} --build-arg RUST_VERSION=${{ env.RUST_VERSION}} . )
|
|
||||||
|
|
||||||
- name: build-revive-debian
|
|
||||||
run: |
|
|
||||||
rustup show
|
|
||||||
cargo --version
|
|
||||||
rustup +nightly show
|
|
||||||
cargo +nightly --version
|
|
||||||
bash --version
|
|
||||||
utils/${{ env.DEBIAN_CONTAINER_RUNNER }} utils/build-revive.sh -o ${{ env.REVIVE_DEBIAN_INSTALL}}
|
|
||||||
|
|
||||||
- uses: actions/upload-artifact@v4
|
|
||||||
with:
|
|
||||||
name: ${{ env.REVIVE_DEBIAN_PACKAGE }}
|
|
||||||
path: ${{ env.REVIVE_DEBIAN_INSTALL }}/${{ env.REVIVE_DEBIAN_BINARY }}
|
|
||||||
retention-days: 1
|
|
||||||
@@ -1,55 +0,0 @@
|
|||||||
name: Build
|
|
||||||
|
|
||||||
on:
|
|
||||||
push:
|
|
||||||
branches: ["main"]
|
|
||||||
pull_request:
|
|
||||||
branches: ["main"]
|
|
||||||
|
|
||||||
env:
|
|
||||||
CARGO_TERM_COLOR: always
|
|
||||||
|
|
||||||
jobs:
|
|
||||||
build-ubuntu-x86:
|
|
||||||
runs-on: ubuntu-latest
|
|
||||||
|
|
||||||
steps:
|
|
||||||
- uses: actions/checkout@v4
|
|
||||||
|
|
||||||
- name: Install solc
|
|
||||||
run: |
|
|
||||||
mkdir -p solc
|
|
||||||
curl -sSL --output solc/solc https://github.com/ethereum/solidity/releases/download/v0.8.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/llvm/llvm-project/releases/download/llvmorg-18.1.4/clang+llvm-18.1.4-x86_64-linux-gnu-ubuntu-18.04.tar.xz
|
|
||||||
tar Jxf llvm.tar.xz
|
|
||||||
mv clang+llvm-18.1.4-x86_64-linux-gnu-ubuntu-18.04 llvm18/
|
|
||||||
echo "$(pwd)/llvm18/bin" >> $GITHUB_PATH
|
|
||||||
|
|
||||||
- name: Install apt dependencies
|
|
||||||
run: |
|
|
||||||
sudo add-apt-repository -y ppa:ethereum/ethereum
|
|
||||||
sudo apt update
|
|
||||||
sudo apt install -y libtinfo5 ethereum
|
|
||||||
|
|
||||||
- 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
|
|
||||||
-16
@@ -1,16 +0,0 @@
|
|||||||
/target
|
|
||||||
*.dot
|
|
||||||
.vscode/
|
|
||||||
.DS_Store
|
|
||||||
/*.sol
|
|
||||||
/*.yul
|
|
||||||
/*.ll
|
|
||||||
/*.s
|
|
||||||
/llvm-project
|
|
||||||
/llvm18.0
|
|
||||||
node_modules
|
|
||||||
artifacts
|
|
||||||
tmp
|
|
||||||
package-lock.json
|
|
||||||
/*.html
|
|
||||||
/build
|
|
||||||
Generated
-11890
File diff suppressed because it is too large
Load Diff
-82
@@ -1,82 +0,0 @@
|
|||||||
[workspace]
|
|
||||||
resolver = "2"
|
|
||||||
members = ["crates/*"]
|
|
||||||
|
|
||||||
[workspace.package]
|
|
||||||
version = "0.1.0"
|
|
||||||
authors = [
|
|
||||||
"Cyrill Leutwiler <cyrill@parity.io>",
|
|
||||||
"Parity Technologies <admin@parity.io>",
|
|
||||||
]
|
|
||||||
license = "MIT/Apache-2.0"
|
|
||||||
edition = "2021"
|
|
||||||
repository = "https://github.com/paritytech/revive"
|
|
||||||
rust-version = "1.80.0"
|
|
||||||
|
|
||||||
[workspace.dependencies]
|
|
||||||
revive-benchmarks = { version = "0.1.0", path = "crates/benchmarks" }
|
|
||||||
revive-builtins = { version = "0.1.0", path = "crates/builtins" }
|
|
||||||
revive-common = { version = "0.1.0", path = "crates/common" }
|
|
||||||
revive-differential = { version = "0.1.0", path = "crates/differential" }
|
|
||||||
revive-integration = { version = "0.1.0", path = "crates/integration" }
|
|
||||||
revive-linker = { version = "0.1.0", path = "crates/linker" }
|
|
||||||
lld-sys = { version = "0.1.0", path = "crates/lld-sys" }
|
|
||||||
revive-llvm-context = { version = "0.1.0", path = "crates/llvm-context" }
|
|
||||||
revive-runtime-api = { version = "0.1.0", path = "crates/runtime-api" }
|
|
||||||
revive-runner = { version = "0.1.0", path = "crates/runner" }
|
|
||||||
revive-solidity = { version = "0.1.0", path = "crates/solidity" }
|
|
||||||
revive-stdlib = { version = "0.1.0", path = "crates/stdlib" }
|
|
||||||
|
|
||||||
hex = "0.4"
|
|
||||||
petgraph = "0.6"
|
|
||||||
cc = "1.0"
|
|
||||||
libc = "0.2"
|
|
||||||
tempfile = "3.8"
|
|
||||||
anyhow = "1.0"
|
|
||||||
semver = { version = "1.0", features = [ "serde" ] }
|
|
||||||
itertools = "0.12"
|
|
||||||
serde = { version = "1.0", features = [ "derive" ] }
|
|
||||||
serde_json = { version = "1.0", features = [ "arbitrary_precision" ] }
|
|
||||||
regex = "1.10"
|
|
||||||
once_cell = "1.19"
|
|
||||||
num = "0.4"
|
|
||||||
sha1 = "0.10"
|
|
||||||
sha2 = "0.10"
|
|
||||||
sha3 = "0.10"
|
|
||||||
md5 = "0.7"
|
|
||||||
colored = "2.1"
|
|
||||||
thiserror = "1.0"
|
|
||||||
which = "5.0"
|
|
||||||
path-slash = "0.2"
|
|
||||||
rayon = "1.8"
|
|
||||||
clap = { version = "4", default-features = false, features = ["derive"] }
|
|
||||||
rand = "0.8"
|
|
||||||
polkavm-common = "0.14"
|
|
||||||
polkavm-linker = "0.14"
|
|
||||||
polkavm-disassembler = "0.14"
|
|
||||||
polkavm = "0.14"
|
|
||||||
alloy-primitives = { version = "0.8", features = ["serde"] }
|
|
||||||
alloy-sol-types = "0.8"
|
|
||||||
alloy-genesis = "0.3"
|
|
||||||
alloy-serde = "0.3"
|
|
||||||
env_logger = { version = "0.10.0", default-features = false }
|
|
||||||
serde_stacker = "0.1"
|
|
||||||
criterion = { version = "0.5", features = ["html_reports"] }
|
|
||||||
log = { version = "0.4" }
|
|
||||||
|
|
||||||
# polkadot-sdk and friends
|
|
||||||
codec = { version = "3.6.12", default-features = false, package = "parity-scale-codec" }
|
|
||||||
scale-info = { version = "2.11.1", default-features = false }
|
|
||||||
polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk", rev = "db40a66db71e8e7fe943dda5cd0e28078efa2a19" }
|
|
||||||
|
|
||||||
# llvm
|
|
||||||
[workspace.dependencies.inkwell]
|
|
||||||
git = "https://github.com/TheDan64/inkwell.git"
|
|
||||||
rev = "7b410298b6a93450adaa90b1841d5805a3038f12"
|
|
||||||
default-features = false
|
|
||||||
features = ["serde", "llvm18-0", "no-libffi-linking", "target-riscv"]
|
|
||||||
|
|
||||||
[profile.bench]
|
|
||||||
inherits = "release"
|
|
||||||
lto = true
|
|
||||||
codegen-units = 1
|
|
||||||
-191
@@ -1,191 +0,0 @@
|
|||||||
|
|
||||||
Apache License
|
|
||||||
Version 2.0, January 2004
|
|
||||||
https://www.apache.org/licenses/
|
|
||||||
|
|
||||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
|
||||||
|
|
||||||
1. Definitions.
|
|
||||||
|
|
||||||
"License" shall mean the terms and conditions for use, reproduction,
|
|
||||||
and distribution as defined by Sections 1 through 9 of this document.
|
|
||||||
|
|
||||||
"Licensor" shall mean the copyright owner or entity authorized by
|
|
||||||
the copyright owner that is granting the License.
|
|
||||||
|
|
||||||
"Legal Entity" shall mean the union of the acting entity and all
|
|
||||||
other entities that control, are controlled by, or are under common
|
|
||||||
control with that entity. For the purposes of this definition,
|
|
||||||
"control" means (i) the power, direct or indirect, to cause the
|
|
||||||
direction or management of such entity, whether by contract or
|
|
||||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
|
||||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
|
||||||
|
|
||||||
"You" (or "Your") shall mean an individual or Legal Entity
|
|
||||||
exercising permissions granted by this License.
|
|
||||||
|
|
||||||
"Source" form shall mean the preferred form for making modifications,
|
|
||||||
including but not limited to software source code, documentation
|
|
||||||
source, and configuration files.
|
|
||||||
|
|
||||||
"Object" form shall mean any form resulting from mechanical
|
|
||||||
transformation or translation of a Source form, including but
|
|
||||||
not limited to compiled object code, generated documentation,
|
|
||||||
and conversions to other media types.
|
|
||||||
|
|
||||||
"Work" shall mean the work of authorship, whether in Source or
|
|
||||||
Object form, made available under the License, as indicated by a
|
|
||||||
copyright notice that is included in or attached to the work
|
|
||||||
(an example is provided in the Appendix below).
|
|
||||||
|
|
||||||
"Derivative Works" shall mean any work, whether in Source or Object
|
|
||||||
form, that is based on (or derived from) the Work and for which the
|
|
||||||
editorial revisions, annotations, elaborations, or other modifications
|
|
||||||
represent, as a whole, an original work of authorship. For the purposes
|
|
||||||
of this License, Derivative Works shall not include works that remain
|
|
||||||
separable from, or merely link (or bind by name) to the interfaces of,
|
|
||||||
the Work and Derivative Works thereof.
|
|
||||||
|
|
||||||
"Contribution" shall mean any work of authorship, including
|
|
||||||
the original version of the Work and any modifications or additions
|
|
||||||
to that Work or Derivative Works thereof, that is intentionally
|
|
||||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
|
||||||
or by an individual or Legal Entity authorized to submit on behalf of
|
|
||||||
the copyright owner. For the purposes of this definition, "submitted"
|
|
||||||
means any form of electronic, verbal, or written communication sent
|
|
||||||
to the Licensor or its representatives, including but not limited to
|
|
||||||
communication on electronic mailing lists, source code control systems,
|
|
||||||
and issue tracking systems that are managed by, or on behalf of, the
|
|
||||||
Licensor for the purpose of discussing and improving the Work, but
|
|
||||||
excluding communication that is conspicuously marked or otherwise
|
|
||||||
designated in writing by the copyright owner as "Not a Contribution."
|
|
||||||
|
|
||||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
|
||||||
on behalf of whom a Contribution has been received by Licensor and
|
|
||||||
subsequently incorporated within the Work.
|
|
||||||
|
|
||||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
copyright license to reproduce, prepare Derivative Works of,
|
|
||||||
publicly display, publicly perform, sublicense, and distribute the
|
|
||||||
Work and such Derivative Works in Source or Object form.
|
|
||||||
|
|
||||||
3. Grant of Patent License. Subject to the terms and conditions of
|
|
||||||
this License, each Contributor hereby grants to You a perpetual,
|
|
||||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
|
||||||
(except as stated in this section) patent license to make, have made,
|
|
||||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
|
||||||
where such license applies only to those patent claims licensable
|
|
||||||
by such Contributor that are necessarily infringed by their
|
|
||||||
Contribution(s) alone or by combination of their Contribution(s)
|
|
||||||
with the Work to which such Contribution(s) was submitted. If You
|
|
||||||
institute patent litigation against any entity (including a
|
|
||||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
|
||||||
or a Contribution incorporated within the Work constitutes direct
|
|
||||||
or contributory patent infringement, then any patent licenses
|
|
||||||
granted to You under this License for that Work shall terminate
|
|
||||||
as of the date such litigation is filed.
|
|
||||||
|
|
||||||
4. Redistribution. You may reproduce and distribute copies of the
|
|
||||||
Work or Derivative Works thereof in any medium, with or without
|
|
||||||
modifications, and in Source or Object form, provided that You
|
|
||||||
meet the following conditions:
|
|
||||||
|
|
||||||
(a) You must give any other recipients of the Work or
|
|
||||||
Derivative Works a copy of this License; and
|
|
||||||
|
|
||||||
(b) You must cause any modified files to carry prominent notices
|
|
||||||
stating that You changed the files; and
|
|
||||||
|
|
||||||
(c) You must retain, in the Source form of any Derivative Works
|
|
||||||
that You distribute, all copyright, patent, trademark, and
|
|
||||||
attribution notices from the Source form of the Work,
|
|
||||||
excluding those notices that do not pertain to any part of
|
|
||||||
the Derivative Works; and
|
|
||||||
|
|
||||||
(d) If the Work includes a "NOTICE" text file as part of its
|
|
||||||
distribution, then any Derivative Works that You distribute must
|
|
||||||
include a readable copy of the attribution notices contained
|
|
||||||
within such NOTICE file, excluding those notices that do not
|
|
||||||
pertain to any part of the Derivative Works, in at least one
|
|
||||||
of the following places: within a NOTICE text file distributed
|
|
||||||
as part of the Derivative Works; within the Source form or
|
|
||||||
documentation, if provided along with the Derivative Works; or,
|
|
||||||
within a display generated by the Derivative Works, if and
|
|
||||||
wherever such third-party notices normally appear. The contents
|
|
||||||
of the NOTICE file are for informational purposes only and
|
|
||||||
do not modify the License. You may add Your own attribution
|
|
||||||
notices within Derivative Works that You distribute, alongside
|
|
||||||
or as an addendum to the NOTICE text from the Work, provided
|
|
||||||
that such additional attribution notices cannot be construed
|
|
||||||
as modifying the License.
|
|
||||||
|
|
||||||
You may add Your own copyright statement to Your modifications and
|
|
||||||
may provide additional or different license terms and conditions
|
|
||||||
for use, reproduction, or distribution of Your modifications, or
|
|
||||||
for any such Derivative Works as a whole, provided Your use,
|
|
||||||
reproduction, and distribution of the Work otherwise complies with
|
|
||||||
the conditions stated in this License.
|
|
||||||
|
|
||||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
|
||||||
any Contribution intentionally submitted for inclusion in the Work
|
|
||||||
by You to the Licensor shall be under the terms and conditions of
|
|
||||||
this License, without any additional terms or conditions.
|
|
||||||
Notwithstanding the above, nothing herein shall supersede or modify
|
|
||||||
the terms of any separate license agreement you may have executed
|
|
||||||
with Licensor regarding such Contributions.
|
|
||||||
|
|
||||||
6. Trademarks. This License does not grant permission to use the trade
|
|
||||||
names, trademarks, service marks, or product names of the Licensor,
|
|
||||||
except as required for reasonable and customary use in describing the
|
|
||||||
origin of the Work and reproducing the content of the NOTICE file.
|
|
||||||
|
|
||||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
|
||||||
agreed to in writing, Licensor provides the Work (and each
|
|
||||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
||||||
implied, including, without limitation, any warranties or conditions
|
|
||||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
|
||||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
|
||||||
appropriateness of using or redistributing the Work and assume any
|
|
||||||
risks associated with Your exercise of permissions under this License.
|
|
||||||
|
|
||||||
8. Limitation of Liability. In no event and under no legal theory,
|
|
||||||
whether in tort (including negligence), contract, or otherwise,
|
|
||||||
unless required by applicable law (such as deliberate and grossly
|
|
||||||
negligent acts) or agreed to in writing, shall any Contributor be
|
|
||||||
liable to You for damages, including any direct, indirect, special,
|
|
||||||
incidental, or consequential damages of any character arising as a
|
|
||||||
result of this License or out of the use or inability to use the
|
|
||||||
Work (including but not limited to damages for loss of goodwill,
|
|
||||||
work stoppage, computer failure or malfunction, or any and all
|
|
||||||
other commercial damages or losses), even if such Contributor
|
|
||||||
has been advised of the possibility of such damages.
|
|
||||||
|
|
||||||
9. Accepting Warranty or Additional Liability. While redistributing
|
|
||||||
the Work or Derivative Works thereof, You may choose to offer,
|
|
||||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
|
||||||
or other liability obligations and/or rights consistent with this
|
|
||||||
License. However, in accepting such obligations, You may act only
|
|
||||||
on Your own behalf and on Your sole responsibility, not on behalf
|
|
||||||
of any other Contributor, and only if You agree to indemnify,
|
|
||||||
defend, and hold each Contributor harmless for any liability
|
|
||||||
incurred by, or claims asserted against, such Contributor by reason
|
|
||||||
of your accepting any such warranty or additional liability.
|
|
||||||
|
|
||||||
END OF TERMS AND CONDITIONS
|
|
||||||
|
|
||||||
Copyright (c) 2019 Matter Labs
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
https://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
||||||
-21
@@ -1,21 +0,0 @@
|
|||||||
MIT License
|
|
||||||
|
|
||||||
Copyright (c) 2019 Matter Labs
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
of this software and associated documentation files (the "Software"), to deal
|
|
||||||
in the Software without restriction, including without limitation the rights
|
|
||||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
||||||
copies of the Software, and to permit persons to whom the Software is
|
|
||||||
furnished to do so, subject to the following conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included in all
|
|
||||||
copies or substantial portions of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
||||||
SOFTWARE.
|
|
||||||
@@ -1,61 +0,0 @@
|
|||||||
.PHONY: install format test test-solidity test-cli test-integration test-workspace clean docs docs-build
|
|
||||||
|
|
||||||
install: install-bin install-npm
|
|
||||||
|
|
||||||
install-bin:
|
|
||||||
cargo install --path crates/solidity
|
|
||||||
|
|
||||||
install-npm:
|
|
||||||
npm install && npm fund
|
|
||||||
|
|
||||||
# install-revive: Build and install to the directory specified in REVIVE_INSTALL_DIR
|
|
||||||
ifeq ($(origin REVIVE_INSTALL_DIR), undefined)
|
|
||||||
REVIVE_INSTALL_DIR=`pwd`/release/revive-debian
|
|
||||||
endif
|
|
||||||
install-revive:
|
|
||||||
cargo install --path crates/solidity --root $(REVIVE_INSTALL_DIR)
|
|
||||||
|
|
||||||
format:
|
|
||||||
cargo fmt --all --check
|
|
||||||
|
|
||||||
clippy:
|
|
||||||
cargo clippy --all-features --workspace --tests --benches -- --deny warnings --allow dead_code
|
|
||||||
|
|
||||||
test: format clippy test-cli test-workspace
|
|
||||||
|
|
||||||
test-integration: install-bin
|
|
||||||
cargo test --package revive-integration
|
|
||||||
|
|
||||||
test-solidity: install
|
|
||||||
cargo test --package revive-solidity
|
|
||||||
|
|
||||||
test-workspace: install
|
|
||||||
cargo test --workspace
|
|
||||||
|
|
||||||
test-cli: install
|
|
||||||
npm run test:cli
|
|
||||||
|
|
||||||
bench-pvm: install-bin
|
|
||||||
cargo criterion --bench execute --features bench-pvm-interpreter --message-format=json \
|
|
||||||
| criterion-table > crates/benchmarks/PVM.md
|
|
||||||
|
|
||||||
bench-evm: install-bin
|
|
||||||
cargo criterion --bench execute --features bench-evm --message-format=json \
|
|
||||||
| criterion-table > crates/benchmarks/EVM.md
|
|
||||||
|
|
||||||
bench: install-bin
|
|
||||||
cargo criterion --all --all-features --message-format=json \
|
|
||||||
| criterion-table > crates/benchmarks/BENCHMARKS.md
|
|
||||||
|
|
||||||
docs: docs-build
|
|
||||||
mdbook serve --open docs/
|
|
||||||
|
|
||||||
docs-build:
|
|
||||||
mdbook test docs/ && mdbook build docs/
|
|
||||||
|
|
||||||
clean:
|
|
||||||
cargo clean ; \
|
|
||||||
rm -rf node_modules ; \
|
|
||||||
rm -rf crates/solidity/src/tests/cli-tests/artifacts ; \
|
|
||||||
cargo uninstall revive-solidity ; \
|
|
||||||
rm -f package-lock.json
|
|
||||||
@@ -1,38 +0,0 @@
|
|||||||
|
|
||||||
|
|
||||||
# revive
|
|
||||||
|
|
||||||
YUL and EVM assembly recompiler to LLVM, targetting RISC-V on [PolkaVM](https://github.com/koute/polkavm).
|
|
||||||
|
|
||||||
[Frontend](https://github.com/matter-labs/era-compiler-solidity) and [code generator](https://github.com/matter-labs/era-compiler-llvm-context) are based of ZKSync `zksolc`.
|
|
||||||
|
|
||||||
## Status
|
|
||||||
|
|
||||||
This is experimental software in active development and not ready just yet for production usage.
|
|
||||||
|
|
||||||
Discussion around the development is hosted on the [Polkadot Forum](https://forum.polkadot.network/t/contracts-update-solidity-on-polkavm/6949#a-new-solidity-compiler-1).
|
|
||||||
|
|
||||||
## Installation
|
|
||||||
|
|
||||||
`resolc` depends on the [solc](https://github.com/ethereum/solidity) binary installed on your system.
|
|
||||||
|
|
||||||
To install the `resolc` Solidity frontend executable:
|
|
||||||
|
|
||||||
```bash
|
|
||||||
bash build-llvm.sh
|
|
||||||
export PATH=${PWD}/llvm18.0/bin:$PATH
|
|
||||||
make install-bin
|
|
||||||
resolc --version
|
|
||||||
```
|
|
||||||
|
|
||||||
### LLVM
|
|
||||||
|
|
||||||
`revive` requires a build of LLVM 18.1.4 or later including `compiler-rt`. Use the provided [build-llvm.sh](build-llvm.sh) build script to compile a compatible LLVM build locally in `$PWD/llvm18.0` (don't forget to add that to `$PATH` afterwards).
|
|
||||||
|
|
||||||
### Development
|
|
||||||
|
|
||||||
Please consult the [Makefile](Makefile) targets to learn how to run tests and benchmarks.
|
|
||||||
Ensure that your branch passes `make test` locally when submitting a pull request.
|
|
||||||
|
|
||||||
## Design overview
|
|
||||||
`revive` uses [solc](https://github.com/ethereum/solidity/), the Ethereum Solidity compiler, as the [Solidity frontend](crates/solidity/src/lib.rs) to process smart contracts written in Solidity. The YUL IR code (or legacy EVM assembly as a fallback for older `solc` versions) emitted by `solc` is then translated to LLVM IR, targetting [Polkadots `revive` pallet](https://docs.rs/pallet-revive/latest/pallet_revive/trait.SyscallDoc.html).
|
|
||||||
@@ -1,92 +0,0 @@
|
|||||||
#!/usr/bin/env bash
|
|
||||||
|
|
||||||
set -euo pipefail
|
|
||||||
|
|
||||||
INSTALL_DIR="${PWD}/llvm18.0"
|
|
||||||
mkdir -p ${INSTALL_DIR}
|
|
||||||
|
|
||||||
|
|
||||||
# Clone LLVM 18 (any revision after commit bd32aaa is supposed to work)
|
|
||||||
if [ ! -d "llvm-project" ]; then
|
|
||||||
git clone --depth 1 --branch release/18.x https://github.com/llvm/llvm-project.git
|
|
||||||
fi
|
|
||||||
|
|
||||||
|
|
||||||
# Build LLVM, clang
|
|
||||||
LLVM_SRC_PREFIX=${PWD}/llvm-project
|
|
||||||
LLVM_SRC_DIR=${LLVM_SRC_PREFIX}/llvm
|
|
||||||
LLVM_BUILD_DIR=${PWD}/build/llvm
|
|
||||||
if [ ! -d ${LLVM_BUILD_DIR} ] ; then
|
|
||||||
mkdir -p ${LLVM_BUILD_DIR}
|
|
||||||
fi
|
|
||||||
|
|
||||||
cmake -G Ninja \
|
|
||||||
-S ${LLVM_SRC_DIR} \
|
|
||||||
-B ${LLVM_BUILD_DIR} \
|
|
||||||
-DLLVM_ENABLE_ASSERTIONS=On \
|
|
||||||
-DLLVM_ENABLE_TERMINFO=Off \
|
|
||||||
-DLLVM_ENABLE_LIBXML2=Off \
|
|
||||||
-DLLVM_ENABLE_ZLIB=Off \
|
|
||||||
-DLLVM_ENABLE_PROJECTS='clang;lld' \
|
|
||||||
-DLLVM_TARGETS_TO_BUILD='RISCV' \
|
|
||||||
-DLLVM_ENABLE_ZSTD=Off \
|
|
||||||
-DCMAKE_BUILD_TYPE=MinSizeRel \
|
|
||||||
-DCMAKE_INSTALL_PREFIX=${INSTALL_DIR}
|
|
||||||
|
|
||||||
cmake --build ${LLVM_BUILD_DIR}
|
|
||||||
cmake --install ${LLVM_BUILD_DIR}
|
|
||||||
|
|
||||||
# Build compiler builtins
|
|
||||||
COMPILER_RT_SRC_DIR=${LLVM_SRC_PREFIX}/compiler-rt
|
|
||||||
COMPILER_RT_BUILD_DIR=${PWD}/build/compiler-rt
|
|
||||||
if [ ! -d ${COMPILER_RT_BUILD_DIR} ] ; then
|
|
||||||
mkdir -p ${COMPILER_RT_BUILD_DIR}
|
|
||||||
fi
|
|
||||||
|
|
||||||
build_compiler_rt() {
|
|
||||||
case "$1" in
|
|
||||||
64) TARGET_ABI=lp64e ;;
|
|
||||||
32) TARGET_ABI=ilp32e ;;
|
|
||||||
*) exit -1
|
|
||||||
esac
|
|
||||||
CFLAGS="--target=riscv${1} -march=rv${1}em -mabi=${TARGET_ABI} -mcpu=generic-rv${1} -nostdlib -nodefaultlibs"
|
|
||||||
|
|
||||||
cmake -G Ninja \
|
|
||||||
-S ${COMPILER_RT_SRC_DIR} \
|
|
||||||
-B ${COMPILER_RT_BUILD_DIR} \
|
|
||||||
-DCMAKE_BUILD_TYPE=Release \
|
|
||||||
-DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} \
|
|
||||||
-DCOMPILER_RT_BUILD_BUILTINS=ON \
|
|
||||||
-DCOMPILER_RT_BUILD_LIBFUZZER=OFF \
|
|
||||||
-DCOMPILER_RT_BUILD_MEMPROF=OFF \
|
|
||||||
-DCOMPILER_RT_BUILD_PROFILE=OFF \
|
|
||||||
-DCOMPILER_RT_BUILD_SANITIZERS=OFF \
|
|
||||||
-DCOMPILER_RT_BUILD_XRAY=OFF \
|
|
||||||
-DCMAKE_C_COMPILER=${INSTALL_DIR}/bin/clang \
|
|
||||||
-DCMAKE_C_COMPILER_TARGET=riscv${1} \
|
|
||||||
-DCMAKE_ASM_COMPILER_TARGET=riscv${1} \
|
|
||||||
-DCMAKE_CXX_COMPILER_TARGET=riscv${1} \
|
|
||||||
-DCMAKE_C_TARGET_BITS=riscv${1} \
|
|
||||||
-DCMAKE_ASM_TARGET_BITS=riscv${1} \
|
|
||||||
-DCMAKE_AR=${INSTALL_DIR}/bin/llvm-ar \
|
|
||||||
-DCMAKE_NM=${INSTALL_DIR}/bin/llvm-nm \
|
|
||||||
-DCMAKE_RANLIB=${INSTALL_DIR}/bin/llvm-ranlib \
|
|
||||||
-DCOMPILER_RT_BAREMETAL_BUILD=ON \
|
|
||||||
-DLLVM_CONFIG_PATH=${INSTALL_DIR}/bin/llvm-config \
|
|
||||||
-DCMAKE_C_FLAGS="${CFLAGS}" \
|
|
||||||
-DCMAKE_ASM_FLAGS="${CFLAGS}" \
|
|
||||||
-DCOMPILER_RT_TEST_COMPILER=${INSTALL_DIR}/bin/clang \
|
|
||||||
-DCMAKE_CXX_FLAGS="${CFLAGS}" \
|
|
||||||
-DCMAKE_SYSTEM_NAME=unknown \
|
|
||||||
-DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON
|
|
||||||
|
|
||||||
cmake --build ${COMPILER_RT_BUILD_DIR}
|
|
||||||
cmake --install ${COMPILER_RT_BUILD_DIR}
|
|
||||||
}
|
|
||||||
|
|
||||||
build_compiler_rt 32
|
|
||||||
build_compiler_rt 64
|
|
||||||
|
|
||||||
echo ""
|
|
||||||
echo "success"
|
|
||||||
echo "add this directory to your PATH: ${INSTALL_DIR}/bin/"
|
|
||||||
@@ -1,73 +0,0 @@
|
|||||||
# Benchmarks
|
|
||||||
|
|
||||||
## Table of Contents
|
|
||||||
|
|
||||||
- [Benchmark Results](#benchmark-results)
|
|
||||||
- [Baseline](#baseline)
|
|
||||||
- [OddPorduct](#oddporduct)
|
|
||||||
- [TriangleNumber](#trianglenumber)
|
|
||||||
- [FibonacciRecursive](#fibonaccirecursive)
|
|
||||||
- [FibonacciIterative](#fibonacciiterative)
|
|
||||||
- [FibonacciBinet](#fibonaccibinet)
|
|
||||||
- [SHA1](#sha1)
|
|
||||||
|
|
||||||
## Benchmark Results
|
|
||||||
|
|
||||||
### Baseline
|
|
||||||
|
|
||||||
| | `EVM` | `PVMInterpreter` |
|
|
||||||
|:--------|:------------------------|:-------------------------------- |
|
|
||||||
| **`0`** | `5.97 us` (✅ **1.00x**) | `27.04 us` (❌ *4.53x slower*) |
|
|
||||||
|
|
||||||
### OddPorduct
|
|
||||||
|
|
||||||
| | `EVM` | `PVMInterpreter` |
|
|
||||||
|:-------------|:--------------------------|:-------------------------------- |
|
|
||||||
| **`10000`** | `4.26 ms` (✅ **1.00x**) | `2.88 ms` (✅ **1.48x faster**) |
|
|
||||||
| **`100000`** | `42.37 ms` (✅ **1.00x**) | `28.35 ms` (✅ **1.49x faster**) |
|
|
||||||
| **`300000`** | `127.88 ms` (✅ **1.00x**) | `88.43 ms` (✅ **1.45x faster**) |
|
|
||||||
|
|
||||||
### TriangleNumber
|
|
||||||
|
|
||||||
| | `EVM` | `PVMInterpreter` |
|
|
||||||
|:-------------|:--------------------------|:-------------------------------- |
|
|
||||||
| **`10000`** | `2.85 ms` (✅ **1.00x**) | `2.37 ms` (✅ **1.20x faster**) |
|
|
||||||
| **`100000`** | `27.85 ms` (✅ **1.00x**) | `23.01 ms` (✅ **1.21x faster**) |
|
|
||||||
| **`360000`** | `103.01 ms` (✅ **1.00x**) | `83.66 ms` (✅ **1.23x faster**) |
|
|
||||||
|
|
||||||
### FibonacciRecursive
|
|
||||||
|
|
||||||
| | `EVM` | `PVMInterpreter` |
|
|
||||||
|:---------|:--------------------------|:--------------------------------- |
|
|
||||||
| **`12`** | `195.19 us` (✅ **1.00x**) | `333.53 us` (❌ *1.71x slower*) |
|
|
||||||
| **`16`** | `1.22 ms` (✅ **1.00x**) | `1.97 ms` (❌ *1.62x slower*) |
|
|
||||||
| **`20`** | `8.14 ms` (✅ **1.00x**) | `13.20 ms` (❌ *1.62x slower*) |
|
|
||||||
| **`24`** | `55.09 ms` (✅ **1.00x**) | `88.56 ms` (❌ *1.61x slower*) |
|
|
||||||
|
|
||||||
### FibonacciIterative
|
|
||||||
|
|
||||||
| | `EVM` | `PVMInterpreter` |
|
|
||||||
|:----------|:-------------------------|:--------------------------------- |
|
|
||||||
| **`64`** | `33.39 us` (✅ **1.00x**) | `86.02 us` (❌ *2.58x slower*) |
|
|
||||||
| **`128`** | `52.91 us` (✅ **1.00x**) | `126.38 us` (❌ *2.39x slower*) |
|
|
||||||
| **`256`** | `82.33 us` (✅ **1.00x**) | `208.74 us` (❌ *2.54x slower*) |
|
|
||||||
|
|
||||||
### FibonacciBinet
|
|
||||||
|
|
||||||
| | `EVM` | `PVMInterpreter` |
|
|
||||||
|:----------|:-------------------------|:--------------------------------- |
|
|
||||||
| **`64`** | `32.29 us` (✅ **1.00x**) | `161.75 us` (❌ *5.01x slower*) |
|
|
||||||
| **`128`** | `36.02 us` (✅ **1.00x**) | `172.59 us` (❌ *4.79x slower*) |
|
|
||||||
| **`256`** | `41.21 us` (✅ **1.00x**) | `185.30 us` (❌ *4.50x slower*) |
|
|
||||||
|
|
||||||
### SHA1
|
|
||||||
|
|
||||||
| | `EVM` | `PVMInterpreter` |
|
|
||||||
|:----------|:--------------------------|:--------------------------------- |
|
|
||||||
| **`1`** | `160.17 us` (✅ **1.00x**) | `403.46 us` (❌ *2.52x slower*) |
|
|
||||||
| **`64`** | `286.69 us` (✅ **1.00x**) | `479.79 us` (❌ *1.67x slower*) |
|
|
||||||
| **`512`** | `1.18 ms` (✅ **1.00x**) | `1.37 ms` (❌ *1.16x slower*) |
|
|
||||||
|
|
||||||
---
|
|
||||||
Made with [criterion-table](https://github.com/nu11ptr/criterion-table)
|
|
||||||
|
|
||||||
@@ -1,28 +0,0 @@
|
|||||||
[package]
|
|
||||||
name = "revive-benchmarks"
|
|
||||||
version.workspace = true
|
|
||||||
license.workspace = true
|
|
||||||
edition.workspace = true
|
|
||||||
repository.workspace = true
|
|
||||||
authors.workspace = true
|
|
||||||
description = "revive compiler benchmarks"
|
|
||||||
|
|
||||||
[features]
|
|
||||||
default = ["bench-pvm-interpreter"]
|
|
||||||
bench-pvm-interpreter = ["revive-runner"]
|
|
||||||
bench-evm = ["revive-differential"]
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
hex = { workspace = true }
|
|
||||||
alloy-primitives = { workspace = true }
|
|
||||||
|
|
||||||
revive-integration = { workspace = true }
|
|
||||||
revive-differential = { workspace = true, optional = true }
|
|
||||||
revive-runner = { workspace = true, optional = true }
|
|
||||||
|
|
||||||
[dev-dependencies]
|
|
||||||
criterion = { workspace = true }
|
|
||||||
|
|
||||||
[[bench]]
|
|
||||||
name = "execute"
|
|
||||||
harness = false
|
|
||||||
@@ -1,124 +0,0 @@
|
|||||||
#![cfg(any(feature = "bench-pvm-interpreter", feature = "bench-evm"))]
|
|
||||||
|
|
||||||
use alloy_primitives::U256;
|
|
||||||
use criterion::{
|
|
||||||
criterion_group, criterion_main,
|
|
||||||
measurement::{Measurement, WallTime},
|
|
||||||
BenchmarkGroup, BenchmarkId, Criterion,
|
|
||||||
};
|
|
||||||
use revive_integration::cases::Contract;
|
|
||||||
|
|
||||||
fn bench<P, L, I>(
|
|
||||||
mut group: BenchmarkGroup<'_, WallTime>,
|
|
||||||
parameters: &[P],
|
|
||||||
labels: &[L],
|
|
||||||
contract: I,
|
|
||||||
) where
|
|
||||||
P: Clone,
|
|
||||||
L: std::fmt::Display,
|
|
||||||
I: Fn(P) -> Contract,
|
|
||||||
{
|
|
||||||
assert_eq!(parameters.len(), labels.len());
|
|
||||||
|
|
||||||
group.sample_size(10);
|
|
||||||
|
|
||||||
for (p, l) in parameters.iter().zip(labels.iter()) {
|
|
||||||
let contract = contract(p.clone());
|
|
||||||
|
|
||||||
#[cfg(feature = "bench-evm")]
|
|
||||||
group.bench_with_input(BenchmarkId::new("EVM", l), p, |b, _| {
|
|
||||||
let code = &contract.evm_runtime;
|
|
||||||
let input = &contract.calldata;
|
|
||||||
b.iter_custom(|iters| revive_benchmarks::measure_evm(code, input, iters));
|
|
||||||
});
|
|
||||||
|
|
||||||
#[cfg(feature = "bench-pvm-interpreter")]
|
|
||||||
group.bench_with_input(BenchmarkId::new("PVMInterpreter", l), p, |b, _| {
|
|
||||||
let specs = revive_benchmarks::create_specs(&contract);
|
|
||||||
b.iter_custom(|iters| revive_benchmarks::measure_pvm(&specs, iters));
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
group.finish();
|
|
||||||
}
|
|
||||||
|
|
||||||
fn group<'error, M>(c: &'error mut Criterion<M>, group_name: &str) -> BenchmarkGroup<'error, M>
|
|
||||||
where
|
|
||||||
M: Measurement,
|
|
||||||
{
|
|
||||||
return c.benchmark_group(group_name);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn bench_baseline(c: &mut Criterion) {
|
|
||||||
let group = group(c, "Baseline");
|
|
||||||
let parameters = &[0u8];
|
|
||||||
|
|
||||||
bench(group, parameters, parameters, |_| Contract::baseline());
|
|
||||||
}
|
|
||||||
|
|
||||||
fn bench_odd_product(c: &mut Criterion) {
|
|
||||||
let group = group(c, "OddPorduct");
|
|
||||||
let parameters = &[10_000, 100_000, 300000];
|
|
||||||
|
|
||||||
bench(group, parameters, parameters, Contract::odd_product);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn bench_triangle_number(c: &mut Criterion) {
|
|
||||||
let group = group(c, "TriangleNumber");
|
|
||||||
let parameters = &[10_000, 100_000, 360000];
|
|
||||||
|
|
||||||
bench(group, parameters, parameters, Contract::triangle_number);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn bench_fibonacci_recurisve(c: &mut Criterion) {
|
|
||||||
let group = group(c, "FibonacciRecursive");
|
|
||||||
let parameters = [12, 16, 20, 24]
|
|
||||||
.iter()
|
|
||||||
.map(|p| U256::from(*p))
|
|
||||||
.collect::<Vec<_>>();
|
|
||||||
|
|
||||||
bench(group, ¶meters, ¶meters, Contract::fib_recursive);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn bench_fibonacci_iterative(c: &mut Criterion) {
|
|
||||||
let group = group(c, "FibonacciIterative");
|
|
||||||
let parameters = [64, 128, 256]
|
|
||||||
.iter()
|
|
||||||
.map(|p| U256::from(*p))
|
|
||||||
.collect::<Vec<_>>();
|
|
||||||
|
|
||||||
bench(group, ¶meters, ¶meters, Contract::fib_iterative);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn bench_fibonacci_binet(c: &mut Criterion) {
|
|
||||||
let group = group(c, "FibonacciBinet");
|
|
||||||
let parameters = [64, 128, 256]
|
|
||||||
.iter()
|
|
||||||
.map(|p| U256::from(*p))
|
|
||||||
.collect::<Vec<_>>();
|
|
||||||
|
|
||||||
bench(group, ¶meters, ¶meters, Contract::fib_binet);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn bench_sha1(c: &mut Criterion) {
|
|
||||||
let group = group(c, "SHA1");
|
|
||||||
let parameters = &[vec![0xff], vec![0xff; 64], vec![0xff; 512]];
|
|
||||||
let labels = parameters.iter().map(|p| p.len()).collect::<Vec<_>>();
|
|
||||||
|
|
||||||
bench(group, parameters, &labels, |input| {
|
|
||||||
Contract::sha1(input.into())
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
criterion_group!(
|
|
||||||
name = execute;
|
|
||||||
config = Criterion::default();
|
|
||||||
targets = bench_baseline,
|
|
||||||
bench_odd_product,
|
|
||||||
bench_triangle_number,
|
|
||||||
bench_fibonacci_recurisve,
|
|
||||||
bench_fibonacci_iterative,
|
|
||||||
bench_fibonacci_binet,
|
|
||||||
bench_sha1
|
|
||||||
);
|
|
||||||
criterion_main!(execute);
|
|
||||||
@@ -1,70 +0,0 @@
|
|||||||
#[cfg(feature = "bench-pvm-interpreter")]
|
|
||||||
pub fn create_specs(contract: &revive_integration::cases::Contract) -> revive_runner::Specs {
|
|
||||||
use revive_runner::*;
|
|
||||||
use SpecsAction::*;
|
|
||||||
Specs {
|
|
||||||
differential: false,
|
|
||||||
actions: vec![
|
|
||||||
Instantiate {
|
|
||||||
code: Code::Bytes(contract.pvm_runtime.to_vec()),
|
|
||||||
origin: TestAddress::Alice,
|
|
||||||
data: Default::default(),
|
|
||||||
value: Default::default(),
|
|
||||||
gas_limit: Default::default(),
|
|
||||||
storage_deposit_limit: Default::default(),
|
|
||||||
salt: Default::default(),
|
|
||||||
},
|
|
||||||
Call {
|
|
||||||
origin: TestAddress::Alice,
|
|
||||||
dest: TestAddress::Instantiated(0),
|
|
||||||
data: contract.calldata.to_vec(),
|
|
||||||
value: Default::default(),
|
|
||||||
gas_limit: Default::default(),
|
|
||||||
storage_deposit_limit: Default::default(),
|
|
||||||
},
|
|
||||||
],
|
|
||||||
..Default::default()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "bench-pvm-interpreter")]
|
|
||||||
pub fn measure_pvm(specs: &revive_runner::Specs, iters: u64) -> std::time::Duration {
|
|
||||||
use revive_runner::*;
|
|
||||||
let mut total_time = std::time::Duration::default();
|
|
||||||
|
|
||||||
for _ in 0..iters {
|
|
||||||
let results = specs.clone().run();
|
|
||||||
|
|
||||||
let CallResult::Exec { result, wall_time } =
|
|
||||||
results.get(1).expect("contract should have been called")
|
|
||||||
else {
|
|
||||||
panic!("expected a execution result");
|
|
||||||
};
|
|
||||||
let ret = result.result.as_ref().unwrap();
|
|
||||||
assert!(!ret.did_revert());
|
|
||||||
|
|
||||||
total_time += *wall_time;
|
|
||||||
}
|
|
||||||
|
|
||||||
total_time
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "bench-evm")]
|
|
||||||
pub fn measure_evm(code: &[u8], input: &[u8], iters: u64) -> std::time::Duration {
|
|
||||||
let mut total_time = std::time::Duration::default();
|
|
||||||
|
|
||||||
let code = hex::encode(code);
|
|
||||||
|
|
||||||
for _ in 0..iters {
|
|
||||||
let log = revive_differential::Evm::default()
|
|
||||||
.code_blob(code.as_bytes().to_vec())
|
|
||||||
.input(input.to_vec().into())
|
|
||||||
.bench(true)
|
|
||||||
.run();
|
|
||||||
assert!(log.output.run_success(), "evm run failed: {log:?}");
|
|
||||||
|
|
||||||
total_time += log.execution_time().unwrap();
|
|
||||||
}
|
|
||||||
|
|
||||||
total_time
|
|
||||||
}
|
|
||||||
@@ -1,14 +0,0 @@
|
|||||||
[package]
|
|
||||||
name = "revive-builtins"
|
|
||||||
version.workspace = true
|
|
||||||
license.workspace = true
|
|
||||||
edition.workspace = true
|
|
||||||
repository.workspace = true
|
|
||||||
authors.workspace = true
|
|
||||||
build = "build.rs"
|
|
||||||
description = "compiler builtins for the revive compiler"
|
|
||||||
|
|
||||||
[features]
|
|
||||||
riscv-64 = []
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
@@ -1,41 +0,0 @@
|
|||||||
use std::{env, fs, io::Read, path::Path, process::Command};
|
|
||||||
|
|
||||||
#[cfg(not(feature = "riscv-64"))]
|
|
||||||
pub const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv32.a";
|
|
||||||
#[cfg(feature = "riscv-64")]
|
|
||||||
pub const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv64.a";
|
|
||||||
|
|
||||||
fn main() {
|
|
||||||
let mut llvm_lib_dir = String::new();
|
|
||||||
|
|
||||||
Command::new("llvm-config")
|
|
||||||
.args(["--libdir"])
|
|
||||||
.output()
|
|
||||||
.expect("llvm-config should be able to provide LD path")
|
|
||||||
.stdout
|
|
||||||
.as_slice()
|
|
||||||
.read_to_string(&mut llvm_lib_dir)
|
|
||||||
.expect("llvm-config output should be utf8");
|
|
||||||
|
|
||||||
let mut lib_path = std::path::PathBuf::from(llvm_lib_dir.trim())
|
|
||||||
.join("linux")
|
|
||||||
.join(BUILTINS_ARCHIVE_FILE);
|
|
||||||
if !lib_path.exists() {
|
|
||||||
lib_path = std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
|
|
||||||
.join(BUILTINS_ARCHIVE_FILE);
|
|
||||||
}
|
|
||||||
let archive = fs::read(lib_path).expect("clang builtins not found");
|
|
||||||
|
|
||||||
let out_dir = env::var_os("OUT_DIR").expect("has OUT_DIR");
|
|
||||||
let archive_path = Path::new(&out_dir).join(BUILTINS_ARCHIVE_FILE);
|
|
||||||
let len = archive.len();
|
|
||||||
std::fs::write(archive_path, &archive).expect("can write to OUT_DIR");
|
|
||||||
|
|
||||||
let src_path = Path::new(&out_dir).join("compiler_rt.rs");
|
|
||||||
let src = format!(
|
|
||||||
"pub static COMPILER_RT: &[u8; {len}] = include_bytes!(\"{BUILTINS_ARCHIVE_FILE}\");"
|
|
||||||
);
|
|
||||||
fs::write(src_path, src).expect("can write to OUT_DIR");
|
|
||||||
|
|
||||||
println!("cargo:rerun-if-changed=build.rs");
|
|
||||||
}
|
|
||||||
Binary file not shown.
Binary file not shown.
@@ -1 +0,0 @@
|
|||||||
include!(concat!(env!("OUT_DIR"), "/compiler_rt.rs"));
|
|
||||||
@@ -1,14 +0,0 @@
|
|||||||
# Generated by Cargo
|
|
||||||
# will have compiled files and executables
|
|
||||||
/target/
|
|
||||||
|
|
||||||
# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
|
|
||||||
# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
|
|
||||||
Cargo.lock
|
|
||||||
|
|
||||||
# These are backup files generated by rustfmt
|
|
||||||
**/*.rs.bk
|
|
||||||
|
|
||||||
# IDE
|
|
||||||
/.idea/
|
|
||||||
/.vscode/
|
|
||||||
@@ -1,23 +0,0 @@
|
|||||||
[package]
|
|
||||||
name = "revive-common"
|
|
||||||
version.workspace = true
|
|
||||||
license.workspace = true
|
|
||||||
edition.workspace = true
|
|
||||||
repository.workspace = true
|
|
||||||
authors = [
|
|
||||||
"Cyrill Leutwiler <cyrill@parity.io>",
|
|
||||||
"Oleksandr Zarudnyi <a.zarudnyy@matterlabs.dev>",
|
|
||||||
]
|
|
||||||
description = "Shared constants of the revive compiler"
|
|
||||||
|
|
||||||
[lib]
|
|
||||||
doctest = false
|
|
||||||
|
|
||||||
[features]
|
|
||||||
riscv-64 = []
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
anyhow = { workspace = true }
|
|
||||||
serde = { workspace = true, features = ["derive"] }
|
|
||||||
serde_json = { workspace = true, features = [ "arbitrary_precision", "unbounded_depth" ] }
|
|
||||||
serde_stacker = { workspace = true }
|
|
||||||
@@ -1,10 +0,0 @@
|
|||||||
# revive: Compiler Common
|
|
||||||
|
|
||||||
## License
|
|
||||||
|
|
||||||
This library is distributed under the terms of either
|
|
||||||
|
|
||||||
- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or <http://www.apache.org/licenses/LICENSE-2.0>)
|
|
||||||
- MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)
|
|
||||||
|
|
||||||
at your option.
|
|
||||||
@@ -1,13 +0,0 @@
|
|||||||
//! The number base constants.
|
|
||||||
|
|
||||||
/// The binary number base.
|
|
||||||
pub const BASE_BINARY: u32 = 2;
|
|
||||||
|
|
||||||
/// The octal number base.
|
|
||||||
pub const BASE_OCTAL: u32 = 8;
|
|
||||||
|
|
||||||
/// The decimal number base.
|
|
||||||
pub const BASE_DECIMAL: u32 = 10;
|
|
||||||
|
|
||||||
/// The hexadecimal number base.
|
|
||||||
pub const BASE_HEXADECIMAL: u32 = 16;
|
|
||||||
@@ -1,31 +0,0 @@
|
|||||||
//! The common sizes in bits.
|
|
||||||
|
|
||||||
/// The `bool` type bit-length.
|
|
||||||
pub const BIT_LENGTH_BOOLEAN: usize = 1;
|
|
||||||
|
|
||||||
/// The `u8` type or byte bit-length.
|
|
||||||
pub const BIT_LENGTH_BYTE: usize = 8;
|
|
||||||
|
|
||||||
/// The x86 word type (usually `u32`) bit-length.
|
|
||||||
pub const BIT_LENGTH_X32: usize = crate::byte_length::BYTE_LENGTH_X32 * BIT_LENGTH_BYTE;
|
|
||||||
|
|
||||||
/// The x86_64 word type (usually `u64`) bit-length.
|
|
||||||
pub const BIT_LENGTH_X64: usize = crate::byte_length::BYTE_LENGTH_X64 * BIT_LENGTH_BYTE;
|
|
||||||
|
|
||||||
/// The ETH address (usually `u160`) bit-length.
|
|
||||||
pub const BIT_LENGTH_ETH_ADDRESS: usize =
|
|
||||||
crate::byte_length::BYTE_LENGTH_ETH_ADDRESS * BIT_LENGTH_BYTE;
|
|
||||||
|
|
||||||
/// The VM word (usually `u256` or `i256`) bit-length.
|
|
||||||
pub const BIT_LENGTH_WORD: usize = crate::byte_length::BYTE_LENGTH_WORD * BIT_LENGTH_BYTE;
|
|
||||||
|
|
||||||
/// Bit length of the runtime value type.
|
|
||||||
pub const BIT_LENGTH_VALUE: usize = BIT_LENGTH_WORD;
|
|
||||||
|
|
||||||
/// Bit length of thre runimte block number type.
|
|
||||||
pub const BIT_LENGTH_BLOCK_NUMBER: usize =
|
|
||||||
crate::byte_length::BYTE_LENGTH_BLOCK_NUMBER * BIT_LENGTH_BYTE;
|
|
||||||
|
|
||||||
/// Bit length of thre runimte block timestamp type.
|
|
||||||
pub const BIT_LENGTH_BLOCK_TIMESTAMP: usize =
|
|
||||||
crate::byte_length::BYTE_LENGTH_BLOCK_TIMESTAMP * BIT_LENGTH_BYTE;
|
|
||||||
@@ -1,28 +0,0 @@
|
|||||||
//! The common sizes in bytes.
|
|
||||||
|
|
||||||
/// The byte-length.
|
|
||||||
pub const BYTE_LENGTH_BYTE: usize = 1;
|
|
||||||
|
|
||||||
/// The x86 word byte-length.
|
|
||||||
pub const BYTE_LENGTH_X32: usize = 4;
|
|
||||||
|
|
||||||
/// The x86_64 word byte-length.
|
|
||||||
pub const BYTE_LENGTH_X64: usize = 8;
|
|
||||||
|
|
||||||
/// EVM native stack alignment size in bytes
|
|
||||||
pub const BYTE_LENGTH_STACK_ALIGN: usize = 32;
|
|
||||||
|
|
||||||
/// The ETH address byte-length.
|
|
||||||
pub const BYTE_LENGTH_ETH_ADDRESS: usize = 20;
|
|
||||||
|
|
||||||
/// The word byte-length.
|
|
||||||
pub const BYTE_LENGTH_WORD: usize = 32;
|
|
||||||
|
|
||||||
/// Byte length of the runtime value type.
|
|
||||||
pub const BYTE_LENGTH_VALUE: usize = 32;
|
|
||||||
|
|
||||||
/// Byte length of the runtime block number type.
|
|
||||||
pub const BYTE_LENGTH_BLOCK_NUMBER: usize = 4;
|
|
||||||
|
|
||||||
/// Byte length of the runtime block timestamp type.
|
|
||||||
pub const BYTE_LENGTH_BLOCK_TIMESTAMP: usize = 4;
|
|
||||||
@@ -1,87 +0,0 @@
|
|||||||
//! The EVM version.
|
|
||||||
|
|
||||||
use serde::Deserialize;
|
|
||||||
use serde::Serialize;
|
|
||||||
|
|
||||||
/// The EVM version.
|
|
||||||
#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
||||||
#[serde(rename_all = "camelCase")]
|
|
||||||
pub enum EVMVersion {
|
|
||||||
/// The corresponding EVM version.
|
|
||||||
#[serde(rename = "homestead")]
|
|
||||||
Homestead,
|
|
||||||
/// The corresponding EVM version.
|
|
||||||
#[serde(rename = "tangerineWhistle")]
|
|
||||||
TangerineWhistle,
|
|
||||||
/// The corresponding EVM version.
|
|
||||||
#[serde(rename = "spuriousDragon")]
|
|
||||||
SpuriousDragon,
|
|
||||||
/// The corresponding EVM version.
|
|
||||||
#[serde(rename = "byzantium")]
|
|
||||||
Byzantium,
|
|
||||||
/// The corresponding EVM version.
|
|
||||||
#[serde(rename = "constantinople")]
|
|
||||||
Constantinople,
|
|
||||||
/// The corresponding EVM version.
|
|
||||||
#[serde(rename = "petersburg")]
|
|
||||||
Petersburg,
|
|
||||||
/// The corresponding EVM version.
|
|
||||||
#[serde(rename = "istanbul")]
|
|
||||||
Istanbul,
|
|
||||||
/// The corresponding EVM version.
|
|
||||||
#[serde(rename = "berlin")]
|
|
||||||
Berlin,
|
|
||||||
/// The corresponding EVM version.
|
|
||||||
#[serde(rename = "london")]
|
|
||||||
London,
|
|
||||||
/// The corresponding EVM version.
|
|
||||||
#[serde(rename = "paris")]
|
|
||||||
Paris,
|
|
||||||
/// The corresponding EVM version.
|
|
||||||
#[serde(rename = "shanghai")]
|
|
||||||
Shanghai,
|
|
||||||
/// The corresponding EVM version.
|
|
||||||
#[serde(rename = "cancun")]
|
|
||||||
Cancun,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl TryFrom<&str> for EVMVersion {
|
|
||||||
type Error = anyhow::Error;
|
|
||||||
|
|
||||||
fn try_from(value: &str) -> Result<Self, Self::Error> {
|
|
||||||
Ok(match value {
|
|
||||||
"homestead" => Self::Homestead,
|
|
||||||
"tangerineWhistle" => Self::TangerineWhistle,
|
|
||||||
"spuriousDragon" => Self::SpuriousDragon,
|
|
||||||
"byzantium" => Self::Byzantium,
|
|
||||||
"constantinople" => Self::Constantinople,
|
|
||||||
"petersburg" => Self::Petersburg,
|
|
||||||
"istanbul" => Self::Istanbul,
|
|
||||||
"berlin" => Self::Berlin,
|
|
||||||
"london" => Self::London,
|
|
||||||
"paris" => Self::Paris,
|
|
||||||
"shanghai" => Self::Shanghai,
|
|
||||||
"cancun" => Self::Cancun,
|
|
||||||
_ => anyhow::bail!("Invalid EVM version: {}", value),
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl std::fmt::Display for EVMVersion {
|
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
||||||
match self {
|
|
||||||
Self::Homestead => write!(f, "homestead"),
|
|
||||||
Self::TangerineWhistle => write!(f, "tangerineWhistle"),
|
|
||||||
Self::SpuriousDragon => write!(f, "spuriousDragon"),
|
|
||||||
Self::Byzantium => write!(f, "byzantium"),
|
|
||||||
Self::Constantinople => write!(f, "constantinople"),
|
|
||||||
Self::Petersburg => write!(f, "petersburg"),
|
|
||||||
Self::Istanbul => write!(f, "istanbul"),
|
|
||||||
Self::Berlin => write!(f, "berlin"),
|
|
||||||
Self::London => write!(f, "london"),
|
|
||||||
Self::Paris => write!(f, "paris"),
|
|
||||||
Self::Shanghai => write!(f, "shanghai"),
|
|
||||||
Self::Cancun => write!(f, "cancun"),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,7 +0,0 @@
|
|||||||
//! The revive exit code constants.
|
|
||||||
|
|
||||||
/// The common application success exit code.
|
|
||||||
pub const EXIT_CODE_SUCCESS: i32 = 0;
|
|
||||||
|
|
||||||
/// The common application failure exit code.
|
|
||||||
pub const EXIT_CODE_FAILURE: i32 = 1;
|
|
||||||
@@ -1,43 +0,0 @@
|
|||||||
//! The file extensions.
|
|
||||||
|
|
||||||
/// The manifest file extension.
|
|
||||||
pub static EXTENSION_MANIFEST: &str = "toml";
|
|
||||||
|
|
||||||
/// The JSON data file extension.
|
|
||||||
pub static EXTENSION_JSON: &str = "json";
|
|
||||||
|
|
||||||
/// The ABI file extension.
|
|
||||||
pub static EXTENSION_ABI: &str = "abi";
|
|
||||||
|
|
||||||
/// The Yul IR file extension.
|
|
||||||
pub static EXTENSION_YUL: &str = "yul";
|
|
||||||
|
|
||||||
/// The EVM legacy assembly IR file extension.
|
|
||||||
pub static EXTENSION_EVMLA: &str = "evmla";
|
|
||||||
|
|
||||||
/// The Ethereal IR file extension.
|
|
||||||
pub static EXTENSION_ETHIR: &str = "ethir";
|
|
||||||
|
|
||||||
/// The EVM file extension.
|
|
||||||
pub static EXTENSION_EVM: &str = "evm";
|
|
||||||
|
|
||||||
/// The EVM bytecode file extension.
|
|
||||||
pub static EXTENSION_EVM_BINARY: &str = "bin";
|
|
||||||
|
|
||||||
/// The Solidity file extension.
|
|
||||||
pub static EXTENSION_SOLIDITY: &str = "sol";
|
|
||||||
|
|
||||||
/// The LLL IR file extension.
|
|
||||||
pub static EXTENSION_LLL: &str = "lll";
|
|
||||||
|
|
||||||
/// The LLVM source code file extension.
|
|
||||||
pub static EXTENSION_LLVM_SOURCE: &str = "ll";
|
|
||||||
|
|
||||||
/// The LLVM bitcode file extension.
|
|
||||||
pub static EXTENSION_LLVM_BINARY: &str = "bc";
|
|
||||||
|
|
||||||
/// The PolkaVM assembly file extension.
|
|
||||||
pub static EXTENSION_POLKAVM_ASSEMBLY: &str = "pvmasm";
|
|
||||||
|
|
||||||
/// The PolkaVM bytecode file extension.
|
|
||||||
pub static EXTENSION_POLKAVM_BINARY: &str = "pvm";
|
|
||||||
@@ -1,17 +0,0 @@
|
|||||||
//! The compiler common library.
|
|
||||||
|
|
||||||
pub(crate) mod base;
|
|
||||||
pub(crate) mod bit_length;
|
|
||||||
pub(crate) mod byte_length;
|
|
||||||
pub(crate) mod evm_version;
|
|
||||||
pub(crate) mod exit_code;
|
|
||||||
pub(crate) mod extension;
|
|
||||||
pub(crate) mod utils;
|
|
||||||
|
|
||||||
pub use self::base::*;
|
|
||||||
pub use self::bit_length::*;
|
|
||||||
pub use self::byte_length::*;
|
|
||||||
pub use self::evm_version::EVMVersion;
|
|
||||||
pub use self::exit_code::*;
|
|
||||||
pub use self::extension::*;
|
|
||||||
pub use self::utils::*;
|
|
||||||
@@ -1,27 +0,0 @@
|
|||||||
//! The compiler common utils.
|
|
||||||
|
|
||||||
/// Deserializes a `serde_json` object from slice with the recursion limit disabled.
|
|
||||||
/// Must be used for all JSON I/O to avoid crashes due to the aforementioned limit.
|
|
||||||
pub fn deserialize_from_slice<O>(input: &[u8]) -> anyhow::Result<O>
|
|
||||||
where
|
|
||||||
O: serde::de::DeserializeOwned,
|
|
||||||
{
|
|
||||||
let mut deserializer = serde_json::Deserializer::from_slice(input);
|
|
||||||
deserializer.disable_recursion_limit();
|
|
||||||
let deserializer = serde_stacker::Deserializer::new(&mut deserializer);
|
|
||||||
let result = O::deserialize(deserializer)?;
|
|
||||||
Ok(result)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Deserializes a `serde_json` object from string with the recursion limit disabled.
|
|
||||||
/// Must be used for all JSON I/O to avoid crashes due to the aforementioned limit.
|
|
||||||
pub fn deserialize_from_str<O>(input: &str) -> anyhow::Result<O>
|
|
||||||
where
|
|
||||||
O: serde::de::DeserializeOwned,
|
|
||||||
{
|
|
||||||
let mut deserializer = serde_json::Deserializer::from_str(input);
|
|
||||||
deserializer.disable_recursion_limit();
|
|
||||||
let deserializer = serde_stacker::Deserializer::new(&mut deserializer);
|
|
||||||
let result = O::deserialize(deserializer)?;
|
|
||||||
Ok(result)
|
|
||||||
}
|
|
||||||
@@ -1,16 +0,0 @@
|
|||||||
[package]
|
|
||||||
name = "revive-differential"
|
|
||||||
version.workspace = true
|
|
||||||
license.workspace = true
|
|
||||||
edition.workspace = true
|
|
||||||
authors.workspace = true
|
|
||||||
repository.workspace = true
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
hex = { workspace = true }
|
|
||||||
tempfile = { workspace = true }
|
|
||||||
serde = { workspace = true }
|
|
||||||
serde_json = { workspace = true }
|
|
||||||
alloy-primitives = { workspace = true, features = ["serde"] }
|
|
||||||
alloy-genesis = { workspace = true }
|
|
||||||
alloy-serde = { workspace = true }
|
|
||||||
@@ -1,40 +0,0 @@
|
|||||||
{
|
|
||||||
"config": {
|
|
||||||
"chainId": 420420420,
|
|
||||||
"homesteadBlock": 0,
|
|
||||||
"eip150Block": 0,
|
|
||||||
"eip155Block": 0,
|
|
||||||
"eip158Block": 0,
|
|
||||||
"byzantiumBlock": 0,
|
|
||||||
"constantinopleBlock": 0,
|
|
||||||
"petersburgBlock": 0,
|
|
||||||
"istanbulBlock": 0,
|
|
||||||
"berlinBlock": 0,
|
|
||||||
"londonBlock": 0,
|
|
||||||
"arrowGlacierBlock": 0,
|
|
||||||
"grayGlacierBlock": 0,
|
|
||||||
"shanghaiTime": 0,
|
|
||||||
"cancunTime": 0,
|
|
||||||
"terminalTotalDifficulty": 0,
|
|
||||||
"terminalTotalDifficultyPassed": true
|
|
||||||
},
|
|
||||||
"coinbase": "0x0000000000000000000000000000000000000000",
|
|
||||||
"difficulty": "0x20000",
|
|
||||||
"extraData": "",
|
|
||||||
"gasLimit": "0xffffffff",
|
|
||||||
"nonce": "0x0000000000000042",
|
|
||||||
"mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
|
|
||||||
"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
|
|
||||||
"timestamp": "0x00",
|
|
||||||
"alloc": {
|
|
||||||
"0101010101010101010101010101010101010101": {
|
|
||||||
"balance": "1000000000"
|
|
||||||
},
|
|
||||||
"0202020202020202020202020202020202020202": {
|
|
||||||
"balance": "1000000000"
|
|
||||||
},
|
|
||||||
"0303030303030303030303030303030303030303": {
|
|
||||||
"balance": "1000000000"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,199 +0,0 @@
|
|||||||
use std::time::Duration;
|
|
||||||
|
|
||||||
/// Parse a go formatted duration.
|
|
||||||
///
|
|
||||||
/// Sources:
|
|
||||||
/// - https://crates.io/crates/go-parse-duration (fixed an utf8 bug)
|
|
||||||
/// - https://github.com/golang/go/blob/master/src/time/format.go
|
|
||||||
pub fn parse_go_duration(value: &str) -> Result<Duration, String> {
|
|
||||||
parse_duration(value).map(|ns| Duration::from_nanos(ns.unsigned_abs()))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn parse_duration(string: &str) -> Result<i64, String> {
|
|
||||||
// [-+]?([0-9]*(\.[0-9]*)?[a-z]+)+
|
|
||||||
let mut s = string;
|
|
||||||
let mut d: i64 = 0; // duration to be returned
|
|
||||||
let mut neg = false;
|
|
||||||
|
|
||||||
// Consume [-+]?
|
|
||||||
if !s.is_empty() {
|
|
||||||
let c = *s.as_bytes().first().unwrap();
|
|
||||||
if c == b'-' || c == b'+' {
|
|
||||||
neg = c == b'-';
|
|
||||||
s = &s[1..];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// Special case: if all that is left is "0", this is zero.
|
|
||||||
if s == "0" {
|
|
||||||
return Ok(0);
|
|
||||||
}
|
|
||||||
if s.is_empty() {
|
|
||||||
return Err(format!("invalid duration: {string}"));
|
|
||||||
}
|
|
||||||
while !s.is_empty() {
|
|
||||||
// integers before, after decimal point
|
|
||||||
let mut v: i64;
|
|
||||||
let mut f: i64 = 0;
|
|
||||||
// value = v + f / scale
|
|
||||||
let mut scale: f64 = 1f64;
|
|
||||||
|
|
||||||
// The next character must be [0-9.]
|
|
||||||
let c = *s.as_bytes().first().unwrap();
|
|
||||||
if !(c == b'.' || c.is_ascii_digit()) {
|
|
||||||
return Err(format!("invalid duration: {string}"));
|
|
||||||
}
|
|
||||||
// Consume [0-9]*
|
|
||||||
let pl = s.len();
|
|
||||||
match leading_int(s) {
|
|
||||||
Ok((_v, _s)) => {
|
|
||||||
v = _v;
|
|
||||||
s = _s;
|
|
||||||
}
|
|
||||||
Err(_) => {
|
|
||||||
return Err(format!("invalid duration: {string}"));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
let pre = pl != s.len(); // whether we consume anything before a period
|
|
||||||
|
|
||||||
// Consume (\.[0-9]*)?
|
|
||||||
let mut post = false;
|
|
||||||
if !s.is_empty() && *s.as_bytes().first().unwrap() == b'.' {
|
|
||||||
s = &s[1..];
|
|
||||||
let pl = s.len();
|
|
||||||
let (f_, scale_, s_) = leading_fraction(s);
|
|
||||||
{
|
|
||||||
f = f_;
|
|
||||||
scale = scale_;
|
|
||||||
s = s_;
|
|
||||||
}
|
|
||||||
post = pl != s.len();
|
|
||||||
}
|
|
||||||
if !pre && !post {
|
|
||||||
// no digits (e.g. ".s" or "-.s")
|
|
||||||
return Err(format!("invalid duration: {string}"));
|
|
||||||
}
|
|
||||||
|
|
||||||
// Consume unit.
|
|
||||||
let mut i = 0;
|
|
||||||
while i < s.len() {
|
|
||||||
let c = *s.as_bytes().get(i).unwrap();
|
|
||||||
if c == b'.' || c.is_ascii_digit() {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
i += 1;
|
|
||||||
}
|
|
||||||
if i == 0 {
|
|
||||||
return Err(format!("missing unit in duration: {string}"));
|
|
||||||
}
|
|
||||||
let u = &s[..i];
|
|
||||||
s = &s[i..];
|
|
||||||
let unit = match u {
|
|
||||||
"ns" => 1i64,
|
|
||||||
"us" => 1000i64,
|
|
||||||
"µs" => 1000i64, // U+00B5 = micro symbol
|
|
||||||
"μs" => 1000i64, // U+03BC = Greek letter mu
|
|
||||||
"ms" => 1000000i64,
|
|
||||||
"s" => 1000000000i64,
|
|
||||||
"m" => 60000000000i64,
|
|
||||||
"h" => 3600000000000i64,
|
|
||||||
_ => {
|
|
||||||
return Err(format!("unknown unit {u} in duration {string}"));
|
|
||||||
}
|
|
||||||
};
|
|
||||||
if v > (1 << (63 - 1)) / unit {
|
|
||||||
// overflow
|
|
||||||
return Err(format!("invalid duration {string}"));
|
|
||||||
}
|
|
||||||
v *= unit;
|
|
||||||
if f > 0 {
|
|
||||||
// f64 is needed to be nanosecond accurate for fractions of hours.
|
|
||||||
// v >= 0 && (f*unit/scale) <= 3.6e+12 (ns/h, h is the largest unit)
|
|
||||||
v += (f as f64 * (unit as f64 / scale)) as i64;
|
|
||||||
if v < 0 {
|
|
||||||
// overflow
|
|
||||||
return Err(format!("invalid duration {string}"));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
d += v;
|
|
||||||
if d < 0 {
|
|
||||||
// overflow
|
|
||||||
return Err(format!("invalid duration {string}"));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if neg {
|
|
||||||
d = -d;
|
|
||||||
}
|
|
||||||
Ok(d)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn leading_int(s: &str) -> Result<(i64, &str), String> {
|
|
||||||
let mut x = 0;
|
|
||||||
let mut i = 0;
|
|
||||||
while i < s.len() {
|
|
||||||
let c = s.chars().nth(i).unwrap();
|
|
||||||
if !c.is_ascii_digit() {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
if x > (1 << (63 - 1)) / 10 {
|
|
||||||
return Err("overflow".into());
|
|
||||||
}
|
|
||||||
let d = i64::from(c.to_digit(10).unwrap());
|
|
||||||
x = x * 10 + d;
|
|
||||||
if x < 0 {
|
|
||||||
// overflow
|
|
||||||
return Err("overflow".into());
|
|
||||||
}
|
|
||||||
i += 1;
|
|
||||||
}
|
|
||||||
Ok((x, &s[i..]))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn leading_fraction(s: &str) -> (i64, f64, &str) {
|
|
||||||
let mut i = 0;
|
|
||||||
let mut x = 0i64;
|
|
||||||
let mut scale = 1f64;
|
|
||||||
let mut overflow = false;
|
|
||||||
while i < s.len() {
|
|
||||||
let c = s.chars().nth(i).unwrap();
|
|
||||||
if !c.is_ascii_digit() {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
if overflow {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
if x > (1 << (63 - 1)) / 10 {
|
|
||||||
// It's possible for overflow to give a positive number, so take care.
|
|
||||||
overflow = true;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
let d = i64::from(c.to_digit(10).unwrap());
|
|
||||||
let y = x * 10 + d;
|
|
||||||
if y < 0 {
|
|
||||||
overflow = true;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
x = y;
|
|
||||||
scale *= 10f64;
|
|
||||||
i += 1;
|
|
||||||
}
|
|
||||||
(x, scale, &s[i..])
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests {
|
|
||||||
use super::parse_duration;
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_parse_duration() {
|
|
||||||
assert_eq!(parse_duration("8.731µs"), Ok(8731));
|
|
||||||
assert_eq!(parse_duration("50ns"), Ok(50));
|
|
||||||
assert_eq!(parse_duration("3ms"), Ok(3000000));
|
|
||||||
assert_eq!(parse_duration("2us"), Ok(2000));
|
|
||||||
assert_eq!(parse_duration("4.0s"), Ok(4000000000));
|
|
||||||
assert_eq!(parse_duration("1h45m"), Ok(6300000000000));
|
|
||||||
assert_eq!(
|
|
||||||
parse_duration("1"),
|
|
||||||
Err(String::from("missing unit in duration: 1")),
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,569 +0,0 @@
|
|||||||
use core::str;
|
|
||||||
use std::{
|
|
||||||
collections::BTreeMap,
|
|
||||||
io::Write,
|
|
||||||
path::PathBuf,
|
|
||||||
process::{Command, Stdio},
|
|
||||||
str::FromStr,
|
|
||||||
time::Duration,
|
|
||||||
};
|
|
||||||
|
|
||||||
use alloy_genesis::{Genesis, GenesisAccount};
|
|
||||||
use alloy_primitives::{hex::ToHexExt, Address, Bytes, B256, U256};
|
|
||||||
use alloy_serde::storage::deserialize_storage_map;
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
use serde_json::{Deserializer, Value};
|
|
||||||
use tempfile::{NamedTempFile, TempPath};
|
|
||||||
|
|
||||||
pub use self::go_duration::parse_go_duration;
|
|
||||||
|
|
||||||
mod go_duration;
|
|
||||||
|
|
||||||
const GENESIS_JSON: &str = include_str!("../genesis.json");
|
|
||||||
const EXECUTABLE_NAME: &str = "evm";
|
|
||||||
const EXECUTABLE_ARGS: [&str; 8] = [
|
|
||||||
"--log.format=json",
|
|
||||||
"run",
|
|
||||||
"--dump",
|
|
||||||
"--nomemory=false",
|
|
||||||
"--noreturndata=false",
|
|
||||||
"--json",
|
|
||||||
"--codefile",
|
|
||||||
"-",
|
|
||||||
];
|
|
||||||
const EXECUTABLE_ARGS_BENCH: [&str; 6] = [
|
|
||||||
"run",
|
|
||||||
"--bench",
|
|
||||||
"--nomemory=false",
|
|
||||||
"--noreturndata=false",
|
|
||||||
"--codefile",
|
|
||||||
"-",
|
|
||||||
];
|
|
||||||
const GAS_USED_MARKER: &str = "EVM gas used:";
|
|
||||||
const REVERT_MARKER: &str = " error: ";
|
|
||||||
|
|
||||||
/// The geth EVM state dump structure
|
|
||||||
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
|
|
||||||
pub struct StateDump {
|
|
||||||
pub root: Bytes,
|
|
||||||
pub accounts: BTreeMap<Address, Account>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<StateDump> for Genesis {
|
|
||||||
fn from(value: StateDump) -> Self {
|
|
||||||
let mut genesis: Genesis = serde_json::from_str(GENESIS_JSON).unwrap();
|
|
||||||
genesis.alloc = value
|
|
||||||
.accounts
|
|
||||||
.iter()
|
|
||||||
.map(|(address, account)| (*address, account.clone().into()))
|
|
||||||
.collect();
|
|
||||||
genesis
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The geth EVM state dump account structure
|
|
||||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
|
||||||
pub struct Account {
|
|
||||||
pub balance: U256,
|
|
||||||
pub nonce: u64,
|
|
||||||
pub code: Option<Bytes>,
|
|
||||||
#[serde(
|
|
||||||
default,
|
|
||||||
skip_serializing_if = "Option::is_none",
|
|
||||||
deserialize_with = "deserialize_storage_map"
|
|
||||||
)]
|
|
||||||
pub storage: Option<BTreeMap<B256, B256>>,
|
|
||||||
pub key: Option<B256>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<Account> for GenesisAccount {
|
|
||||||
fn from(value: Account) -> Self {
|
|
||||||
GenesisAccount {
|
|
||||||
balance: value.balance,
|
|
||||||
nonce: Some(value.nonce),
|
|
||||||
code: value.code,
|
|
||||||
storage: value.storage,
|
|
||||||
private_key: value.key,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Contains the output from geth `emv` invocations
|
|
||||||
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
|
|
||||||
pub struct EvmOutput {
|
|
||||||
pub output: Bytes,
|
|
||||||
#[serde(rename = "gasUsed")]
|
|
||||||
pub gas_used: U256,
|
|
||||||
pub error: Option<String>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl EvmOutput {
|
|
||||||
/// Return if there was no error found.
|
|
||||||
///
|
|
||||||
/// Panics if the gas used is zero as this indicates nothing was run.
|
|
||||||
pub fn run_success(&self) -> bool {
|
|
||||||
assert_ne!(self.gas_used, U256::ZERO, "nothing was executed: {self:?}");
|
|
||||||
self.error.is_none()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Contains the full log from geth `emv` invocations
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
pub struct EvmLog {
|
|
||||||
pub account_deployed: Option<Address>,
|
|
||||||
pub output: EvmOutput,
|
|
||||||
pub state_dump: StateDump,
|
|
||||||
pub stderr: String,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl EvmLog {
|
|
||||||
pub const EXECUTION_TIME_MARKER: &'static str = "execution time:";
|
|
||||||
|
|
||||||
/// Parse the reported execution time from stderr (requires --bench)
|
|
||||||
pub fn execution_time(&self) -> Result<Duration, String> {
|
|
||||||
for line in self.stderr.lines() {
|
|
||||||
if let Some(value) = line.split("execution time:").nth(1) {
|
|
||||||
return parse_go_duration(value.trim());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Err(format!(
|
|
||||||
"execution time marker '{}' not found in raw EVM log",
|
|
||||||
Self::EXECUTION_TIME_MARKER
|
|
||||||
))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn parse_gas_used_from_bench(&mut self) {
|
|
||||||
for line in self.stderr.lines() {
|
|
||||||
if let Some(gas_line) = line.split(GAS_USED_MARKER).nth(1) {
|
|
||||||
let gas_used = gas_line.trim().parse::<u64>().unwrap_or_else(|error| {
|
|
||||||
panic!("invalid output '{gas_line}' for gas used: {error}")
|
|
||||||
});
|
|
||||||
self.output.gas_used = U256::from(gas_used);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<&str> for EvmLog {
|
|
||||||
fn from(value: &str) -> Self {
|
|
||||||
let mut output = None;
|
|
||||||
let mut state_dump = None;
|
|
||||||
for value in Deserializer::from_str(value).into_iter::<Value>() {
|
|
||||||
let Ok(value) = value else { continue };
|
|
||||||
if let Ok(value @ EvmOutput { .. }) = serde_json::from_value(value.clone()) {
|
|
||||||
output = Some(value);
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
if let Ok(value @ StateDump { .. }) = serde_json::from_value(value) {
|
|
||||||
state_dump = Some(value);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if let (Some(output), Some(state_dump)) = (output, state_dump) {
|
|
||||||
return Self {
|
|
||||||
account_deployed: None,
|
|
||||||
output,
|
|
||||||
state_dump,
|
|
||||||
stderr: value.into(),
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
EvmLog {
|
|
||||||
account_deployed: None,
|
|
||||||
output: EvmOutput {
|
|
||||||
error: value.find(REVERT_MARKER).map(|_| REVERT_MARKER.to_string()),
|
|
||||||
..Default::default()
|
|
||||||
},
|
|
||||||
state_dump: Default::default(),
|
|
||||||
stderr: Default::default(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Builder for running contracts in geth `evm`
|
|
||||||
pub struct Evm {
|
|
||||||
genesis_json: Option<String>,
|
|
||||||
genesis_path: Option<PathBuf>,
|
|
||||||
code: Option<Vec<u8>>,
|
|
||||||
input: Option<Bytes>,
|
|
||||||
receiver: Option<String>,
|
|
||||||
sender: String,
|
|
||||||
value: Option<u128>,
|
|
||||||
gas: Option<u64>,
|
|
||||||
create: bool,
|
|
||||||
bench: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Default for Evm {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self {
|
|
||||||
genesis_json: Some(GENESIS_JSON.to_string()),
|
|
||||||
genesis_path: None,
|
|
||||||
code: None,
|
|
||||||
input: None,
|
|
||||||
receiver: None,
|
|
||||||
sender: Address::default().encode_hex(),
|
|
||||||
value: None,
|
|
||||||
gas: None,
|
|
||||||
create: false,
|
|
||||||
bench: false,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Evm {
|
|
||||||
/// Create a new EVM with the given `genesis`
|
|
||||||
pub fn from_genesis(genesis: Genesis) -> Self {
|
|
||||||
Self::default().genesis_json(genesis)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Run the `code`
|
|
||||||
pub fn code_blob(self, blob: Vec<u8>) -> Self {
|
|
||||||
Self {
|
|
||||||
code: Some(blob),
|
|
||||||
..self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Set the calldata
|
|
||||||
pub fn input(self, bytes: Bytes) -> Self {
|
|
||||||
Self {
|
|
||||||
input: (!bytes.is_empty()).then_some(bytes),
|
|
||||||
..self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Set the create flag
|
|
||||||
pub fn deploy(self, enable: bool) -> Self {
|
|
||||||
Self {
|
|
||||||
create: enable,
|
|
||||||
..self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Set the transferred value
|
|
||||||
pub fn value(self, value: u128) -> Self {
|
|
||||||
Self {
|
|
||||||
value: Some(value),
|
|
||||||
..self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Set the gas limit
|
|
||||||
pub fn gas(self, limit: u64) -> Self {
|
|
||||||
Self {
|
|
||||||
gas: Some(limit),
|
|
||||||
..self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Provide the prestate genesis configuration
|
|
||||||
pub fn genesis_json(self, genesis: Genesis) -> Self {
|
|
||||||
let genesis_json = serde_json::to_string(&genesis).expect("state dump should be valid");
|
|
||||||
// TODO: Investigate
|
|
||||||
let genesis_json = genesis_json.replace("\"0x0\"", "0").into();
|
|
||||||
|
|
||||||
Self {
|
|
||||||
genesis_json,
|
|
||||||
genesis_path: None,
|
|
||||||
..self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Provide a path to the genesis file to be used
|
|
||||||
pub fn genesis_path(self, path: PathBuf) -> Self {
|
|
||||||
Self {
|
|
||||||
genesis_path: Some(path),
|
|
||||||
genesis_json: None,
|
|
||||||
..self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Set the callee address
|
|
||||||
pub fn receiver(self, address: Address) -> Self {
|
|
||||||
Self {
|
|
||||||
receiver: Some(address.encode_hex()),
|
|
||||||
..self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Set the caller address
|
|
||||||
pub fn sender(self, address: Address) -> Self {
|
|
||||||
Self {
|
|
||||||
sender: address.encode_hex(),
|
|
||||||
..self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Run as a benchmark
|
|
||||||
pub fn bench(self, flag: bool) -> Self {
|
|
||||||
Self {
|
|
||||||
bench: flag,
|
|
||||||
..self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Calculate the address of the contract account this deploy call would create
|
|
||||||
pub fn expect_account_created(&self) -> Address {
|
|
||||||
assert!(self.create, "expected a deploy call");
|
|
||||||
let sender = Address::from_str(&self.sender).expect("sender address should be valid");
|
|
||||||
let genesis: Genesis = match (self.genesis_json.as_ref(), self.genesis_path.as_ref()) {
|
|
||||||
(Some(json), None) => serde_json::from_str(json).unwrap(),
|
|
||||||
(None, Some(path)) => {
|
|
||||||
serde_json::from_str(&std::fs::read_to_string(path).unwrap()).unwrap()
|
|
||||||
}
|
|
||||||
_ => panic!("provided a genesis json and a genesis json path"),
|
|
||||||
};
|
|
||||||
let nonce = genesis
|
|
||||||
.alloc
|
|
||||||
.get(&sender)
|
|
||||||
.map(|account| account.nonce.unwrap_or(0))
|
|
||||||
.unwrap_or(0);
|
|
||||||
sender.create(nonce)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Return the path to the genesis file;
|
|
||||||
/// writes the genesis file into a tmpdir if necessary.
|
|
||||||
///
|
|
||||||
/// `TempPath`` will delete on drop, so need to keep it around
|
|
||||||
fn write_genesis_file(&self, temp_path: &mut Option<TempPath>) -> String {
|
|
||||||
match (self.genesis_json.as_ref(), self.genesis_path.as_ref()) {
|
|
||||||
(Some(json), None) => {
|
|
||||||
let mut temp_file = NamedTempFile::new().unwrap();
|
|
||||||
temp_file.write_all(json.as_bytes()).unwrap();
|
|
||||||
let path = temp_file.into_temp_path();
|
|
||||||
*temp_path = Some(path);
|
|
||||||
temp_path.as_ref().unwrap().display().to_string()
|
|
||||||
}
|
|
||||||
(None, Some(path)) => path.display().to_string(),
|
|
||||||
_ => panic!("provided a genesis json and a genesis json path"),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Run the call in a geth `evm` subprocess.
|
|
||||||
///
|
|
||||||
/// Definitively not a hairy plumbing function.
|
|
||||||
pub fn run(self) -> EvmLog {
|
|
||||||
let mut temp_path = None;
|
|
||||||
let genesis_json_path = &self.write_genesis_file(&mut temp_path);
|
|
||||||
|
|
||||||
// Static args
|
|
||||||
let mut command = Command::new(PathBuf::from(EXECUTABLE_NAME));
|
|
||||||
command
|
|
||||||
.stdin(Stdio::piped())
|
|
||||||
.stdout(Stdio::piped())
|
|
||||||
.stderr(Stdio::piped());
|
|
||||||
if self.bench {
|
|
||||||
command.args(EXECUTABLE_ARGS_BENCH);
|
|
||||||
} else {
|
|
||||||
command.args(EXECUTABLE_ARGS);
|
|
||||||
};
|
|
||||||
|
|
||||||
// Dynamic args
|
|
||||||
command.args(["--prestate", genesis_json_path]);
|
|
||||||
command.args(["--sender", &self.sender]);
|
|
||||||
if let Some(input) = &self.input {
|
|
||||||
command.args(["--input", hex::encode(input).as_str()]);
|
|
||||||
}
|
|
||||||
let account_deployed = if self.create {
|
|
||||||
command.arg("--create");
|
|
||||||
self.expect_account_created().into()
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
};
|
|
||||||
match (&self.code, &self.receiver) {
|
|
||||||
(Some(_), None) => {}
|
|
||||||
(None, Some(address)) => {
|
|
||||||
command.args(["--receiver", address]);
|
|
||||||
}
|
|
||||||
(Some(_), Some(_)) => panic!("code and receiver specified"),
|
|
||||||
_ => panic!("no code file or receiver specified"),
|
|
||||||
}
|
|
||||||
if let Some(gas) = self.gas {
|
|
||||||
command.args(["--gas", &format!("{gas}")]);
|
|
||||||
}
|
|
||||||
if let Some(value) = self.value {
|
|
||||||
command.args(["--value", &format!("{value}")]);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Run the evm subprocess and assert success return value
|
|
||||||
let process = command.spawn().unwrap_or_else(|error| {
|
|
||||||
panic!("{EXECUTABLE_NAME} subprocess spawning error: {error:?}")
|
|
||||||
});
|
|
||||||
let buf = vec![];
|
|
||||||
process
|
|
||||||
.stdin
|
|
||||||
.as_ref()
|
|
||||||
.unwrap_or_else(|| panic!("{EXECUTABLE_NAME} stdin getting error"))
|
|
||||||
.write_all(self.code.as_ref().unwrap_or(&buf))
|
|
||||||
.unwrap_or_else(|err| panic!("{EXECUTABLE_NAME} stdin writing error: {err:?}"));
|
|
||||||
|
|
||||||
let output = process
|
|
||||||
.wait_with_output()
|
|
||||||
.unwrap_or_else(|err| panic!("{EXECUTABLE_NAME} subprocess output error: {err}"));
|
|
||||||
assert!(
|
|
||||||
output.status.success(),
|
|
||||||
"{EXECUTABLE_NAME} command failed: {output:?}",
|
|
||||||
);
|
|
||||||
drop(temp_path);
|
|
||||||
|
|
||||||
let stdout = str::from_utf8(output.stdout.as_slice())
|
|
||||||
.unwrap_or_else(|err| panic!("{EXECUTABLE_NAME} stdout failed to parse: {err}"));
|
|
||||||
let stderr = str::from_utf8(output.stderr.as_slice())
|
|
||||||
.unwrap_or_else(|err| panic!("{EXECUTABLE_NAME} stderr failed to parse: {err}"));
|
|
||||||
|
|
||||||
let mut log: EvmLog = stdout.into();
|
|
||||||
log.stderr = stderr.into();
|
|
||||||
if self.bench {
|
|
||||||
log.parse_gas_used_from_bench();
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set the deployed account
|
|
||||||
log.account_deployed = account_deployed;
|
|
||||||
log
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests {
|
|
||||||
use std::{str::FromStr, time::Duration};
|
|
||||||
|
|
||||||
use alloy_genesis::Genesis;
|
|
||||||
use alloy_primitives::{Bytes, B256, U256};
|
|
||||||
|
|
||||||
use crate::{Evm, EvmLog, EvmOutput, StateDump};
|
|
||||||
|
|
||||||
const OUTPUT_JSON_OK: &str = r#"{"output":"0000000000000000000000000000000000000000000000000000000000000000","gasUsed":"0x11d"}"#;
|
|
||||||
const OUTPUT_JSON_REVERTED: &str =
|
|
||||||
r#"{"output":"","gasUsed":"0x2d","error":"execution reverted"}"#;
|
|
||||||
const STATE_DUMP: &str = r#"
|
|
||||||
{
|
|
||||||
"root": "eb5d51177cb9049b848ea92f87f9a3f00abfb683d0866c2eddecc5692ad27f86",
|
|
||||||
"accounts": {
|
|
||||||
"0x1f2a98889594024BFfdA3311CbE69728d392C06D": {
|
|
||||||
"balance": "0",
|
|
||||||
"nonce": 1,
|
|
||||||
"root": "0x63cfcda8d81a8b1840b1b9722c37f929a4037e53ad1ce6abdef31c0c8bac1f61",
|
|
||||||
"codeHash": "0xa6e0062c5ba829446695f179b97702a75f7d354e33445d2e928ed00e1a39e88f",
|
|
||||||
"code": "0x608060405260043610610028575f3560e01c80633fa4f2451461002c578063b144adfb1461004a575b5f80fd5b610034610086565b60405161004191906100c5565b60405180910390f35b348015610055575f80fd5b50610070600480360381019061006b919061013c565b61008d565b60405161007d91906100c5565b60405180910390f35b5f34905090565b5f8173ffffffffffffffffffffffffffffffffffffffff16319050919050565b5f819050919050565b6100bf816100ad565b82525050565b5f6020820190506100d85f8301846100b6565b92915050565b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f61010b826100e2565b9050919050565b61011b81610101565b8114610125575f80fd5b50565b5f8135905061013681610112565b92915050565b5f60208284031215610151576101506100de565b5b5f61015e84828501610128565b9150509291505056fea2646970667358221220a2109c2f05a629fff4640e9f0cf12a698bbea9b0858a4029901e88bf5d1c926964736f6c63430008190033",
|
|
||||||
"storage": {
|
|
||||||
"0x0000000000000000000000000000000000000000000000000000000000000000": "02"
|
|
||||||
},
|
|
||||||
"address": "0x1f2a98889594024bffda3311cbe69728d392c06d",
|
|
||||||
"key": "0xcbeeb4463624bc2f332dcfe2b479eddb1c380ec862ee63d9f31b31b854fb7c61"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}"#;
|
|
||||||
const EVM_BIN_FIXTURE: &str = "6080604052348015600e575f80fd5b506040516101403803806101408339818101604052810190602e9190607f565b805f806101000a81548160ff0219169083151502179055505060a5565b5f80fd5b5f8115159050919050565b606181604f565b8114606a575f80fd5b50565b5f81519050607981605a565b92915050565b5f602082840312156091576090604b565b5b5f609c84828501606d565b91505092915050565b608f806100b15f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c8063cde4efa914602a575b5f80fd5b60306032565b005b5f8054906101000a900460ff16155f806101000a81548160ff02191690831515021790555056fea264697066735822122046c92dd2fd612b1ed93d184dad4c49f61c44690722c4a6c7c746ebeb0aadeb4a64736f6c63430008190033";
|
|
||||||
const EVM_BIN_RUNTIME_FIXTURE: &str = "6080604052348015600e575f80fd5b50600436106026575f3560e01c8063cde4efa914602a575b5f80fd5b60306032565b005b5f8054906101000a900460ff16155f806101000a81548160ff02191690831515021790555056fea264697066735822122046c92dd2fd612b1ed93d184dad4c49f61c44690722c4a6c7c746ebeb0aadeb4a64736f6c63430008190033";
|
|
||||||
const EVM_BIN_FIXTURE_INPUT: &str =
|
|
||||||
"0000000000000000000000000000000000000000000000000000000000000001";
|
|
||||||
const EVM_BIN_RUNTIME_FIXTURE_INPUT: &str = "cde4efa9";
|
|
||||||
const STDERR_BENCH_OK: &str = r#"EVM gas used: 560071
|
|
||||||
execution time: 1.460881ms
|
|
||||||
allocations: 29
|
|
||||||
allocated bytes: 2558
|
|
||||||
"#;
|
|
||||||
const STDERR_BENCH_REVERT: &str = r#"EVM gas used: 69
|
|
||||||
execution time: 10.11µs
|
|
||||||
allocations: 43
|
|
||||||
allocated bytes: 3711"#;
|
|
||||||
const STDOUT_BENCH_REVERT: &str = r#" error: execution reverted"#;
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn parse_evm_output_ok() {
|
|
||||||
serde_json::from_str::<EvmOutput>(OUTPUT_JSON_OK).unwrap();
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn parse_evm_output_revert() {
|
|
||||||
serde_json::from_str::<EvmOutput>(OUTPUT_JSON_REVERTED).unwrap();
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn parse_evm_output_bench_ok() {
|
|
||||||
let mut log = EvmLog::from("");
|
|
||||||
log.stderr = STDERR_BENCH_OK.into();
|
|
||||||
log.parse_gas_used_from_bench();
|
|
||||||
assert!(log.output.run_success());
|
|
||||||
|
|
||||||
assert_eq!(log.execution_time().unwrap(), Duration::from_nanos(1460881));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn parse_evm_output_bench_revert() {
|
|
||||||
let mut log = EvmLog::from(STDOUT_BENCH_REVERT);
|
|
||||||
log.stderr = STDERR_BENCH_REVERT.into();
|
|
||||||
log.parse_gas_used_from_bench();
|
|
||||||
assert!(!log.output.run_success());
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn parse_state_dump() {
|
|
||||||
serde_json::from_str::<StateDump>(STATE_DUMP).unwrap();
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn evm_log_from_str() {
|
|
||||||
let log = format!("{OUTPUT_JSON_OK}\n{STATE_DUMP}");
|
|
||||||
let _ = EvmLog::from(log.as_str());
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn generate_genesis() {
|
|
||||||
let log = format!("{OUTPUT_JSON_OK}\n{STATE_DUMP}");
|
|
||||||
let log = EvmLog::from(log.as_str());
|
|
||||||
let mut genesis: Genesis = log.state_dump.into();
|
|
||||||
let storage = genesis
|
|
||||||
.alloc
|
|
||||||
.pop_first()
|
|
||||||
.expect("should have one account in genesis")
|
|
||||||
.1
|
|
||||||
.storage
|
|
||||||
.expect("genesis account should have storage");
|
|
||||||
let storage_value = storage
|
|
||||||
.get(&B256::ZERO)
|
|
||||||
.expect("genesis account should have key 0 occupied");
|
|
||||||
assert_eq!(*storage_value, B256::from(U256::from(2)));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn flipper() {
|
|
||||||
let log_runtime = Evm::default()
|
|
||||||
.code_blob(EVM_BIN_RUNTIME_FIXTURE.as_bytes().to_vec())
|
|
||||||
.input(Bytes::from_str(EVM_BIN_RUNTIME_FIXTURE_INPUT).unwrap())
|
|
||||||
.run();
|
|
||||||
assert!(log_runtime.output.run_success());
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn prestate() {
|
|
||||||
let log_deploy = Evm::default()
|
|
||||||
.code_blob(EVM_BIN_FIXTURE.as_bytes().to_vec())
|
|
||||||
.input(Bytes::from_str(EVM_BIN_FIXTURE_INPUT).unwrap())
|
|
||||||
.deploy(true)
|
|
||||||
.run();
|
|
||||||
assert!(log_deploy.output.run_success());
|
|
||||||
|
|
||||||
let address = log_deploy.account_deployed.unwrap();
|
|
||||||
let genesis: Genesis = log_deploy.state_dump.into();
|
|
||||||
let log_runtime = Evm::default()
|
|
||||||
.genesis_json(genesis)
|
|
||||||
.receiver(address)
|
|
||||||
.input(Bytes::from_str(EVM_BIN_RUNTIME_FIXTURE_INPUT).unwrap())
|
|
||||||
.run();
|
|
||||||
assert!(log_runtime.output.run_success(), "{:?}", log_runtime.output);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn bench_flipper() {
|
|
||||||
let log_runtime = Evm::default()
|
|
||||||
.code_blob(EVM_BIN_RUNTIME_FIXTURE.as_bytes().to_vec())
|
|
||||||
.input(Bytes::from_str(EVM_BIN_RUNTIME_FIXTURE_INPUT).unwrap())
|
|
||||||
.bench(true)
|
|
||||||
.run();
|
|
||||||
assert!(log_runtime.output.run_success());
|
|
||||||
assert!(log_runtime.execution_time().unwrap() > Duration::from_nanos(0));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,29 +0,0 @@
|
|||||||
[package]
|
|
||||||
name = "revive-integration"
|
|
||||||
version.workspace = true
|
|
||||||
license.workspace = true
|
|
||||||
edition.workspace = true
|
|
||||||
repository.workspace = true
|
|
||||||
authors.workspace = true
|
|
||||||
description = "revive compiler integration test cases"
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
polkavm = { workspace = true }
|
|
||||||
alloy-primitives = { workspace = true }
|
|
||||||
alloy-sol-types = { workspace = true }
|
|
||||||
hex = { workspace = true }
|
|
||||||
env_logger = { workspace = true }
|
|
||||||
log = { workspace = true }
|
|
||||||
serde_json = { workspace = true }
|
|
||||||
|
|
||||||
revive-solidity = { workspace = true }
|
|
||||||
revive-differential = { workspace = true }
|
|
||||||
revive-llvm-context = { workspace = true }
|
|
||||||
revive-common = { workspace = true }
|
|
||||||
revive-runner = { workspace = true }
|
|
||||||
|
|
||||||
[dev-dependencies]
|
|
||||||
sha1 = { workspace = true }
|
|
||||||
serde = { workspace = true }
|
|
||||||
serde_json = { workspace = true }
|
|
||||||
rayon = { workspace = true }
|
|
||||||
@@ -1,10 +0,0 @@
|
|||||||
{
|
|
||||||
"Baseline": 967,
|
|
||||||
"Computation": 4022,
|
|
||||||
"DivisionArithmetics": 31787,
|
|
||||||
"ERC20": 44233,
|
|
||||||
"Events": 1743,
|
|
||||||
"FibonacciIterative": 2927,
|
|
||||||
"Flipper": 3408,
|
|
||||||
"SHA1": 26009
|
|
||||||
}
|
|
||||||
@@ -1,22 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
|
|
||||||
{
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"origin": "Alice",
|
|
||||||
"value": 0
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
contract Baseline {
|
|
||||||
function baseline() public payable {}
|
|
||||||
}
|
|
||||||
@@ -1,36 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "Bitwise"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "3fa4f245"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract Bitwise {
|
|
||||||
function opByte(uint i, uint x) public payable returns (uint ret) {
|
|
||||||
assembly {
|
|
||||||
ret := byte(i, x)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,50 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "Block"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "8381f58a"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "b80777ea"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract Block {
|
|
||||||
function timestamp() public view returns (uint ret) {
|
|
||||||
ret = block.timestamp;
|
|
||||||
}
|
|
||||||
|
|
||||||
function number() public view returns (uint ret) {
|
|
||||||
if (block.number == 0) {
|
|
||||||
ret = 1;
|
|
||||||
} else {
|
|
||||||
ret = block.number;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,58 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Upload": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "Callee"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "Caller"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"value": 123
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "5a6535fc00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000004cafebabe00000000000000000000000000000000000000000000000000000000"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract Callee {
|
|
||||||
function echo(bytes memory payload) public pure returns (bytes memory) {
|
|
||||||
return payload;
|
|
||||||
}
|
|
||||||
|
|
||||||
receive() external payable {}
|
|
||||||
}
|
|
||||||
|
|
||||||
contract Caller {
|
|
||||||
constructor() payable {
|
|
||||||
Callee callee = new Callee();
|
|
||||||
payable(address(callee)).transfer(msg.value);
|
|
||||||
}
|
|
||||||
|
|
||||||
function call(bytes memory payload) public returns (bytes memory) {
|
|
||||||
Callee callee = new Callee();
|
|
||||||
return callee.echo(payload);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,61 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "0f760610000000000000000000000000000000000000000000000000000000000000000d"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"VerifyCall": {
|
|
||||||
"success": true,
|
|
||||||
"output": "000000000000000000000000000000000000000000000000000000000000005b"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "00261b660000000000000000000000000000000000000000000000000000000000000005"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"VerifyCall": {
|
|
||||||
"success": true,
|
|
||||||
"output": "00000000000000000000000000000000000000000000000000000000000003b1"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract Computation {
|
|
||||||
function triangle_number(int64 n) public pure returns (int64 sum) {
|
|
||||||
unchecked {
|
|
||||||
for (int64 x = 1; x <= n; x++) {
|
|
||||||
sum += x;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function odd_product(int32 n) public pure returns (int64) {
|
|
||||||
unchecked {
|
|
||||||
int64 prod = 1;
|
|
||||||
for (int32 x = 1; x <= n; x++) {
|
|
||||||
prod *= 2 * int64(x) - 1;
|
|
||||||
}
|
|
||||||
return prod;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,62 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "Context"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "846a1ee1"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "fc9c8d39"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "3af973b1"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract Context {
|
|
||||||
function address_this() public view returns (address ret) {
|
|
||||||
ret = address(this);
|
|
||||||
}
|
|
||||||
|
|
||||||
function caller() public view returns (address ret) {
|
|
||||||
ret = msg.sender;
|
|
||||||
}
|
|
||||||
|
|
||||||
function chain_id() public view returns (uint) {
|
|
||||||
uint256 id;
|
|
||||||
assembly {
|
|
||||||
id := chainid()
|
|
||||||
}
|
|
||||||
return id;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,72 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Upload": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "CreateA"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "CreateB"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"value": 10000
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract CreateA {
|
|
||||||
constructor() payable {}
|
|
||||||
}
|
|
||||||
|
|
||||||
contract CreateB {
|
|
||||||
receive() external payable {
|
|
||||||
new CreateA{value: msg.value}();
|
|
||||||
}
|
|
||||||
|
|
||||||
fallback() external {
|
|
||||||
new CreateA{salt: hex"01"}();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,35 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8.24;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "TestSha3"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "f9fbd5540000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000c68656c6c6f20776f726c64210000000000000000000000000000000000000000"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract TestSha3 {
|
|
||||||
function test(string memory _pre) external payable returns (bytes32) {
|
|
||||||
bytes32 hash = keccak256(bytes(_pre));
|
|
||||||
return bytes32(uint(hash) + 1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,29 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
contract DivisionArithmetics {
|
|
||||||
function div(uint n, uint d) public pure returns (uint q) {
|
|
||||||
assembly {
|
|
||||||
q := div(n, d)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function sdiv(int n, int d) public pure returns (int q) {
|
|
||||||
assembly {
|
|
||||||
q := sdiv(n, d)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function mod(uint n, uint d) public pure returns (uint r) {
|
|
||||||
assembly {
|
|
||||||
r := mod(n, d)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function smod(int n, int d) public pure returns (int r) {
|
|
||||||
assembly {
|
|
||||||
r := smod(n, d)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,125 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Upload": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "ERC20"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "ERC20Tester"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.0.0/contracts/token/ERC20/IERC20.sol
|
|
||||||
interface IERC20 {
|
|
||||||
function totalSupply() external view returns (uint);
|
|
||||||
|
|
||||||
function balanceOf(address account) external view returns (uint);
|
|
||||||
|
|
||||||
function transfer(address recipient, uint amount) external returns (bool);
|
|
||||||
|
|
||||||
function allowance(
|
|
||||||
address owner,
|
|
||||||
address spender
|
|
||||||
) external view returns (uint);
|
|
||||||
|
|
||||||
function approve(address spender, uint amount) external returns (bool);
|
|
||||||
|
|
||||||
function transferFrom(
|
|
||||||
address sender,
|
|
||||||
address recipient,
|
|
||||||
uint amount
|
|
||||||
) external returns (bool);
|
|
||||||
|
|
||||||
event Transfer(address indexed from, address indexed to, uint value);
|
|
||||||
event Approval(address indexed owner, address indexed spender, uint value);
|
|
||||||
}
|
|
||||||
|
|
||||||
contract ERC20 is IERC20 {
|
|
||||||
uint public totalSupply;
|
|
||||||
mapping(address => uint) public balanceOf;
|
|
||||||
mapping(address => mapping(address => uint)) public allowance;
|
|
||||||
string public name = "Solidity by Example";
|
|
||||||
string public symbol = "SOLBYEX";
|
|
||||||
uint8 public decimals = 18;
|
|
||||||
|
|
||||||
function transfer(address recipient, uint amount) external returns (bool) {
|
|
||||||
balanceOf[msg.sender] -= amount;
|
|
||||||
balanceOf[recipient] += amount;
|
|
||||||
emit Transfer(msg.sender, recipient, amount);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
function approve(address spender, uint amount) external returns (bool) {
|
|
||||||
allowance[msg.sender][spender] = amount;
|
|
||||||
emit Approval(msg.sender, spender, amount);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
function transferFrom(
|
|
||||||
address sender,
|
|
||||||
address recipient,
|
|
||||||
uint amount
|
|
||||||
) external returns (bool) {
|
|
||||||
allowance[sender][msg.sender] -= amount;
|
|
||||||
balanceOf[sender] -= amount;
|
|
||||||
balanceOf[recipient] += amount;
|
|
||||||
emit Transfer(sender, recipient, amount);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
function mint(uint amount) external {
|
|
||||||
balanceOf[msg.sender] += amount;
|
|
||||||
totalSupply += amount;
|
|
||||||
emit Transfer(address(0), msg.sender, amount);
|
|
||||||
}
|
|
||||||
|
|
||||||
function burn(uint amount) external {
|
|
||||||
balanceOf[msg.sender] -= amount;
|
|
||||||
totalSupply -= amount;
|
|
||||||
emit Transfer(msg.sender, address(0), amount);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
contract ERC20Tester {
|
|
||||||
constructor() {
|
|
||||||
address BOB = address(0xffffffffffffffffffffffffffffffffffffff);
|
|
||||||
ERC20 token = new ERC20();
|
|
||||||
assert(token.decimals() == 18);
|
|
||||||
|
|
||||||
// use call directly when code_size is implemented on pallet-revive
|
|
||||||
|
|
||||||
address(token).call(abi.encodeWithSignature("mint(uint256)", 300));
|
|
||||||
assert(token.balanceOf(address(this)) == 300);
|
|
||||||
token.transfer(BOB, 100);
|
|
||||||
assert(token.balanceOf(address(this)) == 200);
|
|
||||||
assert(token.balanceOf(BOB) == 100);
|
|
||||||
|
|
||||||
token.approve(address(this), 100);
|
|
||||||
|
|
||||||
token.transferFrom(address(this), BOB, 100);
|
|
||||||
assert(token.balanceOf(BOB) == 200);
|
|
||||||
assert(token.balanceOf(address(this)) == 100);
|
|
||||||
|
|
||||||
address(token).call(abi.encodeWithSignature("burn(uint256)", 100));
|
|
||||||
assert(token.balanceOf(address(this)) == 0);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,49 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "Events"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "4d43bec90000000000000000000000000000000000000000000000000000000000000000"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "4d43bec9000000000000000000000000000000000000000000000000000000000000007b"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract Events {
|
|
||||||
event A() anonymous;
|
|
||||||
event E(uint, uint indexed, uint indexed, uint indexed);
|
|
||||||
|
|
||||||
function emitEvent(uint topics) public {
|
|
||||||
if (topics == 0) {
|
|
||||||
emit A();
|
|
||||||
} else {
|
|
||||||
emit E(topics, 1, 2, 3);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,29 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
contract ExtCode {
|
|
||||||
function ExtCodeSize(address who) public view returns (uint ret) {
|
|
||||||
assembly {
|
|
||||||
ret := extcodesize(who)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function CodeSize() public pure returns (uint ret) {
|
|
||||||
assembly {
|
|
||||||
ret := codesize()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function ExtCodeHash(address who) public view returns (bytes32 ret) {
|
|
||||||
assembly {
|
|
||||||
ret := extcodehash(who)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function CodeHash() public view returns (bytes32 ret) {
|
|
||||||
assembly {
|
|
||||||
ret := extcodehash(address())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,90 +0,0 @@
|
|||||||
// SPDX-License-Identifier: UNLICENSED
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "6b83dd2e0000000000000000000000000000000000000000000000000000000000000006"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"VerifyCall": {
|
|
||||||
"success": true,
|
|
||||||
"output": "0000000000000000000000000000000000000000000000000000000000000008"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract FibonacciRecursive {
|
|
||||||
function f(uint n) internal pure returns (uint) {
|
|
||||||
if (n <= 1) {
|
|
||||||
return n;
|
|
||||||
} else {
|
|
||||||
return f(n - 1) + f(n - 2);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function fib3(uint n) public pure returns (uint) {
|
|
||||||
return f(n);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
contract FibonacciIterative {
|
|
||||||
function fib3(uint n) external pure returns (uint b) {
|
|
||||||
if (n == 0) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
uint a = 1;
|
|
||||||
b = 1;
|
|
||||||
for (uint i = 2; i < n; i++) {
|
|
||||||
unchecked {
|
|
||||||
uint c = a + b;
|
|
||||||
a = b;
|
|
||||||
b = c;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return b;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// https://medium.com/coinmonks/fibonacci-in-solidity-8477d907e22a
|
|
||||||
contract FibonacciBinet {
|
|
||||||
function fib3(uint n) external pure returns (uint a) {
|
|
||||||
if (n == 0) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
uint h = n / 2;
|
|
||||||
uint mask = 1;
|
|
||||||
// find highest set bit in n
|
|
||||||
while (mask <= h) {
|
|
||||||
mask <<= 1;
|
|
||||||
}
|
|
||||||
mask >>= 1;
|
|
||||||
a = 1;
|
|
||||||
uint b = 1;
|
|
||||||
uint c;
|
|
||||||
while (mask > 0) {
|
|
||||||
c = a * a + b * b;
|
|
||||||
if (n & mask > 0) {
|
|
||||||
b = b * (b + 2 * a);
|
|
||||||
a = c;
|
|
||||||
} else {
|
|
||||||
a = a * (2 * b - a);
|
|
||||||
b = c;
|
|
||||||
}
|
|
||||||
mask >>= 1;
|
|
||||||
}
|
|
||||||
return a;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,63 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Upload": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "ImmutablesTester"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "Immutables"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract ImmutablesTester {
|
|
||||||
// Read should work in the runtime code
|
|
||||||
uint public immutable foo;
|
|
||||||
// Read should work in the runtime code
|
|
||||||
uint public immutable bar;
|
|
||||||
// Read should work in the runtime code
|
|
||||||
uint public immutable zoo;
|
|
||||||
|
|
||||||
// Assign and read should work in the constructor
|
|
||||||
constructor(uint _foo) payable {
|
|
||||||
foo = _foo;
|
|
||||||
bar = foo + 1;
|
|
||||||
zoo = bar + 2;
|
|
||||||
|
|
||||||
assert(zoo == _foo + 3);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
contract Immutables {
|
|
||||||
fallback() external {
|
|
||||||
ImmutablesTester tester = new ImmutablesTester(127);
|
|
||||||
|
|
||||||
assert(tester.foo() == 127);
|
|
||||||
assert(tester.bar() == tester.foo() + 1);
|
|
||||||
assert(tester.zoo() == tester.bar() + 2);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,34 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "MCopy"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "0ee188b0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000030102030000000000000000000000000000000000000000000000000000000000"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract MCopy {
|
|
||||||
function memcpy(bytes memory payload) public pure returns (bytes memory) {
|
|
||||||
return payload;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,54 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "MSize",
|
|
||||||
"solc_optimizer": false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "f016832c"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "f4a63aa5"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract MSize {
|
|
||||||
uint[] public data;
|
|
||||||
|
|
||||||
function mSize() public pure returns (uint size) {
|
|
||||||
assembly {
|
|
||||||
size := msize()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function mStore100() public pure returns (uint size) {
|
|
||||||
assembly {
|
|
||||||
mstore(100, msize())
|
|
||||||
size := msize()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,101 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "MStore8"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "b09ad4210000000000000000000000000000000000000000000000000000000000000000"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "b09ad4210000000000000000000000000000000000000000000000000000000000000001"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "b09ad4210000000000000000000000000000000000000000000000000000000000000002"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "b09ad42100000000000000000000000000000000000000000000000000000000000000ff"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "b09ad4210000000000000000000000000000000000000000000000000000000000000100"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "b09ad4210000000000000000000000000000000000000000000000000000000000000101"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "b09ad4210000000000000000000000000000000000000000000000000000000000000102"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "b09ad42100000000000000000000000000000000000000000000000000000000075bcd15"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "b09ad421ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract MStore8 {
|
|
||||||
function mStore8(uint value) public pure returns (uint256 word) {
|
|
||||||
assembly {
|
|
||||||
mstore8(0x80, value)
|
|
||||||
word := mload(0x80)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,53 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Upload": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "Callee"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "ReturnDataOob"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract Callee {
|
|
||||||
function echo(bytes memory payload) public pure returns (bytes memory) {
|
|
||||||
return payload;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
contract ReturnDataOob {
|
|
||||||
fallback() external {
|
|
||||||
new Callee().echo(hex"1234");
|
|
||||||
assembly {
|
|
||||||
let pos := mload(64)
|
|
||||||
let size := add(returndatasize(), 1)
|
|
||||||
returndatacopy(pos, 0, size)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,265 +0,0 @@
|
|||||||
// SPDX-License-Identifier: BSD-2-Clause
|
|
||||||
pragma solidity ^0.8.4;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "SHA1"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "1605782b00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000200ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract SHA1 {
|
|
||||||
function sha1(bytes memory data) public pure returns (bytes20 ret) {
|
|
||||||
assembly {
|
|
||||||
// Get a safe scratch location
|
|
||||||
let scratch := mload(0x40)
|
|
||||||
|
|
||||||
// Get the data length, and point data at the first byte
|
|
||||||
let len := mload(data)
|
|
||||||
data := add(data, 32)
|
|
||||||
|
|
||||||
// Find the length after padding
|
|
||||||
let totallen := add(and(add(len, 1), 0xFFFFFFFFFFFFFFC0), 64)
|
|
||||||
switch lt(sub(totallen, len), 9)
|
|
||||||
case 1 {
|
|
||||||
totallen := add(totallen, 64)
|
|
||||||
}
|
|
||||||
|
|
||||||
let h := 0x6745230100EFCDAB890098BADCFE001032547600C3D2E1F0
|
|
||||||
|
|
||||||
function readword(ptr, off, count) -> result {
|
|
||||||
result := 0
|
|
||||||
if lt(off, count) {
|
|
||||||
result := mload(add(ptr, off))
|
|
||||||
count := sub(count, off)
|
|
||||||
if lt(count, 32) {
|
|
||||||
let mask := not(sub(exp(256, sub(32, count)), 1))
|
|
||||||
result := and(result, mask)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for {
|
|
||||||
let i := 0
|
|
||||||
} lt(i, totallen) {
|
|
||||||
i := add(i, 64)
|
|
||||||
} {
|
|
||||||
mstore(scratch, readword(data, i, len))
|
|
||||||
mstore(add(scratch, 32), readword(data, add(i, 32), len))
|
|
||||||
|
|
||||||
// If we loaded the last byte, store the terminator byte
|
|
||||||
switch lt(sub(len, i), 64)
|
|
||||||
case 1 {
|
|
||||||
mstore8(add(scratch, sub(len, i)), 0x80)
|
|
||||||
}
|
|
||||||
|
|
||||||
// If this is the last block, store the length
|
|
||||||
switch eq(i, sub(totallen, 64))
|
|
||||||
case 1 {
|
|
||||||
mstore(
|
|
||||||
add(scratch, 32),
|
|
||||||
or(mload(add(scratch, 32)), mul(len, 8))
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Expand the 16 32-bit words into 80
|
|
||||||
for {
|
|
||||||
let j := 64
|
|
||||||
} lt(j, 128) {
|
|
||||||
j := add(j, 12)
|
|
||||||
} {
|
|
||||||
let temp := xor(
|
|
||||||
xor(
|
|
||||||
mload(add(scratch, sub(j, 12))),
|
|
||||||
mload(add(scratch, sub(j, 32)))
|
|
||||||
),
|
|
||||||
xor(
|
|
||||||
mload(add(scratch, sub(j, 56))),
|
|
||||||
mload(add(scratch, sub(j, 64)))
|
|
||||||
)
|
|
||||||
)
|
|
||||||
temp := or(
|
|
||||||
and(
|
|
||||||
mul(temp, 2),
|
|
||||||
0xFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFE
|
|
||||||
),
|
|
||||||
and(
|
|
||||||
div(temp, 0x80000000),
|
|
||||||
0x0000000100000001000000010000000100000001000000010000000100000001
|
|
||||||
)
|
|
||||||
)
|
|
||||||
mstore(add(scratch, j), temp)
|
|
||||||
}
|
|
||||||
for {
|
|
||||||
let j := 128
|
|
||||||
} lt(j, 320) {
|
|
||||||
j := add(j, 24)
|
|
||||||
} {
|
|
||||||
let temp := xor(
|
|
||||||
xor(
|
|
||||||
mload(add(scratch, sub(j, 24))),
|
|
||||||
mload(add(scratch, sub(j, 64)))
|
|
||||||
),
|
|
||||||
xor(
|
|
||||||
mload(add(scratch, sub(j, 112))),
|
|
||||||
mload(add(scratch, sub(j, 128)))
|
|
||||||
)
|
|
||||||
)
|
|
||||||
temp := or(
|
|
||||||
and(
|
|
||||||
mul(temp, 4),
|
|
||||||
0xFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFC
|
|
||||||
),
|
|
||||||
and(
|
|
||||||
div(temp, 0x40000000),
|
|
||||||
0x0000000300000003000000030000000300000003000000030000000300000003
|
|
||||||
)
|
|
||||||
)
|
|
||||||
mstore(add(scratch, j), temp)
|
|
||||||
}
|
|
||||||
|
|
||||||
let x := h
|
|
||||||
let f := 0
|
|
||||||
let k := 0
|
|
||||||
for {
|
|
||||||
let j := 0
|
|
||||||
} lt(j, 80) {
|
|
||||||
j := add(j, 1)
|
|
||||||
} {
|
|
||||||
switch div(j, 20)
|
|
||||||
case 0 {
|
|
||||||
// f = d xor (b and (c xor d))
|
|
||||||
f := xor(
|
|
||||||
div(x, 0x100000000000000000000),
|
|
||||||
div(x, 0x10000000000)
|
|
||||||
)
|
|
||||||
f := and(div(x, 0x1000000000000000000000000000000), f)
|
|
||||||
f := xor(div(x, 0x10000000000), f)
|
|
||||||
k := 0x5A827999
|
|
||||||
}
|
|
||||||
case 1 {
|
|
||||||
// f = b xor c xor d
|
|
||||||
f := xor(
|
|
||||||
div(x, 0x1000000000000000000000000000000),
|
|
||||||
div(x, 0x100000000000000000000)
|
|
||||||
)
|
|
||||||
f := xor(div(x, 0x10000000000), f)
|
|
||||||
k := 0x6ED9EBA1
|
|
||||||
}
|
|
||||||
case 2 {
|
|
||||||
// f = (b and c) or (d and (b or c))
|
|
||||||
f := or(
|
|
||||||
div(x, 0x1000000000000000000000000000000),
|
|
||||||
div(x, 0x100000000000000000000)
|
|
||||||
)
|
|
||||||
f := and(div(x, 0x10000000000), f)
|
|
||||||
f := or(
|
|
||||||
and(
|
|
||||||
div(x, 0x1000000000000000000000000000000),
|
|
||||||
div(x, 0x100000000000000000000)
|
|
||||||
),
|
|
||||||
f
|
|
||||||
)
|
|
||||||
k := 0x8F1BBCDC
|
|
||||||
}
|
|
||||||
case 3 {
|
|
||||||
// f = b xor c xor d
|
|
||||||
f := xor(
|
|
||||||
div(x, 0x1000000000000000000000000000000),
|
|
||||||
div(x, 0x100000000000000000000)
|
|
||||||
)
|
|
||||||
f := xor(div(x, 0x10000000000), f)
|
|
||||||
k := 0xCA62C1D6
|
|
||||||
}
|
|
||||||
// temp = (a leftrotate 5) + f + e + k + w[i]
|
|
||||||
let temp := and(
|
|
||||||
div(
|
|
||||||
x,
|
|
||||||
0x80000000000000000000000000000000000000000000000
|
|
||||||
),
|
|
||||||
0x1F
|
|
||||||
)
|
|
||||||
temp := or(
|
|
||||||
and(
|
|
||||||
div(x, 0x800000000000000000000000000000000000000),
|
|
||||||
0xFFFFFFE0
|
|
||||||
),
|
|
||||||
temp
|
|
||||||
)
|
|
||||||
temp := add(f, temp)
|
|
||||||
temp := add(and(x, 0xFFFFFFFF), temp)
|
|
||||||
temp := add(k, temp)
|
|
||||||
temp := add(
|
|
||||||
div(
|
|
||||||
mload(add(scratch, mul(j, 4))),
|
|
||||||
0x100000000000000000000000000000000000000000000000000000000
|
|
||||||
),
|
|
||||||
temp
|
|
||||||
)
|
|
||||||
x := or(
|
|
||||||
div(x, 0x10000000000),
|
|
||||||
mul(temp, 0x10000000000000000000000000000000000000000)
|
|
||||||
)
|
|
||||||
x := or(
|
|
||||||
and(
|
|
||||||
x,
|
|
||||||
0xFFFFFFFF00FFFFFFFF000000000000FFFFFFFF00FFFFFFFF
|
|
||||||
),
|
|
||||||
mul(
|
|
||||||
or(
|
|
||||||
and(div(x, 0x4000000000000), 0xC0000000),
|
|
||||||
and(div(x, 0x400000000000000000000), 0x3FFFFFFF)
|
|
||||||
),
|
|
||||||
0x100000000000000000000
|
|
||||||
)
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
h := and(
|
|
||||||
add(h, x),
|
|
||||||
0xFFFFFFFF00FFFFFFFF00FFFFFFFF00FFFFFFFF00FFFFFFFF
|
|
||||||
)
|
|
||||||
}
|
|
||||||
ret := mul(
|
|
||||||
or(
|
|
||||||
or(
|
|
||||||
or(
|
|
||||||
or(
|
|
||||||
and(
|
|
||||||
div(h, 0x100000000),
|
|
||||||
0xFFFFFFFF00000000000000000000000000000000
|
|
||||||
),
|
|
||||||
and(
|
|
||||||
div(h, 0x1000000),
|
|
||||||
0xFFFFFFFF000000000000000000000000
|
|
||||||
)
|
|
||||||
),
|
|
||||||
and(div(h, 0x10000), 0xFFFFFFFF0000000000000000)
|
|
||||||
),
|
|
||||||
and(div(h, 0x100), 0xFFFFFFFF00000000)
|
|
||||||
),
|
|
||||||
and(h, 0xFFFFFFFF)
|
|
||||||
),
|
|
||||||
0x1000000000000000000000000
|
|
||||||
)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,55 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "Storage"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "fabc9efaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "558b9f9bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract Storage {
|
|
||||||
function transient(uint value) public returns (uint ret) {
|
|
||||||
assembly {
|
|
||||||
let slot := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
|
|
||||||
tstore(slot, value)
|
|
||||||
let success := call(0, 0, 0, 0, 0, 0, 0)
|
|
||||||
ret := tload(slot)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function persistent(uint value) public returns (uint ret) {
|
|
||||||
assembly {
|
|
||||||
let slot := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
|
|
||||||
sstore(slot, value)
|
|
||||||
ret := sload(slot)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,54 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
pragma solidity ^0.8.0;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Upload": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "TransactionOrigin"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "TransactionTester"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "f8a8fd6d"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract TransactionTester {
|
|
||||||
constructor() payable {
|
|
||||||
assert(tx.origin == new TransactionOrigin().test());
|
|
||||||
}
|
|
||||||
|
|
||||||
function test() public payable returns (address ret) {
|
|
||||||
ret = tx.origin;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
contract TransactionOrigin {
|
|
||||||
function test() public payable returns (address ret) {
|
|
||||||
assert(msg.sender != tx.origin);
|
|
||||||
|
|
||||||
ret = tx.origin;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,54 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "Transfer"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"value": 11
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "1c8d16b30000000000000000000000000303030303030303030303030303030303030303000000000000000000000000000000000000000000000000000000000000000a"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "fb9e8d0500000000000000000000000003030303030303030303030303030303030303030000000000000000000000000000000000000000000000000000000000000001"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract Transfer {
|
|
||||||
constructor() payable {
|
|
||||||
transfer_self(msg.value);
|
|
||||||
}
|
|
||||||
|
|
||||||
function address_self() internal view returns (address payable) {
|
|
||||||
return payable(address(this));
|
|
||||||
}
|
|
||||||
|
|
||||||
function transfer_self(uint _amount) public payable {
|
|
||||||
transfer_to(address_self(), _amount);
|
|
||||||
}
|
|
||||||
|
|
||||||
function transfer_to(address payable _dest, uint _amount) public payable {
|
|
||||||
_dest.transfer(_amount);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,66 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"differential": true,
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Upload": {
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "ValueTester"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"value": 1024,
|
|
||||||
"code": {
|
|
||||||
"Solidity": {
|
|
||||||
"contract": "Value"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"value": 123,
|
|
||||||
"data": "3fa4f245"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract ValueTester {
|
|
||||||
constructor() payable {}
|
|
||||||
|
|
||||||
function balance_self() public view returns (uint ret) {
|
|
||||||
ret = address(this).balance;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
contract Value {
|
|
||||||
constructor() payable {
|
|
||||||
ValueTester tester = new ValueTester{value: msg.value}();
|
|
||||||
|
|
||||||
// own account
|
|
||||||
assert(address(this).balance == 0);
|
|
||||||
|
|
||||||
// tester account
|
|
||||||
assert(address(tester).balance == msg.value);
|
|
||||||
assert(tester.balance_self() == msg.value);
|
|
||||||
|
|
||||||
// non-existant account
|
|
||||||
assert(address(0xdeadbeef).balance == 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
function value() public payable returns (uint ret) {
|
|
||||||
ret = msg.value;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,52 +0,0 @@
|
|||||||
// SPDX-License-Identifier: MIT
|
|
||||||
pragma solidity ^0.8;
|
|
||||||
|
|
||||||
/* runner.json
|
|
||||||
{
|
|
||||||
"actions": [
|
|
||||||
{
|
|
||||||
"Instantiate": {
|
|
||||||
"data": "0000000000000000000000000000000000000000000000000000000000000001"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"VerifyStorage": {
|
|
||||||
"contract": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"key": "0000000000000000000000000000000000000000000000000000000000000000",
|
|
||||||
"expected": "0100000000000000000000000000000000000000000000000000000000000000"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"Call": {
|
|
||||||
"dest": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"data": "cde4efa9"
|
|
||||||
}
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"VerifyStorage": {
|
|
||||||
"contract": {
|
|
||||||
"Instantiated": 0
|
|
||||||
},
|
|
||||||
"key": "0000000000000000000000000000000000000000000000000000000000000000",
|
|
||||||
"expected": "0000000000000000000000000000000000000000000000000000000000000000"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
contract Flipper {
|
|
||||||
bool coin;
|
|
||||||
|
|
||||||
constructor(bool _coin) {
|
|
||||||
coin = _coin;
|
|
||||||
}
|
|
||||||
|
|
||||||
function flip() public {
|
|
||||||
coin = !coin;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,308 +0,0 @@
|
|||||||
use alloy_primitives::{Address, Bytes, I256, U256};
|
|
||||||
use alloy_sol_types::{sol, SolCall, SolConstructor};
|
|
||||||
|
|
||||||
use revive_solidity::test_utils::*;
|
|
||||||
|
|
||||||
#[derive(Clone)]
|
|
||||||
pub struct Contract {
|
|
||||||
pub name: &'static str,
|
|
||||||
pub evm_runtime: Vec<u8>,
|
|
||||||
pub pvm_runtime: Vec<u8>,
|
|
||||||
pub calldata: Vec<u8>,
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! case {
|
|
||||||
// Arguments:
|
|
||||||
// 1. The file name, expect to live under "../contracts/"
|
|
||||||
// 2. The Solidity contract name
|
|
||||||
// 3. The derived Solidity function call name
|
|
||||||
// 4. The method name on [Contract]
|
|
||||||
// 5. Any parameters to the Solidity functions
|
|
||||||
($file_name:literal, $contract_name:ident, $contract_method:ident, $method_name:ident, $( $v:ident: $t:ty ),* ) => {
|
|
||||||
impl Contract {
|
|
||||||
pub fn $method_name($($v: $t),*) -> Self {
|
|
||||||
let code = include_str!(concat!("../contracts/", $file_name));
|
|
||||||
let args = $contract_name::$contract_method::new(($($v,)*)).abi_encode();
|
|
||||||
let name = stringify!($contract_name);
|
|
||||||
Contract::build(args, name, code)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
// Arguments:
|
|
||||||
// 1. The file name, expect to live under "../contracts/"
|
|
||||||
// 2. The Solidity contract name
|
|
||||||
// 3. Raw Calldata
|
|
||||||
// 4. The method name on [Contract]
|
|
||||||
($file_name:literal, $contract_name:literal, $calldata:expr, $method_name:ident) => {
|
|
||||||
impl Contract {
|
|
||||||
pub fn $method_name() -> Self {
|
|
||||||
let code = include_str!(concat!("../contracts/", $file_name));
|
|
||||||
Contract::build($calldata, $contract_name, code)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
case!("Create.sol", "CreateA", vec![0; 4], create_a);
|
|
||||||
case!("Create.sol", "CreateB", vec![0; 4], create_b);
|
|
||||||
|
|
||||||
sol!(contract Baseline { function baseline() public payable; });
|
|
||||||
case!("Baseline.sol", Baseline, baselineCall, baseline,);
|
|
||||||
|
|
||||||
sol!(contract Flipper {
|
|
||||||
constructor (bool);
|
|
||||||
|
|
||||||
function flip() public;
|
|
||||||
});
|
|
||||||
case!("flipper.sol", Flipper, flipCall, flipper,);
|
|
||||||
case!("flipper.sol", Flipper, constructorCall, flipper_constructor, coin: bool);
|
|
||||||
|
|
||||||
sol!(contract Computation {
|
|
||||||
function odd_product(int32 n) public pure returns (int64);
|
|
||||||
function triangle_number(int64 n) public pure returns (int64 sum);
|
|
||||||
});
|
|
||||||
case!("Computation.sol", Computation, odd_productCall, odd_product, n: i32);
|
|
||||||
case!("Computation.sol", Computation, triangle_numberCall, triangle_number, n: i64);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract FibonacciRecursive {
|
|
||||||
function fib3(uint n) public pure returns (uint);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("Fibonacci.sol", FibonacciRecursive, fib3Call, fib_recursive, n: U256);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract FibonacciIterative {
|
|
||||||
function fib3(uint n) external pure returns (uint b);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("Fibonacci.sol", FibonacciIterative, fib3Call, fib_iterative, n: U256);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract FibonacciBinet {
|
|
||||||
function fib3(uint n) external pure returns (uint a);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("Fibonacci.sol", FibonacciBinet, fib3Call, fib_binet, n: U256);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract SHA1 {
|
|
||||||
function sha1(bytes memory data) public pure returns (bytes20 ret);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("SHA1.sol", SHA1, sha1Call, sha1, pre: Bytes);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract ERC20 {
|
|
||||||
function totalSupply() external view returns (uint);
|
|
||||||
|
|
||||||
function balanceOf(address account) external view returns (uint);
|
|
||||||
|
|
||||||
function transfer(address recipient, uint amount) external returns (bool);
|
|
||||||
|
|
||||||
function allowance(
|
|
||||||
address owner,
|
|
||||||
address spender
|
|
||||||
) external view returns (uint);
|
|
||||||
|
|
||||||
function approve(address spender, uint amount) external returns (bool);
|
|
||||||
|
|
||||||
function transferFrom(
|
|
||||||
address sender,
|
|
||||||
address recipient,
|
|
||||||
uint amount
|
|
||||||
) external returns (bool);
|
|
||||||
|
|
||||||
event Transfer(address indexed from, address indexed to, uint value);
|
|
||||||
event Approval(address indexed owner, address indexed spender, uint value);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("ERC20.sol", ERC20, totalSupplyCall, erc20,);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract Block {
|
|
||||||
function timestamp() public view returns (uint ret);
|
|
||||||
|
|
||||||
function number() public view returns (uint ret);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("Block.sol", Block, numberCall, block_number,);
|
|
||||||
case!("Block.sol", Block, timestampCall, block_timestamp,);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract Context {
|
|
||||||
function address_this() public view returns (address);
|
|
||||||
|
|
||||||
function caller() public pure returns (address);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("Context.sol", Context, address_thisCall, context_address,);
|
|
||||||
case!("Context.sol", Context, callerCall, context_caller,);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract DivisionArithmetics {
|
|
||||||
function div(uint n, uint d) public pure returns (uint q);
|
|
||||||
|
|
||||||
function sdiv(int n, int d) public pure returns (int q);
|
|
||||||
|
|
||||||
function mod(uint n, uint d) public pure returns (uint r);
|
|
||||||
|
|
||||||
function smod(int n, int d) public pure returns (int r);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("DivisionArithmetics.sol", DivisionArithmetics, divCall, division_arithmetics_div, n: U256, d: U256);
|
|
||||||
case!("DivisionArithmetics.sol", DivisionArithmetics, sdivCall, division_arithmetics_sdiv, n: I256, d: I256);
|
|
||||||
case!("DivisionArithmetics.sol", DivisionArithmetics, modCall, division_arithmetics_mod, n: U256, d: U256);
|
|
||||||
case!("DivisionArithmetics.sol", DivisionArithmetics, smodCall, division_arithmetics_smod, n: I256, d: I256);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract MStore8 {
|
|
||||||
function mStore8(uint value) public pure returns (uint256 word);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("MStore8.sol", MStore8, mStore8Call, mstore8, value: U256);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract Events {
|
|
||||||
event A(uint) anonymous;
|
|
||||||
event E(uint indexed, uint indexed, uint indexed);
|
|
||||||
|
|
||||||
function emitEvent(uint topics) public;
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("Events.sol", Events, emitEventCall, event, topics: U256);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract ExtCode {
|
|
||||||
function ExtCodeSize(address who) public view returns (uint ret);
|
|
||||||
|
|
||||||
function CodeSize() public pure returns (uint ret);
|
|
||||||
|
|
||||||
function ExtCodeHash(address who) public view returns (bytes32 ret);
|
|
||||||
|
|
||||||
function CodeHash() public view returns (bytes32 ret);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("ExtCode.sol", ExtCode, ExtCodeSizeCall, ext_code_size, address: Address);
|
|
||||||
case!("ExtCode.sol", ExtCode, CodeSizeCall, code_size,);
|
|
||||||
case!("ExtCode.sol", ExtCode, ExtCodeHashCall, ext_code_hash, address: Address);
|
|
||||||
case!("ExtCode.sol", ExtCode, CodeHashCall, code_hash,);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract MCopy {
|
|
||||||
function memcpy(bytes memory payload) public pure returns (bytes memory);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("MCopy.sol", MCopy, memcpyCall, memcpy, payload: Bytes);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract Call {
|
|
||||||
function value_transfer(address payable destination) public payable;
|
|
||||||
|
|
||||||
function echo(bytes memory payload) public payable returns (bytes memory);
|
|
||||||
|
|
||||||
function call(
|
|
||||||
address callee,
|
|
||||||
bytes memory payload
|
|
||||||
) public payable returns (bytes memory);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("Call.sol", Call, value_transferCall, call_value_transfer, destination: Address);
|
|
||||||
case!("Call.sol", Call, callCall, call_call, destination: Address, payload: Bytes);
|
|
||||||
case!("Call.sol", "Call", vec![], call_constructor);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract Value {
|
|
||||||
function balance_of(address _address) public view returns (uint ret);
|
|
||||||
function balance_self() public view returns (uint ret);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("Value.sol", Value, balance_ofCall, value_balance_of, address: Address);
|
|
||||||
case!("Value.sol", Value, balance_selfCall, value_balance_self,);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract Bitwise {
|
|
||||||
function opByte(uint i, uint x) public payable returns (uint ret);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("Bitwise.sol", Bitwise, opByteCall, bitwise_byte, index: U256, value: U256);
|
|
||||||
|
|
||||||
sol!(
|
|
||||||
contract Storage {
|
|
||||||
function transient(uint value) public returns (uint ret);
|
|
||||||
}
|
|
||||||
);
|
|
||||||
case!("Storage.sol", Storage, transientCall, storage_transient, value: U256);
|
|
||||||
|
|
||||||
impl Contract {
|
|
||||||
fn build(calldata: Vec<u8>, name: &'static str, code: &str) -> Self {
|
|
||||||
Self {
|
|
||||||
name,
|
|
||||||
evm_runtime: compile_evm_bin_runtime(name, code),
|
|
||||||
pvm_runtime: compile_blob(name, code),
|
|
||||||
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};
|
|
||||||
|
|
||||||
use super::Contract;
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn codesize() {
|
|
||||||
let path = "codesize.json";
|
|
||||||
|
|
||||||
let existing = File::open(path)
|
|
||||||
.map(|file| {
|
|
||||||
BTreeMap::<String, usize>::deserialize(&mut serde_json::Deserializer::from_reader(
|
|
||||||
file,
|
|
||||||
))
|
|
||||||
.expect("should be able to deserialze codesize data")
|
|
||||||
})
|
|
||||||
.ok();
|
|
||||||
|
|
||||||
let extract_code_size = |compile: fn() -> Contract| {
|
|
||||||
let contract = compile();
|
|
||||||
let contract_length = contract.pvm_runtime.len();
|
|
||||||
let size_change = existing
|
|
||||||
.as_ref()
|
|
||||||
.and_then(|map| map.get(contract.name))
|
|
||||||
.filter(|old| **old != 0)
|
|
||||||
.map(|old| {
|
|
||||||
let old = *old as f32;
|
|
||||||
let p = (contract_length as f32 - old) / old * 100.0;
|
|
||||||
format!("({p}% change from {old} bytes)",)
|
|
||||||
})
|
|
||||||
.unwrap_or_default();
|
|
||||||
|
|
||||||
println!("{}: {contract_length} bytes {size_change}", contract.name);
|
|
||||||
|
|
||||||
(contract.name, contract_length)
|
|
||||||
};
|
|
||||||
|
|
||||||
[
|
|
||||||
Contract::baseline as fn() -> Contract,
|
|
||||||
Contract::flipper as fn() -> Contract,
|
|
||||||
(|| Contract::odd_product(0)) as fn() -> Contract,
|
|
||||||
(|| Contract::fib_iterative(U256::ZERO)) as fn() -> Contract,
|
|
||||||
Contract::erc20 as fn() -> Contract,
|
|
||||||
(|| Contract::sha1(Bytes::new())) as fn() -> Contract,
|
|
||||||
(|| Contract::division_arithmetics_div(U256::ZERO, U256::ZERO)) as fn() -> Contract,
|
|
||||||
(|| Contract::event(U256::ZERO)) as fn() -> Contract,
|
|
||||||
]
|
|
||||||
.into_par_iter()
|
|
||||||
.map(extract_code_size)
|
|
||||||
.collect::<BTreeMap<_, _>>()
|
|
||||||
.serialize(&mut serde_json::Serializer::pretty(
|
|
||||||
File::create(path).unwrap(),
|
|
||||||
))
|
|
||||||
.unwrap_or_else(|err| panic!("can not write codesize data to '{path}': {err}"));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,4 +0,0 @@
|
|||||||
pub mod cases;
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests;
|
|
||||||
@@ -1,376 +0,0 @@
|
|||||||
use std::str::FromStr;
|
|
||||||
|
|
||||||
use alloy_primitives::*;
|
|
||||||
use revive_runner::*;
|
|
||||||
use SpecsAction::*;
|
|
||||||
|
|
||||||
use crate::cases::Contract;
|
|
||||||
|
|
||||||
/// Parameters:
|
|
||||||
/// - The function name of the test
|
|
||||||
/// - The contract name to fill in empty code based on the file path
|
|
||||||
/// - The contract source file
|
|
||||||
macro_rules! test_spec {
|
|
||||||
($test_name:ident, $contract_name:literal, $source_file:literal) => {
|
|
||||||
#[test]
|
|
||||||
fn $test_name() {
|
|
||||||
let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").expect("should always exist");
|
|
||||||
let path = format!("{manifest_dir}/../integration/contracts/{}", $source_file);
|
|
||||||
Specs::from_comment($contract_name, &path).remove(0).run();
|
|
||||||
}
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
test_spec!(baseline, "Baseline", "Baseline.sol");
|
|
||||||
test_spec!(flipper, "Flipper", "flipper.sol");
|
|
||||||
test_spec!(fibonacci_recursive, "FibonacciRecursive", "Fibonacci.sol");
|
|
||||||
test_spec!(fibonacci_iterative, "FibonacciIterative", "Fibonacci.sol");
|
|
||||||
test_spec!(fibonacci_binet, "FibonacciBinet", "Fibonacci.sol");
|
|
||||||
test_spec!(hash_keccak_256, "TestSha3", "Crypto.sol");
|
|
||||||
test_spec!(erc20, "ERC20", "ERC20.sol");
|
|
||||||
test_spec!(computation, "Computation", "Computation.sol");
|
|
||||||
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!(events, "Events", "Events.sol");
|
|
||||||
test_spec!(storage, "Storage", "Storage.sol");
|
|
||||||
test_spec!(mstore8, "MStore8", "MStore8.sol");
|
|
||||||
test_spec!(address, "Context", "Context.sol");
|
|
||||||
test_spec!(balance, "Value", "Value.sol");
|
|
||||||
test_spec!(create, "CreateB", "Create.sol");
|
|
||||||
test_spec!(call, "Caller", "Call.sol");
|
|
||||||
test_spec!(transfer, "Transfer", "Transfer.sol");
|
|
||||||
test_spec!(return_data_oob, "ReturnDataOob", "ReturnDataOob.sol");
|
|
||||||
test_spec!(immutables, "Immutables", "Immutables.sol");
|
|
||||||
test_spec!(transaction, "Transaction", "Transaction.sol");
|
|
||||||
|
|
||||||
fn instantiate(path: &str, contract: &str) -> Vec<SpecsAction> {
|
|
||||||
vec![Instantiate {
|
|
||||||
origin: TestAddress::Alice,
|
|
||||||
value: 0,
|
|
||||||
gas_limit: Some(GAS_LIMIT),
|
|
||||||
storage_deposit_limit: None,
|
|
||||||
code: Code::Solidity {
|
|
||||||
path: Some(path.into()),
|
|
||||||
contract: contract.to_string(),
|
|
||||||
solc_optimizer: None,
|
|
||||||
pipeline: None,
|
|
||||||
},
|
|
||||||
data: vec![],
|
|
||||||
salt: OptionalHex::default(),
|
|
||||||
}]
|
|
||||||
}
|
|
||||||
|
|
||||||
fn run_differential(actions: Vec<SpecsAction>) {
|
|
||||||
Specs {
|
|
||||||
differential: true,
|
|
||||||
actions,
|
|
||||||
..Default::default()
|
|
||||||
}
|
|
||||||
.run();
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn bitwise_byte() {
|
|
||||||
let mut actions = instantiate("contracts/Bitwise.sol", "Bitwise");
|
|
||||||
|
|
||||||
let de_bruijn_sequence =
|
|
||||||
hex::decode("4060503824160d0784426150b864361d0f88c4a27148ac5a2f198d46e391d8f4").unwrap();
|
|
||||||
let value = U256::from_be_bytes::<32>(de_bruijn_sequence.clone().try_into().unwrap());
|
|
||||||
for input in de_bruijn_sequence
|
|
||||||
.iter()
|
|
||||||
.enumerate()
|
|
||||||
.map(|(index, _)| Contract::bitwise_byte(U256::from(index), value).calldata)
|
|
||||||
.chain([
|
|
||||||
Contract::bitwise_byte(U256::ZERO, U256::ZERO).calldata,
|
|
||||||
Contract::bitwise_byte(U256::ZERO, U256::MAX).calldata,
|
|
||||||
Contract::bitwise_byte(U256::MAX, U256::ZERO).calldata,
|
|
||||||
Contract::bitwise_byte(U256::from_str("18446744073709551619").unwrap(), U256::MAX)
|
|
||||||
.calldata,
|
|
||||||
])
|
|
||||||
{
|
|
||||||
actions.push(Call {
|
|
||||||
origin: TestAddress::Alice,
|
|
||||||
dest: TestAddress::Instantiated(0),
|
|
||||||
value: 0,
|
|
||||||
gas_limit: None,
|
|
||||||
storage_deposit_limit: None,
|
|
||||||
data: input,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
run_differential(actions);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn unsigned_division() {
|
|
||||||
let mut actions = instantiate("contracts/DivisionArithmetics.sol", "DivisionArithmetics");
|
|
||||||
|
|
||||||
let one = U256::from(1);
|
|
||||||
let two = U256::from(2);
|
|
||||||
let five = U256::from(5);
|
|
||||||
for (n, d) in [
|
|
||||||
(five, five),
|
|
||||||
(five, one),
|
|
||||||
(U256::ZERO, U256::MAX),
|
|
||||||
(five, two),
|
|
||||||
(one, U256::ZERO),
|
|
||||||
] {
|
|
||||||
actions.push(Call {
|
|
||||||
origin: TestAddress::Alice,
|
|
||||||
dest: TestAddress::Instantiated(0),
|
|
||||||
value: 0,
|
|
||||||
gas_limit: None,
|
|
||||||
storage_deposit_limit: None,
|
|
||||||
data: Contract::division_arithmetics_div(n, d).calldata,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
run_differential(actions);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn signed_division() {
|
|
||||||
let mut actions = instantiate("contracts/DivisionArithmetics.sol", "DivisionArithmetics");
|
|
||||||
|
|
||||||
let one = I256::try_from(1).unwrap();
|
|
||||||
let two = I256::try_from(2).unwrap();
|
|
||||||
let minus_two = I256::try_from(-2).unwrap();
|
|
||||||
let five = I256::try_from(5).unwrap();
|
|
||||||
let minus_five = I256::try_from(-5).unwrap();
|
|
||||||
for (n, d) in [
|
|
||||||
(five, five),
|
|
||||||
(five, one),
|
|
||||||
(I256::ZERO, I256::MAX),
|
|
||||||
(I256::ZERO, I256::MINUS_ONE),
|
|
||||||
(five, two),
|
|
||||||
(five, I256::MINUS_ONE),
|
|
||||||
(I256::MINUS_ONE, minus_two),
|
|
||||||
(minus_five, minus_five),
|
|
||||||
(minus_five, two),
|
|
||||||
(I256::MINUS_ONE, I256::MIN),
|
|
||||||
(one, I256::ZERO),
|
|
||||||
] {
|
|
||||||
actions.push(Call {
|
|
||||||
origin: TestAddress::Alice,
|
|
||||||
dest: TestAddress::Instantiated(0),
|
|
||||||
value: 0,
|
|
||||||
gas_limit: None,
|
|
||||||
storage_deposit_limit: None,
|
|
||||||
data: Contract::division_arithmetics_sdiv(n, d).calldata,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
run_differential(actions);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn unsigned_remainder() {
|
|
||||||
let mut actions = instantiate("contracts/DivisionArithmetics.sol", "DivisionArithmetics");
|
|
||||||
|
|
||||||
let one = U256::from(1);
|
|
||||||
let two = U256::from(2);
|
|
||||||
let five = U256::from(5);
|
|
||||||
for (n, d) in [
|
|
||||||
(five, five),
|
|
||||||
(five, one),
|
|
||||||
(U256::ZERO, U256::MAX),
|
|
||||||
(U256::MAX, U256::MAX),
|
|
||||||
(five, two),
|
|
||||||
(two, five),
|
|
||||||
(U256::MAX, U256::ZERO),
|
|
||||||
] {
|
|
||||||
actions.push(Call {
|
|
||||||
origin: TestAddress::Alice,
|
|
||||||
dest: TestAddress::Instantiated(0),
|
|
||||||
value: 0,
|
|
||||||
gas_limit: None,
|
|
||||||
storage_deposit_limit: None,
|
|
||||||
data: Contract::division_arithmetics_mod(n, d).calldata,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
run_differential(actions);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn signed_remainder() {
|
|
||||||
let mut actions = instantiate("contracts/DivisionArithmetics.sol", "DivisionArithmetics");
|
|
||||||
|
|
||||||
let one = I256::try_from(1).unwrap();
|
|
||||||
let two = I256::try_from(2).unwrap();
|
|
||||||
let minus_two = I256::try_from(-2).unwrap();
|
|
||||||
let five = I256::try_from(5).unwrap();
|
|
||||||
let minus_five = I256::try_from(-5).unwrap();
|
|
||||||
for (n, d) in [
|
|
||||||
(five, five),
|
|
||||||
(five, one),
|
|
||||||
(I256::ZERO, I256::MAX),
|
|
||||||
(I256::MAX, I256::MAX),
|
|
||||||
(five, two),
|
|
||||||
(two, five),
|
|
||||||
(five, minus_five),
|
|
||||||
(five, I256::MINUS_ONE),
|
|
||||||
(five, minus_two),
|
|
||||||
(minus_five, two),
|
|
||||||
(minus_two, five),
|
|
||||||
(minus_five, minus_five),
|
|
||||||
(minus_five, I256::MINUS_ONE),
|
|
||||||
(minus_five, minus_two),
|
|
||||||
(minus_two, minus_five),
|
|
||||||
(I256::MIN, I256::MINUS_ONE),
|
|
||||||
(I256::ZERO, I256::ZERO),
|
|
||||||
] {
|
|
||||||
actions.push(Call {
|
|
||||||
origin: TestAddress::Alice,
|
|
||||||
dest: TestAddress::Instantiated(0),
|
|
||||||
value: 0,
|
|
||||||
gas_limit: None,
|
|
||||||
storage_deposit_limit: None,
|
|
||||||
data: Contract::division_arithmetics_smod(n, d).calldata,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
run_differential(actions);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn ext_code_hash() {
|
|
||||||
let mut actions = instantiate("contracts/ExtCode.sol", "ExtCode");
|
|
||||||
|
|
||||||
// First do contract instantiation to figure out address and code hash
|
|
||||||
let results = Specs {
|
|
||||||
actions: actions.clone(),
|
|
||||||
..Default::default()
|
|
||||||
}
|
|
||||||
.run();
|
|
||||||
let (addr, code_hash) = match results.first().cloned() {
|
|
||||||
Some(CallResult::Instantiate {
|
|
||||||
result, code_hash, ..
|
|
||||||
}) => (result.result.unwrap().addr, code_hash),
|
|
||||||
_ => panic!("instantiate contract failed"),
|
|
||||||
};
|
|
||||||
|
|
||||||
// code hash of itself
|
|
||||||
actions.push(Call {
|
|
||||||
origin: TestAddress::Alice,
|
|
||||||
dest: TestAddress::Instantiated(0),
|
|
||||||
value: 0,
|
|
||||||
gas_limit: None,
|
|
||||||
storage_deposit_limit: None,
|
|
||||||
data: Contract::code_hash().calldata,
|
|
||||||
});
|
|
||||||
actions.push(VerifyCall(VerifyCallExpectation {
|
|
||||||
success: true,
|
|
||||||
output: OptionalHex::from(code_hash.as_bytes().to_vec()),
|
|
||||||
gas_consumed: None,
|
|
||||||
}));
|
|
||||||
|
|
||||||
// code hash for a given contract address
|
|
||||||
actions.push(Call {
|
|
||||||
origin: TestAddress::Alice,
|
|
||||||
dest: TestAddress::Instantiated(0),
|
|
||||||
value: 0,
|
|
||||||
gas_limit: None,
|
|
||||||
storage_deposit_limit: None,
|
|
||||||
data: Contract::ext_code_hash(Address::from(addr.to_fixed_bytes())).calldata,
|
|
||||||
});
|
|
||||||
actions.push(VerifyCall(VerifyCallExpectation {
|
|
||||||
success: true,
|
|
||||||
output: OptionalHex::from(code_hash.as_bytes().to_vec()),
|
|
||||||
gas_consumed: None,
|
|
||||||
}));
|
|
||||||
|
|
||||||
// EOA returns fixed hash
|
|
||||||
actions.push(Call {
|
|
||||||
origin: TestAddress::Alice,
|
|
||||||
dest: TestAddress::Instantiated(0),
|
|
||||||
value: 0,
|
|
||||||
gas_limit: None,
|
|
||||||
storage_deposit_limit: None,
|
|
||||||
data: Contract::ext_code_hash(Address::from(CHARLIE.to_fixed_bytes())).calldata,
|
|
||||||
});
|
|
||||||
actions.push(VerifyCall(VerifyCallExpectation {
|
|
||||||
success: true,
|
|
||||||
output: OptionalHex::from(
|
|
||||||
hex!("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").to_vec(),
|
|
||||||
),
|
|
||||||
gas_consumed: None,
|
|
||||||
}));
|
|
||||||
|
|
||||||
// non-existing account
|
|
||||||
actions.push(Call {
|
|
||||||
origin: TestAddress::Alice,
|
|
||||||
dest: TestAddress::Instantiated(0),
|
|
||||||
value: 0,
|
|
||||||
gas_limit: None,
|
|
||||||
storage_deposit_limit: None,
|
|
||||||
data: Contract::ext_code_hash(Address::from([8u8; 20])).calldata,
|
|
||||||
});
|
|
||||||
actions.push(VerifyCall(VerifyCallExpectation {
|
|
||||||
success: true,
|
|
||||||
output: OptionalHex::from([0u8; 32].to_vec()),
|
|
||||||
gas_consumed: None,
|
|
||||||
}));
|
|
||||||
|
|
||||||
Specs {
|
|
||||||
actions,
|
|
||||||
..Default::default()
|
|
||||||
}
|
|
||||||
.run();
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
// These test were implement for the mock-runtime and need to be ported yet.
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn create2_failure() {
|
|
||||||
let mut state = State::default();
|
|
||||||
let contract_a = Contract::create_a();
|
|
||||||
state.upload_code(&contract_a.pvm_runtime);
|
|
||||||
|
|
||||||
let contract = Contract::create_b();
|
|
||||||
let (state, output) = state
|
|
||||||
.transaction()
|
|
||||||
.with_default_account(&contract.pvm_runtime)
|
|
||||||
.calldata(contract.calldata.clone())
|
|
||||||
.call();
|
|
||||||
|
|
||||||
assert_eq!(output.flags, ReturnFlags::Success);
|
|
||||||
|
|
||||||
// The address already exists, which should cause the contract to revert
|
|
||||||
|
|
||||||
let (_, output) = state
|
|
||||||
.transaction()
|
|
||||||
.with_default_account(&contract.pvm_runtime)
|
|
||||||
.calldata(contract.calldata)
|
|
||||||
.call();
|
|
||||||
|
|
||||||
assert_eq!(output.flags, ReturnFlags::Revert);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn ext_code_size() {
|
|
||||||
let contract = Contract::ext_code_size(Transaction::default_address());
|
|
||||||
let (_, output) = assert_success(&contract, false);
|
|
||||||
let received = U256::from_be_slice(&output.data);
|
|
||||||
let expected = U256::from(contract.pvm_runtime.len());
|
|
||||||
assert_eq!(received, expected);
|
|
||||||
|
|
||||||
let contract = Contract::ext_code_size(Default::default());
|
|
||||||
let (_, output) = assert_success(&contract, false);
|
|
||||||
let received = U256::from_be_slice(&output.data);
|
|
||||||
let expected = U256::ZERO;
|
|
||||||
assert_eq!(received, expected);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn code_size() {
|
|
||||||
let contract = Contract::code_size();
|
|
||||||
let (_, output) = assert_success(&contract, false);
|
|
||||||
let expected = U256::from(contract.pvm_runtime.len());
|
|
||||||
let received = U256::from_be_slice(&output.data);
|
|
||||||
assert_eq!(expected, received);
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
@@ -1,22 +0,0 @@
|
|||||||
[package]
|
|
||||||
name = "revive-linker"
|
|
||||||
version.workspace = true
|
|
||||||
license.workspace = true
|
|
||||||
edition.workspace = true
|
|
||||||
repository.workspace = true
|
|
||||||
authors.workspace = true
|
|
||||||
description = "revive compiler linker utils"
|
|
||||||
|
|
||||||
[features]
|
|
||||||
riscv-64 = []
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
inkwell = { workspace = true }
|
|
||||||
tempfile = { workspace = true }
|
|
||||||
polkavm-linker = { workspace = true }
|
|
||||||
polkavm-common = { workspace = true }
|
|
||||||
libc = { workspace = true }
|
|
||||||
anyhow = { workspace = true }
|
|
||||||
|
|
||||||
revive-builtins = { workspace = true }
|
|
||||||
lld-sys = { workspace = true }
|
|
||||||
@@ -1,88 +0,0 @@
|
|||||||
use std::{env, ffi::CString, fs};
|
|
||||||
|
|
||||||
use lld_sys::LLDELFLink;
|
|
||||||
use revive_builtins::COMPILER_RT;
|
|
||||||
|
|
||||||
const LINKER_SCRIPT: &str = r#"
|
|
||||||
SECTIONS {
|
|
||||||
.text : { KEEP(*(.text.polkavm_export)) *(.text .text.*) }
|
|
||||||
}"#;
|
|
||||||
|
|
||||||
#[cfg(not(feature = "riscv-64"))]
|
|
||||||
const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv32.a";
|
|
||||||
#[cfg(feature = "riscv-64")]
|
|
||||||
const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv64.a";
|
|
||||||
|
|
||||||
#[cfg(not(feature = "riscv-64"))]
|
|
||||||
const BUILTINS_LIB_NAME: &str = "clang_rt.builtins-riscv32";
|
|
||||||
#[cfg(feature = "riscv-64")]
|
|
||||||
const BUILTINS_LIB_NAME: &str = "clang_rt.builtins-riscv64";
|
|
||||||
|
|
||||||
fn invoke_lld(cmd_args: &[&str]) -> bool {
|
|
||||||
let c_strings = cmd_args
|
|
||||||
.iter()
|
|
||||||
.map(|arg| CString::new(*arg).expect("ld.lld args should not contain null bytes"))
|
|
||||||
.collect::<Vec<_>>();
|
|
||||||
|
|
||||||
let args: Vec<*const libc::c_char> = c_strings.iter().map(|arg| arg.as_ptr()).collect();
|
|
||||||
|
|
||||||
unsafe { LLDELFLink(args.as_ptr(), args.len()) == 0 }
|
|
||||||
}
|
|
||||||
|
|
||||||
fn polkavm_linker<T: AsRef<[u8]>>(code: T) -> anyhow::Result<Vec<u8>> {
|
|
||||||
let mut config = polkavm_linker::Config::default();
|
|
||||||
config.set_strip(true);
|
|
||||||
config.set_optimize(true);
|
|
||||||
|
|
||||||
polkavm_linker::program_from_elf(config, code.as_ref())
|
|
||||||
.map_err(|reason| anyhow::anyhow!("polkavm linker failed: {}", reason))
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn link<T: AsRef<[u8]>>(input: T) -> anyhow::Result<Vec<u8>> {
|
|
||||||
let dir = tempfile::tempdir().expect("failed to create temp directory for linking");
|
|
||||||
let output_path = dir.path().join("out.so");
|
|
||||||
let object_path = dir.path().join("out.o");
|
|
||||||
let linker_script_path = dir.path().join("linker.ld");
|
|
||||||
let compiler_rt_path = dir.path().join(BUILTINS_ARCHIVE_FILE);
|
|
||||||
|
|
||||||
fs::write(&object_path, input).map_err(|msg| anyhow::anyhow!("{msg} {object_path:?}"))?;
|
|
||||||
|
|
||||||
if env::var("PVM_LINKER_DUMP_OBJ").is_ok() {
|
|
||||||
fs::copy(&object_path, "/tmp/out.o")?;
|
|
||||||
}
|
|
||||||
|
|
||||||
fs::write(&linker_script_path, LINKER_SCRIPT)
|
|
||||||
.map_err(|msg| anyhow::anyhow!("{msg} {linker_script_path:?}"))?;
|
|
||||||
|
|
||||||
fs::write(&compiler_rt_path, COMPILER_RT)
|
|
||||||
.map_err(|msg| anyhow::anyhow!("{msg} {compiler_rt_path:?}"))?;
|
|
||||||
|
|
||||||
let ld_args = [
|
|
||||||
"ld.lld",
|
|
||||||
"--lto=full",
|
|
||||||
"--error-limit=0",
|
|
||||||
"--relocatable",
|
|
||||||
"--emit-relocs",
|
|
||||||
"--no-relax",
|
|
||||||
"--gc-sections",
|
|
||||||
"--library-path",
|
|
||||||
dir.path().to_str().expect("should be utf8"),
|
|
||||||
"--library",
|
|
||||||
BUILTINS_LIB_NAME,
|
|
||||||
linker_script_path.to_str().expect("should be utf8"),
|
|
||||||
object_path.to_str().expect("should be utf8"),
|
|
||||||
"-o",
|
|
||||||
output_path.to_str().expect("should be utf8"),
|
|
||||||
];
|
|
||||||
|
|
||||||
if invoke_lld(&ld_args) {
|
|
||||||
return Err(anyhow::anyhow!("ld.lld failed"));
|
|
||||||
}
|
|
||||||
|
|
||||||
if env::var("PVM_LINKER_DUMP_SO").is_ok() {
|
|
||||||
fs::copy(&output_path, "/tmp/out.so")?;
|
|
||||||
};
|
|
||||||
|
|
||||||
let blob = fs::read(&output_path)?;
|
|
||||||
polkavm_linker(blob)
|
|
||||||
}
|
|
||||||
@@ -1,15 +0,0 @@
|
|||||||
[package]
|
|
||||||
name = "lld-sys"
|
|
||||||
version.workspace = true
|
|
||||||
license.workspace = true
|
|
||||||
edition.workspace = true
|
|
||||||
repository.workspace = true
|
|
||||||
authors.workspace = true
|
|
||||||
build = "build.rs"
|
|
||||||
description = "bindings for ld.lld core"
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
libc = { workspace = true }
|
|
||||||
|
|
||||||
[build-dependencies]
|
|
||||||
cc = { workspace = true }
|
|
||||||
@@ -1,48 +0,0 @@
|
|||||||
fn llvm_config(arg: &str) -> String {
|
|
||||||
let output = std::process::Command::new("llvm-config")
|
|
||||||
.args([arg])
|
|
||||||
.output()
|
|
||||||
.unwrap_or_else(|_| panic!("`llvm-config {arg}` failed"));
|
|
||||||
|
|
||||||
String::from_utf8(output.stdout)
|
|
||||||
.unwrap_or_else(|_| panic!("output of `llvm-config {arg}` should be utf8"))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn set_rustc_link_flags() {
|
|
||||||
println!("cargo:rustc-link-search=native={}", llvm_config("--libdir"));
|
|
||||||
|
|
||||||
for lib in [
|
|
||||||
"lldELF",
|
|
||||||
"lldCommon",
|
|
||||||
"lldMachO",
|
|
||||||
"LLVMSupport",
|
|
||||||
"LLVMLinker",
|
|
||||||
"LLVMCore",
|
|
||||||
"LLVMLTO",
|
|
||||||
"LLVMTargetParser",
|
|
||||||
"LLVMBinaryFormat",
|
|
||||||
"LLVMDemangle",
|
|
||||||
] {
|
|
||||||
println!("cargo:rustc-link-lib=static={lib}");
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(target_os = "linux")]
|
|
||||||
{
|
|
||||||
println!("cargo:rustc-link-lib=dylib=stdc++");
|
|
||||||
println!("cargo:rustc-link-lib=tinfo");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn main() {
|
|
||||||
llvm_config("--cxxflags")
|
|
||||||
.split_whitespace()
|
|
||||||
.fold(&mut cc::Build::new(), |builder, flag| builder.flag(flag))
|
|
||||||
.flag("-Wno-unused-parameter")
|
|
||||||
.cpp(true)
|
|
||||||
.file("src/linker.cpp")
|
|
||||||
.compile("liblinker.a");
|
|
||||||
|
|
||||||
set_rustc_link_flags();
|
|
||||||
|
|
||||||
println!("cargo:rerun-if-changed=build.rs");
|
|
||||||
}
|
|
||||||
@@ -1,3 +0,0 @@
|
|||||||
extern "C" {
|
|
||||||
pub fn LLDELFLink(args: *const *const libc::c_char, size: libc::size_t) -> libc::c_int;
|
|
||||||
}
|
|
||||||
@@ -1,22 +0,0 @@
|
|||||||
#include "lld/Common/Driver.h"
|
|
||||||
#include "lld/Common/CommonLinkerContext.h"
|
|
||||||
#include "llvm/Support/CrashRecoveryContext.h"
|
|
||||||
|
|
||||||
LLD_HAS_DRIVER(elf);
|
|
||||||
|
|
||||||
extern "C" bool LLDELFLink(const char *argv[], size_t length)
|
|
||||||
{
|
|
||||||
bool canRunAgain;
|
|
||||||
|
|
||||||
{
|
|
||||||
llvm::ArrayRef<const char *> args(argv, length);
|
|
||||||
llvm::CrashRecoveryContext crc;
|
|
||||||
if (!crc.RunSafely([&]()
|
|
||||||
{ canRunAgain = lld::elf::link(args, llvm::outs(), llvm::errs(), false, false); }))
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
llvm::CrashRecoveryContext crc;
|
|
||||||
return canRunAgain && crc.RunSafely([&]()
|
|
||||||
{ lld::CommonLinkerContext::destroy(); });
|
|
||||||
}
|
|
||||||
@@ -1,40 +0,0 @@
|
|||||||
[package]
|
|
||||||
name = "revive-llvm-context"
|
|
||||||
version.workspace = true
|
|
||||||
license.workspace = true
|
|
||||||
edition.workspace = true
|
|
||||||
repository.workspace = true
|
|
||||||
authors = [
|
|
||||||
"Oleksandr Zarudnyi <a.zarudnyy@matterlabs.dev>",
|
|
||||||
"Cyrill Leutwiler <cyrill@parity.io>",
|
|
||||||
]
|
|
||||||
description = "Shared front end code of the revive PolkaVM compilers"
|
|
||||||
|
|
||||||
[lib]
|
|
||||||
doctest = false
|
|
||||||
|
|
||||||
[features]
|
|
||||||
riscv-zbb = []
|
|
||||||
riscv-64 = []
|
|
||||||
|
|
||||||
[dependencies]
|
|
||||||
anyhow = { workspace = true }
|
|
||||||
semver = { workspace = true }
|
|
||||||
itertools = { workspace = true }
|
|
||||||
serde = { workspace = true, features = ["derive"] }
|
|
||||||
regex = { workspace = true }
|
|
||||||
once_cell = { workspace = true }
|
|
||||||
num = { workspace = true }
|
|
||||||
hex = { workspace = true }
|
|
||||||
sha2 = { workspace = true }
|
|
||||||
sha3 = { workspace = true }
|
|
||||||
md5 = { workspace = true }
|
|
||||||
inkwell = { workspace = true }
|
|
||||||
polkavm-disassembler = { workspace = true }
|
|
||||||
polkavm-common = { workspace = true }
|
|
||||||
|
|
||||||
revive-common = { workspace = true }
|
|
||||||
revive-runtime-api = { workspace = true }
|
|
||||||
revive-linker = { workspace = true }
|
|
||||||
revive-builtins = { workspace = true }
|
|
||||||
revive-stdlib = { workspace = true }
|
|
||||||
@@ -1,36 +0,0 @@
|
|||||||
//! The debug IR type.
|
|
||||||
|
|
||||||
/// The debug IR type.
|
|
||||||
#[allow(non_camel_case_types)]
|
|
||||||
#[allow(clippy::upper_case_acronyms)]
|
|
||||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
||||||
pub enum IRType {
|
|
||||||
/// Whether to dump the Yul code.
|
|
||||||
Yul,
|
|
||||||
/// Whether to dump the EVM legacy assembly code.
|
|
||||||
EVMLA,
|
|
||||||
/// Whether to dump the Ethereal IR code.
|
|
||||||
EthIR,
|
|
||||||
/// Whether to dump the LLVM IR code.
|
|
||||||
LLVM,
|
|
||||||
/// Whether to dump the assembly code.
|
|
||||||
Assembly,
|
|
||||||
/// Whether to jump JSON
|
|
||||||
#[cfg(debug_assertions)]
|
|
||||||
JSON,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl IRType {
|
|
||||||
/// Returns the file extension for the specified IR.
|
|
||||||
pub fn file_extension(&self) -> &'static str {
|
|
||||||
match self {
|
|
||||||
Self::Yul => revive_common::EXTENSION_YUL,
|
|
||||||
Self::EthIR => revive_common::EXTENSION_ETHIR,
|
|
||||||
Self::EVMLA => revive_common::EXTENSION_EVMLA,
|
|
||||||
Self::LLVM => revive_common::EXTENSION_LLVM_SOURCE,
|
|
||||||
Self::Assembly => revive_common::EXTENSION_POLKAVM_ASSEMBLY,
|
|
||||||
#[cfg(debug_assertions)]
|
|
||||||
Self::JSON => revive_common::EXTENSION_JSON,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,124 +0,0 @@
|
|||||||
//! The debug configuration.
|
|
||||||
|
|
||||||
pub mod ir_type;
|
|
||||||
|
|
||||||
use std::path::PathBuf;
|
|
||||||
|
|
||||||
use serde::Deserialize;
|
|
||||||
use serde::Serialize;
|
|
||||||
|
|
||||||
use self::ir_type::IRType;
|
|
||||||
|
|
||||||
/// The debug configuration.
|
|
||||||
#[derive(Debug, Default, Serialize, Deserialize, Clone)]
|
|
||||||
pub struct DebugConfig {
|
|
||||||
/// The directory to dump the IRs to.
|
|
||||||
pub output_directory: PathBuf,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl DebugConfig {
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(output_directory: PathBuf) -> Self {
|
|
||||||
Self { output_directory }
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Dumps the Yul IR.
|
|
||||||
pub fn dump_yul(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
|
|
||||||
let mut file_path = self.output_directory.to_owned();
|
|
||||||
let full_file_name = Self::full_file_name(contract_path, None, IRType::Yul);
|
|
||||||
file_path.push(full_file_name);
|
|
||||||
std::fs::write(file_path, code)?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Dumps the EVM legacy assembly IR.
|
|
||||||
pub fn dump_evmla(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
|
|
||||||
let mut file_path = self.output_directory.to_owned();
|
|
||||||
let full_file_name = Self::full_file_name(contract_path, None, IRType::EVMLA);
|
|
||||||
file_path.push(full_file_name);
|
|
||||||
std::fs::write(file_path, code)?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Dumps the Ethereal IR.
|
|
||||||
pub fn dump_ethir(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
|
|
||||||
let mut file_path = self.output_directory.to_owned();
|
|
||||||
let full_file_name = Self::full_file_name(contract_path, None, IRType::EthIR);
|
|
||||||
file_path.push(full_file_name);
|
|
||||||
std::fs::write(file_path, code)?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Dumps the unoptimized LLVM IR.
|
|
||||||
pub fn dump_llvm_ir_unoptimized(
|
|
||||||
&self,
|
|
||||||
contract_path: &str,
|
|
||||||
module: &inkwell::module::Module,
|
|
||||||
) -> anyhow::Result<()> {
|
|
||||||
let llvm_code = module.print_to_string().to_string();
|
|
||||||
|
|
||||||
let mut file_path = self.output_directory.to_owned();
|
|
||||||
let full_file_name = Self::full_file_name(contract_path, Some("unoptimized"), IRType::LLVM);
|
|
||||||
file_path.push(full_file_name);
|
|
||||||
std::fs::write(file_path, llvm_code)?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Dumps the optimized LLVM IR.
|
|
||||||
pub fn dump_llvm_ir_optimized(
|
|
||||||
&self,
|
|
||||||
contract_path: &str,
|
|
||||||
module: &inkwell::module::Module,
|
|
||||||
) -> anyhow::Result<()> {
|
|
||||||
let llvm_code = module.print_to_string().to_string();
|
|
||||||
|
|
||||||
let mut file_path = self.output_directory.to_owned();
|
|
||||||
let full_file_name = Self::full_file_name(contract_path, Some("optimized"), IRType::LLVM);
|
|
||||||
file_path.push(full_file_name);
|
|
||||||
std::fs::write(file_path, llvm_code)?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Dumps the assembly.
|
|
||||||
pub fn dump_assembly(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
|
|
||||||
let mut file_path = self.output_directory.to_owned();
|
|
||||||
let full_file_name = Self::full_file_name(contract_path, None, IRType::Assembly);
|
|
||||||
file_path.push(full_file_name);
|
|
||||||
std::fs::write(file_path, code)?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Dumps the stage output as a json file suitable for use with --recursive-process
|
|
||||||
#[cfg(debug_assertions)]
|
|
||||||
pub fn dump_stage_output(
|
|
||||||
&self,
|
|
||||||
contract_path: &str,
|
|
||||||
contract_suffix: Option<&str>,
|
|
||||||
stage_json: &Vec<u8>,
|
|
||||||
) -> anyhow::Result<()> {
|
|
||||||
let mut file_path = self.output_directory.to_owned();
|
|
||||||
let full_file_name = Self::full_file_name(contract_path, contract_suffix, IRType::JSON);
|
|
||||||
file_path.push(full_file_name);
|
|
||||||
std::fs::write(file_path, stage_json)?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a full file name, given the contract full path, suffix, and extension.
|
|
||||||
fn full_file_name(contract_path: &str, suffix: Option<&str>, ir_type: IRType) -> String {
|
|
||||||
let mut full_file_name = contract_path.replace('/', "_").replace(':', ".");
|
|
||||||
if let Some(suffix) = suffix {
|
|
||||||
full_file_name.push('.');
|
|
||||||
full_file_name.push_str(suffix);
|
|
||||||
}
|
|
||||||
full_file_name.push('.');
|
|
||||||
full_file_name.push_str(ir_type.file_extension());
|
|
||||||
full_file_name
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,76 +0,0 @@
|
|||||||
//! The LLVM context library.
|
|
||||||
|
|
||||||
pub(crate) mod debug_config;
|
|
||||||
pub(crate) mod optimizer;
|
|
||||||
pub(crate) mod polkavm;
|
|
||||||
pub(crate) mod target_machine;
|
|
||||||
|
|
||||||
pub use self::debug_config::ir_type::IRType as DebugConfigIR;
|
|
||||||
pub use self::debug_config::DebugConfig;
|
|
||||||
pub use self::optimizer::settings::size_level::SizeLevel as OptimizerSettingsSizeLevel;
|
|
||||||
pub use self::optimizer::settings::Settings as OptimizerSettings;
|
|
||||||
pub use self::optimizer::Optimizer;
|
|
||||||
pub use self::polkavm::build_assembly_text as polkavm_build_assembly_text;
|
|
||||||
pub use self::polkavm::context::address_space::AddressSpace as PolkaVMAddressSpace;
|
|
||||||
pub use self::polkavm::context::argument::Argument as PolkaVMArgument;
|
|
||||||
pub use self::polkavm::context::attribute::Attribute as PolkaVMAttribute;
|
|
||||||
pub use self::polkavm::context::build::Build as PolkaVMBuild;
|
|
||||||
pub use self::polkavm::context::code_type::CodeType as PolkaVMCodeType;
|
|
||||||
pub use self::polkavm::context::evmla_data::EVMLAData as PolkaVMContextEVMLAData;
|
|
||||||
pub use self::polkavm::context::function::block::evmla_data::key::Key as PolkaVMFunctionBlockKey;
|
|
||||||
pub use self::polkavm::context::function::block::evmla_data::EVMLAData as PolkaVMFunctionBlockEVMLAData;
|
|
||||||
pub use self::polkavm::context::function::block::Block as PolkaVMFunctionBlock;
|
|
||||||
pub use self::polkavm::context::function::declaration::Declaration as PolkaVMFunctionDeclaration;
|
|
||||||
pub use self::polkavm::context::function::evmla_data::EVMLAData as PolkaVMFunctionEVMLAData;
|
|
||||||
pub use self::polkavm::context::function::intrinsics::Intrinsics as PolkaVMIntrinsicFunction;
|
|
||||||
pub use self::polkavm::context::function::llvm_runtime::LLVMRuntime as PolkaVMLLVMRuntime;
|
|
||||||
pub use self::polkavm::context::function::r#return::Return as PolkaVMFunctionReturn;
|
|
||||||
pub use self::polkavm::context::function::runtime::deploy_code::DeployCode as PolkaVMDeployCodeFunction;
|
|
||||||
pub use self::polkavm::context::function::runtime::entry::Entry as PolkaVMEntryFunction;
|
|
||||||
pub use self::polkavm::context::function::runtime::immutable_data_load::ImmutableDataLoad as PolkaVMImmutableDataLoadFunction;
|
|
||||||
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::Pointer as PolkaVMPointer;
|
|
||||||
pub use self::polkavm::context::r#loop::Loop as PolkaVMLoop;
|
|
||||||
pub use self::polkavm::context::solidity_data::SolidityData as PolkaVMContextSolidityData;
|
|
||||||
pub use self::polkavm::context::yul_data::YulData as PolkaVMContextYulData;
|
|
||||||
pub use self::polkavm::context::Context as PolkaVMContext;
|
|
||||||
pub use self::polkavm::evm::arithmetic as polkavm_evm_arithmetic;
|
|
||||||
pub use self::polkavm::evm::bitwise as polkavm_evm_bitwise;
|
|
||||||
pub use self::polkavm::evm::call as polkavm_evm_call;
|
|
||||||
pub use self::polkavm::evm::calldata as polkavm_evm_calldata;
|
|
||||||
pub use self::polkavm::evm::comparison as polkavm_evm_comparison;
|
|
||||||
pub use self::polkavm::evm::context as polkavm_evm_contract_context;
|
|
||||||
pub use self::polkavm::evm::create as polkavm_evm_create;
|
|
||||||
pub use self::polkavm::evm::crypto as polkavm_evm_crypto;
|
|
||||||
pub use self::polkavm::evm::ether_gas as polkavm_evm_ether_gas;
|
|
||||||
pub use self::polkavm::evm::event as polkavm_evm_event;
|
|
||||||
pub use self::polkavm::evm::ext_code as polkavm_evm_ext_code;
|
|
||||||
pub use self::polkavm::evm::immutable as polkavm_evm_immutable;
|
|
||||||
pub use self::polkavm::evm::math as polkavm_evm_math;
|
|
||||||
pub use self::polkavm::evm::memory as polkavm_evm_memory;
|
|
||||||
pub use self::polkavm::evm::r#return as polkavm_evm_return;
|
|
||||||
pub use self::polkavm::evm::return_data as polkavm_evm_return_data;
|
|
||||||
pub use self::polkavm::evm::storage as polkavm_evm_storage;
|
|
||||||
pub use self::polkavm::metadata_hash::MetadataHash as PolkaVMMetadataHash;
|
|
||||||
pub use self::polkavm::r#const as polkavm_const;
|
|
||||||
pub use self::polkavm::utils as polkavm_utils;
|
|
||||||
pub use self::polkavm::Dependency as PolkaVMDependency;
|
|
||||||
pub use self::polkavm::DummyDependency as PolkaVMDummyDependency;
|
|
||||||
pub use self::polkavm::DummyLLVMWritable as PolkaVMDummyLLVMWritable;
|
|
||||||
pub use self::polkavm::WriteLLVM as PolkaVMWriteLLVM;
|
|
||||||
pub use self::target_machine::target::Target;
|
|
||||||
pub use self::target_machine::TargetMachine;
|
|
||||||
|
|
||||||
/// Initializes the target machine.
|
|
||||||
pub fn initialize_target(target: Target) {
|
|
||||||
match target {
|
|
||||||
Target::PVM => self::polkavm::initialize_target(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,41 +0,0 @@
|
|||||||
//! The LLVM optimizing tools.
|
|
||||||
|
|
||||||
pub mod settings;
|
|
||||||
|
|
||||||
use serde::Deserialize;
|
|
||||||
use serde::Serialize;
|
|
||||||
|
|
||||||
use crate::target_machine::TargetMachine;
|
|
||||||
|
|
||||||
use self::settings::Settings;
|
|
||||||
|
|
||||||
/// The LLVM optimizing tools.
|
|
||||||
#[derive(Debug, Serialize, Deserialize)]
|
|
||||||
pub struct Optimizer {
|
|
||||||
/// The optimizer settings.
|
|
||||||
settings: Settings,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Optimizer {
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(settings: Settings) -> Self {
|
|
||||||
Self { settings }
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Runs the new pass manager.
|
|
||||||
pub fn run(
|
|
||||||
&self,
|
|
||||||
target_machine: &TargetMachine,
|
|
||||||
module: &inkwell::module::Module,
|
|
||||||
) -> Result<(), inkwell::support::LLVMString> {
|
|
||||||
target_machine.run_optimization_passes(
|
|
||||||
module,
|
|
||||||
format!("default<O{}>", self.settings.middle_end_as_string()).as_str(),
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the optimizer settings reference.
|
|
||||||
pub fn settings(&self) -> &Settings {
|
|
||||||
&self.settings
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,228 +0,0 @@
|
|||||||
//! The LLVM optimizer settings.
|
|
||||||
|
|
||||||
pub mod size_level;
|
|
||||||
|
|
||||||
use serde::Deserialize;
|
|
||||||
use serde::Serialize;
|
|
||||||
|
|
||||||
use itertools::Itertools;
|
|
||||||
|
|
||||||
use self::size_level::SizeLevel;
|
|
||||||
|
|
||||||
/// The LLVM optimizer settings.
|
|
||||||
#[derive(Debug, Serialize, Deserialize, Clone, Eq)]
|
|
||||||
pub struct Settings {
|
|
||||||
/// The middle-end optimization level.
|
|
||||||
pub level_middle_end: inkwell::OptimizationLevel,
|
|
||||||
/// The middle-end size optimization level.
|
|
||||||
pub level_middle_end_size: SizeLevel,
|
|
||||||
/// The back-end optimization level.
|
|
||||||
pub level_back_end: inkwell::OptimizationLevel,
|
|
||||||
|
|
||||||
/// Fallback to optimizing for size if the bytecode is too large.
|
|
||||||
pub is_fallback_to_size_enabled: bool,
|
|
||||||
|
|
||||||
/// Whether the LLVM `verify each` option is enabled.
|
|
||||||
pub is_verify_each_enabled: bool,
|
|
||||||
/// Whether the LLVM `debug logging` option is enabled.
|
|
||||||
pub is_debug_logging_enabled: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Settings {
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(
|
|
||||||
level_middle_end: inkwell::OptimizationLevel,
|
|
||||||
level_middle_end_size: SizeLevel,
|
|
||||||
level_back_end: inkwell::OptimizationLevel,
|
|
||||||
) -> Self {
|
|
||||||
Self {
|
|
||||||
level_middle_end,
|
|
||||||
level_middle_end_size,
|
|
||||||
level_back_end,
|
|
||||||
|
|
||||||
is_fallback_to_size_enabled: false,
|
|
||||||
|
|
||||||
is_verify_each_enabled: false,
|
|
||||||
is_debug_logging_enabled: false,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A shortcut constructor with debugging tools.
|
|
||||||
pub fn new_debug(
|
|
||||||
level_middle_end: inkwell::OptimizationLevel,
|
|
||||||
level_middle_end_size: SizeLevel,
|
|
||||||
level_back_end: inkwell::OptimizationLevel,
|
|
||||||
|
|
||||||
is_verify_each_enabled: bool,
|
|
||||||
is_debug_logging_enabled: bool,
|
|
||||||
) -> Self {
|
|
||||||
Self {
|
|
||||||
level_middle_end,
|
|
||||||
level_middle_end_size,
|
|
||||||
level_back_end,
|
|
||||||
|
|
||||||
is_fallback_to_size_enabled: false,
|
|
||||||
|
|
||||||
is_verify_each_enabled,
|
|
||||||
is_debug_logging_enabled,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates settings from a CLI optimization parameter.
|
|
||||||
pub fn try_from_cli(value: char) -> anyhow::Result<Self> {
|
|
||||||
Ok(match value {
|
|
||||||
'0' => Self::new(
|
|
||||||
// The middle-end optimization level.
|
|
||||||
inkwell::OptimizationLevel::None,
|
|
||||||
// The middle-end size optimization level.
|
|
||||||
SizeLevel::Zero,
|
|
||||||
// The back-end optimization level.
|
|
||||||
inkwell::OptimizationLevel::None,
|
|
||||||
),
|
|
||||||
'1' => Self::new(
|
|
||||||
inkwell::OptimizationLevel::Less,
|
|
||||||
SizeLevel::Zero,
|
|
||||||
// The back-end does not currently distinguish between O1, O2, and O3.
|
|
||||||
inkwell::OptimizationLevel::Less,
|
|
||||||
),
|
|
||||||
'2' => Self::new(
|
|
||||||
inkwell::OptimizationLevel::Default,
|
|
||||||
SizeLevel::Zero,
|
|
||||||
// The back-end does not currently distinguish between O1, O2, and O3.
|
|
||||||
inkwell::OptimizationLevel::Default,
|
|
||||||
),
|
|
||||||
'3' => Self::new(
|
|
||||||
inkwell::OptimizationLevel::Aggressive,
|
|
||||||
SizeLevel::Zero,
|
|
||||||
inkwell::OptimizationLevel::Aggressive,
|
|
||||||
),
|
|
||||||
's' => Self::new(
|
|
||||||
// The middle-end optimization level is ignored when SizeLevel is set.
|
|
||||||
inkwell::OptimizationLevel::Default,
|
|
||||||
SizeLevel::S,
|
|
||||||
inkwell::OptimizationLevel::Aggressive,
|
|
||||||
),
|
|
||||||
'z' => Self::new(
|
|
||||||
// The middle-end optimization level is ignored when SizeLevel is set.
|
|
||||||
inkwell::OptimizationLevel::Default,
|
|
||||||
SizeLevel::Z,
|
|
||||||
inkwell::OptimizationLevel::Aggressive,
|
|
||||||
),
|
|
||||||
char => anyhow::bail!("Unexpected optimization option '{}'", char),
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the settings without optimizations.
|
|
||||||
pub fn none() -> Self {
|
|
||||||
Self::new(
|
|
||||||
inkwell::OptimizationLevel::None,
|
|
||||||
SizeLevel::Zero,
|
|
||||||
inkwell::OptimizationLevel::None,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the settings for the optimal number of VM execution cycles.
|
|
||||||
pub fn cycles() -> Self {
|
|
||||||
Self::new(
|
|
||||||
inkwell::OptimizationLevel::Aggressive,
|
|
||||||
SizeLevel::Zero,
|
|
||||||
inkwell::OptimizationLevel::Aggressive,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the settings for the optimal size.
|
|
||||||
pub fn size() -> Self {
|
|
||||||
Self::new(
|
|
||||||
inkwell::OptimizationLevel::Default,
|
|
||||||
SizeLevel::Z,
|
|
||||||
inkwell::OptimizationLevel::Aggressive,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the middle-end optimization parameter as string.
|
|
||||||
pub fn middle_end_as_string(&self) -> String {
|
|
||||||
match self.level_middle_end_size {
|
|
||||||
SizeLevel::Zero => (self.level_middle_end as u8).to_string(),
|
|
||||||
size_level => size_level.to_string(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Checks whether there are middle-end optimizations enabled.
|
|
||||||
pub fn is_middle_end_enabled(&self) -> bool {
|
|
||||||
self.level_middle_end != inkwell::OptimizationLevel::None
|
|
||||||
|| self.level_middle_end_size != SizeLevel::Zero
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns all possible combinations of the optimizer settings.
|
|
||||||
/// Used only for testing purposes.
|
|
||||||
pub fn combinations() -> Vec<Self> {
|
|
||||||
let performance_combinations: Vec<Self> = vec![
|
|
||||||
inkwell::OptimizationLevel::None,
|
|
||||||
inkwell::OptimizationLevel::Less,
|
|
||||||
inkwell::OptimizationLevel::Default,
|
|
||||||
inkwell::OptimizationLevel::Aggressive,
|
|
||||||
]
|
|
||||||
.into_iter()
|
|
||||||
.cartesian_product(vec![
|
|
||||||
inkwell::OptimizationLevel::None,
|
|
||||||
inkwell::OptimizationLevel::Aggressive,
|
|
||||||
])
|
|
||||||
.map(|(optimization_level_middle, optimization_level_back)| {
|
|
||||||
Self::new(
|
|
||||||
optimization_level_middle,
|
|
||||||
SizeLevel::Zero,
|
|
||||||
optimization_level_back,
|
|
||||||
)
|
|
||||||
})
|
|
||||||
.collect();
|
|
||||||
|
|
||||||
let size_combinations: Vec<Self> = vec![SizeLevel::S, SizeLevel::Z]
|
|
||||||
.into_iter()
|
|
||||||
.cartesian_product(vec![
|
|
||||||
inkwell::OptimizationLevel::None,
|
|
||||||
inkwell::OptimizationLevel::Aggressive,
|
|
||||||
])
|
|
||||||
.map(|(size_level, optimization_level_back)| {
|
|
||||||
Self::new(
|
|
||||||
inkwell::OptimizationLevel::Default,
|
|
||||||
size_level,
|
|
||||||
optimization_level_back,
|
|
||||||
)
|
|
||||||
})
|
|
||||||
.collect();
|
|
||||||
|
|
||||||
let mut combinations = performance_combinations;
|
|
||||||
combinations.extend(size_combinations);
|
|
||||||
|
|
||||||
combinations
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sets the fallback to optimizing for size if the bytecode is too large.
|
|
||||||
pub fn enable_fallback_to_size(&mut self) {
|
|
||||||
self.is_fallback_to_size_enabled = true;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Whether the fallback to optimizing for size is enabled.
|
|
||||||
pub fn is_fallback_to_size_enabled(&self) -> bool {
|
|
||||||
self.is_fallback_to_size_enabled
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl PartialEq for Settings {
|
|
||||||
fn eq(&self, other: &Self) -> bool {
|
|
||||||
self.level_middle_end == other.level_middle_end
|
|
||||||
&& self.level_middle_end_size == other.level_middle_end_size
|
|
||||||
&& self.level_back_end == other.level_back_end
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl std::fmt::Display for Settings {
|
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
||||||
write!(
|
|
||||||
f,
|
|
||||||
"M{}B{}",
|
|
||||||
self.middle_end_as_string(),
|
|
||||||
self.level_back_end as u8,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,35 +0,0 @@
|
|||||||
//! The LLVM optimizer settings size level.
|
|
||||||
|
|
||||||
use serde::Deserialize;
|
|
||||||
use serde::Serialize;
|
|
||||||
|
|
||||||
/// The LLVM optimizer settings size level.
|
|
||||||
#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq)]
|
|
||||||
pub enum SizeLevel {
|
|
||||||
/// No size optimizations.
|
|
||||||
Zero,
|
|
||||||
/// The default size optimizations.
|
|
||||||
S,
|
|
||||||
/// The aggresize size optimizations.
|
|
||||||
Z,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<SizeLevel> for u32 {
|
|
||||||
fn from(level: SizeLevel) -> Self {
|
|
||||||
match level {
|
|
||||||
SizeLevel::Zero => 0,
|
|
||||||
SizeLevel::S => 1,
|
|
||||||
SizeLevel::Z => 2,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl std::fmt::Display for SizeLevel {
|
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
||||||
match self {
|
|
||||||
SizeLevel::Zero => write!(f, "0"),
|
|
||||||
SizeLevel::S => write!(f, "s"),
|
|
||||||
SizeLevel::Z => write!(f, "z"),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,23 +0,0 @@
|
|||||||
//! The LLVM context constants.
|
|
||||||
|
|
||||||
/// The LLVM framework version.
|
|
||||||
pub const LLVM_VERSION: semver::Version = semver::Version::new(18, 1, 4);
|
|
||||||
|
|
||||||
/// The register width sized type
|
|
||||||
pub static XLEN: usize = revive_common::BIT_LENGTH_X32;
|
|
||||||
|
|
||||||
/// The heap memory pointer pointer global variable name.
|
|
||||||
pub static GLOBAL_HEAP_MEMORY_POINTER: &str = "memory_pointer";
|
|
||||||
|
|
||||||
/// The calldata pointer global variable name.
|
|
||||||
pub static GLOBAL_CALLDATA_POINTER: &str = "ptr_calldata";
|
|
||||||
|
|
||||||
/// The calldata size global variable name.
|
|
||||||
pub static GLOBAL_CALLDATA_SIZE: &str = "calldatasize";
|
|
||||||
|
|
||||||
/// The call flags global variable name.
|
|
||||||
pub static GLOBAL_CALL_FLAGS: &str = "call_flags";
|
|
||||||
|
|
||||||
/// The deployer call header size that consists of:
|
|
||||||
/// - bytecode hash (32 bytes)
|
|
||||||
pub const DEPLOYER_CALL_HEADER_SIZE: usize = revive_common::BYTE_LENGTH_WORD;
|
|
||||||
@@ -1,26 +0,0 @@
|
|||||||
//! The address space aliases.
|
|
||||||
|
|
||||||
/// The address space aliases.
|
|
||||||
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
||||||
pub enum AddressSpace {
|
|
||||||
/// The stack memory.
|
|
||||||
#[default]
|
|
||||||
Stack,
|
|
||||||
/// The heap memory.
|
|
||||||
Heap,
|
|
||||||
/// The generic memory page.
|
|
||||||
Storage,
|
|
||||||
/// The transient storage.
|
|
||||||
TransientStorage,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<AddressSpace> for inkwell::AddressSpace {
|
|
||||||
fn from(value: AddressSpace) -> Self {
|
|
||||||
match value {
|
|
||||||
AddressSpace::Stack => Self::from(0),
|
|
||||||
AddressSpace::Heap => Self::from(1),
|
|
||||||
AddressSpace::Storage => Self::from(5),
|
|
||||||
AddressSpace::TransientStorage => Self::from(6),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,64 +0,0 @@
|
|||||||
//! The LLVM argument with metadata.
|
|
||||||
|
|
||||||
/// The LLVM argument with metadata.
|
|
||||||
#[derive(Debug, Clone)]
|
|
||||||
pub struct Argument<'ctx> {
|
|
||||||
/// The actual LLVM operand.
|
|
||||||
pub value: inkwell::values::BasicValueEnum<'ctx>,
|
|
||||||
/// The original AST value. Used mostly for string literals.
|
|
||||||
pub original: Option<String>,
|
|
||||||
/// The preserved constant value, if available.
|
|
||||||
pub constant: Option<num::BigUint>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'ctx> Argument<'ctx> {
|
|
||||||
/// The calldata offset argument index.
|
|
||||||
pub const ARGUMENT_INDEX_CALLDATA_OFFSET: usize = 0;
|
|
||||||
|
|
||||||
/// The calldata length argument index.
|
|
||||||
pub const ARGUMENT_INDEX_CALLDATA_LENGTH: usize = 1;
|
|
||||||
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(value: inkwell::values::BasicValueEnum<'ctx>) -> Self {
|
|
||||||
Self {
|
|
||||||
value,
|
|
||||||
original: None,
|
|
||||||
constant: None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new_with_original(
|
|
||||||
value: inkwell::values::BasicValueEnum<'ctx>,
|
|
||||||
original: String,
|
|
||||||
) -> Self {
|
|
||||||
Self {
|
|
||||||
value,
|
|
||||||
original: Some(original),
|
|
||||||
constant: None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new_with_constant(
|
|
||||||
value: inkwell::values::BasicValueEnum<'ctx>,
|
|
||||||
constant: num::BigUint,
|
|
||||||
) -> Self {
|
|
||||||
Self {
|
|
||||||
value,
|
|
||||||
original: None,
|
|
||||||
constant: Some(constant),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the inner LLVM value.
|
|
||||||
pub fn to_llvm(&self) -> inkwell::values::BasicValueEnum<'ctx> {
|
|
||||||
self.value
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'ctx> From<inkwell::values::BasicValueEnum<'ctx>> for Argument<'ctx> {
|
|
||||||
fn from(value: inkwell::values::BasicValueEnum<'ctx>) -> Self {
|
|
||||||
Self::new(value)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,124 +0,0 @@
|
|||||||
//! The LLVM attribute.
|
|
||||||
|
|
||||||
use serde::Deserialize;
|
|
||||||
use serde::Serialize;
|
|
||||||
|
|
||||||
/// The LLVM attribute.
|
|
||||||
/// In order to check the real order in a new major version of LLVM, find the `Attributes.inc` file
|
|
||||||
/// inside of the LLVM build directory. This order is actually generated during the building.
|
|
||||||
#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
||||||
pub enum Attribute {
|
|
||||||
Unused = 0,
|
|
||||||
AllocAlign = 1,
|
|
||||||
AllocatedPointer = 2,
|
|
||||||
AlwaysInline = 3,
|
|
||||||
Builtin = 4,
|
|
||||||
Cold = 5,
|
|
||||||
Convergent = 6,
|
|
||||||
CoroDestroyOnlyWhenComplete = 7,
|
|
||||||
DeadOnUnwind = 8,
|
|
||||||
DisableSanitizerInstrumentation = 9,
|
|
||||||
FnRetThunkExtern = 10,
|
|
||||||
Hot = 11,
|
|
||||||
ImmArg = 12,
|
|
||||||
InReg = 13,
|
|
||||||
InlineHint = 14,
|
|
||||||
JumpTable = 15,
|
|
||||||
MinSize = 16,
|
|
||||||
MustProgress = 17,
|
|
||||||
Naked = 18,
|
|
||||||
Nest = 19,
|
|
||||||
NoAlias = 20,
|
|
||||||
NoBuiltin = 21,
|
|
||||||
NoCallback = 22,
|
|
||||||
NoCapture = 23,
|
|
||||||
NoCfCheck = 24,
|
|
||||||
NoDuplicate = 25,
|
|
||||||
NoFree = 26,
|
|
||||||
NoImplicitFloat = 27,
|
|
||||||
NoInline = 28,
|
|
||||||
NoMerge = 29,
|
|
||||||
NoProfile = 30,
|
|
||||||
NoRecurse = 31,
|
|
||||||
NoRedZone = 32,
|
|
||||||
NoReturn = 33,
|
|
||||||
NoSanitizeBounds = 34,
|
|
||||||
NoSanitizeCoverage = 35,
|
|
||||||
NoSync = 36,
|
|
||||||
NoUndef = 37,
|
|
||||||
NoUnwind = 38,
|
|
||||||
NonLazyBind = 39,
|
|
||||||
NonNull = 40,
|
|
||||||
NullPointerIsValid = 41,
|
|
||||||
OptForFuzzing = 42,
|
|
||||||
OptimizeForDebugging = 43,
|
|
||||||
OptimizeForSize = 44,
|
|
||||||
OptimizeNone = 45,
|
|
||||||
PresplitCoroutine = 46,
|
|
||||||
ReadNone = 47,
|
|
||||||
ReadOnly = 48,
|
|
||||||
Returned = 49,
|
|
||||||
ReturnsTwice = 50,
|
|
||||||
SExt = 51,
|
|
||||||
SafeStack = 52,
|
|
||||||
SanitizeAddress = 53,
|
|
||||||
SanitizeHWAddress = 54,
|
|
||||||
SanitizeMemTag = 55,
|
|
||||||
SanitizeMemory = 56,
|
|
||||||
SanitizeThread = 57,
|
|
||||||
ShadowCallStack = 58,
|
|
||||||
SkipProfile = 59,
|
|
||||||
Speculatable = 60,
|
|
||||||
SpeculativeLoadHardening = 61,
|
|
||||||
StackProtect = 62,
|
|
||||||
StackProtectReq = 63,
|
|
||||||
StackProtectStrong = 64,
|
|
||||||
StrictFP = 65,
|
|
||||||
SwiftAsync = 66,
|
|
||||||
SwiftError = 67,
|
|
||||||
SwiftSelf = 68,
|
|
||||||
WillReturn = 69,
|
|
||||||
Writable = 70,
|
|
||||||
WriteOnly = 71,
|
|
||||||
ZExt = 72,
|
|
||||||
// LastEnumAttr = 72,
|
|
||||||
// FirstTypeAttr = 73,
|
|
||||||
ByRef = 73,
|
|
||||||
ByVal = 74,
|
|
||||||
ElementType = 75,
|
|
||||||
InAlloca = 76,
|
|
||||||
Preallocated = 77,
|
|
||||||
StructRet = 78,
|
|
||||||
// LastTypeAttr = 78,
|
|
||||||
// FirstIntAttr = 79,
|
|
||||||
Alignment = 79,
|
|
||||||
AllocKind = 80,
|
|
||||||
AllocSize = 81,
|
|
||||||
Dereferenceable = 82,
|
|
||||||
DereferenceableOrNull = 83,
|
|
||||||
Memory = 84,
|
|
||||||
NoFPClass = 85,
|
|
||||||
StackAlignment = 86,
|
|
||||||
UWTable = 87,
|
|
||||||
VScaleRange = 88,
|
|
||||||
// LastIntAttr = 88,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl TryFrom<&str> for Attribute {
|
|
||||||
type Error = String;
|
|
||||||
|
|
||||||
fn try_from(value: &str) -> Result<Self, Self::Error> {
|
|
||||||
match value {
|
|
||||||
"AlwaysInline" => Ok(Attribute::AlwaysInline),
|
|
||||||
"Cold" => Ok(Attribute::Cold),
|
|
||||||
"Hot" => Ok(Attribute::Hot),
|
|
||||||
"MinSize" => Ok(Attribute::MinSize),
|
|
||||||
"OptimizeForSize" => Ok(Attribute::OptimizeForSize),
|
|
||||||
"NoInline" => Ok(Attribute::NoInline),
|
|
||||||
"WillReturn" => Ok(Attribute::WillReturn),
|
|
||||||
"NoReturn" => Ok(Attribute::NoReturn),
|
|
||||||
"MustProgress" => Ok(Attribute::MustProgress),
|
|
||||||
_ => Err(value.to_owned()),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,39 +0,0 @@
|
|||||||
//! The LLVM module build.
|
|
||||||
|
|
||||||
use std::collections::BTreeMap;
|
|
||||||
|
|
||||||
use serde::Deserialize;
|
|
||||||
use serde::Serialize;
|
|
||||||
|
|
||||||
/// The LLVM module build.
|
|
||||||
#[derive(Debug, Serialize, Deserialize)]
|
|
||||||
pub struct Build {
|
|
||||||
/// The PolkaVM text assembly.
|
|
||||||
pub assembly_text: String,
|
|
||||||
/// The metadata hash.
|
|
||||||
pub metadata_hash: Option<[u8; revive_common::BYTE_LENGTH_WORD]>,
|
|
||||||
/// The PolkaVM binary bytecode.
|
|
||||||
pub bytecode: Vec<u8>,
|
|
||||||
/// The PolkaVM bytecode hash.
|
|
||||||
pub bytecode_hash: String,
|
|
||||||
/// The hash-to-full-path mapping of the contract factory dependencies.
|
|
||||||
pub factory_dependencies: BTreeMap<String, String>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Build {
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(
|
|
||||||
assembly_text: String,
|
|
||||||
metadata_hash: Option<[u8; revive_common::BYTE_LENGTH_WORD]>,
|
|
||||||
bytecode: Vec<u8>,
|
|
||||||
bytecode_hash: String,
|
|
||||||
) -> Self {
|
|
||||||
Self {
|
|
||||||
assembly_text,
|
|
||||||
metadata_hash,
|
|
||||||
bytecode,
|
|
||||||
bytecode_hash,
|
|
||||||
factory_dependencies: BTreeMap::new(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,21 +0,0 @@
|
|||||||
//! The contract code types.
|
|
||||||
|
|
||||||
/// The contract code types (deploy and runtime).
|
|
||||||
/// They do not represent any entities in the final bytecode, but this separation is always present
|
|
||||||
/// in the IRs used for translation to the EVM bytecode.
|
|
||||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
||||||
pub enum CodeType {
|
|
||||||
/// The deploy code.
|
|
||||||
Deploy,
|
|
||||||
/// The runtime code.
|
|
||||||
Runtime,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl std::fmt::Display for CodeType {
|
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
||||||
match self {
|
|
||||||
Self::Deploy => write!(f, "deploy"),
|
|
||||||
Self::Runtime => write!(f, "runtime"),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,97 +0,0 @@
|
|||||||
//! The LLVM debug information.
|
|
||||||
|
|
||||||
use inkwell::debug_info::AsDIScope;
|
|
||||||
use num::Zero;
|
|
||||||
|
|
||||||
/// The LLVM debug information.
|
|
||||||
pub struct DebugInfo<'ctx> {
|
|
||||||
/// The compile unit.
|
|
||||||
compile_unit: inkwell::debug_info::DICompileUnit<'ctx>,
|
|
||||||
/// The debug info builder.
|
|
||||||
builder: inkwell::debug_info::DebugInfoBuilder<'ctx>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'ctx> DebugInfo<'ctx> {
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(module: &inkwell::module::Module<'ctx>) -> Self {
|
|
||||||
let (builder, compile_unit) = module.create_debug_info_builder(
|
|
||||||
true,
|
|
||||||
inkwell::debug_info::DWARFSourceLanguage::C,
|
|
||||||
module.get_name().to_string_lossy().as_ref(),
|
|
||||||
"",
|
|
||||||
"",
|
|
||||||
false,
|
|
||||||
"",
|
|
||||||
0,
|
|
||||||
"",
|
|
||||||
inkwell::debug_info::DWARFEmissionKind::Full,
|
|
||||||
0,
|
|
||||||
false,
|
|
||||||
false,
|
|
||||||
"",
|
|
||||||
"",
|
|
||||||
);
|
|
||||||
|
|
||||||
Self {
|
|
||||||
compile_unit,
|
|
||||||
builder,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a function info.
|
|
||||||
pub fn create_function(
|
|
||||||
&self,
|
|
||||||
name: &str,
|
|
||||||
) -> anyhow::Result<inkwell::debug_info::DISubprogram<'ctx>> {
|
|
||||||
let subroutine_type = self.builder.create_subroutine_type(
|
|
||||||
self.compile_unit.get_file(),
|
|
||||||
Some(self.create_type(revive_common::BIT_LENGTH_FIELD)?),
|
|
||||||
&[],
|
|
||||||
inkwell::debug_info::DIFlags::zero(),
|
|
||||||
);
|
|
||||||
|
|
||||||
let function = self.builder.create_function(
|
|
||||||
self.compile_unit.get_file().as_debug_info_scope(),
|
|
||||||
name,
|
|
||||||
None,
|
|
||||||
self.compile_unit.get_file(),
|
|
||||||
42,
|
|
||||||
subroutine_type,
|
|
||||||
true,
|
|
||||||
false,
|
|
||||||
1,
|
|
||||||
inkwell::debug_info::DIFlags::zero(),
|
|
||||||
false,
|
|
||||||
);
|
|
||||||
|
|
||||||
self.builder.create_lexical_block(
|
|
||||||
function.as_debug_info_scope(),
|
|
||||||
self.compile_unit.get_file(),
|
|
||||||
1,
|
|
||||||
1,
|
|
||||||
);
|
|
||||||
|
|
||||||
Ok(function)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a primitive type info.
|
|
||||||
pub fn create_type(
|
|
||||||
&self,
|
|
||||||
bit_length: usize,
|
|
||||||
) -> anyhow::Result<inkwell::debug_info::DIType<'ctx>> {
|
|
||||||
self.builder
|
|
||||||
.create_basic_type(
|
|
||||||
"U256",
|
|
||||||
bit_length as u64,
|
|
||||||
0,
|
|
||||||
inkwell::debug_info::DIFlags::zero(),
|
|
||||||
)
|
|
||||||
.map(|basic_type| basic_type.as_type())
|
|
||||||
.map_err(|error| anyhow::anyhow!("Debug info error: {}", error))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Finalizes the builder.
|
|
||||||
pub fn finalize(&self) {
|
|
||||||
self.builder.finalize();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,27 +0,0 @@
|
|||||||
//! The LLVM IR generator EVM legacy assembly data.
|
|
||||||
|
|
||||||
use crate::polkavm::context::argument::Argument;
|
|
||||||
|
|
||||||
/// The LLVM IR generator EVM legacy assembly data.
|
|
||||||
/// Describes some data that is only relevant to the EVM legacy assembly.
|
|
||||||
#[derive(Debug, Clone)]
|
|
||||||
pub struct EVMLAData<'ctx> {
|
|
||||||
/// The Solidity compiler version.
|
|
||||||
/// Some instruction behave differenly depending on the version.
|
|
||||||
pub version: semver::Version,
|
|
||||||
/// The static stack allocated for the current function.
|
|
||||||
pub stack: Vec<Argument<'ctx>>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'ctx> EVMLAData<'ctx> {
|
|
||||||
/// The default stack size.
|
|
||||||
pub const DEFAULT_STACK_SIZE: usize = 64;
|
|
||||||
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(version: semver::Version) -> Self {
|
|
||||||
Self {
|
|
||||||
version,
|
|
||||||
stack: Vec::with_capacity(Self::DEFAULT_STACK_SIZE),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,34 +0,0 @@
|
|||||||
//! The LLVM IR generator function block key.
|
|
||||||
|
|
||||||
use crate::polkavm::context::code_type::CodeType;
|
|
||||||
|
|
||||||
/// The LLVM IR generator function block key.
|
|
||||||
/// Is only relevant to the EVM legacy assembly.
|
|
||||||
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
||||||
pub struct Key {
|
|
||||||
/// The block code type.
|
|
||||||
pub code_type: CodeType,
|
|
||||||
/// The block tag.
|
|
||||||
pub tag: num::BigUint,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Key {
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(code_type: CodeType, tag: num::BigUint) -> Self {
|
|
||||||
Self { code_type, tag }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl std::fmt::Display for Key {
|
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
||||||
write!(
|
|
||||||
f,
|
|
||||||
"{}_{}",
|
|
||||||
match self.code_type {
|
|
||||||
CodeType::Deploy => "dt",
|
|
||||||
CodeType::Runtime => "rt",
|
|
||||||
},
|
|
||||||
self.tag
|
|
||||||
)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,18 +0,0 @@
|
|||||||
//! The LLVM function block EVM legacy assembly data.
|
|
||||||
|
|
||||||
pub mod key;
|
|
||||||
|
|
||||||
/// The LLVM function block EVM legacy assembly data.
|
|
||||||
/// Describes some data that is only relevant to the EVM legacy assembly.
|
|
||||||
#[derive(Debug, Clone)]
|
|
||||||
pub struct EVMLAData {
|
|
||||||
/// The initial hashes of the allowed stack states.
|
|
||||||
pub stack_hashes: Vec<md5::Digest>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl EVMLAData {
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(stack_hashes: Vec<md5::Digest>) -> Self {
|
|
||||||
Self { stack_hashes }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,52 +0,0 @@
|
|||||||
//! The LLVM IR generator function block.
|
|
||||||
|
|
||||||
pub mod evmla_data;
|
|
||||||
|
|
||||||
use self::evmla_data::EVMLAData;
|
|
||||||
|
|
||||||
/// The LLVM IR generator function block.
|
|
||||||
#[derive(Debug, Clone)]
|
|
||||||
pub struct Block<'ctx> {
|
|
||||||
/// The inner block.
|
|
||||||
inner: inkwell::basic_block::BasicBlock<'ctx>,
|
|
||||||
/// The EVM legacy assembly compiler data.
|
|
||||||
evmla_data: Option<EVMLAData>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'ctx> Block<'ctx> {
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(inner: inkwell::basic_block::BasicBlock<'ctx>) -> Self {
|
|
||||||
Self {
|
|
||||||
inner,
|
|
||||||
evmla_data: None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sets the EVM legacy assembly data.
|
|
||||||
pub fn set_evmla_data(&mut self, data: EVMLAData) {
|
|
||||||
self.evmla_data = Some(data);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The LLVM object reference.
|
|
||||||
pub fn inner(&self) -> inkwell::basic_block::BasicBlock<'ctx> {
|
|
||||||
self.inner
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the EVM data reference.
|
|
||||||
/// # Panics
|
|
||||||
/// If the EVM data has not been initialized.
|
|
||||||
pub fn evm(&self) -> &EVMLAData {
|
|
||||||
self.evmla_data
|
|
||||||
.as_ref()
|
|
||||||
.expect("The EVM data must have been initialized")
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the EVM data mutable reference.
|
|
||||||
/// # Panics
|
|
||||||
/// If the EVM data has not been initialized.
|
|
||||||
pub fn evm_mut(&mut self) -> &mut EVMLAData {
|
|
||||||
self.evmla_data
|
|
||||||
.as_mut()
|
|
||||||
.expect("The EVM data must have been initialized")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,20 +0,0 @@
|
|||||||
//! The LLVM function declaration.
|
|
||||||
|
|
||||||
/// The LLVM function declaration.
|
|
||||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
||||||
pub struct Declaration<'ctx> {
|
|
||||||
/// The function type.
|
|
||||||
pub r#type: inkwell::types::FunctionType<'ctx>,
|
|
||||||
/// The function value.
|
|
||||||
pub value: inkwell::values::FunctionValue<'ctx>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'ctx> Declaration<'ctx> {
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(
|
|
||||||
r#type: inkwell::types::FunctionType<'ctx>,
|
|
||||||
value: inkwell::values::FunctionValue<'ctx>,
|
|
||||||
) -> Self {
|
|
||||||
Self { r#type, value }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,74 +0,0 @@
|
|||||||
//! The LLVM function EVM legacy assembly data.
|
|
||||||
|
|
||||||
use std::collections::BTreeMap;
|
|
||||||
|
|
||||||
use crate::polkavm::context::function::block::evmla_data::key::Key as BlockKey;
|
|
||||||
use crate::polkavm::context::function::block::Block;
|
|
||||||
|
|
||||||
/// The LLVM function EVM legacy assembly data.
|
|
||||||
/// Describes some data that is only relevant to the EVM legacy assembly.
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct EVMLAData<'ctx> {
|
|
||||||
/// The ordinary blocks with numeric tags.
|
|
||||||
/// Is only used by the Solidity EVM compiler.
|
|
||||||
pub blocks: BTreeMap<BlockKey, Vec<Block<'ctx>>>,
|
|
||||||
/// The function stack size.
|
|
||||||
pub stack_size: usize,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'ctx> EVMLAData<'ctx> {
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(stack_size: usize) -> Self {
|
|
||||||
Self {
|
|
||||||
blocks: BTreeMap::new(),
|
|
||||||
stack_size,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Inserts a function block.
|
|
||||||
pub fn insert_block(&mut self, key: BlockKey, block: Block<'ctx>) {
|
|
||||||
if let Some(blocks) = self.blocks.get_mut(&key) {
|
|
||||||
blocks.push(block);
|
|
||||||
} else {
|
|
||||||
self.blocks.insert(key, vec![block]);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the block with the specified tag and initial stack pattern.
|
|
||||||
/// If there is only one block, it is returned unconditionally.
|
|
||||||
pub fn find_block(
|
|
||||||
&self,
|
|
||||||
key: &BlockKey,
|
|
||||||
stack_hash: &md5::Digest,
|
|
||||||
) -> anyhow::Result<Block<'ctx>> {
|
|
||||||
if self
|
|
||||||
.blocks
|
|
||||||
.get(key)
|
|
||||||
.ok_or_else(|| anyhow::anyhow!("Undeclared function block {}", key))?
|
|
||||||
.len()
|
|
||||||
== 1
|
|
||||||
{
|
|
||||||
return self
|
|
||||||
.blocks
|
|
||||||
.get(key)
|
|
||||||
.ok_or_else(|| anyhow::anyhow!("Undeclared function block {}", key))?
|
|
||||||
.first()
|
|
||||||
.cloned()
|
|
||||||
.ok_or_else(|| anyhow::anyhow!("Undeclared function block {}", key));
|
|
||||||
}
|
|
||||||
|
|
||||||
self.blocks
|
|
||||||
.get(key)
|
|
||||||
.ok_or_else(|| anyhow::anyhow!("Undeclared function block {}", key))?
|
|
||||||
.iter()
|
|
||||||
.find(|block| {
|
|
||||||
block
|
|
||||||
.evm()
|
|
||||||
.stack_hashes
|
|
||||||
.iter()
|
|
||||||
.any(|hash| hash == stack_hash)
|
|
||||||
})
|
|
||||||
.cloned()
|
|
||||||
.ok_or_else(|| anyhow::anyhow!("Undeclared function block {}", key))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,97 +0,0 @@
|
|||||||
//! The LLVM intrinsic functions.
|
|
||||||
|
|
||||||
use inkwell::types::BasicType;
|
|
||||||
|
|
||||||
use crate::polkavm::context::function::declaration::Declaration as FunctionDeclaration;
|
|
||||||
|
|
||||||
/// The LLVM intrinsic functions, implemented in the LLVM back-end.
|
|
||||||
/// Most of them are translated directly into bytecode instructions.
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct Intrinsics<'ctx> {
|
|
||||||
/// The trap.
|
|
||||||
pub trap: FunctionDeclaration<'ctx>,
|
|
||||||
/// Performs endianness swaps on i256 values
|
|
||||||
pub byte_swap_word: FunctionDeclaration<'ctx>,
|
|
||||||
/// Performs endianness swaps on i160 values
|
|
||||||
pub byte_swap_eth_address: FunctionDeclaration<'ctx>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'ctx> Intrinsics<'ctx> {
|
|
||||||
/// The corresponding intrinsic function name.
|
|
||||||
pub const FUNCTION_TRAP: &'static str = "llvm.trap";
|
|
||||||
|
|
||||||
/// The corresponding intrinsic function name.
|
|
||||||
pub const FUNCTION_BYTE_SWAP_WORD: &'static str = "llvm.bswap.i256";
|
|
||||||
|
|
||||||
/// The corresponding intrinsic function name.
|
|
||||||
pub const FUNCTION_BYTE_SWAP_ETH_ADDRESS: &'static str = "llvm.bswap.i160";
|
|
||||||
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(
|
|
||||||
llvm: &'ctx inkwell::context::Context,
|
|
||||||
module: &inkwell::module::Module<'ctx>,
|
|
||||||
) -> Self {
|
|
||||||
let void_type = llvm.void_type();
|
|
||||||
let word_type = llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32);
|
|
||||||
let address_type = llvm.custom_width_int_type(revive_common::BIT_LENGTH_ETH_ADDRESS as u32);
|
|
||||||
|
|
||||||
let trap = Self::declare(
|
|
||||||
llvm,
|
|
||||||
module,
|
|
||||||
Self::FUNCTION_TRAP,
|
|
||||||
void_type.fn_type(&[], false),
|
|
||||||
);
|
|
||||||
let byte_swap_word = Self::declare(
|
|
||||||
llvm,
|
|
||||||
module,
|
|
||||||
Self::FUNCTION_BYTE_SWAP_WORD,
|
|
||||||
word_type.fn_type(&[word_type.as_basic_type_enum().into()], false),
|
|
||||||
);
|
|
||||||
let byte_swap_eth_address = Self::declare(
|
|
||||||
llvm,
|
|
||||||
module,
|
|
||||||
Self::FUNCTION_BYTE_SWAP_ETH_ADDRESS,
|
|
||||||
address_type.fn_type(&[address_type.as_basic_type_enum().into()], false),
|
|
||||||
);
|
|
||||||
|
|
||||||
Self {
|
|
||||||
trap,
|
|
||||||
byte_swap_word,
|
|
||||||
byte_swap_eth_address,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Finds the specified LLVM intrinsic function in the target and returns its declaration.
|
|
||||||
pub fn declare(
|
|
||||||
llvm: &'ctx inkwell::context::Context,
|
|
||||||
module: &inkwell::module::Module<'ctx>,
|
|
||||||
name: &str,
|
|
||||||
r#type: inkwell::types::FunctionType<'ctx>,
|
|
||||||
) -> FunctionDeclaration<'ctx> {
|
|
||||||
let intrinsic = inkwell::intrinsics::Intrinsic::find(name)
|
|
||||||
.unwrap_or_else(|| panic!("Intrinsic function `{name}` does not exist"));
|
|
||||||
let argument_types = Self::argument_types(llvm, name);
|
|
||||||
let value = intrinsic
|
|
||||||
.get_declaration(module, argument_types.as_slice())
|
|
||||||
.unwrap_or_else(|| panic!("Intrinsic function `{name}` declaration error"));
|
|
||||||
FunctionDeclaration::new(r#type, value)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the LLVM types for selecting via the signature.
|
|
||||||
pub fn argument_types(
|
|
||||||
llvm: &'ctx inkwell::context::Context,
|
|
||||||
name: &str,
|
|
||||||
) -> Vec<inkwell::types::BasicTypeEnum<'ctx>> {
|
|
||||||
let word_type = llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32);
|
|
||||||
|
|
||||||
match name {
|
|
||||||
name if name == Self::FUNCTION_BYTE_SWAP_WORD => vec![word_type.as_basic_type_enum()],
|
|
||||||
name if name == Self::FUNCTION_BYTE_SWAP_ETH_ADDRESS => {
|
|
||||||
vec![llvm
|
|
||||||
.custom_width_int_type(revive_common::BIT_LENGTH_ETH_ADDRESS as u32)
|
|
||||||
.as_basic_type_enum()]
|
|
||||||
}
|
|
||||||
_ => vec![],
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,128 +0,0 @@
|
|||||||
//! 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;
|
|
||||||
|
|
||||||
/// The runtime functions, implemented on the LLVM side.
|
|
||||||
/// The functions are automatically linked to the LLVM implementations if the signatures match.
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct LLVMRuntime<'ctx> {
|
|
||||||
/// The corresponding LLVM runtime function.
|
|
||||||
pub add_mod: FunctionDeclaration<'ctx>,
|
|
||||||
/// The corresponding LLVM runtime function.
|
|
||||||
pub mul_mod: FunctionDeclaration<'ctx>,
|
|
||||||
/// The corresponding LLVM runtime function.
|
|
||||||
pub exp: FunctionDeclaration<'ctx>,
|
|
||||||
/// The corresponding LLVM runtime function.
|
|
||||||
pub sign_extend: FunctionDeclaration<'ctx>,
|
|
||||||
|
|
||||||
/// The corresponding LLVM runtime function.
|
|
||||||
pub sha3: FunctionDeclaration<'ctx>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'ctx> LLVMRuntime<'ctx> {
|
|
||||||
/// The corresponding runtime function name.
|
|
||||||
pub const FUNCTION_ADDMOD: &'static str = "__addmod";
|
|
||||||
|
|
||||||
/// The corresponding runtime function name.
|
|
||||||
pub const FUNCTION_MULMOD: &'static str = "__mulmod";
|
|
||||||
|
|
||||||
/// The corresponding runtime function name.
|
|
||||||
pub const FUNCTION_EXP: &'static str = "__exp";
|
|
||||||
|
|
||||||
/// The corresponding runtime function name.
|
|
||||||
pub const FUNCTION_SIGNEXTEND: &'static str = "__signextend";
|
|
||||||
|
|
||||||
/// The corresponding runtime function name.
|
|
||||||
pub const FUNCTION_SHA3: &'static str = "__sha3";
|
|
||||||
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(
|
|
||||||
llvm: &'ctx inkwell::context::Context,
|
|
||||||
module: &inkwell::module::Module<'ctx>,
|
|
||||||
optimizer: &Optimizer,
|
|
||||||
) -> Self {
|
|
||||||
let add_mod =
|
|
||||||
Self::define(module, Self::FUNCTION_ADDMOD).expect("should be declared in stdlib");
|
|
||||||
Function::set_default_attributes(llvm, add_mod, optimizer);
|
|
||||||
Function::set_pure_function_attributes(llvm, add_mod);
|
|
||||||
|
|
||||||
let mul_mod =
|
|
||||||
Self::define(module, Self::FUNCTION_MULMOD).expect("should be declared in stdlib");
|
|
||||||
Function::set_default_attributes(llvm, mul_mod, optimizer);
|
|
||||||
Function::set_pure_function_attributes(llvm, mul_mod);
|
|
||||||
|
|
||||||
let exp = Self::define(module, Self::FUNCTION_EXP).expect("should be declared in stdlib");
|
|
||||||
Function::set_default_attributes(llvm, exp, optimizer);
|
|
||||||
Function::set_pure_function_attributes(llvm, exp);
|
|
||||||
|
|
||||||
let sign_extend =
|
|
||||||
Self::define(module, Self::FUNCTION_SIGNEXTEND).expect("should be declared in stdlib");
|
|
||||||
Function::set_default_attributes(llvm, sign_extend, optimizer);
|
|
||||||
Function::set_pure_function_attributes(llvm, sign_extend);
|
|
||||||
|
|
||||||
let sha3 = Self::declare(
|
|
||||||
module,
|
|
||||||
Self::FUNCTION_SHA3,
|
|
||||||
llvm.custom_width_int_type(revive_common::BIT_LENGTH_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,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Declares an LLVM runtime function in the `module`,
|
|
||||||
pub fn declare(
|
|
||||||
module: &inkwell::module::Module<'ctx>,
|
|
||||||
name: &str,
|
|
||||||
r#type: inkwell::types::FunctionType<'ctx>,
|
|
||||||
linkage: Option<inkwell::module::Linkage>,
|
|
||||||
) -> FunctionDeclaration<'ctx> {
|
|
||||||
let value = module.add_function(name, r#type, linkage);
|
|
||||||
FunctionDeclaration::new(r#type, value)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Create the function definition from an existing symbol.
|
|
||||||
pub fn define(
|
|
||||||
module: &inkwell::module::Module<'ctx>,
|
|
||||||
name: &str,
|
|
||||||
) -> Option<FunctionDeclaration<'ctx>> {
|
|
||||||
let value = module.get_function(name)?;
|
|
||||||
value.set_linkage(inkwell::module::Linkage::External);
|
|
||||||
FunctionDeclaration::new(value.get_type(), value).into()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,338 +0,0 @@
|
|||||||
//! The LLVM IR generator function.
|
|
||||||
|
|
||||||
pub mod block;
|
|
||||||
pub mod declaration;
|
|
||||||
pub mod evmla_data;
|
|
||||||
pub mod intrinsics;
|
|
||||||
pub mod llvm_runtime;
|
|
||||||
pub mod r#return;
|
|
||||||
pub mod runtime;
|
|
||||||
pub mod yul_data;
|
|
||||||
|
|
||||||
use std::collections::HashMap;
|
|
||||||
|
|
||||||
use crate::optimizer::settings::size_level::SizeLevel;
|
|
||||||
use crate::optimizer::Optimizer;
|
|
||||||
use crate::polkavm::context::attribute::Attribute;
|
|
||||||
use crate::polkavm::context::pointer::Pointer;
|
|
||||||
|
|
||||||
use self::declaration::Declaration;
|
|
||||||
use self::evmla_data::EVMLAData;
|
|
||||||
use self::r#return::Return;
|
|
||||||
use self::yul_data::YulData;
|
|
||||||
|
|
||||||
/// The LLVM IR generator function.
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct Function<'ctx> {
|
|
||||||
/// The high-level source code name.
|
|
||||||
name: String,
|
|
||||||
/// The LLVM function declaration.
|
|
||||||
declaration: Declaration<'ctx>,
|
|
||||||
/// The stack representation.
|
|
||||||
stack: HashMap<String, Pointer<'ctx>>,
|
|
||||||
/// The return value entity.
|
|
||||||
r#return: Return<'ctx>,
|
|
||||||
|
|
||||||
/// The entry block. Each LLVM IR functions must have an entry block.
|
|
||||||
entry_block: inkwell::basic_block::BasicBlock<'ctx>,
|
|
||||||
/// The return/leave block. LLVM IR functions may have multiple returning blocks, but it is
|
|
||||||
/// more reasonable to have a single returning block and other high-level language returns
|
|
||||||
/// jumping to it. This way it is easier to implement some additional checks and clean-ups
|
|
||||||
/// before the returning.
|
|
||||||
return_block: inkwell::basic_block::BasicBlock<'ctx>,
|
|
||||||
|
|
||||||
/// The Yul compiler data.
|
|
||||||
yul_data: Option<YulData>,
|
|
||||||
/// The EVM legacy assembly compiler data.
|
|
||||||
evmla_data: Option<EVMLAData<'ctx>>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'ctx> Function<'ctx> {
|
|
||||||
/// The stack hashmap default capacity.
|
|
||||||
const STACK_HASHMAP_INITIAL_CAPACITY: usize = 64;
|
|
||||||
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(
|
|
||||||
name: String,
|
|
||||||
declaration: Declaration<'ctx>,
|
|
||||||
r#return: Return<'ctx>,
|
|
||||||
|
|
||||||
entry_block: inkwell::basic_block::BasicBlock<'ctx>,
|
|
||||||
return_block: inkwell::basic_block::BasicBlock<'ctx>,
|
|
||||||
) -> Self {
|
|
||||||
Self {
|
|
||||||
name,
|
|
||||||
declaration,
|
|
||||||
stack: HashMap::with_capacity(Self::STACK_HASHMAP_INITIAL_CAPACITY),
|
|
||||||
r#return,
|
|
||||||
|
|
||||||
entry_block,
|
|
||||||
return_block,
|
|
||||||
|
|
||||||
yul_data: None,
|
|
||||||
evmla_data: None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the function name reference.
|
|
||||||
pub fn name(&self) -> &str {
|
|
||||||
self.name.as_str()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Checks whether the function is defined outside of the front-end.
|
|
||||||
pub fn is_name_external(name: &str) -> bool {
|
|
||||||
name.starts_with("llvm.")
|
|
||||||
|| (name.starts_with("__")
|
|
||||||
&& name != self::runtime::FUNCTION_ENTRY
|
|
||||||
&& name != self::runtime::FUNCTION_DEPLOY_CODE
|
|
||||||
&& name != self::runtime::FUNCTION_RUNTIME_CODE
|
|
||||||
&& name != self::runtime::FUNCTION_LOAD_IMMUTABLE_DATA)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the LLVM function declaration.
|
|
||||||
pub fn declaration(&self) -> Declaration<'ctx> {
|
|
||||||
self.declaration
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the N-th parameter of the function.
|
|
||||||
pub fn get_nth_param(&self, index: usize) -> inkwell::values::BasicValueEnum<'ctx> {
|
|
||||||
self.declaration()
|
|
||||||
.value
|
|
||||||
.get_nth_param(index as u32)
|
|
||||||
.expect("Always exists")
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sets the memory writer function attributes.
|
|
||||||
pub fn set_attributes(
|
|
||||||
llvm: &'ctx inkwell::context::Context,
|
|
||||||
declaration: Declaration<'ctx>,
|
|
||||||
attributes: Vec<Attribute>,
|
|
||||||
force: bool,
|
|
||||||
) {
|
|
||||||
for attribute_kind in attributes.into_iter() {
|
|
||||||
match attribute_kind {
|
|
||||||
Attribute::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),
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
attribute_kind @ Attribute::NoInline if force => {
|
|
||||||
declaration.value.remove_enum_attribute(
|
|
||||||
inkwell::attributes::AttributeLoc::Function,
|
|
||||||
Attribute::AlwaysInline as u32,
|
|
||||||
);
|
|
||||||
declaration.value.add_attribute(
|
|
||||||
inkwell::attributes::AttributeLoc::Function,
|
|
||||||
llvm.create_enum_attribute(attribute_kind as u32, 0),
|
|
||||||
);
|
|
||||||
}
|
|
||||||
attribute_kind => declaration.value.add_attribute(
|
|
||||||
inkwell::attributes::AttributeLoc::Function,
|
|
||||||
llvm.create_enum_attribute(attribute_kind as u32, 0),
|
|
||||||
),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Remove specified attributes existing on the given declaration.
|
|
||||||
pub fn remove_attributes(declaration: Declaration, attributes: &[Attribute]) {
|
|
||||||
for attribute in attributes.iter().filter(|attribute| {
|
|
||||||
declaration
|
|
||||||
.value
|
|
||||||
.get_enum_attribute(
|
|
||||||
inkwell::attributes::AttributeLoc::Function,
|
|
||||||
**attribute as u32,
|
|
||||||
)
|
|
||||||
.is_some()
|
|
||||||
}) {
|
|
||||||
declaration.value.remove_enum_attribute(
|
|
||||||
inkwell::attributes::AttributeLoc::Function,
|
|
||||||
*attribute as u32,
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sets the default attributes.
|
|
||||||
/// The attributes only affect the LLVM optimizations.
|
|
||||||
pub fn set_default_attributes(
|
|
||||||
llvm: &'ctx inkwell::context::Context,
|
|
||||||
declaration: Declaration<'ctx>,
|
|
||||||
optimizer: &Optimizer,
|
|
||||||
) {
|
|
||||||
if optimizer.settings().level_middle_end == inkwell::OptimizationLevel::None {
|
|
||||||
Self::remove_attributes(
|
|
||||||
declaration,
|
|
||||||
&[Attribute::OptimizeForSize, Attribute::AlwaysInline],
|
|
||||||
);
|
|
||||||
Self::set_attributes(
|
|
||||||
llvm,
|
|
||||||
declaration,
|
|
||||||
vec![Attribute::OptimizeNone, Attribute::NoInline],
|
|
||||||
false,
|
|
||||||
);
|
|
||||||
} else if optimizer.settings().level_middle_end_size == SizeLevel::Z {
|
|
||||||
Self::set_attributes(
|
|
||||||
llvm,
|
|
||||||
declaration,
|
|
||||||
vec![Attribute::OptimizeForSize, Attribute::MinSize],
|
|
||||||
false,
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
Self::set_attributes(llvm, declaration, vec![Attribute::NoFree], false);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sets the front-end runtime attributes.
|
|
||||||
pub fn set_frontend_runtime_attributes(
|
|
||||||
llvm: &'ctx inkwell::context::Context,
|
|
||||||
declaration: Declaration<'ctx>,
|
|
||||||
optimizer: &Optimizer,
|
|
||||||
) {
|
|
||||||
if optimizer.settings().level_middle_end_size == SizeLevel::Z {
|
|
||||||
Self::set_attributes(llvm, declaration, vec![Attribute::NoInline], false);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sets the exception handler attributes.
|
|
||||||
pub fn set_exception_handler_attributes(
|
|
||||||
llvm: &'ctx inkwell::context::Context,
|
|
||||||
declaration: Declaration<'ctx>,
|
|
||||||
) {
|
|
||||||
Self::set_attributes(llvm, declaration, vec![Attribute::NoInline], false);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sets the CXA-throw attributes.
|
|
||||||
pub fn set_cxa_throw_attributes(
|
|
||||||
llvm: &'ctx inkwell::context::Context,
|
|
||||||
declaration: Declaration<'ctx>,
|
|
||||||
) {
|
|
||||||
Self::set_attributes(llvm, declaration, vec![Attribute::NoProfile], false);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sets the pure function attributes.
|
|
||||||
pub fn set_pure_function_attributes(
|
|
||||||
llvm: &'ctx inkwell::context::Context,
|
|
||||||
declaration: Declaration<'ctx>,
|
|
||||||
) {
|
|
||||||
Self::set_attributes(
|
|
||||||
llvm,
|
|
||||||
declaration,
|
|
||||||
vec![
|
|
||||||
Attribute::MustProgress,
|
|
||||||
Attribute::NoUnwind,
|
|
||||||
Attribute::WillReturn,
|
|
||||||
],
|
|
||||||
false,
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Saves the pointer to a stack variable, returning the pointer to the shadowed variable,
|
|
||||||
/// if it exists.
|
|
||||||
pub fn insert_stack_pointer(
|
|
||||||
&mut self,
|
|
||||||
name: String,
|
|
||||||
pointer: Pointer<'ctx>,
|
|
||||||
) -> Option<Pointer<'ctx>> {
|
|
||||||
self.stack.insert(name, pointer)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Gets the pointer to a stack variable.
|
|
||||||
pub fn get_stack_pointer(&self, name: &str) -> Option<Pointer<'ctx>> {
|
|
||||||
self.stack.get(name).copied()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Removes the pointer to a stack variable.
|
|
||||||
pub fn remove_stack_pointer(&mut self, name: &str) {
|
|
||||||
self.stack.remove(name);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the return entity representation.
|
|
||||||
pub fn r#return(&self) -> Return<'ctx> {
|
|
||||||
self.r#return
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the pointer to the function return value.
|
|
||||||
/// # Panics
|
|
||||||
/// If the pointer has not been set yet.
|
|
||||||
pub fn return_pointer(&self) -> Option<Pointer<'ctx>> {
|
|
||||||
self.r#return.return_pointer()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the return data size in bytes, based on the default stack alignment.
|
|
||||||
/// # Panics
|
|
||||||
/// If the pointer has not been set yet.
|
|
||||||
pub fn return_data_size(&self) -> usize {
|
|
||||||
self.r#return.return_data_size()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the function entry block.
|
|
||||||
pub fn entry_block(&self) -> inkwell::basic_block::BasicBlock<'ctx> {
|
|
||||||
self.entry_block
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the function return block.
|
|
||||||
pub fn return_block(&self) -> inkwell::basic_block::BasicBlock<'ctx> {
|
|
||||||
self.return_block
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sets the EVM legacy assembly data.
|
|
||||||
pub fn set_evmla_data(&mut self, data: EVMLAData<'ctx>) {
|
|
||||||
self.evmla_data = Some(data);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the EVM legacy assembly data reference.
|
|
||||||
/// # Panics
|
|
||||||
/// If the EVM data has not been initialized.
|
|
||||||
pub fn evmla(&self) -> &EVMLAData<'ctx> {
|
|
||||||
self.evmla_data
|
|
||||||
.as_ref()
|
|
||||||
.expect("The EVM data must have been initialized")
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the EVM legacy assembly data mutable reference.
|
|
||||||
/// # Panics
|
|
||||||
/// If the EVM data has not been initialized.
|
|
||||||
pub fn evmla_mut(&mut self) -> &mut EVMLAData<'ctx> {
|
|
||||||
self.evmla_data
|
|
||||||
.as_mut()
|
|
||||||
.expect("The EVM data must have been initialized")
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sets the Yul data.
|
|
||||||
pub fn set_yul_data(&mut self, data: YulData) {
|
|
||||||
self.yul_data = Some(data);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the Yul data reference.
|
|
||||||
/// # Panics
|
|
||||||
/// If the Yul data has not been initialized.
|
|
||||||
pub fn yul(&self) -> &YulData {
|
|
||||||
self.yul_data
|
|
||||||
.as_ref()
|
|
||||||
.expect("The Yul data must have been initialized")
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the Yul data mutable reference.
|
|
||||||
/// # Panics
|
|
||||||
/// If the Yul data has not been initialized.
|
|
||||||
pub fn yul_mut(&mut self) -> &mut YulData {
|
|
||||||
self.yul_data
|
|
||||||
.as_mut()
|
|
||||||
.expect("The Yul data must have been initialized")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,59 +0,0 @@
|
|||||||
//! The LLVM IR generator function return entity.
|
|
||||||
|
|
||||||
use crate::polkavm::context::pointer::Pointer;
|
|
||||||
|
|
||||||
/// The LLVM IR generator function return entity.
|
|
||||||
#[derive(Debug, Clone, Copy)]
|
|
||||||
pub enum Return<'ctx> {
|
|
||||||
/// The function does not return a value.
|
|
||||||
None,
|
|
||||||
/// The function returns a primitive value.
|
|
||||||
Primitive {
|
|
||||||
/// The primitive value pointer allocated at the function entry.
|
|
||||||
pointer: Pointer<'ctx>,
|
|
||||||
},
|
|
||||||
/// The function returns a compound value.
|
|
||||||
/// In this case, the return pointer is allocated on the stack by the callee.
|
|
||||||
Compound {
|
|
||||||
/// The structure pointer allocated at the function entry.
|
|
||||||
pointer: Pointer<'ctx>,
|
|
||||||
/// The function return type size.
|
|
||||||
size: usize,
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'ctx> Return<'ctx> {
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn none() -> Self {
|
|
||||||
Self::None
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn primitive(pointer: Pointer<'ctx>) -> Self {
|
|
||||||
Self::Primitive { pointer }
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn compound(pointer: Pointer<'ctx>, size: usize) -> Self {
|
|
||||||
Self::Compound { pointer, size }
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the pointer to the function return value.
|
|
||||||
pub fn return_pointer(&self) -> Option<Pointer<'ctx>> {
|
|
||||||
match self {
|
|
||||||
Return::None => None,
|
|
||||||
Return::Primitive { pointer } => Some(pointer.to_owned()),
|
|
||||||
Return::Compound { pointer, .. } => Some(pointer.to_owned()),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the return data size in bytes, based on the default stack alignment.
|
|
||||||
pub fn return_data_size(&self) -> usize {
|
|
||||||
revive_common::BYTE_LENGTH_WORD
|
|
||||||
* match self {
|
|
||||||
Self::None => 0,
|
|
||||||
Self::Primitive { .. } => 1,
|
|
||||||
Self::Compound { size, .. } => *size,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,79 +0,0 @@
|
|||||||
//! The deploy code function.
|
|
||||||
|
|
||||||
use std::marker::PhantomData;
|
|
||||||
|
|
||||||
use crate::polkavm::context::code_type::CodeType;
|
|
||||||
use crate::polkavm::context::function::runtime;
|
|
||||||
use crate::polkavm::context::Context;
|
|
||||||
use crate::polkavm::Dependency;
|
|
||||||
use crate::polkavm::WriteLLVM;
|
|
||||||
|
|
||||||
/// The deploy code function.
|
|
||||||
/// Is a special function that is only used by the front-end generated code.
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct DeployCode<B, D>
|
|
||||||
where
|
|
||||||
B: WriteLLVM<D>,
|
|
||||||
D: Dependency + Clone,
|
|
||||||
{
|
|
||||||
/// The deploy code AST representation.
|
|
||||||
inner: B,
|
|
||||||
/// The `D` phantom data.
|
|
||||||
_pd: PhantomData<D>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<B, D> DeployCode<B, D>
|
|
||||||
where
|
|
||||||
B: WriteLLVM<D>,
|
|
||||||
D: Dependency + Clone,
|
|
||||||
{
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(inner: B) -> Self {
|
|
||||||
Self {
|
|
||||||
inner,
|
|
||||||
_pd: PhantomData,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<B, D> WriteLLVM<D> for DeployCode<B, D>
|
|
||||||
where
|
|
||||||
B: WriteLLVM<D>,
|
|
||||||
D: Dependency + Clone,
|
|
||||||
{
|
|
||||||
fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
|
|
||||||
let function_type = context.function_type::<inkwell::types::BasicTypeEnum>(vec![], 0);
|
|
||||||
context.add_function(
|
|
||||||
runtime::FUNCTION_DEPLOY_CODE,
|
|
||||||
function_type,
|
|
||||||
0,
|
|
||||||
Some(inkwell::module::Linkage::External),
|
|
||||||
)?;
|
|
||||||
|
|
||||||
self.inner.declare(context)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
|
|
||||||
context.set_current_function(runtime::FUNCTION_DEPLOY_CODE)?;
|
|
||||||
|
|
||||||
context.set_basic_block(context.current_function().borrow().entry_block());
|
|
||||||
context.set_code_type(CodeType::Deploy);
|
|
||||||
|
|
||||||
self.inner.into_llvm(context)?;
|
|
||||||
match context
|
|
||||||
.basic_block()
|
|
||||||
.get_last_instruction()
|
|
||||||
.map(|instruction| instruction.get_opcode())
|
|
||||||
{
|
|
||||||
Some(inkwell::values::InstructionOpcode::Br) => {}
|
|
||||||
Some(inkwell::values::InstructionOpcode::Switch) => {}
|
|
||||||
_ => context
|
|
||||||
.build_unconditional_branch(context.current_function().borrow().return_block()),
|
|
||||||
}
|
|
||||||
|
|
||||||
context.set_basic_block(context.current_function().borrow().return_block());
|
|
||||||
context.build_return(None);
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,230 +0,0 @@
|
|||||||
//! The entry function.
|
|
||||||
|
|
||||||
use inkwell::types::BasicType;
|
|
||||||
|
|
||||||
use crate::polkavm::context::address_space::AddressSpace;
|
|
||||||
use crate::polkavm::context::function::runtime;
|
|
||||||
use crate::polkavm::context::Context;
|
|
||||||
use crate::polkavm::Dependency;
|
|
||||||
use crate::polkavm::WriteLLVM;
|
|
||||||
|
|
||||||
/// The entry function.
|
|
||||||
/// The function is a wrapper managing the runtime and deploy code calling logic.
|
|
||||||
/// Is a special runtime function that is only used by the front-end generated code.
|
|
||||||
#[derive(Debug, Default)]
|
|
||||||
pub struct Entry {}
|
|
||||||
|
|
||||||
impl Entry {
|
|
||||||
/// The call flags argument index.
|
|
||||||
pub const ARGUMENT_INDEX_CALL_FLAGS: usize = 0;
|
|
||||||
|
|
||||||
/// Reserve 1kb for calldata.
|
|
||||||
pub const MAX_CALLDATA_SIZE: usize = 1024;
|
|
||||||
|
|
||||||
/// Initializes the global variables.
|
|
||||||
/// The pointers are not initialized, because it's not possible to create a null pointer.
|
|
||||||
pub fn initialize_globals<D>(context: &mut Context<D>) -> anyhow::Result<()>
|
|
||||||
where
|
|
||||||
D: Dependency + Clone,
|
|
||||||
{
|
|
||||||
context.declare_global(
|
|
||||||
revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER,
|
|
||||||
context.word_type().array_type(0),
|
|
||||||
AddressSpace::Stack,
|
|
||||||
);
|
|
||||||
|
|
||||||
context.declare_global(
|
|
||||||
revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE,
|
|
||||||
context.xlen_type(),
|
|
||||||
AddressSpace::Stack,
|
|
||||||
);
|
|
||||||
|
|
||||||
let calldata_type = context.array_type(context.byte_type(), Self::MAX_CALLDATA_SIZE);
|
|
||||||
context.set_global(
|
|
||||||
crate::polkavm::GLOBAL_CALLDATA_POINTER,
|
|
||||||
calldata_type,
|
|
||||||
AddressSpace::Stack,
|
|
||||||
calldata_type.get_undef(),
|
|
||||||
);
|
|
||||||
|
|
||||||
context.set_global(
|
|
||||||
crate::polkavm::GLOBAL_HEAP_MEMORY_POINTER,
|
|
||||||
context.llvm().ptr_type(AddressSpace::Heap.into()),
|
|
||||||
AddressSpace::Stack,
|
|
||||||
context.xlen_type().get_undef(),
|
|
||||||
);
|
|
||||||
context.build_store(
|
|
||||||
context
|
|
||||||
.get_global(crate::polkavm::GLOBAL_HEAP_MEMORY_POINTER)?
|
|
||||||
.into(),
|
|
||||||
context.build_sbrk(
|
|
||||||
context.xlen_type().const_zero(),
|
|
||||||
context.xlen_type().const_zero(),
|
|
||||||
)?,
|
|
||||||
)?;
|
|
||||||
|
|
||||||
context.set_global(
|
|
||||||
crate::polkavm::GLOBAL_CALLDATA_SIZE,
|
|
||||||
context.word_type(),
|
|
||||||
AddressSpace::Stack,
|
|
||||||
context.word_undef(),
|
|
||||||
);
|
|
||||||
|
|
||||||
context.set_global(
|
|
||||||
crate::polkavm::GLOBAL_CALL_FLAGS,
|
|
||||||
context.word_type(),
|
|
||||||
AddressSpace::Stack,
|
|
||||||
context.word_const(0),
|
|
||||||
);
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Load the calldata via seal `input` and initialize the calldata end
|
|
||||||
/// and calldata size globals.
|
|
||||||
pub fn load_calldata<D>(context: &mut Context<D>) -> anyhow::Result<()>
|
|
||||||
where
|
|
||||||
D: Dependency + Clone,
|
|
||||||
{
|
|
||||||
let input_pointer = context
|
|
||||||
.get_global(crate::polkavm::GLOBAL_CALLDATA_POINTER)?
|
|
||||||
.value
|
|
||||||
.as_pointer_value();
|
|
||||||
let input_pointer_casted = context.builder.build_ptr_to_int(
|
|
||||||
input_pointer,
|
|
||||||
context.xlen_type(),
|
|
||||||
"input_pointer_casted",
|
|
||||||
)?;
|
|
||||||
|
|
||||||
let length_pointer = context.build_alloca_at_entry(context.xlen_type(), "len_ptr");
|
|
||||||
let length_pointer_casted = context.builder.build_ptr_to_int(
|
|
||||||
length_pointer.value,
|
|
||||||
context.xlen_type(),
|
|
||||||
"length_pointer_casted",
|
|
||||||
)?;
|
|
||||||
|
|
||||||
context.build_store(
|
|
||||||
length_pointer,
|
|
||||||
context.integer_const(crate::polkavm::XLEN, Self::MAX_CALLDATA_SIZE as u64),
|
|
||||||
)?;
|
|
||||||
context.build_runtime_call(
|
|
||||||
revive_runtime_api::polkavm_imports::INPUT,
|
|
||||||
&[input_pointer_casted.into(), length_pointer_casted.into()],
|
|
||||||
);
|
|
||||||
|
|
||||||
// Store the calldata size
|
|
||||||
let calldata_size = context
|
|
||||||
.build_load(length_pointer, "input_size")?
|
|
||||||
.into_int_value();
|
|
||||||
let calldata_size_casted = context.builder().build_int_z_extend(
|
|
||||||
calldata_size,
|
|
||||||
context.word_type(),
|
|
||||||
"zext_input_len",
|
|
||||||
)?;
|
|
||||||
context.set_global(
|
|
||||||
crate::polkavm::GLOBAL_CALLDATA_SIZE,
|
|
||||||
context.word_type(),
|
|
||||||
AddressSpace::Stack,
|
|
||||||
calldata_size_casted,
|
|
||||||
);
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Calls the deploy code if the first function argument was `1`.
|
|
||||||
/// Calls the runtime code otherwise.
|
|
||||||
pub fn leave_entry<D>(context: &mut Context<D>) -> anyhow::Result<()>
|
|
||||||
where
|
|
||||||
D: Dependency + Clone,
|
|
||||||
{
|
|
||||||
let is_deploy = context
|
|
||||||
.current_function()
|
|
||||||
.borrow()
|
|
||||||
.get_nth_param(Self::ARGUMENT_INDEX_CALL_FLAGS);
|
|
||||||
|
|
||||||
context.set_global(
|
|
||||||
crate::polkavm::GLOBAL_CALL_FLAGS,
|
|
||||||
is_deploy.get_type(),
|
|
||||||
AddressSpace::Stack,
|
|
||||||
is_deploy.into_int_value(),
|
|
||||||
);
|
|
||||||
|
|
||||||
let deploy_code_call_block = context.append_basic_block("deploy_code_call_block");
|
|
||||||
let runtime_code_call_block = context.append_basic_block("runtime_code_call_block");
|
|
||||||
|
|
||||||
context.build_conditional_branch(
|
|
||||||
is_deploy.into_int_value(),
|
|
||||||
deploy_code_call_block,
|
|
||||||
runtime_code_call_block,
|
|
||||||
)?;
|
|
||||||
|
|
||||||
let deploy_code = context
|
|
||||||
.functions
|
|
||||||
.get(runtime::FUNCTION_DEPLOY_CODE)
|
|
||||||
.cloned()
|
|
||||||
.ok_or_else(|| anyhow::anyhow!("Contract deploy code not found"))?;
|
|
||||||
let runtime_code = context
|
|
||||||
.functions
|
|
||||||
.get(runtime::FUNCTION_RUNTIME_CODE)
|
|
||||||
.cloned()
|
|
||||||
.ok_or_else(|| anyhow::anyhow!("Contract runtime code not found"))?;
|
|
||||||
|
|
||||||
context.set_basic_block(deploy_code_call_block);
|
|
||||||
context.build_call(deploy_code.borrow().declaration, &[], "deploy_code_call");
|
|
||||||
context.build_unconditional_branch(context.current_function().borrow().return_block());
|
|
||||||
|
|
||||||
context.set_basic_block(runtime_code_call_block);
|
|
||||||
context.build_call(runtime_code.borrow().declaration, &[], "runtime_code_call");
|
|
||||||
context.build_unconditional_branch(context.current_function().borrow().return_block());
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<D> WriteLLVM<D> for Entry
|
|
||||||
where
|
|
||||||
D: Dependency + Clone,
|
|
||||||
{
|
|
||||||
fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
|
|
||||||
let entry_arguments = vec![context.bool_type().as_basic_type_enum()];
|
|
||||||
let entry_function_type = context.function_type(entry_arguments, 0);
|
|
||||||
context.add_function(
|
|
||||||
runtime::FUNCTION_ENTRY,
|
|
||||||
entry_function_type,
|
|
||||||
0,
|
|
||||||
Some(inkwell::module::Linkage::External),
|
|
||||||
)?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Instead of a single entrypoint, the runtime expects two exports: `call ` and `deploy`.
|
|
||||||
/// `call` and `deploy` directly call `entry`, signaling a deploy if the first arg is `1`.
|
|
||||||
/// The `entry` function loads calldata, sets globals and calls the runtime or deploy code.
|
|
||||||
fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
|
|
||||||
let entry = context
|
|
||||||
.get_function(runtime::FUNCTION_ENTRY)
|
|
||||||
.expect("the entry function should already be declared")
|
|
||||||
.borrow()
|
|
||||||
.declaration;
|
|
||||||
crate::PolkaVMFunction::set_attributes(
|
|
||||||
context.llvm(),
|
|
||||||
entry,
|
|
||||||
vec![crate::PolkaVMAttribute::NoReturn],
|
|
||||||
true,
|
|
||||||
);
|
|
||||||
|
|
||||||
context.set_current_function(runtime::FUNCTION_ENTRY)?;
|
|
||||||
context.set_basic_block(context.current_function().borrow().entry_block());
|
|
||||||
|
|
||||||
Self::initialize_globals(context)?;
|
|
||||||
Self::load_calldata(context)?;
|
|
||||||
Self::leave_entry(context)?;
|
|
||||||
|
|
||||||
context.build_unconditional_branch(context.current_function().borrow().return_block());
|
|
||||||
context.set_basic_block(context.current_function().borrow().return_block());
|
|
||||||
context.build_unreachable();
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,116 +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::Private),
|
|
||||||
)?;
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
|
|
||||||
context.set_current_function(runtime::FUNCTION_LOAD_IMMUTABLE_DATA)?;
|
|
||||||
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);
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,18 +0,0 @@
|
|||||||
//! The front-end runtime functions.
|
|
||||||
|
|
||||||
pub mod deploy_code;
|
|
||||||
pub mod entry;
|
|
||||||
pub mod immutable_data_load;
|
|
||||||
pub mod runtime_code;
|
|
||||||
|
|
||||||
/// The main entry function name.
|
|
||||||
pub const FUNCTION_ENTRY: &str = "__entry";
|
|
||||||
|
|
||||||
/// The deploy code function name.
|
|
||||||
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";
|
|
||||||
@@ -1,78 +0,0 @@
|
|||||||
//! The runtime code function.
|
|
||||||
|
|
||||||
use std::marker::PhantomData;
|
|
||||||
|
|
||||||
use crate::polkavm::context::code_type::CodeType;
|
|
||||||
use crate::polkavm::context::function::runtime;
|
|
||||||
use crate::polkavm::context::Context;
|
|
||||||
use crate::polkavm::Dependency;
|
|
||||||
use crate::polkavm::WriteLLVM;
|
|
||||||
|
|
||||||
/// The runtime code function.
|
|
||||||
/// Is a special function that is only used by the front-end generated code.
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct RuntimeCode<B, D>
|
|
||||||
where
|
|
||||||
B: WriteLLVM<D>,
|
|
||||||
D: Dependency + Clone,
|
|
||||||
{
|
|
||||||
/// The runtime code AST representation.
|
|
||||||
inner: B,
|
|
||||||
/// The `D` phantom data.
|
|
||||||
_pd: PhantomData<D>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<B, D> RuntimeCode<B, D>
|
|
||||||
where
|
|
||||||
B: WriteLLVM<D>,
|
|
||||||
D: Dependency + Clone,
|
|
||||||
{
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new(inner: B) -> Self {
|
|
||||||
Self {
|
|
||||||
inner,
|
|
||||||
_pd: PhantomData,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<B, D> WriteLLVM<D> for RuntimeCode<B, D>
|
|
||||||
where
|
|
||||||
B: WriteLLVM<D>,
|
|
||||||
D: Dependency + Clone,
|
|
||||||
{
|
|
||||||
fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
|
|
||||||
let function_type = context.function_type::<inkwell::types::BasicTypeEnum>(vec![], 0);
|
|
||||||
context.add_function(
|
|
||||||
runtime::FUNCTION_RUNTIME_CODE,
|
|
||||||
function_type,
|
|
||||||
0,
|
|
||||||
Some(inkwell::module::Linkage::External),
|
|
||||||
)?;
|
|
||||||
|
|
||||||
self.inner.declare(context)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
|
|
||||||
context.set_current_function(runtime::FUNCTION_RUNTIME_CODE)?;
|
|
||||||
|
|
||||||
context.set_basic_block(context.current_function().borrow().entry_block());
|
|
||||||
context.set_code_type(CodeType::Runtime);
|
|
||||||
self.inner.into_llvm(context)?;
|
|
||||||
match context
|
|
||||||
.basic_block()
|
|
||||||
.get_last_instruction()
|
|
||||||
.map(|instruction| instruction.get_opcode())
|
|
||||||
{
|
|
||||||
Some(inkwell::values::InstructionOpcode::Br) => {}
|
|
||||||
Some(inkwell::values::InstructionOpcode::Switch) => {}
|
|
||||||
_ => context
|
|
||||||
.build_unconditional_branch(context.current_function().borrow().return_block()),
|
|
||||||
}
|
|
||||||
|
|
||||||
context.set_basic_block(context.current_function().borrow().return_block());
|
|
||||||
context.build_unreachable();
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,42 +0,0 @@
|
|||||||
//! The LLVM function Yul data.
|
|
||||||
|
|
||||||
use std::collections::HashMap;
|
|
||||||
|
|
||||||
use num::BigUint;
|
|
||||||
|
|
||||||
/// The LLVM function Yul data.
|
|
||||||
/// Describes some data that is only relevant to Yul.
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct YulData {
|
|
||||||
/// The constants saved to variables. Used for peculiar cases like call simulation.
|
|
||||||
/// It is a partial implementation of the constant propagation.
|
|
||||||
constants: HashMap<String, BigUint>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Default for YulData {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self {
|
|
||||||
constants: HashMap::with_capacity(Self::CONSTANTS_HASHMAP_INITIAL_CAPACITY),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl YulData {
|
|
||||||
/// The constants hashmap default capacity.
|
|
||||||
const CONSTANTS_HASHMAP_INITIAL_CAPACITY: usize = 16;
|
|
||||||
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new() -> Self {
|
|
||||||
Self::default()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns a constant if it has been saved.
|
|
||||||
pub fn get_constant(&self, name: &str) -> Option<BigUint> {
|
|
||||||
self.constants.get(name).cloned()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Saves a constant detected with the partial constant propagation.
|
|
||||||
pub fn insert_constant(&mut self, name: String, value: BigUint) {
|
|
||||||
self.constants.insert(name, value);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,81 +0,0 @@
|
|||||||
//! The LLVM global value.
|
|
||||||
|
|
||||||
use inkwell::types::BasicType;
|
|
||||||
use inkwell::values::BasicValue;
|
|
||||||
|
|
||||||
use crate::polkavm::context::address_space::AddressSpace;
|
|
||||||
use crate::polkavm::context::Context;
|
|
||||||
use crate::PolkaVMDependency;
|
|
||||||
|
|
||||||
/// The LLVM global value.
|
|
||||||
#[derive(Debug, Clone, Copy)]
|
|
||||||
pub struct Global<'ctx> {
|
|
||||||
/// The global type.
|
|
||||||
pub r#type: inkwell::types::BasicTypeEnum<'ctx>,
|
|
||||||
/// The global value.
|
|
||||||
pub value: inkwell::values::GlobalValue<'ctx>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'ctx> Global<'ctx> {
|
|
||||||
/// A shortcut constructor.
|
|
||||||
pub fn new<D, T, V>(
|
|
||||||
context: &mut Context<'ctx, D>,
|
|
||||||
r#type: T,
|
|
||||||
address_space: AddressSpace,
|
|
||||||
initializer: V,
|
|
||||||
name: &str,
|
|
||||||
) -> Self
|
|
||||||
where
|
|
||||||
D: PolkaVMDependency + Clone,
|
|
||||||
T: BasicType<'ctx>,
|
|
||||||
V: BasicValue<'ctx>,
|
|
||||||
{
|
|
||||||
let r#type = r#type.as_basic_type_enum();
|
|
||||||
|
|
||||||
let value = context
|
|
||||||
.module()
|
|
||||||
.add_global(r#type, Some(address_space.into()), name);
|
|
||||||
let global = Self { r#type, value };
|
|
||||||
|
|
||||||
global.value.set_linkage(inkwell::module::Linkage::Private);
|
|
||||||
global
|
|
||||||
.value
|
|
||||||
.set_visibility(inkwell::GlobalVisibility::Default);
|
|
||||||
global.value.set_externally_initialized(false);
|
|
||||||
if !r#type.is_pointer_type() {
|
|
||||||
global.value.set_initializer(&initializer);
|
|
||||||
} else {
|
|
||||||
global.value.set_initializer(&r#type.const_zero());
|
|
||||||
context.build_store(global.into(), initializer).unwrap();
|
|
||||||
}
|
|
||||||
|
|
||||||
global
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Construct an external global.
|
|
||||||
pub fn declare<D, T>(
|
|
||||||
context: &mut Context<'ctx, D>,
|
|
||||||
r#type: T,
|
|
||||||
address_space: AddressSpace,
|
|
||||||
name: &str,
|
|
||||||
) -> Self
|
|
||||||
where
|
|
||||||
D: PolkaVMDependency + Clone,
|
|
||||||
T: BasicType<'ctx>,
|
|
||||||
{
|
|
||||||
let r#type = r#type.as_basic_type_enum();
|
|
||||||
|
|
||||||
let value = context
|
|
||||||
.module()
|
|
||||||
.add_global(r#type, Some(address_space.into()), name);
|
|
||||||
let global = Self { r#type, value };
|
|
||||||
|
|
||||||
global.value.set_linkage(inkwell::module::Linkage::External);
|
|
||||||
global
|
|
||||||
.value
|
|
||||||
.set_visibility(inkwell::GlobalVisibility::Default);
|
|
||||||
global.value.set_externally_initialized(true);
|
|
||||||
|
|
||||||
global
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user