Auto merge of rust-lang#3878 - rust-lang:rustup-2024-09-11, r=RalfJung

Automatic Rustup

compiler/rustc_builtin_macros/src/asm.rs

@@ -812,6 +812,44 @@ pub(super) fn expand_asm<'cx>(
  })
 }
 
+pub(super) fn expand_naked_asm<'cx>(
+ ecx: &'cx mut ExtCtxt<'_>,
+ sp: Span,
+ tts: TokenStream,
+) -> MacroExpanderResult<'cx> {
+ ExpandResult::Ready(match parse_args(ecx, sp, tts, false) {
+ Ok(args) => {
+ let ExpandResult::Ready(mac) = expand_preparsed_asm(ecx, args) else {
+ return ExpandResult::Retry(());
+ };
+ let expr = match mac {
+ Ok(mut inline_asm) => {
+ // for future compatibility, we always set the NORETURN option.
+ //
+ // When we turn `asm!` into `naked_asm!` with this implementation, we can drop
+ // the `options(noreturn)`, which makes the upgrade smooth when `naked_asm!`
+ // starts disallowing the `noreturn` option in the future
+ inline_asm.options |= ast::InlineAsmOptions::NORETURN;
+
+ P(ast::Expr {
+ id: ast::DUMMY_NODE_ID,
+ kind: ast::ExprKind::InlineAsm(P(inline_asm)),
+ span: sp,
+ attrs: ast::AttrVec::new(),
+ tokens: None,
+ })
+ }
+ Err(guar) => DummyResult::raw_expr(sp, Some(guar)),
+ };
+ MacEager::expr(expr)
+ }
+ Err(err) => {
+ let guar = err.emit();
+ DummyResult::any(sp, guar)
+ }
+ })
+}
+
 pub(super) fn expand_global_asm<'cx>(
  ecx: &'cx mut ExtCtxt<'_>,
  sp: Span,

compiler/rustc_builtin_macros/src/lib.rs

@@ -94,6 +94,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
  line: source_util::expand_line,
  log_syntax: log_syntax::expand_log_syntax,
  module_path: source_util::expand_mod,
+ naked_asm: asm::expand_naked_asm,
  option_env: env::expand_option_env,
  pattern_type: pattern_type::expand,
  std_panic: edition_panic::expand_panic,

compiler/rustc_builtin_macros/src/test_harness.rs

@@ -326,6 +326,8 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
  let main_attr = ecx.attr_word(sym::rustc_main, sp);
  // #[coverage(off)]
  let coverage_attr = ecx.attr_nested_word(sym::coverage, sym::off, sp);
+ // #[allow(missing_docs)]
+ let missing_docs_attr = ecx.attr_nested_word(sym::allow, sym::missing_docs, sp);
 
  // pub fn main() { ... }
  let main_ret_ty = ecx.ty(sp, ast::TyKind::Tup(ThinVec::new()));
