feat: succinct-1.85.0

Author: nhtyy

.github/workflows/ci.yml

@@ -1,45 +1,9 @@
-# This file defines our primary CI workflow that runs on pull requests
-# and also on pushes to special branches (auto, try).
-#
-# The actual definition of the executed jobs is calculated by a Python
-# script located at src/ci/github-actions/calculate-job-matrix.py, which
-# uses job definition data from src/ci/github-actions/jobs.yml.
-# You should primarily modify the `jobs.yml` file if you want to modify
-# what jobs are executed in CI.
-
 name: CI
+
 on:
-  push:
-    branches:
-      - auto
-      - try
-      - try-perf
-      - automation/bors/try
-  pull_request:
-    branches:
-      - "**"
-
-permissions:
-  contents: read
-  packages: write
-
-defaults:
-  run:
-    # On Linux, macOS, and Windows, use the system-provided bash as the default
-    # shell. (This should only make a difference on Windows, where the default
-    # shell is PowerShell.)
-    shell: bash
-
-concurrency:
-  # For a given workflow, if we push to the same branch, cancel all previous builds on that branch.
-  # We add an exception for try builds (try branch) and unrolled rollup builds (try-perf), which
-  # are all triggered on the same branch, but which should be able to run concurrently.
-  group: ${{ github.workflow }}-${{ ((github.ref == 'refs/heads/try' || github.ref == 'refs/heads/try-perf') && github.sha) || github.ref }}
-  cancel-in-progress: true
-env:
-  TOOLSTATE_REPO: "https://github.com/rust-lang-nursery/rust-toolstate"
-  # This will be empty in PR jobs.
-  TOOLSTATE_REPO_ACCESS_TOKEN: ${{ secrets.TOOLSTATE_REPO_ACCESS_TOKEN }}
+  workflow_call:
+  workflow_dispatch:
+
 jobs:
   # The job matrix for `calculate_matrix` is defined in src/ci/github-actions/jobs.yml.
   # It calculates which jobs should be executed, based on the data of the ${{ github }} context.
@@ -76,33 +40,28 @@ jobs:
       CACHE_DOMAIN: ci-caches.rust-lang.org
     continue-on-error: ${{ matrix.continue_on_error || false }}
     strategy:
+      fail-fast: false
       matrix:
-        # Check the `calculate_matrix` job to see how is the matrix defined.
-        include: ${{ fromJSON(needs.calculate_matrix.outputs.jobs) }}
+        include:
+          - os: macos-14
+            triple: aarch64-apple-darwin
+          - os: macos-13
+            triple: x86_64-apple-darwin
+          - os: buildjet-32vcpu-ubuntu-2004
+            triple: x86_64-unknown-linux-gnu
+    runs-on: ${{ matrix.os }}
     steps:
-      - if: contains(matrix.os, 'windows')
-        uses: msys2/[email protected]
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
         with:
-          # i686 jobs use mingw32. x86_64 and cross-compile jobs use mingw64.
-          msystem: ${{ contains(matrix.name, 'i686') && 'mingw32' || 'mingw64' }}
-          # don't try to download updates for already installed packages
-          update: false
-          # don't try to use the msys that comes built-in to the github runner,
-          # so we can control what is installed (i.e. not python)
-          release: true
-          # Inherit the full path from the Windows environment, with MSYS2's */bin/
-          # dirs placed in front. This lets us run Windows-native Python etc.
-          path-type: inherit
-          install: >
-            make
+          toolchain: stable
+      - uses: lukka/[email protected]
 
-      - name: disable git crlf conversion
-        run: git config --global core.autocrlf false
-
-      - name: checkout the source code
-        uses: actions/checkout@v4
+      - name: Install Go
+        uses: actions/setup-go@v4
         with:
-          fetch-depth: 2
+          go-version: 1.21.4
+          check-latest: true
 
       # Free up disk space on Linux by removing preinstalled components that
       # we do not need. We do this to enable some of the less resource
@@ -207,23 +166,17 @@ jobs:
       - name: upload artifacts to github
         uses: actions/upload-artifact@v4
         with:
