wasm-builder: Use the custom target riscv32emac-unknown-none-polkavm

Signed-off-by: Jarkko Sakkinen <[email protected]>

cumulus/pallets/parachain-system/src/validate_block/trie_cache.rs

@@ -85,7 +85,10 @@ impl<H: Hasher> CacheProvider<H> {
 }
 
 impl<H: Hasher> TrieCacheProvider<H> for CacheProvider<H> {
-	type Cache<'a> = TrieCache<'a, H> where H: 'a;
+	type Cache<'a>
+		= TrieCache<'a, H>
+	where
+		H: 'a;
 
 	fn as_trie_db_cache(&self, storage_root: <H as Hasher>::Out) -> Self::Cache<'_> {
 		TrieCache {

cumulus/pallets/parachain-system/src/validate_block/trie_recorder.rs

@@ -115,7 +115,10 @@ impl<H: Hasher> SizeOnlyRecorderProvider<H> {
 }
 
 impl<H: trie_db::Hasher> sp_trie::TrieRecorderProvider<H> for SizeOnlyRecorderProvider<H> {
-	type Recorder<'a> = SizeOnlyRecorder<'a, H> where H: 'a;
+	type Recorder<'a>
+		= SizeOnlyRecorder<'a, H>
+	where
+		H: 'a;
 
 	fn drain_storage_proof(self) -> Option<StorageProof> {
 		None

prdoc/pr_6419.prdoc

@@ -0,0 +1,12 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Use the custom target riscv32emac-unknown-none-polkavm
+doc:
+  - audience: Runtime Dev
+    description: |
+      Closes: https://github.com/paritytech/polkadot-sdk/issues/6335
+
+crates:
+- name: substrate-wasm-builder
+  bump: patch

substrate/primitives/state-machine/src/trie_backend.rs

@@ -73,7 +73,10 @@ pub trait TrieCacheProvider<H: Hasher> {
 
 #[cfg(feature = "std")]
 impl<H: Hasher> TrieCacheProvider<H> for LocalTrieCache<H> {
-	type Cache<'a> = TrieCache<'a, H> where H: 'a;
+	type Cache<'a>
+		= TrieCache<'a, H>
+	where
+		H: 'a;
 
 	fn as_trie_db_cache(&self, storage_root: H::Out) -> Self::Cache<'_> {
 		self.as_trie_db_cache(storage_root)
@@ -90,7 +93,10 @@ impl<H: Hasher> TrieCacheProvider<H> for LocalTrieCache<H> {
 
 #[cfg(feature = "std")]
 impl<H: Hasher> TrieCacheProvider<H> for &LocalTrieCache<H> {
-	type Cache<'a> = TrieCache<'a, H> where Self: 'a;
+	type Cache<'a>
+		= TrieCache<'a, H>
+	where
+		Self: 'a;
 
 	fn as_trie_db_cache(&self, storage_root: H::Out) -> Self::Cache<'_> {
 		(*self).as_trie_db_cache(storage_root)
@@ -139,7 +145,10 @@ impl<H: Hasher> trie_db::TrieCache<NodeCodec<H>> for UnimplementedCacheProvider<
 
 #[cfg(not(feature = "std"))]
 impl<H: Hasher> TrieCacheProvider<H> for UnimplementedCacheProvider<H> {
-	type Cache<'a> = UnimplementedCacheProvider<H> where H: 'a;
+	type Cache<'a>
+		= UnimplementedCacheProvider<H>
+	where
+		H: 'a;
 
 	fn as_trie_db_cache(&self, _storage_root: <H as Hasher>::Out) -> Self::Cache<'_> {
 		unimplemented!()
@@ -176,7 +185,10 @@ impl<H: Hasher> trie_db::TrieRecorder<H::Out> for UnimplementedRecorderProvider<
 
 #[cfg(not(feature = "std"))]
 impl<H: Hasher> TrieRecorderProvider<H> for UnimplementedRecorderProvider<H> {
-	type Recorder<'a> = UnimplementedRecorderProvider<H> where H: 'a;
+	type Recorder<'a>
+		= UnimplementedRecorderProvider<H>
+	where
+		H: 'a;
 
 	fn drain_storage_proof(self) -> Option<StorageProof> {
 		unimplemented!()

substrate/primitives/trie/src/recorder.rs

@@ -252,7 +252,10 @@ pub struct TrieRecorder<'a, H: Hasher> {
 }
 
 impl<H: Hasher> crate::TrieRecorderProvider<H> for Recorder<H> {
-	type Recorder<'a> = TrieRecorder<'a, H> where H: 'a;
+	type Recorder<'a>
+		= TrieRecorder<'a, H>
+	where
+		H: 'a;
 
 	fn drain_storage_proof(self) -> Option<StorageProof> {
 		Some(Recorder::drain_storage_proof(self))

substrate/utils/wasm-builder/riscv32emac-unknown-none-polkavm.json

@@ -0,0 +1,26 @@
+{
+  "arch": "riscv32",
+  "cpu": "generic-rv32",
+  "crt-objects-fallback": "false",
+  "data-layout": "e-m:e-p:32:32-i64:64-n32-S32",
+  "eh-frame-header": false,
+  "emit-debug-gdb-scripts": false,
+  "features": "+e,+m,+a,+c,+lui-addi-fusion,+xtheadcondmov",
+  "linker": "rust-lld",
+  "linker-flavor": "ld.lld",
+  "llvm-abiname": "ilp32e",
+  "llvm-target": "riscv32",
+  "max-atomic-width": 64,
+  "panic-strategy": "abort",
+  "relocation-model": "pie",
+  "target-pointer-width": "32",
+  "singlethread": true,
+  "pre-link-args": {
+    "ld": [
+      "--emit-relocs",
+      "--unique",
+      "--relocatable"
+    ]
+  },
+  "env": "polkavm"
+}

substrate/utils/wasm-builder/src/builder.rs

@@ -235,7 +235,13 @@ impl WasmBuilder {
 
 	/// Build the WASM binary.
 	pub fn build(mut self) {
-		let target = crate::runtime_target();
+		let Some(target) = RuntimeTarget::new() else {
+			build_helper::warning!(
+				"RUNTIME_TARGET environment variable must be set to either \"wasm\" or \"riscv\""
+			);
+			std::process::exit(1);
+		};
+
 		if target == RuntimeTarget::Wasm {
 			if self.export_heap_base {
 				self.rust_flags.push("-Clink-arg=--export=__heap_base".into());

substrate/utils/wasm-builder/src/lib.rs

@@ -112,7 +112,6 @@
 //! wasm32-unknown-unknown --toolchain nightly-2020-02-20`.
 
 use std::{
-	collections::BTreeSet,
 	env, fs,
 	io::BufRead,
 	path::{Path, PathBuf},
@@ -254,26 +253,22 @@ struct CargoCommand {
 	program: String,
 	args: Vec<String>,
 	version: Option<Version>,
-	target_list: Option<BTreeSet<String>>,
 }
 
 impl CargoCommand {
 	fn new(program: &str) -> Self {
 		let version = Self::extract_version(program, &[]);
-		let target_list = Self::extract_target_list(program, &[]);
 
-		CargoCommand { program: program.into(), args: Vec::new(), version, target_list }
+		CargoCommand { program: program.into(), args: Vec::new(), version }
 	}
 
 	fn new_with_args(program: &str, args: &[&str]) -> Self {
 		let version = Self::extract_version(program, args);
-		let target_list = Self::extract_target_list(program, args);
 
 		CargoCommand {
 			program: program.into(),
 			args: args.iter().map(ToString::to_string).collect(),
 			version,
-			target_list,
 		}
 	}
 
@@ -294,23 +289,6 @@ impl CargoCommand {
 		Version::extract(&version)
 	}
 
-	fn extract_target_list(program: &str, args: &[&str]) -> Option<BTreeSet<String>> {
-		// This is technically an unstable option, but we don't care because we only need this
-		// to build RISC-V runtimes, and those currently require a specific nightly toolchain
-		// anyway, so it's totally fine for this to fail in other cases.
-		let list = Command::new(program)
-			.args(args)
-			.args(&["rustc", "-Z", "unstable-options", "--print", "target-list"])
-			// Make sure if we're called from within a `build.rs` the host toolchain won't override
-			// a rustup toolchain we've picked.
-			.env_remove("RUSTC")
-			.output()
-			.ok()
-			.and_then(|o| String::from_utf8(o.stdout).ok())?;
-
-		Some(list.trim().split("\n").map(ToString::to_string).collect())
-	}
-
 	/// Returns the version of this cargo command or `None` if it failed to extract the version.
 	fn version(&self) -> Option<Version> {
 		self.version
@@ -326,19 +304,10 @@ impl CargoCommand {
 	fn supports_substrate_runtime_env(&self, target: RuntimeTarget) -> bool {
 		match target {
 			RuntimeTarget::Wasm => self.supports_substrate_runtime_env_wasm(),
-			RuntimeTarget::Riscv => self.supports_substrate_runtime_env_riscv(),
+			RuntimeTarget::Riscv => true,
 		}
 	}
 
-	/// Check if the supplied cargo command supports our RISC-V runtime environment.
-	fn supports_substrate_runtime_env_riscv(&self) -> bool {
-		let Some(target_list) = self.target_list.as_ref() else { return false };
-		// This is our custom target which currently doesn't exist on any upstream toolchain,
-		// so if it exists it's guaranteed to be our custom toolchain and have have everything
-		// we need, so any further version checks are unnecessary at this point.
-		target_list.contains("riscv32ema-unknown-none-elf")
-	}
-
 	/// Check if the supplied cargo command supports our Substrate wasm environment.
 	///
 	/// This means that either the cargo version is at minimum 1.68.0 or this is a nightly cargo.
@@ -411,7 +380,7 @@ fn get_bool_environment_variable(name: &str) -> Option<bool> {
 
 /// Returns whether we need to also compile the standard library when compiling the runtime.
 fn build_std_required() -> bool {
-	let default = runtime_target() == RuntimeTarget::Wasm;
+	let default = RuntimeTarget::new() != None;
 
 	crate::get_bool_environment_variable(crate::WASM_BUILD_STD).unwrap_or(default)
 }
@@ -423,13 +392,30 @@ enum RuntimeTarget {
 }
 
 impl RuntimeTarget {
-	fn rustc_target(self) -> &'static str {
-		match self {
-			RuntimeTarget::Wasm => "wasm32-unknown-unknown",
-			RuntimeTarget::Riscv => "riscv32ema-unknown-none-elf",
+	/// Creates a new instance.
+	fn new() -> Option<Self> {
+		let Some(value) = env::var_os(RUNTIME_TARGET) else {
+			return Some(Self::Wasm);
+		};
+		if value == "wasm" {
+			Some(Self::Wasm)
+		} else if value == "riscv" {
+			Some(Self::Riscv)
+		} else {
+			None
 		}
 	}
 
+	/// Figures out the target parameter value for rustc. For the PolkaVM custom targets, apply the
+	/// full path to the JSON file.
+	fn rustc_target(self) -> String {
+		if self == RuntimeTarget::Wasm {
+			return "wasm32-unknown-unknown".to_string();
+		}
+		let path: &'static str = env!("CARGO_MANIFEST_DIR");
+		format!("{path}/riscv32emac-unknown-none-polkavm.json")
+	}
+
 	fn build_subdirectory(self) -> &'static str {
 		// Keep the build directories separate so that when switching between
 		// the targets we won't trigger unnecessary rebuilds.
@@ -439,20 +425,3 @@ impl RuntimeTarget {
 		}
 	}
 }
-
-fn runtime_target() -> RuntimeTarget {
-	let Some(value) = env::var_os(RUNTIME_TARGET) else {
-		return RuntimeTarget::Wasm;
-	};
-
-	if value == "wasm" {
-		RuntimeTarget::Wasm
-	} else if value == "riscv" {
-		RuntimeTarget::Riscv
-	} else {
-		build_helper::warning!(
-			"the '{RUNTIME_TARGET}' environment variable has an invalid value; it must be either 'wasm' or 'riscv'"
-		);
-		std::process::exit(1);
-	}
-}

substrate/utils/wasm-builder/src/wasm_project.rs

@@ -910,7 +910,10 @@ fn build_bloaty_blob(
 	if crate::build_std_required() {
 		// Unfortunately this is still a nightly-only flag, but FWIW it is pretty widely used
 		// so it's unlikely to break without a replacement.
-		build_cmd.arg("-Z").arg("build-std");
+		match target {
+			RuntimeTarget::Wasm => build_cmd.arg("-Z").arg("build-std"),
+			RuntimeTarget::Riscv => build_cmd.arg("-Z").arg("build-std=core,alloc"),
+		};
 		if !cargo_cmd.supports_nightly_features() {
 			build_cmd.env("RUSTC_BOOTSTRAP", "1");
 		}