@@ -355,7 +357,7 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
 
  let main = P(ast::Item {
  ident: main_id,
- attrs: thin_vec![main_attr, coverage_attr],
+ attrs: thin_vec![main_attr, coverage_attr, missing_docs_attr],
  id: ast::DUMMY_NODE_ID,
  kind: main,
  vis: ast::Visibility { span: sp, kind: ast::VisibilityKind::Public, tokens: None },

compiler/rustc_codegen_cranelift/example/float-minmax-pass.rs

@@ -9,13 +9,13 @@
 
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
-struct f32x4(pub f32, pub f32, pub f32, pub f32);
+struct f32x4(pub [f32; 4]);
 
 use std::intrinsics::simd::*;
 
 fn main() {
- let x = f32x4(1.0, 2.0, 3.0, 4.0);
- let y = f32x4(2.0, 1.0, 4.0, 3.0);
+ let x = f32x4([1.0, 2.0, 3.0, 4.0]);
+ let y = f32x4([2.0, 1.0, 4.0, 3.0]);
 
  #[cfg(not(any(target_arch = "mips", target_arch = "mips64")))]
  let nan = f32::NAN;
@@ -24,13 +24,13 @@ fn main() {
  #[cfg(any(target_arch = "mips", target_arch = "mips64"))]
  let nan = f32::from_bits(f32::NAN.to_bits() - 1);
 
- let n = f32x4(nan, nan, nan, nan);
+ let n = f32x4([nan, nan, nan, nan]);
 
  unsafe {
  let min0 = simd_fmin(x, y);
  let min1 = simd_fmin(y, x);
  assert_eq!(min0, min1);
- let e = f32x4(1.0, 1.0, 3.0, 3.0);
+ let e = f32x4([1.0, 1.0, 3.0, 3.0]);
  assert_eq!(min0, e);
  let minn = simd_fmin(x, n);
  assert_eq!(minn, x);
@@ -40,7 +40,7 @@ fn main() {
  let max0 = simd_fmax(x, y);
  let max1 = simd_fmax(y, x);
  assert_eq!(max0, max1);
- let e = f32x4(2.0, 2.0, 4.0, 4.0);
+ let e = f32x4([2.0, 2.0, 4.0, 4.0]);
  assert_eq!(max0, e);
  let maxn = simd_fmax(x, n);
  assert_eq!(maxn, x);

compiler/rustc_codegen_cranelift/example/std_example.rs

@@ -166,7 +166,7 @@ fn main() {
  enum Never {}
  }
 
- foo(I64X2(0, 0));
+ foo(I64X2([0, 0]));
 
  transmute_fat_pointer();
 
@@ -204,7 +204,7 @@ fn rust_call_abi() {
 }
 
 #[repr(simd)]
-struct I64X2(i64, i64);
+struct I64X2([i64; 2]);
 
 #[allow(improper_ctypes_definitions)]
 extern "C" fn foo(_a: I64X2) {}

compiler/rustc_codegen_gcc/src/back/lto.rs

@@ -272,7 +272,6 @@ fn fat_lto(
  }*/
  }
  };
- let mut serialized_bitcode = Vec::new();
  {
  info!("using {:?} as a base module", module.name);
 
@@ -317,7 +316,6 @@ fn fat_lto(
  unimplemented!("from uncompressed file")
  }
  }
- serialized_bitcode.push(bc_decoded);
  }
  save_temp_bitcode(cgcx, &module, "lto.input");
 
@@ -337,7 +335,7 @@ fn fat_lto(
  // of now.
  module.module_llvm.temp_dir = Some(tmp_path);
 
- Ok(LtoModuleCodegen::Fat { module, _serialized_bitcode: serialized_bitcode })
+ Ok(LtoModuleCodegen::Fat(module))
 }
 
 pub struct ModuleBuffer(PathBuf);

compiler/rustc_codegen_llvm/src/back/lto.rs

@@ -314,7 +314,6 @@ fn fat_lto(
  }
  }
  };
- let mut serialized_bitcode = Vec::new();
  {
  let (llcx, llmod) = {
  let llvm = &module.module_llvm;
@@ -342,9 +341,7 @@ fn fat_lto(
  serialized_modules.sort_by(|module1, module2| module1.1.cmp(&module2.1));
 
  // For all serialized bitcode files we parse them and link them in as we did
- // above, this is all mostly handled in C++. Like above, though, we don't
- // know much about the memory management here so we err on the side of being
- // save and persist everything with the original module.
+ // above, this is all mostly handled in C++.
  let mut linker = Linker::new(llmod);
  for (bc_decoded, name) in serialized_modules {
  let _timer = cgcx
@@ -355,7 +352,6 @@ fn fat_lto(
  info!("linking {:?}", name);
  let data = bc_decoded.data();
  linker.add(data).map_err(|()| write::llvm_err(dcx, LlvmError::LoadBitcode { name }))?;
- serialized_bitcode.push(bc_decoded);
  }
  drop(linker);
  save_temp_bitcode(cgcx, &module, "lto.input");
@@ -372,7 +368,7 @@ fn fat_lto(
  }
  }
 
- Ok(LtoModuleCodegen::Fat { module, _serialized_bitcode: serialized_bitcode })
+ Ok(LtoModuleCodegen::Fat(module))
 }
 
 pub(crate) struct Linker<'a>(&'a mut llvm::Linker<'a>);

compiler/rustc_codegen_ssa/src/back/lto.rs

@@ -41,18 +41,14 @@ pub struct ThinShared<B: WriteBackendMethods> {
 }
 
 pub enum LtoModuleCodegen<B: WriteBackendMethods> {
- Fat {
- module: ModuleCodegen<B::Module>,
- _serialized_bitcode: Vec<SerializedModule<B::ModuleBuffer>>,
- },
-
+ Fat(ModuleCodegen<B::Module>),
  Thin(ThinModule<B>),
 }
 
 impl<B: WriteBackendMethods> LtoModuleCodegen<B> {
  pub fn name(&self) -> &str {
  match *self {
- LtoModuleCodegen::Fat { .. } => "everything",
+ LtoModuleCodegen::Fat(_) => "everything",
  LtoModuleCodegen::Thin(ref m) => m.name(),
  }
  }
@@ -68,7 +64,7 @@ impl<B: WriteBackendMethods> LtoModuleCodegen<B> {
  cgcx: &CodegenContext<B>,
  ) -> Result<ModuleCodegen<B::Module>, FatalError> {
  match self {
- LtoModuleCodegen::Fat { mut module, .. } => {
+ LtoModuleCodegen::Fat(mut module) => {
  B::optimize_fat(cgcx, &mut module)?;
  Ok(module)
  }
@@ -81,7 +77,7 @@ impl<B: WriteBackendMethods> LtoModuleCodegen<B> {
  pub fn cost(&self) -> u64 {
  match *self {
  // Only one module with fat LTO, so the cost doesn't matter.
- LtoModuleCodegen::Fat { .. } => 0,
+ LtoModuleCodegen::Fat(_) => 0,
  LtoModuleCodegen::Thin(ref m) => m.cost(),
  }
  }

compiler/rustc_error_codes/src/error_codes/E0074.md

@@ -11,7 +11,7 @@ This will cause an error:
 #![feature(repr_simd)]
 
 #[repr(simd)]
-struct Bad<T>(T, T, T, T);
+struct Bad<T>([T; 4]);
 ```
 
 This will not:
@@ -20,5 +20,5 @@ This will not:
 #![feature(repr_simd)]
 
 #[repr(simd)]
-struct Good(u32, u32, u32, u32);
+struct Good([u32; 4]);
 ```

compiler/rustc_error_codes/src/error_codes/E0075.md

@@ -1,6 +1,6 @@
-A `#[simd]` attribute was applied to an empty tuple struct.
+A `#[simd]` attribute was applied to an empty or multi-field struct.
 
-Erroneous code example:
+Erroneous code examples:
 
 ```compile_fail,E0075
 #![feature(repr_simd)]
@@ -9,15 +9,21 @@ Erroneous code example:
 struct Bad; // error!
 ```
 
-The `#[simd]` attribute can only be applied to non empty tuple structs, because
-it doesn't make sense to try to use SIMD operations when there are no values to
-operate on.
+```compile_fail,E0075
+#![feature(repr_simd)]
+
+#[repr(simd)]
+struct Bad([u32; 1], [u32; 1]); // error!
+```
+
+The `#[simd]` attribute can only be applied to a single-field struct, because
+the one field must be the array of values in the vector.
 
 Fixed example:
 
 ```
 #![feature(repr_simd)]
 
 #[repr(simd)]
-struct Good(u32); // ok!
+struct Good([u32; 2]); // ok!
 ```

compiler/rustc_error_codes/src/error_codes/E0076.md

@@ -1,4 +1,4 @@
-All types in a tuple struct aren't the same when using the `#[simd]`
+The type of the field in a tuple struct isn't an array when using the `#[simd]`
 attribute.
 
 Erroneous code example:
@@ -7,18 +7,18 @@ Erroneous code example:
 #![feature(repr_simd)]
 
 #[repr(simd)]
-struct Bad(u16, u32, u32 u32); // error!
+struct Bad(u16); // error!
 ```
 
 When using the `#[simd]` attribute to automatically use SIMD operations in tuple
-struct, the types in the struct must all be of the same type, or the compiler
-will trigger this error.
+structs, if you want a single-lane vector then the field must be a 1-element
+array, or the compiler will trigger this error.
 
 Fixed example:
 
 ```
 #![feature(repr_simd)]
 
 #[repr(simd)]
-struct Good(u32, u32, u32, u32); // ok!
+struct Good([u16; 1]); // ok!
 ```

compiler/rustc_error_codes/src/error_codes/E0077.md

@@ -7,7 +7,7 @@ Erroneous code example:
 #![feature(repr_simd)]
 
 #[repr(simd)]
-struct Bad(String); // error!
+struct Bad([String; 2]); // error!
 ```
 
 When using the `#[simd]` attribute on a tuple struct, the elements in the tuple
@@ -19,5 +19,5 @@ Fixed example:
 #![feature(repr_simd)]
 
 #[repr(simd)]
-struct Good(u32, u32, u32, u32); // ok!
+struct Good([u32; 4]); // ok!
 ```

compiler/rustc_error_codes/src/error_codes/E0511.md

@@ -23,11 +23,11 @@ The generic type has to be a SIMD type. Example:
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
-struct i32x2(i32, i32);
+struct i32x2([i32; 2]);
 
 extern "rust-intrinsic" {
  fn simd_add<T>(a: T, b: T) -> T;
 }
 
-unsafe { simd_add(i32x2(0, 0), i32x2(1, 2)); } // ok!
+unsafe { simd_add(i32x2([0, 0]), i32x2([1, 2])); } // ok!
 ```

compiler/rustc_hir/src/hir.rs

@@ -168,6 +168,19 @@ impl Lifetime {
  (LifetimeSuggestionPosition::Normal, self.ident.span)
  }
  }
+
+ pub fn suggestion(&self, new_lifetime: &str) -> (Span, String) {
+ debug_assert!(new_lifetime.starts_with('\''));
+ let (pos, span) = self.suggestion_position();
+ let code = match pos {
+ LifetimeSuggestionPosition::Normal => format!("{new_lifetime}"),
+ LifetimeSuggestionPosition::Ampersand => format!("{new_lifetime} "),
+ LifetimeSuggestionPosition::ElidedPath => format!("<{new_lifetime}>"),
+ LifetimeSuggestionPosition::ElidedPathArgument => format!("{new_lifetime}, "),
+ LifetimeSuggestionPosition::ObjectDefault => format!("+ {new_lifetime}"),
+ };
+ (span, code)
+ }
 }
 
 /// A `Path` is essentially Rust's notion of a name; for instance,