-          # name is set in previous step
-          name: ${{ env.DOC_ARTIFACT_NAME }}
-          path: obj/artifacts/doc
-          if-no-files-found: ignore
-          retention-days: 5
-
-      - name: upload artifacts to S3
-        run: src/ci/scripts/upload-artifacts.sh
-        env:
-          AWS_ACCESS_KEY_ID: ${{ env.ARTIFACTS_AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets[format('AWS_SECRET_ACCESS_KEY_{0}', env.ARTIFACTS_AWS_ACCESS_KEY_ID)] }}
-        # Adding a condition on DEPLOY=1 or DEPLOY_ALT=1 is not needed as all deploy
-        # builders *should* have the AWS credentials available. Still, explicitly
-        # adding the condition is helpful as this way CI will not silently skip
-        # deploying artifacts from a dist builder if the variables are misconfigured,
-        # erroring about invalid credentials instead.
-        if: github.event_name == 'push' || env.DEPLOY == '1' || env.DEPLOY_ALT == '1'
+          submodules: "recursive"
+          path: rust
+          fetch-depth: 0
+          ref: ${{ github.ref }}
+
+      - name: Check out succinctlabs/sp1
+        uses: actions/checkout@v3
+        with:
+          repository: succinctlabs/sp1
+          ref: dev
+          path: sp1
 
       - name: upload job metrics to DataDog
         if: needs.calculate_matrix.outputs.run_type != 'pr'
@@ -245,20 +198,46 @@ jobs:
     # !cancelled() executes the job regardless of whether the previous jobs passed or failed
     if: ${{ !cancelled() && contains(fromJSON('["auto", "try"]'), needs.calculate_matrix.outputs.run_type) }}
     steps:
-      - name: checkout the source code
-        uses: actions/checkout@v4
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
         with:
-          fetch-depth: 2
-      # Calculate the exit status of the whole CI workflow.
-      # If all dependent jobs were successful, this exits with 0 (and the outcome job continues successfully).
-      # If a some dependent job has failed, this exits with 1.
-      - name: calculate the correct exit status
-        run: jq --exit-status 'all(.result == "success" or .result == "skipped")' <<< '${{ toJson(needs) }}'
-      # Publish the toolstate if an auto build succeeds (just before push to master)
-      - name: publish toolstate
-        run: src/ci/publish_toolstate.sh
-        shell: bash
-        if: needs.calculate_matrix.outputs.run_type == 'auto'
-        env:
-          TOOLSTATE_ISSUES_API_URL: https://api.github.com/repos/rust-lang/rust/issues
-          TOOLSTATE_PUBLISH: 1
+          toolchain: stable
+      - uses: lukka/[email protected]
+
+      - name: Install Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: 1.21.4
+          check-latest: true
+
+      - name: Show rust version
+        run: |
+          cargo version
+          rustup toolchain list
+
+      - name: Check out succinctlabs/rust
+        uses: actions/checkout@v3
+        with:
+          submodules: "recursive"
+          path: rust
+          fetch-depth: 0
+          ref: ${{ github.ref }}
+
+      - name: Check out succinctlabs/sp1
+        uses: actions/checkout@v3
+        with:
+          repository: succinctlabs/sp1
+          ref: dev
+          path: sp1
+
+      - name: Build
+        run: |
+          cd sp1/crates/cli
+          GITHUB_ACTIONS=false SP1_BUILD_DIR=$GITHUB_WORKSPACE cargo run --bin cargo-prove -- prove build-toolchain
+
+      - name: Archive build output
+        uses: actions/upload-artifact@v3
+        with:
+          name: rust-toolchain-aarch64-unknown-linux-gnu
+          path: sp1/crates/cli/rust-toolchain-aarch64-unknown-linux-gnu.tar.gz
+

.github/workflows/release.yml

