Merge pull request rust-lang#450 from rust-lang/sync_from_rust_2024_0…

…2_20

Sync from rust 2024/02/20

build_system/src/prepare.rs

@@ -159,21 +159,6 @@ where
  let repo_path = Path::new(crate::BUILD_DIR).join(&clone_result.repo_name);
  run_command(&[&"git", &"checkout", &"--", &"."], Some(&repo_path))?;
  run_command(&[&"git", &"checkout", &checkout_commit], Some(&repo_path))?;
- let filter = format!("-{}-", clone_result.repo_name);
- walk_dir(
- "patches/crate_patches",
- |_| Ok(()),
- |file_path| {
- let patch = file_path.as_os_str().to_str().unwrap();
- if patch.contains(&filter) && patch.ends_with(".patch") {
- run_command_with_output(
- &[&"git", &"am", &file_path.canonicalize().unwrap()],
- Some(&repo_path),
- )?;
- }
- Ok(())
- },
- )?;
  if let Some(extra) = extra {
  extra(&repo_path)?;
  }
@@ -238,7 +223,7 @@ pub fn run() -> Result<(), String> {
  let to_clone = &[
  (
  "https://github.com/rust-random/rand.git",
- "0f933f9c7176e53b2a3c7952ded484e1783f0bf1",
+ "1f4507a8e1cf8050e4ceef95eeda8f64645b6719",
  None,
  ),
  (

example/mini_core.rs

@@ -4,7 +4,7 @@
  thread_local
 )]
 #![no_core]
-#![allow(dead_code, internal_features)]
+#![allow(dead_code, internal_features, ambiguous_wide_pointer_comparisons)]
 
 #[no_mangle]
 unsafe extern "C" fn _Unwind_Resume() {
@@ -100,9 +100,6 @@ unsafe impl<T: ?Sized> Freeze for &mut T {}
 #[lang = "structural_peq"]
 pub trait StructuralPartialEq {}
 
-#[lang = "structural_teq"]
-pub trait StructuralEq {}
-
 #[lang = "not"]
 pub trait Not {
  type Output;

example/mini_core_hello_world.rs

@@ -98,6 +98,9 @@ fn start<T: Termination + 'static>(
 }
 
 static mut NUM: u8 = 6 * 7;
+
+// FIXME: Use `SyncUnsafeCell` instead of allowing `static_mut_refs` lint
+#[allow(static_mut_refs)]
 static NUM_REF: &'static u8 = unsafe { &NUM };
 
 macro_rules! assert {

example/std_example.rs

@@ -1,3 +1,4 @@
+#![allow(internal_features)]
 #![feature(core_intrinsics, coroutines, coroutine_trait, is_sorted)]
 
 #[cfg(feature="master")]

patches/0022-core-Disable-not-compiling-tests.patch

@@ -39,6 +39,4 @@ index 42a26ae..5ac1042 100644
 +#![cfg(test)]
  #![feature(alloc_layout_extra)]
  #![feature(array_chunks)]
- #![feature(array_methods)]
---
-2.21.0 (Apple Git-122)
+ #![feature(array_windows)]

patches/cross_patches/0001-Disable-libstd-and-libtest-dylib.patch

@@ -21,19 +21,3 @@ index 5b21355..cb0c49b 100644
 
  [dependencies]
  alloc = { path = "../alloc", public = true }
-diff --git a/library/test/Cargo.toml b/library/test/Cargo.toml
-index 91a1abd..a58c160 100644
---- a/library/test/Cargo.toml
-+++ b/library/test/Cargo.toml
-@@ -4,7 +4,7 @@ version = "0.0.0"
- edition = "2021"
-
- [lib]
--crate-type = ["dylib", "rlib"]
-+crate-type = ["rlib"]
-
- [dependencies]
- getopts = { version = "0.2.21", features = ['rustc-dep-of-std'] }
--- 
-2.42.0
-

rust-toolchain

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2023-11-17"
+channel = "nightly-2024-02-20"
 components = ["rust-src", "rustc-dev", "llvm-tools-preview"]

src/allocator.rs

@@ -90,7 +90,7 @@ fn create_wrapper_function(
  .collect();
  let func = context.new_function(None, FunctionType::Exported, output.unwrap_or(void), &args, from_name, false);
 
- if tcx.sess.target.options.default_hidden_visibility {
+ if tcx.sess.default_hidden_visibility() {
  #[cfg(feature="master")]
  func.add_attribute(FnAttribute::Visibility(gccjit::Visibility::Hidden));
  }

src/asm.rs

@@ -109,7 +109,7 @@ enum ConstraintOrRegister {
 impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
  fn codegen_inline_asm(&mut self, template: &[InlineAsmTemplatePiece], rust_operands: &[InlineAsmOperandRef<'tcx, Self>], options: InlineAsmOptions, span: &[Span], instance: Instance<'_>, _dest_catch_funclet: Option<(Self::BasicBlock, Self::BasicBlock, Option<&Self::Funclet>)>) {
  if options.contains(InlineAsmOptions::MAY_UNWIND) {
- self.sess()
+ self.sess().dcx()
  .create_err(UnwindingInlineAsm { span: span[0] })
  .emit();
  return;
@@ -634,6 +634,7 @@ fn reg_to_gcc(reg: InlineAsmRegOrRegClass) -> ConstraintOrRegister {
  }
  InlineAsmRegClass::Wasm(WasmInlineAsmRegClass::local) => "r",
  InlineAsmRegClass::S390x(S390xInlineAsmRegClass::reg) => "r",
+ InlineAsmRegClass::S390x(S390xInlineAsmRegClass::reg_addr) => "a",
  InlineAsmRegClass::S390x(S390xInlineAsmRegClass::freg) => "f",
  InlineAsmRegClass::Err => unreachable!(),
  }
@@ -704,7 +705,9 @@ fn dummy_output_type<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, reg: InlineAsmRegCl
  InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
  bug!("LLVM backend does not support SPIR-V")
  },
- InlineAsmRegClass::S390x(S390xInlineAsmRegClass::reg) => cx.type_i32(),
+ InlineAsmRegClass::S390x(
+ S390xInlineAsmRegClass::reg | S390xInlineAsmRegClass::reg_addr
+ ) => cx.type_i32(),
  InlineAsmRegClass::S390x(S390xInlineAsmRegClass::freg) => cx.type_f64(),
  InlineAsmRegClass::Err => unreachable!(),
  }

src/attributes.rs

@@ -62,9 +62,6 @@ pub fn from_fn_attrs<'gcc, 'tcx>(
  if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::COLD) {
  func.add_attribute(FnAttribute::Cold);
  }
- if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::FFI_RETURNS_TWICE) {
- func.add_attribute(FnAttribute::ReturnsTwice);
- }
  if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::FFI_PURE) {
  func.add_attribute(FnAttribute::Pure);
  }
@@ -80,7 +77,7 @@ pub fn from_fn_attrs<'gcc, 'tcx>(
  let span = cx.tcx
  .get_attr(instance.def_id(), sym::target_feature)
  .map_or_else(|| cx.tcx.def_span(instance.def_id()), |a| a.span);
- cx.tcx.sess.create_err(TiedTargetFeatures {
+ cx.tcx.dcx().create_err(TiedTargetFeatures {
  features: features.join(", "),
  span,
  })

src/back/lto.rs

@@ -30,7 +30,7 @@ use rustc_codegen_ssa::back::write::{CodegenContext, FatLtoInput};
 use rustc_codegen_ssa::traits::*;
 use rustc_codegen_ssa::{looks_like_rust_object_file, ModuleCodegen, ModuleKind};
 use rustc_data_structures::memmap::Mmap;
-use rustc_errors::{FatalError, Handler};
+use rustc_errors::{FatalError, DiagCtxt};
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_middle::dep_graph::WorkProduct;
 use rustc_middle::middle::exported_symbols::{SymbolExportInfo, SymbolExportLevel};
@@ -61,7 +61,7 @@ struct LtoData {
  tmp_path: TempDir,
 }
 
-fn prepare_lto(cgcx: &CodegenContext<GccCodegenBackend>, diag_handler: &Handler) -> Result<LtoData, FatalError> {
+fn prepare_lto(cgcx: &CodegenContext<GccCodegenBackend>, dcx: &DiagCtxt) -> Result<LtoData, FatalError> {
  let export_threshold = match cgcx.lto {
  // We're just doing LTO for our one crate
  Lto::ThinLocal => SymbolExportLevel::Rust,
@@ -106,18 +106,18 @@ fn prepare_lto(cgcx: &CodegenContext<GccCodegenBackend>, diag_handler: &Handler)
  // Make sure we actually can run LTO
  for crate_type in cgcx.crate_types.iter() {
  if !crate_type_allows_lto(*crate_type) {
- diag_handler.emit_err(LtoDisallowed);
+ dcx.emit_err(LtoDisallowed);
  return Err(FatalError);
  } else if *crate_type == CrateType::Dylib {
  if !cgcx.opts.unstable_opts.dylib_lto {
- diag_handler.emit_err(LtoDylib);
+ dcx.emit_err(LtoDylib);
  return Err(FatalError);
  }
  }
  }
 
  if cgcx.opts.cg.prefer_dynamic && !cgcx.opts.unstable_opts.dylib_lto {
- diag_handler.emit_err(DynamicLinkingWithLTO);
+ dcx.emit_err(DynamicLinkingWithLTO);
  return Err(FatalError);
  }
 
@@ -154,7 +154,7 @@ fn prepare_lto(cgcx: &CodegenContext<GccCodegenBackend>, diag_handler: &Handler)
  upstream_modules.push((module, CString::new(name).unwrap()));
  }
  Err(e) => {
- diag_handler.emit_err(e);
+ dcx.emit_err(e);
  return Err(FatalError);
  }
  }
@@ -183,16 +183,16 @@ pub(crate) fn run_fat(
  modules: Vec<FatLtoInput<GccCodegenBackend>>,
  cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
 ) -> Result<LtoModuleCodegen<GccCodegenBackend>, FatalError> {
- let diag_handler = cgcx.create_diag_handler();
- let lto_data = prepare_lto(cgcx, &diag_handler)?;
+ let dcx = cgcx.create_dcx();
+ let lto_data = prepare_lto(cgcx, &dcx)?;
  /*let symbols_below_threshold =
  lto_data.symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::<Vec<_>>();*/
- fat_lto(cgcx, &diag_handler, modules, cached_modules, lto_data.upstream_modules, lto_data.tmp_path,
+ fat_lto(cgcx, &dcx, modules, cached_modules, lto_data.upstream_modules, lto_data.tmp_path,
  //&symbols_below_threshold,
  )
 }
 
-fn fat_lto(cgcx: &CodegenContext<GccCodegenBackend>, _diag_handler: &Handler, modules: Vec<FatLtoInput<GccCodegenBackend>>, cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>, mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>, tmp_path: TempDir,
+fn fat_lto(cgcx: &CodegenContext<GccCodegenBackend>, _dcx: &DiagCtxt, modules: Vec<FatLtoInput<GccCodegenBackend>>, cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>, mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>, tmp_path: TempDir,
  //symbols_below_threshold: &[*const libc::c_char],
 ) -> Result<LtoModuleCodegen<GccCodegenBackend>, FatalError> {
  let _timer = cgcx.prof.generic_activity("GCC_fat_lto_build_monolithic_module");
@@ -257,7 +257,7 @@ fn fat_lto(cgcx: &CodegenContext<GccCodegenBackend>, _diag_handler: &Handler, mo
  let (buffer, name) = serialized_modules.remove(0);
  info!("no in-memory regular modules to choose from, parsing {:?}", name);
  ModuleCodegen {
- module_llvm: GccContext::parse(cgcx, &name, buffer.data(), diag_handler)?,
+ module_llvm: GccContext::parse(cgcx, &name, buffer.data(), dcx)?,
  name: name.into_string().unwrap(),
  kind: ModuleKind::Regular,
  }*/

src/back/write.rs

@@ -4,7 +4,7 @@ use gccjit::OutputKind;
 use rustc_codegen_ssa::{CompiledModule, ModuleCodegen};
 use rustc_codegen_ssa::back::link::ensure_removed;
 use rustc_codegen_ssa::back::write::{BitcodeSection, CodegenContext, EmitObj, ModuleConfig};
-use rustc_errors::Handler;
+use rustc_errors::DiagCtxt;
 use rustc_fs_util::link_or_copy;
 use rustc_session::config::OutputType;
 use rustc_span::fatal_error::FatalError;
@@ -13,7 +13,7 @@ use rustc_target::spec::SplitDebuginfo;
 use crate::{GccCodegenBackend, GccContext};
 use crate::errors::CopyBitcode;
 
-pub(crate) unsafe fn codegen(cgcx: &CodegenContext<GccCodegenBackend>, diag_handler: &Handler, module: ModuleCodegen<GccContext>, config: &ModuleConfig) -> Result<CompiledModule, FatalError> {
+pub(crate) unsafe fn codegen(cgcx: &CodegenContext<GccCodegenBackend>, dcx: &DiagCtxt, module: ModuleCodegen<GccContext>, config: &ModuleConfig) -> Result<CompiledModule, FatalError> {
  let _timer = cgcx.prof.generic_activity_with_arg("GCC_module_codegen", &*module.name);
  {
  let context = &module.module_llvm.context;
@@ -128,12 +128,12 @@ pub(crate) unsafe fn codegen(cgcx: &CodegenContext<GccCodegenBackend>, diag_hand
  EmitObj::Bitcode => {
  debug!("copying bitcode {:?} to obj {:?}", bc_out, obj_out);
  if let Err(err) = link_or_copy(&bc_out, &obj_out) {
- diag_handler.emit_err(CopyBitcode { err });
+ dcx.emit_err(CopyBitcode { err });
  }
 
  if !config.emit_bc {
  debug!("removing_bitcode {:?}", bc_out);
- ensure_removed(diag_handler, &bc_out);
+ ensure_removed(dcx, &bc_out);
  }
  }
 
@@ -149,7 +149,7 @@ pub(crate) unsafe fn codegen(cgcx: &CodegenContext<GccCodegenBackend>, diag_hand
  ))
 }
 
-pub(crate) fn link(_cgcx: &CodegenContext<GccCodegenBackend>, _diag_handler: &Handler, mut _modules: Vec<ModuleCodegen<GccContext>>) -> Result<ModuleCodegen<GccContext>, FatalError> {
+pub(crate) fn link(_cgcx: &CodegenContext<GccCodegenBackend>, _dcx: &DiagCtxt, mut _modules: Vec<ModuleCodegen<GccContext>>) -> Result<ModuleCodegen<GccContext>, FatalError> {
  unimplemented!();
 }
 

src/builder.rs

@@ -1313,7 +1313,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
  }
 
  // Atomic Operations
- fn atomic_cmpxchg(&mut self, dst: RValue<'gcc>, cmp: RValue<'gcc>, src: RValue<'gcc>, order: AtomicOrdering, failure_order: AtomicOrdering, weak: bool) -> RValue<'gcc> {
+ fn atomic_cmpxchg(&mut self, dst: RValue<'gcc>, cmp: RValue<'gcc>, src: RValue<'gcc>, order: AtomicOrdering, failure_order: AtomicOrdering, weak: bool) -> (RValue<'gcc>, RValue<'gcc>) {
  let expected = self.current_func().new_local(None, cmp.get_type(), "expected");
  self.llbb().add_assignment(None, expected, cmp);
  // NOTE: gcc doesn't support a failure memory model that is stronger than the success
@@ -1327,20 +1327,12 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
  };
  let success = self.compare_exchange(dst, expected, src, order, failure_order, weak);
 
- let pair_type = self.cx.type_struct(&[src.get_type(), self.bool_type], false);
- let result = self.current_func().new_local(None, pair_type, "atomic_cmpxchg_result");
- let align = Align::from_bits(64).expect("align"); // TODO(antoyo): use good align.
+ // NOTE: since success contains the call to the intrinsic, it must be added to the basic block before
+ // expected so that we store expected after the call.
+ let success_var = self.current_func().new_local(None, self.bool_type, "success");
+ self.llbb().add_assignment(None, success_var, success);
 
- let value_type = result.to_rvalue().get_type();
- if let Some(struct_type) = value_type.is_struct() {
- self.store(success, result.access_field(None, struct_type.get_field(1)).get_address(None), align);
- // NOTE: since success contains the call to the intrinsic, it must be stored before
- // expected so that we store expected after the call.
- self.store(expected.to_rvalue(), result.access_field(None, struct_type.get_field(0)).get_address(None), align);
- }
- // TODO(antoyo): handle when value is not a struct.
-
- result.to_rvalue()
+ (expected.to_rvalue(), success_var.to_rvalue())
  }
 
  fn atomic_rmw(&mut self, op: AtomicRmwBinOp, dst: RValue<'gcc>, src: RValue<'gcc>, order: AtomicOrdering) -> RValue<'gcc> {

src/common.rs

@@ -199,7 +199,8 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
  }
  }
  Scalar::Ptr(ptr, _size) => {
- let (alloc_id, offset) = ptr.into_parts();
+ let (prov, offset) = ptr.into_parts(); // we know the `offset` is relative
+ let alloc_id = prov.alloc_id();
  let base_addr =
  match self.tcx.global_alloc(alloc_id) {
  GlobalAlloc::Memory(alloc) => {
@@ -376,9 +377,6 @@ pub trait TypeReflection<'gcc, 'tcx> {
  fn is_i128(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
  fn is_u128(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
 
- fn is_f32(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
- fn is_f64(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
-
  fn is_vector(&self) -> bool;
 }
 
@@ -463,14 +461,6 @@ impl<'gcc, 'tcx> TypeReflection<'gcc, 'tcx> for Type<'gcc> {
  self.unqualified() == cx.u128_type.unqualified()
  }
 
- fn is_f32(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
- self.unqualified() == cx.context.new_type::<f32>()
- }
-
- fn is_f64(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
- self.unqualified() == cx.context.new_type::<f64>()
- }
-
  fn is_vector(&self) -> bool {
  let mut typ = self.clone();
  loop {