Rollup of 11 pull requests

Cargo.lock

@@ -1318,6 +1318,17 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
 
+[[package]]
+name = "emmy_dap_types"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2310ff06ab812a0332ffa037bbda9d994b3721a7f8a308ff38c28bdb20c37f56"
+dependencies = [
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "ena"
 version = "0.14.4"
@@ -2551,6 +2562,7 @@ dependencies = [
  "chrono-tz",
  "colored",
  "directories",
+ "emmy_dap_types",
  "genmc-sys",
  "getrandom 0.4.3",
  "ipc-channel",

compiler/rustc_ast/src/util/literal.rs

@@ -1,6 +1,5 @@
 //! Code related to parsing literals.
 
-use std::fmt::Write as _;
 use std::{ascii, fmt, str};
 
 use rustc_literal_escaper::{
@@ -38,19 +37,8 @@ pub fn escape_string_symbol(symbol: Symbol) -> Symbol {
     let mut escaped = String::with_capacity(s.len() + 1);
     escaped.push_str(prefix);
 
-    // Don't use escape_default() here, because using it is slower than escaping manually.
-    for c in suffix.chars() {
-        match c {
-            '\t' => escaped.push_str("\\t"),
-            '\r' => escaped.push_str("\\r"),
-            '\n' => escaped.push_str("\\n"),
-            '\\' => escaped.push_str("\\\\"),
-            '\'' => escaped.push_str("\\'"),
-            '\"' => escaped.push_str("\\\""),
-            '\x20'..='\x7e' => escaped.push(c),
-            c => write!(escaped, "\\u{{{:x}}}", c as u32).unwrap(),
-        }
-    }
+    escaped.extend(suffix.escape_default());
+
     Symbol::intern(&escaped)
 }
 

compiler/rustc_builtin_macros/src/lib.rs

@@ -46,6 +46,7 @@ mod iter;
 mod log_syntax;
 mod offload;
 mod pattern_type;
+mod rustdoc_skip_body;
 mod source_util;
 mod test;
 mod test_binder_constraints;
@@ -125,6 +126,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         eii_shared_macro: eii::eii_shared_macro,
         global_allocator: global_allocator::expand,
         offload_kernel: offload::expand_kernel,
+        rustdoc_skip_body: rustdoc_skip_body::expand,
         test: test::expand_test,
         test_case: test::expand_test_case,
         unsafe_eii: eii::unsafe_eii,

compiler/rustc_builtin_macros/src/rustdoc_skip_body.rs

@@ -0,0 +1,93 @@
+//! The expansion from a function when the code would not compile with rustdoc: so if `cfg(doc)`,
+//! expands to a `loop {}`.
+
+use rustc_ast::token::{self, Delimiter, IdentKind};
+use rustc_ast::tokenstream::{DelimSpacing, DelimSpan, Spacing, TokenStream, TokenTree};
+use rustc_ast::{
+    AssocItemKind, AttrArgs, AttrItem, Attribute, DelimArgs, ExprKind, Fn, ItemKind, MetaItem,
+    Safety,
+};
+use rustc_expand::base::*;
+use rustc_span::{Ident, Span, sym};
+use thin_vec::ThinVec;
+
+pub(crate) fn expand(
+    cx: &mut ExtCtxt<'_>,
+    attr_path_sp: Span,
+    meta_item: &MetaItem,
+    mut item: Annotatable,
+) -> Vec<Annotatable> {
+    if !meta_item.is_word() {
+        cx.dcx().struct_span_err(attr_path_sp, "`rustdoc_skip_body` doesn't take arguments").emit();
+    }
+    let mut is_expected_item = false;
+    match item {
+        Annotatable::Item(ref mut item) => {
+            if let ItemKind::Fn(ref mut fn_) = item.kind {
+                expand_macro(cx, attr_path_sp, fn_);
+                is_expected_item = true;
+            }
+        }
+        Annotatable::AssocItem(ref mut item, _) => {
+            if let AssocItemKind::Fn(ref mut fn_) = item.kind {
+                expand_macro(cx, attr_path_sp, fn_);
+                is_expected_item = true;
+            }
+        }
+        _ => {}
+    }
+    if !is_expected_item {
+        cx.dcx()
+            .struct_span_err(attr_path_sp, "`rustdoc_skip_body` can only be used on functions")
+            .emit();
+    }
+    vec![item]
+}
+
+fn cfg_not_doc(cx: &mut ExtCtxt<'_>, sp: Span) -> Attribute {
+    // `not(doc)`
+    let not_doc = TokenStream::new(vec![
+        TokenTree::token_alone(token::Ident(sym::not, IdentKind::Normal), sp),
+        TokenTree::Delimited(
+            DelimSpan::from_single(sp),
+            DelimSpacing::new(Spacing::JointHidden, Spacing::Alone),
+            Delimiter::Parenthesis,
+            TokenStream::token_alone(token::Ident(sym::doc, IdentKind::Normal), sp),
+        ),
+    ]);
+
+    cx.attr_nested(
+        AttrItem {
+            unsafety: Safety::Default,
+            path: cx.path_ident(sp, Ident::new(sym::cfg, sp)),
+            args: AttrArgs::Delimited(DelimArgs {
+                dspan: DelimSpan::from_single(sp),
+                delim: Delimiter::Parenthesis,
+                tokens: not_doc,
+            }),
+            span: sp,
+        },
+        sp,
+    )
+}
+
+fn expand_macro(cx: &mut ExtCtxt<'_>, sp: Span, fn_: &mut Fn) {
+    let Some(old_body) = fn_.body.take() else {
+        // No body... Well, no possibility to not compile I guess so all good.
+        return;
+    };
+    let mut old_body = cx.expr_block(old_body);
+    // We add on the function's body `#[cfg(not(doc))]`.
+    old_body.attrs.push(cfg_not_doc(cx, sp));
+
+    // We create the `#[cfg(doc)] loop {}` "block".
+    let mut loop_expr = cx.expr(sp, ExprKind::Loop(cx.block(sp, ThinVec::new()), None, sp));
+    loop_expr.attrs.push(cx.attr_nested_word(sym::cfg, sym::doc, sp));
+
+    let mut stmts = ThinVec::new();
+    stmts.push(cx.stmt_expr(loop_expr));
+    stmts.push(cx.stmt_expr(old_body));
+
+    // We create a new function body containing both blocks.
+    fn_.body = Some(cx.block(sp, stmts));
+}

compiler/rustc_codegen_gcc/.github/workflows/ci.yml

@@ -116,8 +116,6 @@ jobs:
     - name: Set env
       run: |
         echo "workspace="$GITHUB_WORKSPACE >> $GITHUB_ENV
-        # /tmp is a small tmpfs, and rustdoc keeps every compiled doctest there until the run ends.
-        echo "TMPDIR=$RUNNER_TEMP" >> $GITHUB_ENV
 
     #- name: Cache rust repository
       ## We only clone the rust repository for rustc tests

compiler/rustc_codegen_gcc/.github/workflows/rustup.yml

@@ -77,8 +77,6 @@ jobs:
     - name: Set env
       run: |
         echo "workspace="$GITHUB_WORKSPACE >> $GITHUB_ENV
-        # /tmp is a small tmpfs, and rustdoc keeps every compiled doctest there until the run ends.
-        echo "TMPDIR=$RUNNER_TEMP" >> $GITHUB_ENV
 
     - name: Prepare
       if: ${{ matrix.run_cargo_tests }}

compiler/rustc_codegen_gcc/Cargo.lock

@@ -56,18 +56,18 @@ dependencies = [
 
 [[package]]
 name = "gccjit"
-version = "7.2.0"
+version = "7.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27cd340f3c265988de3379689cbbd103c25b1f8a3d0cc73f91a49083e899d3e1"
+checksum = "ea1820165dfb376a3bbfe8b69628d9e5a851c423e0480a666f71f560e2d0a924"
 dependencies = [
  "gccjit_sys",
 ]
 
 [[package]]
 name = "gccjit_sys"
-version = "4.2.0"
+version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da2d9d74572f004908f17ec1bd0af071e5db63a12c3335c9651a6125593951c6"
+checksum = "a6091291fc118448b91df5b662d20564020198fee46d8445a6aa0c25b6b435be"
 dependencies = [
  "libc",
 ]

compiler/rustc_codegen_gcc/Cargo.toml

@@ -20,7 +20,7 @@ default = ["master"]
 [dependencies]
 object = { version = "0.39.0", default-features = false, features = ["std", "read"] }
 tempfile = "3.20"
-gccjit = { version = "7.2.0", features = ["dlopen"] }
+gccjit = { version = "7.3.0", features = ["dlopen"] }
 #gccjit = { git = "https://github.com/rust-lang/gccjit.rs", branch = "error-dlopen", features = ["dlopen"] }
 
 # Local copy.

compiler/rustc_codegen_gcc/build_system/src/build.rs

@@ -6,7 +6,8 @@ use std::path::{Path, PathBuf};
 
 use crate::config::{Channel, ConfigInfo};
 use crate::utils::{
-    create_dir, get_sysroot_dir, run_command, run_command_with_output_and_env, walk_dir,
+    create_dir, get_sysroot_dir, run_command, run_command_with_output_and_env, rustc_version_info,
+    walk_dir,
 };
 
 #[derive(Default)]
@@ -137,17 +138,16 @@ pub fn build_sysroot(env: &HashMap<String, String>, config: &ConfigInfo) -> Resu
     // Builds libs
     let mut rustflags = env.get("RUSTFLAGS").cloned().unwrap_or_default();
 
-    // Record the sysroot sources under the path the `rust-src` component uses, which is where
-    // rustc looks for them to turn a sysroot span into `/rustc/$hash`. Without this, ui tests
-    // print the build path where they expect `$SRC_DIR`.
-    let sysroot_source_dir = lib_path.join("rustlib/src/rust/library");
+    // Remap both source spans and embedded panic locations to the standard virtual path.
+    let sysroot_source_dir = start_dir.join("sysroot_src");
+    let rustc_commit = rustc_version_info(env.get("RUSTC").map(String::as_str))?
+        .commit_hash
+        .ok_or_else(|| "Couldn't retrieve rustc commit hash".to_string())?;
+    // Cargo passes workspace-relative filenames, including those used by panic locations.
+    // Also: the `==` is intentional! The first `=` is "FROM" and the second `=` is for "TO".
+    rustflags.push_str(&format!(" --remap-path-prefix==/rustc/{rustc_commit}/library"));
     rustflags.push_str(&format!(
-        " --remap-path-prefix={library_dir}={sysroot_source_dir}",
-        library_dir = std::path::absolute(&library_dir)
-            .map_err(|error| format!(
-                "Failed to get the absolute path of the sysroot sources: {error:?}"
-            ))?
-            .display(),
+        " --remap-path-prefix={sysroot_source_dir}=/rustc/{rustc_commit}",
         sysroot_source_dir = std::path::absolute(&sysroot_source_dir)
             .map_err(|error| format!(
                 "Failed to get the absolute path of the sysroot sources: {error:?}"

compiler/rustc_codegen_gcc/doc/subtree.md

@@ -1,54 +1,13 @@
-# git subtree sync
+# Subtree sync procedure
 
-`rustc_codegen_gcc` is a subtree of the rust compiler. As such, it needs to be
-synced from time to time to ensure changes that happened on their side are also
-included on our side.
+`rustc_codegen_gcc` is using [Josh] to perform subtree synces with the `rust-lang/rust` repository.
 
-### How to install a forked git-subtree
+[Josh]: https://josh-project.dev/docs/intro.html
 
-Using git-subtree with `rustc` requires a patched git to make it work.
-The PR that is needed is [here](https://github.com/gitgitgadget/git/pull/493).
-Use the following instructions to install it:
+The procedure for performing subtree synchronizations is documented [here][rdg-josh].
 
-```bash
-git clone git@github.com:tqc/git.git
-cd git
-git checkout tqc/subtree
-make
-make install
-cd contrib/subtree
-make
-cp git-subtree ~/bin
-```
+[rdg-josh]: https://rustc-dev-guide.rust-lang.org/external-repos.html#synchronizing-a-josh-subtree
 
-### Syncing with rust compiler
+## Pushing changes to `rust-lang/rust`
 
-Do a sync with this command:
-
-```bash
-PATH="$HOME/bin:$PATH" ~/bin/git-subtree push -P compiler/rustc_codegen_gcc/ ../rustc_codegen_gcc/ sync_branch_name
-cd ../rustc_codegen_gcc
-git checkout master
-git pull
-git checkout sync_branch_name
-git merge master
-```
-
-To send the changes to the rust repo:
-
-```bash
-cd ../rust
-git pull origin master
-git checkout -b subtree-update_cg_gcc_YYYY-MM-DD
-PATH="$HOME/bin:$PATH" ~/bin/git-subtree pull --prefix=compiler/rustc_codegen_gcc/ https://github.com/rust-lang/rustc_codegen_gcc.git master
-# Don't forget to update the `gcc` submodule to the same version as the
-# one in `rustc_codegen_gcc/libgccjit.version`.
-git push
-
-# Immediately merge the merge commit into cg_gcc to prevent merge conflicts when syncing from rust-lang/rust later.
-PATH="$HOME/bin:$PATH" ~/bin/git-subtree push -P compiler/rustc_codegen_gcc/ ../rustc_codegen_gcc/ sync_branch_name
-```
-
-FIXME: write a script that does the above.
-
-https://rust-lang.zulipchat.com/#narrow/stream/301329-t-devtools/topic/subtree.20madness/near/258877725
+If the used GCC commit (recorded in `libgccjit.version`) changed in `rustc_codegen_gcc`, then you will have to update the `gcc` submodule in the `rust-lang/rust` repository in the push sync PR. The CI in `rust-lang/rust` should ensure that these two commit references match. You can simply update the `gcc` submodule commit and push it to your push sync PR once it has been created.

compiler/rustc_codegen_gcc/libgccjit.version

@@ -1 +1 @@
-37ea7cd851f04ee6a313c5067c9fde9328f876aa
+e1c6e07b095d091177376a163da44039475e05e3

compiler/rustc_codegen_gcc/rust-toolchain.toml

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2026-10-19"
+channel = "nightly-2026-10-24"
 components = ["rust-src", "rustc-dev", "llvm-tools-preview"]

compiler/rustc_codegen_gcc/src/attributes.rs

@@ -20,7 +20,7 @@ use crate::base;
 use crate::context::CodegenCx;
 #[cfg(feature = "master")]
 use crate::gcc_util::to_gcc_aarch64_extension;
-use crate::gcc_util::to_gcc_features;
+use crate::gcc_util::{to_gcc_features, to_gcc_target_attribute_feature};
 
 /// Checks if the function `instance` is recursively inline.
 /// Returns `false` if a functions is guaranteed to be non-recursive, and `true` if it *might* be recursive.
@@ -192,20 +192,7 @@ pub fn from_fn_attrs<'gcc, 'tcx>(
     }
     let target_features = function_features
         .iter()
-        .filter_map(|feature| {
-            // FIXME(antoyo): support soft-float.
-            if feature.contains("soft-float") {
-                return None;
-            }
-
-            if feature.starts_with('-') {
-                Some(format!("no{}", feature))
-            } else if let Some(stripped) = feature.strip_prefix('+') {
-                Some(stripped.to_string())
-            } else {
-                Some(feature.to_string())
-            }
-        })
+        .filter_map(|feature| to_gcc_target_attribute_feature(feature))
         .collect::<Vec<_>>()
         .join(",");
     if !target_features.is_empty() {