@@ -0,0 +1,39 @@
+name: Release
+on:
+  push:
+    tags:
+      - "*"
+jobs:
+  build:
+    uses: ./.github/workflows/ci.yml
+  release:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@v3
+        with:
+          path: artifacts
+      - name: List artifact contents
+        run: |
+          echo "Listing artifacts directory:"
+          ls -R artifacts
+      - name: Create release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          echo "Installing gh CLI..."
+          curl -L https://github.com/cli/cli/releases/download/v2.17.0/gh_2.17.0_linux_amd64.tar.gz | \
+            tar xvz  --strip-components=2 --exclude=man
+          chmod +x ./gh
+          mkdir tars
+          find artifacts -name "*.tar.gz" -exec mv {} tars/ \;
+          if [ "$(ls -A tars)" ]; then
+            ./gh release create -p --repo "$GITHUB_REPOSITORY" "$GITHUB_REF_NAME" ./tars/* || \
+            ./gh release upload --repo "$GITHUB_REPOSITORY" "$GITHUB_REF_NAME" ./tars/*
+          else
+            echo "No files to release. Exiting."
+            exit 1
+          fi

compiler/rustc_target/src/spec/mod.rs

@@ -1864,7 +1864,7 @@ supported_targets! {
     ("x86_64-unknown-trusty", x86_64_unknown_trusty),
 
     ("riscv32i-unknown-none-elf", riscv32i_unknown_none_elf),
-    ("riscv32im-risc0-zkvm-elf", riscv32im_risc0_zkvm_elf),
+    ("riscv32im-succinct-zkvm-elf", riscv32im_succinct_zkvm_elf),
     ("riscv32im-unknown-none-elf", riscv32im_unknown_none_elf),
     ("riscv32ima-unknown-none-elf", riscv32ima_unknown_none_elf),
     ("riscv32imc-unknown-none-elf", riscv32imc_unknown_none_elf),

compiler/rustc_target/src/spec/targets/riscv32im_risc0_zkvm_elf.rs renamed to compiler/rustc_target/src/spec/targets/riscv32im_succinct_zkvm_elf.rs

@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
 
         options: TargetOptions {
             os: "zkvm".into(),
-            vendor: "risc0".into(),
+            vendor: "succinct".into(),
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             linker: Some("rust-lld".into()),
             cpu: "generic-rv32".into(),

library/std/src/sys/pal/zkvm/abi.rs

@@ -1,10 +1,10 @@
-//! ABI definitions for symbols exported by risc0-zkvm-platform.
+//! ABI definitions for symbols exported by sp1-zkvm.
 
-// Included here so we don't have to depend on risc0-zkvm-platform.
+// Included here so we don't have to depend on sp1-zkvm.
 //
 // FIXME: Should we move this to the "libc" crate?  It seems like other
 // architectures put a lot of this kind of stuff there.  But there's
-// currently no risc0 fork of the libc crate, so we'd either have to
+// currently no succinct fork of the libc crate, so we'd either have to
 // fork it or upstream it.
 
 #![allow(dead_code)]
@@ -19,7 +19,7 @@ pub mod fileno {
 }
 
 extern "C" {
-    // Wrappers around syscalls provided by risc0-zkvm-platform:
+    // Wrappers around syscalls provided by sp1-zkvm-platform:
     pub fn sys_halt();
     pub fn sys_output(output_id: u32, output_value: u32);
     pub fn sys_sha_compress(
@@ -34,7 +34,7 @@ extern "C" {
         buf: *const u8,
         count: u32,
     );
-    pub fn sys_rand(recv_buf: *mut u32, words: usize);
+    pub fn sys_rand(recv_buf: *mut u8, words: usize);
     pub fn sys_panic(msg_ptr: *const u8, len: usize) -> !;
     pub fn sys_log(msg_ptr: *const u8, len: usize);
     pub fn sys_cycle_count() -> usize;

library/std/src/sys/pal/zkvm/mod.rs

@@ -1,4 +1,4 @@
-//! System bindings for the risc0 zkvm platform
+//! System bindings for sp1-zkvm.
 //!
 //! This module contains the facade (aka platform-specific) implementations of
 //! OS level functionality for zkvm.
@@ -60,3 +60,13 @@ pub fn decode_error_kind(_code: i32) -> crate::io::ErrorKind {
 pub fn abort_internal() -> ! {
     core::intrinsics::abort();
 }
+
+pub fn hashmap_random_keys() -> (u64, u64) {
+    let mut buf = [0u8; 16];
+    unsafe {
+        abi::sys_rand(buf.as_mut_ptr(), buf.len());
+    };
+    let a = u64::from_le_bytes(buf[0..8].try_into().unwrap());
+    let b = u64::from_le_bytes(buf[8..16].try_into().unwrap());
+    (a, b)
+}

src/doc/rustc/src/platform-support/riscv32im-risc0-zkvm-elf.md renamed to src/doc/rustc/src/platform-support/riscv32im-succinct-zkvm-elf.md

@@ -1,14 +1,8 @@
-# `riscv32im-risc0-zkvm-elf`
+# `riscv32im-succinct-zkvm-elf`
 
 **Tier: 3**
 
-RISC Zero's Zero Knowledge Virtual Machine (zkVM) implementing the RV32IM instruction set.
-
-## Target maintainers
-
-- Frank Laub, `[email protected]`, https://github.com/flaub
-- Jeremy Bruestle, `[email protected]`, https://github.com/jbruestle
-- Erik Kaneda, `[email protected]`, https://github.com/SchmErik
+Succinct's Zero Knowledge Virtual Machine (zkVM) implementing the RV32IM instruction set.
 
 ## Background
 
@@ -20,7 +14,7 @@ cryptographic seal. This receipt can be verified to ensure the integrity of the
 computation and its result. This target is implemented as software only; it has
 no hardware implementation.
 
-We have a cargo extension called [cargo-risczero] that allow users to generate
+We have a cargo extension called [cargo-prove] that allow users to generate
 project templates, install tools for improved user experience, build the binary
 using a docker environment and test programs.
 
@@ -44,7 +38,7 @@ Calling `extern "C"` on the target uses the C calling convention outlined in the
 
 Programs for the zkVM could be built by adding it to the `target` list in
 `config.toml`. However, we recommend building programs in our starter template
-generated by the [cargo-risczero] utility and the [risc0-build] crate. This
+generated by the [cargo-prove] utility and the [sp1-build] crate. This
 crate calls `rustc` with `-C "link-arg=-Ttext=` so that it maps the text in the
 appropriate location as well as generating variables that represent the ELF and
 a unique ID associated with the ELF. The starter template provides developers
@@ -57,15 +51,15 @@ Rust does not yet ship pre-compiled artifacts for this target. To compile for
 this target, you will either need to build Rust with the target enabled (see
 "Building the target" above). We do not recommend using `build-std` as we have
 run into issues building core in the past on our starter template. An alternate
-solution is to download the risc0 tool chain by running `cargo risczero install`.
+solution is to download the risc0 tool chain by running `cargo prove install`.
 
 ## Testing
 
 Note: the target is implemented as a software emulator called the zkVM and there
 is no hardware implementation of the target.
 
 The most practical way to test the target program is to use our starter template
-that can be generated by using the `cargo risczero new` command. The template
+that can be generated by using the `cargo prove new` command. The template
 generates a sample "host" and "guest" code. The guest code compiled to the
 target (which is RV32IM) whereas the "host" code is compiled to run on the
 programmer's machine running either a Linux distribution or macOS. The host
@@ -82,5 +76,4 @@ target.  On clang and ld.lld linker, it can be generated using the
 target `riscv32-unknown-none`.
 
 [RISC-V specification]: https://riscv.org/wp-content/uploads/2015/01/riscv-calling.pdf
-[cargo-risczero]: https://docs.rs/cargo-risczero/latest/cargo_risczero/
-[risc0-build]: https://crates.io/crates/risc0-build
+[sp1-build]: https://crates.io/crates/sp1-build

src/tools/build-manifest/src/main.rs

@@ -134,7 +134,7 @@ static TARGETS: &[&str] = &[
     "powerpc64le-unknown-linux-gnu",
     "powerpc64le-unknown-linux-musl",
     "riscv32i-unknown-none-elf",
-    "riscv32im-risc0-zkvm-elf",
+    "riscv32im-succinct-zkvm-elf",
     "riscv32im-unknown-none-elf",
     "riscv32ima-unknown-none-elf",
     "riscv32imc-unknown-none-elf",

tests/assembly/targets/targets-elf.rs

@@ -393,9 +393,9 @@
 //@ revisions: riscv32i_unknown_none_elf
 //@ [riscv32i_unknown_none_elf] compile-flags: --target riscv32i-unknown-none-elf
 //@ [riscv32i_unknown_none_elf] needs-llvm-components: riscv
-//@ revisions: riscv32im_risc0_zkvm_elf
-//@ [riscv32im_risc0_zkvm_elf] compile-flags: --target riscv32im-risc0-zkvm-elf
-//@ [riscv32im_risc0_zkvm_elf] needs-llvm-components: riscv
+//@ revisions: riscv32im_succinct_zkvm_elf
+//@ [riscv32im_succinct_zkvm_elf] compile-flags: --target riscv32im-succinct-zkvm-elf
+//@ [riscv32im_succinct_zkvm_elf] needs-llvm-components: riscv
 //@ revisions: riscv32im_unknown_none_elf
 //@ [riscv32im_unknown_none_elf] compile-flags: --target riscv32im-unknown-none-elf
 //@ [riscv32im_unknown_none_elf] needs-llvm-components: riscv

tests/ui/check-cfg/well-known-values.stderr

@@ -230,7 +230,7 @@ warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
 LL |     target_vendor = "_UNEXPECTED_VALUE",
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
+   = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `nintendo`, `nvidia`, `pc`, `succinct`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`