Auto merge of rust-lang#127067 - matthiaskrgr:rollup-85ecygb, r=matth…

…iaskrgr

Rollup of 6 pull requests

Successful merges:

 - rust-lang#124741 (patchable-function-entry: Add unstable compiler flag and attribute)
 - rust-lang#126470 (make cargo submodule optional)
 - rust-lang#126701 (ignore `llvm::Lld` if lld is not enabled)
 - rust-lang#126956 (core: avoid `extern type`s in formatting infrastructure)
 - rust-lang#126970 (Simplify `str::clone_into`)
 - rust-lang#127058 (Tighten `fn_decl_span` for async blocks)

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

compiler/rustc_ast/src/ast.rs

@@ -1454,7 +1454,10 @@ pub enum ExprKind {
  Block(P<Block>, Option<Label>),
  /// An `async` block (`async move { ... }`),
  /// or a `gen` block (`gen move { ... }`)
- Gen(CaptureBy, P<Block>, GenBlockKind),
+ ///
+ /// The span is the "decl", which is the header before the body `{ }`
+ /// including the `asyng`/`gen` keywords and possibly `move`.
+ Gen(CaptureBy, P<Block>, GenBlockKind, Span),
  /// An await expression (`my_future.await`). Span is of await keyword.
  Await(P<Expr>, Span),
 

compiler/rustc_ast/src/mut_visit.rs

@@ -1528,8 +1528,9 @@ pub fn noop_visit_expr<T: MutVisitor>(
  visit_opt(label, |label| vis.visit_label(label));
  vis.visit_block(blk);
  }
- ExprKind::Gen(_capture_by, body, _kind) => {
+ ExprKind::Gen(_capture_by, body, _kind, decl_span) => {
  vis.visit_block(body);
+ vis.visit_span(decl_span);
  }
  ExprKind::Await(expr, await_kw_span) => {
  vis.visit_expr(expr);

compiler/rustc_ast/src/visit.rs

@@ -1122,7 +1122,7 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) -> V
  visit_opt!(visitor, visit_label, opt_label);
  try_visit!(visitor.visit_block(block));
  }
- ExprKind::Gen(_capt, body, _kind) => try_visit!(visitor.visit_block(body)),
+ ExprKind::Gen(_capt, body, _kind, _decl_span) => try_visit!(visitor.visit_block(body)),
  ExprKind::Await(expr, _span) => try_visit!(visitor.visit_expr(expr)),
  ExprKind::Assign(lhs, rhs, _span) => {
  try_visit!(visitor.visit_expr(lhs));

compiler/rustc_ast_lowering/src/expr.rs

@@ -227,7 +227,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  *fn_arg_span,
  ),
  },
