Auto merge of rust-lang#128698 - tgross35:rollup-oan6ari, r=tgross35

Rollup of 8 pull requests

Successful merges:

 - rust-lang#122049 (Promote riscv64gc-unknown-linux-musl to tier 2)
 - rust-lang#125558 (Tweak type inference for `const` operands in inline asm)
 - rust-lang#128638 (run-make: enable msvc for `link-dedup`)
 - rust-lang#128647 (Enable msvc for link-args-order)
 - rust-lang#128649 (run-make: Enable msvc for `no-duplicate-libs` and `zero-extend-abi-param-passing`)
 - rust-lang#128656 (Enable msvc for run-make/rust-lld)
 - rust-lang#128688 (custom MIR: add support for tail calls)
 - rust-lang#128691 (Update `compiler-builtins` to 0.1.115)

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_hir_analysis/src/check/intrinsicck.rs

@@ -2,7 +2,7 @@ use rustc_ast::InlineAsmTemplatePiece;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_hir::{self as hir, LangItem};
 use rustc_middle::bug;
-use rustc_middle::ty::{self, Article, FloatTy, IntTy, Ty, TyCtxt, TypeVisitableExt, UintTy};
+use rustc_middle::ty::{self, FloatTy, IntTy, Ty, TyCtxt, TypeVisitableExt, UintTy};
 use rustc_session::lint;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::Symbol;
@@ -455,32 +455,22 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
  );
  }
  }
- // No special checking is needed for these:
- // - Typeck has checked that Const operands are integers.
- // - AST lowering guarantees that SymStatic points to a static.
- hir::InlineAsmOperand::Const { .. } | hir::InlineAsmOperand::SymStatic { .. } => {}
- // Check that sym actually points to a function. Later passes
- // depend on this.
+ // Typeck has checked that Const operands are integers.
+ hir::InlineAsmOperand::Const { anon_const } => {
+ debug_assert!(matches!(
+ self.tcx.type_of(anon_const.def_id).instantiate_identity().kind(),
+ ty::Error(_) | ty::Int(_) | ty::Uint(_)
+ ));
+ }
+ // Typeck has checked that SymFn refers to a function.
  hir::InlineAsmOperand::SymFn { anon_const } => {
- let ty = self.tcx.type_of(anon_const.def_id).instantiate_identity();
- match ty.kind() {
- ty::Never | ty::Error(_) => {}
- ty::FnDef(..) => {}
- _ => {
- self.tcx
- .dcx()
- .struct_span_err(*op_sp, "invalid `sym` operand")
- .with_span_label(
- self.tcx.def_span(anon_const.def_id),
- format!("is {} `{}`", ty.kind().article(), ty),
- )
- .with_help(
- "`sym` operands must refer to either a function or a static",
- )
- .emit();
- }
- };
+ debug_assert!(matches!(
+ self.tcx.type_of(anon_const.def_id).instantiate_identity().kind(),
+ ty::Error(_) | ty::FnDef(..)
+ ));
  }
+ // AST lowering guarantees that SymStatic points to a static.
+ hir::InlineAsmOperand::SymStatic { .. } => {}
  // No special checking is needed for labels.
  hir::InlineAsmOperand::Label { .. } => {}
  }

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -7,7 +7,7 @@ use rustc_hir::HirId;
 use rustc_middle::query::plumbing::CyclePlaceholder;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
 use rustc_middle::ty::util::IntTypeExt;
