Remove extern "wasm" ABI

Remove the unstable `extern "wasm"` ABI (`wasm_abi` feature tracked in #83788). As discussed in #127513 (comment) and following, this ABI is a failed experiment that did not end up being used for anything. Keeping support for this ABI in LLVM 19 would require us to switch wasm targets to the `experimental-mv` ABI, which we do not want to do. It should be noted that `Abi::Wasm` was internally used for two things: The `-Z wasm-c-abi=legacy` ABI that is still used by default on some wasm targets, and the `extern "wasm"` ABI. Despite both being `Abi::Wasm` internally, they were not the same. An explicit `extern "wasm"` additionally enabled the `+multivalue` feature. I've opted to remove `Abi::Wasm` in this patch entirely, instead of keeping it as an ABI with only internal usage. Both `-Z wasm-c-abi` variants are now treated as part of the normal C ABI, just with different different treatment in adjust_for_foreign_abi.
rust-lang · Jul 11, 2024 · 8a50bcb · 8a50bcb
1 parent 0fdfb61
commit 8a50bcb
Show file tree

Hide file tree

Showing 25 changed files with 87 additions and 382 deletions.
diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -6,7 +6,6 @@ use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, PatchableFuncti
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_session::config::{FunctionReturn, OptLevel};
 use rustc_span::symbol::sym;
-use rustc_target::spec::abi::Abi;
 use rustc_target::spec::{FramePointer, SanitizerSet, StackProbeType, StackProtector};
 use smallvec::SmallVec;
 
@@ -482,7 +481,7 @@ pub fn from_fn_attrs<'ll, 'tcx>(
  return;
  }
 
- let mut function_features = function_features
+ let function_features = function_features
  .iter()
  .flat_map(|feat| {
  llvm_util::to_llvm_features(cx.tcx.sess, feat).into_iter().map(|f| format!("+{f}"))
@@ -504,17 +503,6 @@ pub fn from_fn_attrs<'ll, 'tcx>(
  let name = name.as_str();
  to_add.push(llvm::CreateAttrStringValue(cx.llcx, "wasm-import-name", name));
  }
-
- // The `"wasm"` abi on wasm targets automatically enables the
- // `+multivalue` feature because the purpose of the wasm abi is to match
- // the WebAssembly specification, which has this feature. This won't be
- // needed when LLVM enables this `multivalue` feature by default.
- if !cx.tcx.is_closure_like(instance.def_id()) {
- let abi = cx.tcx.fn_sig(instance.def_id()).skip_binder().abi();
- if abi == Abi::Wasm {
- function_features.push("+multivalue".to_string());
- }
- }
  }
 
  let global_features = cx.tcx.global_backend_features(()).iter().map(|s| s.as_str());

diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs
@@ -215,6 +215,9 @@ declare_features! (
  /// Permits specifying whether a function should permit unwinding or abort on unwind.
  (removed, unwind_attributes, "1.56.0", Some(58760), Some("use the C-unwind ABI instead")),
  (removed, visible_private_types, "1.0.0", None, None),
+ /// Allows `extern "wasm" fn`
+ (removed, wasm_abi, "CURRENT_RUSTC_VERSION", Some(83788),
+ Some("non-standard wasm ABI is no longer supported")),
  // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!!
  // Features are listed in alphabetical order. Tidy will fail if you don't keep it this way.
  // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!!

diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
@@ -640,8 +640,6 @@ declare_features! (
  (unstable, unsized_tuple_coercion, "1.20.0", Some(42877)),
  /// Allows using the `#[used(linker)]` (or `#[used(compiler)]`) attribute.
  (unstable, used_with_arg, "1.60.0", Some(93798)),
- /// Allows `extern "wasm" fn`
- (unstable, wasm_abi, "1.53.0", Some(83788)),
  /// Allows `do yeet` expressions
  (unstable, yeet_expr, "1.62.0", Some(96373)),
  // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!!

diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
@@ -1212,7 +1212,6 @@ pub fn fn_can_unwind(tcx: TyCtxt<'_>, fn_def_id: Option<DefId>, abi: SpecAbi) ->
  | RiscvInterruptM
  | RiscvInterruptS
  | CCmseNonSecureCall
- | Wasm
  | Unadjusted => false,
  Rust | RustCall | RustCold | RustIntrinsic => {
  tcx.sess.panic_strategy() == PanicStrategy::Unwind

diff --git a/compiler/rustc_smir/src/rustc_internal/internal.rs b/compiler/rustc_smir/src/rustc_internal/internal.rs
@@ -466,7 +466,6 @@ impl RustcInternal for Abi {
  Abi::AvrInterrupt => rustc_target::spec::abi::Abi::AvrInterrupt,
  Abi::AvrNonBlockingInterrupt => rustc_target::spec::abi::Abi::AvrNonBlockingInterrupt,
  Abi::CCmseNonSecureCall => rustc_target::spec::abi::Abi::CCmseNonSecureCall,
- Abi::Wasm => rustc_target::spec::abi::Abi::Wasm,
  Abi::System { unwind } => rustc_target::spec::abi::Abi::System { unwind },
  Abi::RustIntrinsic => rustc_target::spec::abi::Abi::RustIntrinsic,
  Abi::RustCall => rustc_target::spec::abi::Abi::RustCall,

diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
@@ -909,7 +909,6 @@ impl<'tcx> Stable<'tcx> for rustc_target::spec::abi::Abi {
  abi::Abi::AvrInterrupt => Abi::AvrInterrupt,
  abi::Abi::AvrNonBlockingInterrupt => Abi::AvrNonBlockingInterrupt,
  abi::Abi::CCmseNonSecureCall => Abi::CCmseNonSecureCall,
- abi::Abi::Wasm => Abi::Wasm,
  abi::Abi::System { unwind } => Abi::System { unwind },
  abi::Abi::RustIntrinsic => Abi::RustIntrinsic,
  abi::Abi::RustCall => Abi::RustCall,

diff --git a/compiler/rustc_target/src/abi/call/mod.rs b/compiler/rustc_target/src/abi/call/mod.rs
@@ -1,6 +1,6 @@
 use crate::abi::{self, Abi, Align, FieldsShape, Size};
 use crate::abi::{HasDataLayout, TyAbiInterface, TyAndLayout};
-use crate::spec::{self, HasTargetSpec, HasWasmCAbiOpt};
+use crate::spec::{self, HasTargetSpec, HasWasmCAbiOpt, WasmCAbi};
 use rustc_macros::HashStable_Generic;
 use rustc_span::Symbol;
 use std::fmt;
@@ -854,7 +854,8 @@ impl<'a, Ty> FnAbi<'a, Ty> {
  return Ok(());
  }
 
- match &cx.target_spec().arch[..] {
+ let spec = cx.target_spec();
+ match &spec.arch[..] {
  "x86" => {
  let flavor = if let spec::abi::Abi::Fastcall { .. }
  | spec::abi::Abi::Vectorcall { .. } = abi
@@ -901,9 +902,7 @@ impl<'a, Ty> FnAbi<'a, Ty> {
  "sparc" => sparc::compute_abi_info(cx, self),
  "sparc64" => sparc64::compute_abi_info(cx, self),
  "nvptx64" => {
- if cx.target_spec().adjust_abi(cx, abi, self.c_variadic)
- == spec::abi::Abi::PtxKernel
- {
+ if cx.target_spec().adjust_abi(abi, self.c_variadic) == spec::abi::Abi::PtxKernel {
  nvptx64::compute_ptx_kernel_abi_info(cx, self)
  } else {
  nvptx64::compute_abi_info(self)
@@ -912,13 +911,14 @@ impl<'a, Ty> FnAbi<'a, Ty> {
  "hexagon" => hexagon::compute_abi_info(self),
  "xtensa" => xtensa::compute_abi_info(cx, self),
  "riscv32" | "riscv64" => riscv::compute_abi_info(cx, self),
- "wasm32" | "wasm64" => {
- if cx.target_spec().adjust_abi(cx, abi, self.c_variadic) == spec::abi::Abi::Wasm {
+ "wasm32" => {
+ if spec.os == "unknown" && cx.wasm_c_abi_opt() == WasmCAbi::Legacy {
  wasm::compute_wasm_abi_info(self)
  } else {
  wasm::compute_c_abi_info(cx, self)
  }
  }
+ "wasm64" => wasm::compute_c_abi_info(cx, self),
  "bpf" => bpf::compute_abi_info(self),
  arch => {
  return Err(AdjustForForeignAbiError::Unsupported {

diff --git a/compiler/rustc_target/src/spec/abi/mod.rs b/compiler/rustc_target/src/spec/abi/mod.rs
@@ -48,7 +48,6 @@ pub enum Abi {
  AvrInterrupt,
  AvrNonBlockingInterrupt,
  CCmseNonSecureCall,
- Wasm,
  System {
  unwind: bool,
  },
@@ -123,7 +122,6 @@ const AbiDatas: &[AbiData] = &[
  AbiData { abi: Abi::AvrInterrupt, name: "avr-interrupt" },
  AbiData { abi: Abi::AvrNonBlockingInterrupt, name: "avr-non-blocking-interrupt" },
  AbiData { abi: Abi::CCmseNonSecureCall, name: "C-cmse-nonsecure-call" },
- AbiData { abi: Abi::Wasm, name: "wasm" },
  AbiData { abi: Abi::System { unwind: false }, name: "system" },
  AbiData { abi: Abi::System { unwind: true }, name: "system-unwind" },
  AbiData { abi: Abi::RustIntrinsic, name: "rust-intrinsic" },
@@ -149,6 +147,9 @@ pub fn lookup(name: &str) -> Result<Abi, AbiUnsupported> {
  "riscv-interrupt-u" => AbiUnsupported::Reason {
  explain: "user-mode interrupt handlers have been removed from LLVM pending standardization, see: https://reviews.llvm.org/D149314",
  },
+ "wasm" => AbiUnsupported::Reason {
+ explain: "non-standard wasm ABI is no longer supported",
+ },
 
  _ => AbiUnsupported::Unrecognized,
 
@@ -241,10 +242,6 @@ pub fn is_stable(name: &str) -> Result<(), AbiDisabled> {
  feature: sym::abi_c_cmse_nonsecure_call,
  explain: "C-cmse-nonsecure-call ABI is experimental and subject to change",
  }),
- "wasm" => Err(AbiDisabled::Unstable {
- feature: sym::wasm_abi,
- explain: "wasm ABI is experimental and subject to change",
- }),
  _ => Err(AbiDisabled::Unrecognized),
  }
 }
@@ -287,16 +284,15 @@ impl Abi {
  AvrInterrupt => 23,
  AvrNonBlockingInterrupt => 24,
  CCmseNonSecureCall => 25,
- Wasm => 26,
  // Cross-platform ABIs
- System { unwind: false } => 27,
- System { unwind: true } => 28,
- RustIntrinsic => 29,
- RustCall => 30,
- Unadjusted => 31,
- RustCold => 32,
- RiscvInterruptM => 33,
- RiscvInterruptS => 34,
+ System { unwind: false } => 26,
+ System { unwind: true } => 27,
+ RustIntrinsic => 28,
+ RustCall => 29,
+ Unadjusted => 30,
+ RustCold => 31,
+ RiscvInterruptM => 32,
+ RiscvInterruptS => 33,
  };
  debug_assert!(
  AbiDatas

diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
@@ -2608,22 +2608,8 @@ impl DerefMut for Target {
 
 impl Target {
  /// Given a function ABI, turn it into the correct ABI for this target.
- pub fn adjust_abi<C>(&self, cx: &C, abi: Abi, c_variadic: bool) -> Abi
- where
- C: HasWasmCAbiOpt,
- {
+ pub fn adjust_abi(&self, abi: Abi, c_variadic: bool) -> Abi {
  match abi {
- Abi::C { .. } => {
- if self.arch == "wasm32"
- && self.os == "unknown"
- && cx.wasm_c_abi_opt() == WasmCAbi::Legacy
- {
- Abi::Wasm
- } else {
- abi
- }
- }
-
  // On Windows, `extern "system"` behaves like msvc's `__stdcall`.
  // `__stdcall` only applies on x86 and on non-variadic functions:
  // https://learn.microsoft.com/en-us/cpp/cpp/stdcall?view=msvc-170
@@ -2676,7 +2662,6 @@ impl Target {
  Msp430Interrupt => self.arch == "msp430",
  RiscvInterruptM | RiscvInterruptS => ["riscv32", "riscv64"].contains(&&self.arch[..]),
  AvrInterrupt | AvrNonBlockingInterrupt => self.arch == "avr",
- Wasm => ["wasm32", "wasm64"].contains(&&self.arch[..]),
  Thiscall { .. } => self.arch == "x86",
  // On windows these fall-back to platform native calling convention (C) when the
  // architecture is not supported.

diff --git a/compiler/rustc_ty_utils/src/abi.rs b/compiler/rustc_ty_utils/src/abi.rs
@@ -324,7 +324,7 @@ fn fn_sig_for_fn_abi<'tcx>(
 #[inline]
 fn conv_from_spec_abi(tcx: TyCtxt<'_>, abi: SpecAbi, c_variadic: bool) -> Conv {
  use rustc_target::spec::abi::Abi::*;
- match tcx.sess.target.adjust_abi(&tcx, abi, c_variadic) {
+ match tcx.sess.target.adjust_abi(abi, c_variadic) {
  RustIntrinsic | Rust | RustCall => Conv::Rust,
 
  // This is intentionally not using `Conv::Cold`, as that has to preserve
@@ -352,7 +352,6 @@ fn conv_from_spec_abi(tcx: TyCtxt<'_>, abi: SpecAbi, c_variadic: bool) -> Conv {
  AvrNonBlockingInterrupt => Conv::AvrNonBlockingInterrupt,
  RiscvInterruptM => Conv::RiscvInterrupt { kind: RiscvInterruptKind::Machine },
  RiscvInterruptS => Conv::RiscvInterrupt { kind: RiscvInterruptKind::Supervisor },
- Wasm => Conv::C,
 
  // These API constants ought to be more specific...
  Cdecl { .. } => Conv::C,

diff --git a/compiler/stable_mir/src/ty.rs b/compiler/stable_mir/src/ty.rs
@@ -1045,7 +1045,6 @@ pub enum Abi {
  AvrInterrupt,
  AvrNonBlockingInterrupt,
  CCmseNonSecureCall,
- Wasm,
  System { unwind: bool },
  RustIntrinsic,
  RustCall,

diff --git a/tests/run-make/wasm-abi/foo.rs b/tests/run-make/wasm-abi/foo.rs
diff --git a/tests/run-make/wasm-abi/host.wat b/tests/run-make/wasm-abi/host.wat
diff --git a/tests/run-make/wasm-abi/rmake.rs b/tests/run-make/wasm-abi/rmake.rs
diff --git a/tests/ui/abi/removed-wasm-abi.rs b/tests/ui/abi/removed-wasm-abi.rs
@@ -0,0 +1,4 @@
+extern "wasm" fn test() {}
+//~^ ERROR invalid ABI: found `wasm`
+
+fn main() {}