- ExprKind::Gen(capture_clause, block, genblock_kind) => {
+ ExprKind::Gen(capture_clause, block, genblock_kind, decl_span) => {
  let desugaring_kind = match genblock_kind {
  GenBlockKind::Async => hir::CoroutineDesugaring::Async,
  GenBlockKind::Gen => hir::CoroutineDesugaring::Gen,
@@ -237,6 +237,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  *capture_clause,
  e.id,
  None,
+ *decl_span,
  e.span,
  desugaring_kind,
  hir::CoroutineSource::Block,
@@ -616,6 +617,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  capture_clause: CaptureBy,
  closure_node_id: NodeId,
  return_ty: Option<hir::FnRetTy<'hir>>,
+ fn_decl_span: Span,
  span: Span,
  desugaring_kind: hir::CoroutineDesugaring,
  coroutine_source: hir::CoroutineSource,
@@ -692,7 +694,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  bound_generic_params: &[],
  fn_decl,
  body,
- fn_decl_span: self.lower_span(span),
+ fn_decl_span: self.lower_span(fn_decl_span),
  fn_arg_span: None,
  kind: hir::ClosureKind::Coroutine(coroutine_kind),
  constness: hir::Constness::NotConst,
@@ -1083,6 +1085,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  let (parameters, expr) = this.lower_coroutine_body_with_moved_arguments(
  &inner_decl,
  |this| this.with_new_scopes(fn_decl_span, |this| this.lower_expr_mut(body)),
+ fn_decl_span,
  body.span,
  coroutine_kind,
  hir::CoroutineSource::Closure,

compiler/rustc_ast_lowering/src/item.rs

@@ -211,6 +211,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  // declaration (decl), not the return types.
  let coroutine_kind = header.coroutine_kind;
  let body_id = this.lower_maybe_coroutine_body(
+ *fn_sig_span,
  span,
  hir_id,
  decl,
@@ -799,6 +800,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  }
  AssocItemKind::Fn(box Fn { sig, generics, body: Some(body), .. }) => {
  let body_id = self.lower_maybe_coroutine_body(
+ sig.span,
  i.span,
  hir_id,
  &sig.decl,
@@ -915,6 +917,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  ),
  AssocItemKind::Fn(box Fn { sig, generics, body, .. }) => {
  let body_id = self.lower_maybe_coroutine_body(
+ sig.span,
  i.span,
  hir_id,
  &sig.decl,
@@ -1111,6 +1114,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  /// `gen {}` block as appropriate.
  fn lower_maybe_coroutine_body(
  &mut self,
+ fn_decl_span: Span,
  span: Span,
  fn_id: hir::HirId,
  decl: &FnDecl,
@@ -1124,6 +1128,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  let (parameters, expr) = this.lower_coroutine_body_with_moved_arguments(
  decl,
  |this| this.lower_block_expr(body),
+ fn_decl_span,
  body.span,
  coroutine_kind,
  hir::CoroutineSource::Fn,
@@ -1145,6 +1150,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  &mut self,
  decl: &FnDecl,
  lower_body: impl FnOnce(&mut LoweringContext<'_, 'hir>) -> hir::Expr<'hir>,
+ fn_decl_span: Span,
  body_span: Span,
  coroutine_kind: CoroutineKind,
  coroutine_source: hir::CoroutineSource,
@@ -1315,13 +1321,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
  };
  let closure_id = coroutine_kind.closure_id();
 
- let span = if let FnRetTy::Default(span) = decl.output
- && matches!(coroutine_source, rustc_hir::CoroutineSource::Closure)
- {
- body_span.with_lo(span.lo())
- } else {
- body_span
- };
  let coroutine_expr = self.make_desugared_coroutine_expr(
  // The default capture mode here is by-ref. Later on during upvar analysis,
  // we will force the captured arguments to by-move, but for async closures,
@@ -1330,7 +1329,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
  CaptureBy::Ref,
  closure_id,
  None,
- span,
+ fn_decl_span,
+ body_span,
  desugaring_kind,
  coroutine_source,
  mkbody,

compiler/rustc_ast_pretty/src/pprust/state/expr.rs

@@ -540,7 +540,7 @@ impl<'a> State<'a> {
  self.ibox(0);
  self.print_block_with_attrs(blk, attrs);
  }
- ast::ExprKind::Gen(capture_clause, blk, kind) => {
+ ast::ExprKind::Gen(capture_clause, blk, kind, _decl_span) => {
  self.word_nbsp(kind.modifier());
  self.print_capture_clause(*capture_clause);
  // cbox/ibox in analogy to the `ExprKind::Block` arm above

compiler/rustc_builtin_macros/src/assert/context.rs

@@ -298,7 +298,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
  // sync with the `rfc-2011-nicer-assert-messages/all-expr-kinds.rs` test.
  ExprKind::Assign(_, _, _)
  | ExprKind::AssignOp(_, _, _)
- | ExprKind::Gen(_, _, _)
+ | ExprKind::Gen(_, _, _, _)
  | ExprKind::Await(_, _)
  | ExprKind::Block(_, _)
  | ExprKind::Break(_, _)

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -2,7 +2,7 @@
 
 use rustc_codegen_ssa::traits::*;
 use rustc_hir::def_id::DefId;
-use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
+use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, PatchableFunctionEntry};
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_session::config::{FunctionReturn, OptLevel};
 use rustc_span::symbol::sym;
@@ -53,6 +53,34 @@ fn inline_attr<'ll>(cx: &CodegenCx<'ll, '_>, inline: InlineAttr) -> Option<&'ll
  }
 }
 
+#[inline]
+fn patchable_function_entry_attrs<'ll>(
+ cx: &CodegenCx<'ll, '_>,
+ attr: Option<PatchableFunctionEntry>,
+) -> SmallVec<[&'ll Attribute; 2]> {
+ let mut attrs = SmallVec::new();
+ let patchable_spec = attr.unwrap_or_else(|| {
+ PatchableFunctionEntry::from_config(cx.tcx.sess.opts.unstable_opts.patchable_function_entry)
+ });
+ let entry = patchable_spec.entry();
+ let prefix = patchable_spec.prefix();
+ if entry > 0 {
+ attrs.push(llvm::CreateAttrStringValue(
+ cx.llcx,
+ "patchable-function-entry",
+ &format!("{}", entry),
+ ));
+ }
+ if prefix > 0 {
+ attrs.push(llvm::CreateAttrStringValue(
+ cx.llcx,
+ "patchable-function-prefix",
+ &format!("{}", prefix),
+ ));
+ }
+ attrs
+}
+
 /// Get LLVM sanitize attributes.
 #[inline]
 pub fn sanitize_attrs<'ll>(
@@ -421,6 +449,7 @@ pub fn from_fn_attrs<'ll, 'tcx>(
  llvm::set_alignment(llfn, align);
  }
  to_add.extend(sanitize_attrs(cx, codegen_fn_attrs.no_sanitize));
+ to_add.extend(patchable_function_entry_attrs(cx, codegen_fn_attrs.patchable_function_entry));
 
  // Always annotate functions with the target-cpu they are compiled for.
  // Without this, ThinLTO won't inline Rust functions into Clang generated

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -1,11 +1,13 @@
 use rustc_ast::{ast, attr, MetaItemKind, NestedMetaItem};
 use rustc_attr::{list_contains_name, InlineAttr, InstructionSetAttr, OptimizeAttr};
-use rustc_errors::{codes::*, struct_span_code_err};
+use rustc_errors::{codes::*, struct_span_code_err, DiagMessage, SubdiagMessage};
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId, LOCAL_CRATE};
 use rustc_hir::{lang_items, weak_lang_items::WEAK_LANG_ITEMS, LangItem};
-use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs};
+use rustc_middle::middle::codegen_fn_attrs::{
+ CodegenFnAttrFlags, CodegenFnAttrs, PatchableFunctionEntry,
+};
 use rustc_middle::mir::mono::Linkage;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::{self as ty, TyCtxt};
@@ -447,6 +449,80 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
  None
  };
  }
+ sym::patchable_function_entry => {
+ codegen_fn_attrs.patchable_function_entry = attr.meta_item_list().and_then(|l| {
+ let mut prefix = None;
+ let mut entry = None;
+ for item in l {
+ let Some(meta_item) = item.meta_item() else {
+ tcx.dcx().span_err(item.span(), "expected name value pair");
+ continue;
+ };
+
+ let Some(name_value_lit) = meta_item.name_value_literal() else {
+ tcx.dcx().span_err(item.span(), "expected name value pair");
+ continue;
+ };
+
+ fn emit_error_with_label(
+ tcx: TyCtxt<'_>,
+ span: Span,
+ error: impl Into<DiagMessage>,
+ label: impl Into<SubdiagMessage>,
+ ) {
+ let mut err: rustc_errors::Diag<'_, _> =
+ tcx.dcx().struct_span_err(span, error);
+ err.span_label(span, label);
+ err.emit();
+ }
+
+ let attrib_to_write = match meta_item.name_or_empty() {
+ sym::prefix_nops => &mut prefix,
+ sym::entry_nops => &mut entry,
+ _ => {
+ emit_error_with_label(
+ tcx,
+ item.span(),
+ "unexpected parameter name",
+ format!("expected {} or {}", sym::prefix_nops, sym::entry_nops),
+ );
+ continue;
+ }
+ };
+
+ let rustc_ast::LitKind::Int(val, _) = name_value_lit.kind else {
+ emit_error_with_label(
+ tcx,
+ name_value_lit.span,
+ "invalid literal value",
+ "value must be an integer between `0` and `255`",
+ );
+ continue;
+ };
+
+ let Ok(val) = val.get().try_into() else {
+ emit_error_with_label(
+ tcx,
+ name_value_lit.span,
+ "integer value out of range",
+ "value must be between `0` and `255`",
+ );
+ continue;
+ };
+
+ *attrib_to_write = Some(val);
+ }
+
+ if let (None, None) = (prefix, entry) {
+ tcx.dcx().span_err(attr.span, "must specify at least one parameter");
+ }
+
+ Some(PatchableFunctionEntry::from_prefix_and_entry(
+ prefix.unwrap_or(0),
+ entry.unwrap_or(0),
+ ))
+ })
+ }
  _ => {}
  }
  }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -585,6 +585,13 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
  EncodeCrossCrate::No, derive_smart_pointer, experimental!(pointee)
  ),
 