-use rustc_middle::ty::{self, IsSuggestable, Ty, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{self, Article, IsSuggestable, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::{bug, span_bug};
 use rustc_span::symbol::Ident;
 use rustc_span::{Span, DUMMY_SP};
@@ -34,6 +34,20 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
  let parent_node_id = tcx.parent_hir_id(hir_id);
  let parent_node = tcx.hir_node(parent_node_id);
 
+ let find_sym_fn = |&(op, op_sp)| match op {
+ hir::InlineAsmOperand::SymFn { anon_const } if anon_const.hir_id == hir_id => {
+ Some((anon_const, op_sp))
+ }
+ _ => None,
+ };
+
+ let find_const = |&(op, op_sp)| match op {
+ hir::InlineAsmOperand::Const { anon_const } if anon_const.hir_id == hir_id => {
+ Some((anon_const, op_sp))
+ }
+ _ => None,
+ };
+
  match parent_node {
  // Anon consts "inside" the type system.
  Node::ConstArg(&ConstArg {
@@ -45,13 +59,51 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
  // Anon consts outside the type system.
  Node::Expr(&Expr { kind: ExprKind::InlineAsm(asm), .. })
  | Node::Item(&Item { kind: ItemKind::GlobalAsm(asm), .. })
- if asm.operands.iter().any(|(op, _op_sp)| match op {
- hir::InlineAsmOperand::Const { anon_const }
- | hir::InlineAsmOperand::SymFn { anon_const } => anon_const.hir_id == hir_id,
- _ => false,
- }) =>
+ if let Some((anon_const, op_sp)) = asm.operands.iter().find_map(find_sym_fn) =>
  {
- tcx.typeck(def_id).node_type(hir_id)
+ let ty = tcx.typeck(def_id).node_type(hir_id);
+
+ match ty.kind() {
+ ty::Error(_) => ty,
+ ty::FnDef(..) => ty,
+ _ => {
+ let guar = tcx
+ .dcx()
+ .struct_span_err(op_sp, "invalid `sym` operand")
+ .with_span_label(
+ tcx.def_span(anon_const.def_id),
+ format!("is {} `{}`", ty.kind().article(), ty),
+ )
+ .with_help("`sym` operands must refer to either a function or a static")
+ .emit();
+
+ Ty::new_error(tcx, guar)
+ }
+ }
+ }
+ Node::Expr(&Expr { kind: ExprKind::InlineAsm(asm), .. })
+ | Node::Item(&Item { kind: ItemKind::GlobalAsm(asm), .. })
+ if let Some((anon_const, op_sp)) = asm.operands.iter().find_map(find_const) =>
+ {
+ let ty = tcx.typeck(def_id).node_type(hir_id);
+
+ match ty.kind() {
+ ty::Error(_) => ty,
+ ty::Int(_) | ty::Uint(_) => ty,
+ _ => {
+ let guar = tcx
+ .dcx()
+ .struct_span_err(op_sp, "invalid type for `const` operand")
+ .with_span_label(
+ tcx.def_span(anon_const.def_id),
+ format!("is {} `{}`", ty.kind().article(), ty),
+ )
+ .with_help("`const` operands must be of an integer type")
+ .emit();
+
+ Ty::new_error(tcx, guar)
+ }
+ }
  }
  Node::Variant(Variant { disr_expr: Some(ref e), .. }) if e.hir_id == hir_id => {
  tcx.adt_def(tcx.hir().get_parent_item(hir_id)).repr().discr_type().to_ty(tcx)

compiler/rustc_hir_typeck/src/lib.rs

@@ -265,11 +265,10 @@ fn infer_type_if_missing<'tcx>(fcx: &FnCtxt<'_, 'tcx>, node: Node<'tcx>) -> Opti
  Node::Expr(&hir::Expr { kind: hir::ExprKind::InlineAsm(asm), span, .. })
  | Node::Item(&hir::Item { kind: hir::ItemKind::GlobalAsm(asm), span, .. }) => {
  asm.operands.iter().find_map(|(op, _op_sp)| match op {
- hir::InlineAsmOperand::Const { anon_const } if anon_const.hir_id == id => {
- // Inline assembly constants must be integers.
- Some(fcx.next_int_var())
- }
- hir::InlineAsmOperand::SymFn { anon_const } if anon_const.hir_id == id => {
+ hir::InlineAsmOperand::Const { anon_const }
+ | hir::InlineAsmOperand::SymFn { anon_const }
+ if anon_const.hir_id == id =>
+ {
  Some(fcx.next_ty_var(span))
  }
  _ => None,

compiler/rustc_mir_build/src/build/custom/parse/instruction.rs

@@ -75,6 +75,9 @@ impl<'tcx, 'body> ParseCtxt<'tcx, 'body> {
  @call(mir_call, args) => {
  self.parse_call(args)
  },
+ @call(mir_tail_call, args) => {
+ self.parse_tail_call(args)
+ },
  ExprKind::Match { scrutinee, arms, .. } => {
  let discr = self.parse_operand(*scrutinee)?;
  self.parse_match(arms, expr.span).map(|t| TerminatorKind::SwitchInt { discr, targets: t })
@@ -187,6 +190,25 @@ impl<'tcx, 'body> ParseCtxt<'tcx, 'body> {
  )
  }
 
+ fn parse_tail_call(&self, args: &[ExprId]) -> PResult<TerminatorKind<'tcx>> {
+ parse_by_kind!(self, args[0], _, "tail call",
+ ExprKind::Call { fun, args, fn_span, .. } => {
+ let fun = self.parse_operand(*fun)?;
+ let args = args
+ .iter()
+ .map(|arg|
+ Ok(Spanned { node: self.parse_operand(*arg)?, span: self.thir.exprs[*arg].span } )
+ )
+ .collect::<PResult<Box<[_]>>>()?;
+ Ok(TerminatorKind::TailCall {
+ func: fun,
+ args,
+ fn_span: *fn_span,
+ })
+ },
+ )
+ }
+
  fn parse_rvalue(&self, expr_id: ExprId) -> PResult<Rvalue<'tcx>> {
  parse_by_kind!(self, expr_id, expr, "rvalue",
  @call(mir_discriminant, args) => self.parse_place(args[0]).map(Rvalue::Discriminant),

compiler/rustc_span/src/symbol.rs

@@ -1216,6 +1216,7 @@ symbols! {
  mir_static_mut,
  mir_storage_dead,
  mir_storage_live,
+ mir_tail_call,
  mir_unreachable,
  mir_unwind_cleanup,
  mir_unwind_continue,

compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_musl.rs

@@ -21,6 +21,7 @@ pub fn target() -> Target {
  llvm_abiname: "lp64d".into(),
  max_atomic_width: Some(64),
  supported_split_debuginfo: Cow::Borrowed(&[SplitDebuginfo::Off]),
+ crt_static_default: false,
  ..base::linux_musl::opts()
  },
  }

library/Cargo.lock

@@ -58,9 +58,9 @@ dependencies = [
 
 [[package]]
 name = "compiler_builtins"
-version = "0.1.114"
+version = "0.1.115"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb58b199190fcfe0846f55a3b545cd6b07a34bdd5930a476ff856f3ebcc5558a"
+checksum = "3358508f8fe5c43b1d59deef1c190287490a00cce3d7b4a3744e4a35e3f220d0"
 dependencies = [
  "cc",
  "rustc-std-workspace-core",

library/alloc/Cargo.toml

@@ -10,10 +10,7 @@ edition = "2021"
 
 [dependencies]
 core = { path = "../core" }
-compiler_builtins = { version = "0.1.114", features = ['rustc-dep-of-std'] }
-
-[target.'cfg(not(any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")))'.dependencies]
-compiler_builtins = { version = "0.1.114", features = ["no-f16-f128"] }
+compiler_builtins = { version = "0.1.115", features = ['rustc-dep-of-std'] }
 
 [dev-dependencies]
 rand = { version = "0.8.5", default-features = false, features = ["alloc"] }

library/core/src/intrinsics/mir.rs

@@ -247,6 +247,8 @@
 //! otherwise branch.
 //! - [`Call`] has an associated function as well, with special syntax:
 //! `Call(ret_val = function(arg1, arg2, ...), ReturnTo(next_block), UnwindContinue())`.
+//! - [`TailCall`] does not have a return destination or next block, so its syntax is just
+//! `TailCall(function(arg1, arg2, ...))`.
 
 #![unstable(
  feature = "custom_mir",
@@ -350,6 +352,12 @@ define!("mir_call",
  /// - [`UnwindCleanup`]
  fn Call(call: (), goto: ReturnToArg, unwind_action: UnwindActionArg)
 );
+define!("mir_tail_call",
+ /// Call a function.
+ ///
+ /// The argument must be of the form `fun(arg1, arg2, ...)`.
+ fn TailCall<T>(call: T)
+);
 define!("mir_unwind_resume",
  /// A terminator that resumes the unwinding.
  fn UnwindResume()

library/std/Cargo.toml

@@ -17,7 +17,7 @@ cfg-if = { version = "1.0", features = ['rustc-dep-of-std'] }
 panic_unwind = { path = "../panic_unwind", optional = true }
 panic_abort = { path = "../panic_abort" }
 core = { path = "../core", public = true }
-compiler_builtins = { version = "0.1.114" }
+compiler_builtins = { version = "0.1.115" }
 profiler_builtins = { path = "../profiler_builtins", optional = true }
 unwind = { path = "../unwind" }
 hashbrown = { version = "0.14", default-features = false, features = [

src/ci/docker/host-x86_64/dist-various-2/Dockerfile

@@ -24,7 +24,8 @@ RUN apt-get update && apt-get build-dep -y clang llvm && apt-get install -y --no
  # Needed for apt-key to work:
  dirmngr \
  gpg-agent \
- g++-9-arm-linux-gnueabi
+ g++-9-arm-linux-gnueabi \
+ g++-11-riscv64-linux-gnu
 
 RUN apt-key adv --batch --yes --keyserver keyserver.ubuntu.com --recv-keys 74DA7924C5513486
 RUN add-apt-repository -y 'deb https://apt.dilos.org/dilos dilos2 main'
@@ -73,6 +74,10 @@ RUN env \
  CC=arm-linux-gnueabi-gcc-9 CFLAGS="-march=armv7-a" \
  CXX=arm-linux-gnueabi-g++-9 CXXFLAGS="-march=armv7-a" \
  bash musl.sh armv7 && \
+ env \
+ CC=riscv64-linux-gnu-gcc-11 \
+ CXX=riscv64-linux-gnu-g++-11 \
+ bash musl.sh riscv64gc && \
  rm -rf /build/*
 
 WORKDIR /tmp
@@ -125,14 +130,19 @@ ENV TARGETS=$TARGETS,x86_64-unknown-none
 ENV TARGETS=$TARGETS,aarch64-unknown-uefi
 ENV TARGETS=$TARGETS,i686-unknown-uefi
 ENV TARGETS=$TARGETS,x86_64-unknown-uefi
+ENV TARGETS=$TARGETS,riscv64gc-unknown-linux-musl
 
 # As per https://bugs.launchpad.net/ubuntu/+source/gcc-defaults/+bug/1300211
 # we need asm in the search path for gcc-9 (for gnux32) but not in the search path of the
 # cross compilers.
 # Luckily one of the folders is /usr/local/include so symlink /usr/include/x86_64-linux-gnu/asm there
 RUN ln -s /usr/include/x86_64-linux-gnu/asm /usr/local/include/asm
 
+# musl-gcc can't find libgcc_s.so.1 since it doesn't use the standard search paths.
+RUN ln -s /usr/riscv64-linux-gnu/lib/libgcc_s.so.1 /usr/lib/gcc-cross/riscv64-linux-gnu/11/
+
 ENV RUST_CONFIGURE_ARGS --enable-extended --enable-lld --enable-llvm-bitcode-linker --disable-docs \
- --musl-root-armv7=/musl-armv7
+ --musl-root-armv7=/musl-armv7 \
+ --musl-root-riscv64gc=/musl-riscv64gc
 
 ENV SCRIPT python3 ../x.py dist --host='' --target $TARGETS

src/doc/rustc/src/SUMMARY.md

@@ -66,6 +66,7 @@
  - [riscv32imac-unknown-xous-elf](platform-support/riscv32imac-unknown-xous-elf.md)
  - [riscv32*-unknown-none-elf](platform-support/riscv32-unknown-none-elf.md)
  - [riscv64gc-unknown-linux-gnu](platform-support/riscv64gc-unknown-linux-gnu.md)
+ - [riscv64gc-unknown-linux-musl](platform-support/riscv64gc-unknown-linux-musl.md)
  - [sparc-unknown-none-elf](./platform-support/sparc-unknown-none-elf.md)
  - [*-pc-windows-gnullvm](platform-support/pc-windows-gnullvm.md)
  - [\*-nto-qnx-\*](platform-support/nto-qnx.md)

src/doc/rustc/src/platform-support.md

@@ -98,6 +98,7 @@ target | notes
 `powerpc64-unknown-linux-gnu` | PPC64 Linux (kernel 3.2, glibc 2.17)
 `powerpc64le-unknown-linux-gnu` | PPC64LE Linux (kernel 3.10, glibc 2.17)
 [`riscv64gc-unknown-linux-gnu`](platform-support/riscv64gc-unknown-linux-gnu.md) | RISC-V Linux (kernel 4.20, glibc 2.29)
+[`riscv64gc-unknown-linux-musl`](platform-support/riscv64gc-unknown-linux-musl.md) | RISC-V Linux (kernel 4.20, musl 1.2.3)
 `s390x-unknown-linux-gnu` | S390x Linux (kernel 3.2, glibc 2.17)
 `x86_64-unknown-freebsd` | 64-bit FreeBSD
 `x86_64-unknown-illumos` | illumos
@@ -354,7 +355,6 @@ target | std | host | notes
 [`riscv64gc-unknown-hermit`](platform-support/hermit.md) | ✓ | | RISC-V Hermit
 `riscv64gc-unknown-freebsd` | | | RISC-V FreeBSD
 `riscv64gc-unknown-fuchsia` | | | RISC-V Fuchsia
-`riscv64gc-unknown-linux-musl` | | | RISC-V Linux (kernel 4.20, musl 1.2.3)
 [`riscv64gc-unknown-netbsd`](platform-support/netbsd.md) | ✓ | ✓ | RISC-V NetBSD
 [`riscv64gc-unknown-openbsd`](platform-support/openbsd.md) | ✓ | ✓ | OpenBSD/riscv64
 [`riscv64-linux-android`](platform-support/android.md) | | | RISC-V 64-bit Android

src/doc/rustc/src/platform-support/riscv64gc-unknown-linux-musl.md

@@ -0,0 +1,47 @@
+# riscv64gc-unknown-linux-musl
+
+**Tier: 2**
+
+Target for RISC-V Linux programs using musl libc.
+
+## Target maintainers
+
+- [@Amanieu](https://github.com/Amanieu)
+- [@kraj](https://github.com/kraj)
+
+## Requirements
+
+Building the target itself requires a RISC-V compiler that is supported by `cc-rs`.
+
+## Building the target
+
+The target can be built by enabling it for a `rustc` build.
+
+```toml
+[build]
+target = ["riscv64gc-unknown-linux-musl"]
+```
+
+Make sure your C compiler is included in `$PATH`, then add it to the `config.toml`:
+
+```toml
+[target.riscv64gc-unknown-linux-musl]
+cc = "riscv64-linux-gnu-gcc"
+cxx = "riscv64-linux-gnu-g++"
+ar = "riscv64-linux-gnu-ar"
+linker = "riscv64-linux-gnu-gcc"
+```
+
+## Building Rust programs
+
+This target are distributed through `rustup`, and otherwise require no
+special configuration.
+
+## Cross-compilation
+
+This target can be cross-compiled from any host.
+
+## Testing
+
+This target can be tested as normal with `x.py` on a RISC-V host or via QEMU
+emulation.

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

@@ -141,6 +141,7 @@ static TARGETS: &[&str] = &[
  "riscv64gc-unknown-hermit",
  "riscv64gc-unknown-none-elf",
  "riscv64gc-unknown-linux-gnu",
+ "riscv64gc-unknown-linux-musl",
  "s390x-unknown-linux-gnu",
  "sparc64-unknown-linux-gnu",
  "sparcv9-sun-solaris",