+ // RFC 3543
+ // `#[patchable_function_entry(prefix_nops = m, entry_nops = n)]`
+ gated!(
+ patchable_function_entry, Normal, template!(List: "prefix_nops = m, entry_nops = n"), ErrorPreceding,
+ EncodeCrossCrate::Yes, experimental!(patchable_function_entry)
+ ),
+
  // ==========================================================================
  // Internal attributes: Stability, deprecation, and unsafe:
  // ==========================================================================

compiler/rustc_feature/src/unstable.rs

@@ -563,6 +563,8 @@ declare_features! (
  (unstable, offset_of_slice, "CURRENT_RUSTC_VERSION", Some(126151)),
  /// Allows using `#[optimize(X)]`.
  (unstable, optimize_attribute, "1.34.0", Some(54882)),
+ /// Allows specifying nop padding on functions for dynamic patching.
+ (unstable, patchable_function_entry, "CURRENT_RUSTC_VERSION", Some(123115)),
  /// Allows postfix match `expr.match { ... }`
  (unstable, postfix_match, "1.79.0", Some(121618)),
  /// Allows `use<'a, 'b, A, B>` in `impl Trait + use<...>` for precise capture of generic args.

compiler/rustc_interface/src/tests.rs

@@ -8,8 +8,8 @@ use rustc_session::config::{
  ErrorOutputType, ExternEntry, ExternLocation, Externs, FunctionReturn, InliningThreshold,
  Input, InstrumentCoverage, InstrumentXRay, LinkSelfContained, LinkerPluginLto, LocationDetail,
  LtoCli, NextSolverConfig, OomStrategy, Options, OutFileName, OutputType, OutputTypes, PAuthKey,
- PacRet, Passes, Polonius, ProcMacroExecutionStrategy, Strip, SwitchWithOptPath,
- SymbolManglingVersion, WasiExecModel,
+ PacRet, Passes, PatchableFunctionEntry, Polonius, ProcMacroExecutionStrategy, Strip,
+ SwitchWithOptPath, SymbolManglingVersion, WasiExecModel,
 };
 use rustc_session::lint::Level;
 use rustc_session::search_paths::SearchPath;
@@ -813,6 +813,11 @@ fn test_unstable_options_tracking_hash() {
  tracked!(packed_bundled_libs, true);
  tracked!(panic_abort_tests, true);
  tracked!(panic_in_drop, PanicStrategy::Abort);
+ tracked!(
+ patchable_function_entry,
+ PatchableFunctionEntry::from_total_and_prefix_nops(10, 5)
+ .expect("total must be greater than or equal to prefix")
+ );
  tracked!(plt, Some(true));
  tracked!(polonius, Polonius::Legacy);
  tracked!(precise_enum_drop_elaboration, false);

compiler/rustc_middle/src/middle/codegen_fn_attrs.rs

@@ -45,6 +45,32 @@ pub struct CodegenFnAttrs {
  /// The `#[repr(align(...))]` attribute. Indicates the value of which the function should be
  /// aligned to.
  pub alignment: Option<Align>,
+ /// The `#[patchable_function_entry(...)]` attribute. Indicates how many nops should be around
+ /// the function entry.
+ pub patchable_function_entry: Option<PatchableFunctionEntry>,
+}
+
+#[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)]
+pub struct PatchableFunctionEntry {
+ /// Nops to prepend to the function
+ prefix: u8,
+ /// Nops after entry, but before body
+ entry: u8,
+}
+
+impl PatchableFunctionEntry {
+ pub fn from_config(config: rustc_session::config::PatchableFunctionEntry) -> Self {
+ Self { prefix: config.prefix(), entry: config.entry() }
+ }
+ pub fn from_prefix_and_entry(prefix: u8, entry: u8) -> Self {
+ Self { prefix, entry }
+ }
+ pub fn prefix(&self) -> u8 {
+ self.prefix
+ }
+ pub fn entry(&self) -> u8 {
+ self.entry
+ }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)]
@@ -121,6 +147,7 @@ impl CodegenFnAttrs {
  no_sanitize: SanitizerSet::empty(),
  instruction_set: None,
  alignment: None,
+ patchable_function_entry: None,
  }
  }