Rollup of 6 pull requests

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

@@ -30,6 +30,7 @@ pub(crate) fn target() -> Target {
         stack_probes: StackProbeType::Inline,
         panic_strategy: PanicStrategy::Abort,
         default_uwtable: true,
+        supports_xray: true,
         ..Default::default()
     };
     Target {

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

@@ -27,6 +27,7 @@ pub(crate) fn target() -> Target {
         stack_probes: StackProbeType::Inline,
         panic_strategy: PanicStrategy::Abort,
         default_uwtable: true,
+        supports_xray: true,
         ..Default::default()
     };
     Target {

src/ci/docker/host-aarch64/dist-aarch64-freebsd/Dockerfile

@@ -0,0 +1,44 @@
+FROM ubuntu:26.04
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+  clang \
+  make \
+  ninja-build \
+  file \
+  curl \
+  ca-certificates \
+  python3 \
+  git \
+  cmake \
+  sudo \
+  bzip2 \
+  xz-utils \
+  texinfo \
+  wget \
+  libssl-dev \
+  pkg-config \
+  && rm -rf /var/lib/apt/lists/*
+
+COPY scripts/freebsd-toolchain.sh /tmp/
+RUN /tmp/freebsd-toolchain.sh aarch64
+
+COPY scripts/sccache.sh /scripts/
+RUN sh /scripts/sccache.sh
+
+COPY scripts/cmake.sh /scripts/
+RUN /scripts/cmake.sh
+
+ENV \
+    AR_aarch64_unknown_freebsd=aarch64-unknown-freebsd14-ar \
+    CC_aarch64_unknown_freebsd=aarch64-unknown-freebsd14-clang \
+    CXX_aarch64_unknown_freebsd=aarch64-unknown-freebsd14-clang++
+
+ENV HOSTS=aarch64-unknown-freebsd
+
+ENV RUST_CONFIGURE_ARGS="--enable-full-tools \
+    --enable-extended \
+    --enable-profiler \
+    --enable-sanitizers \
+    --disable-docs"
+
+ENV SCRIPT="python3 ../x.py dist --host $HOSTS --target $HOSTS"

src/ci/docker/scripts/freebsd-toolchain.sh

@@ -46,6 +46,7 @@ mkdir -p "$sysroot"
 case $arch in
   (x86_64) freebsd_arch=amd64 ;;
   (i686) freebsd_arch=i386 ;;
+  (aarch64) freebsd_arch=arm64 ;;
 esac
 
 files_to_extract=(

src/ci/github-actions/jobs.yml

@@ -261,6 +261,9 @@ auto:
   - name: dist-x86_64-freebsd
     <<: *job-linux-4c
 
+  - name: dist-aarch64-freebsd
+    <<: *job-aarch64-linux
+
   - name: dist-x86_64-illumos
     <<: *job-linux-4c
 

src/doc/unstable-book/src/compiler-flags/instrument-xray.md

@@ -37,3 +37,4 @@ which on their own don't do anything useful.
 In order to actually trace the functions,
 you will need to link a separate runtime library of your choice,
 such as Clang's [XRay Runtime Library](https://www.llvm.org/docs/XRay.html#xray-runtime-library).
+On targets where such a runtime is not available but instrumentation is supported, you must supply and link your own runtime library.

src/librustdoc/html/highlight.rs

@@ -23,8 +23,8 @@ use crate::display::Joined as _;
 use crate::html::escape::EscapeBodyText;
 use crate::html::format::HrefInfo;
 use crate::html::macro_expansion::ExpandedCode;
-use crate::html::render::span_map::{DUMMY_SP, Span};
-use crate::html::render::{Context, LinkFromSrc};
+use crate::html::render::Context;
+use crate::html::span_map::{DUMMY_SP, LinkFromSrc, Span};
 
 /// This type is needed in case we want to render links on items to allow to go to their definition.
 pub(crate) struct HrefContext<'a, 'tcx> {

src/librustdoc/html/mod.rs

@@ -8,6 +8,7 @@ pub(crate) mod macro_expansion;
 pub mod markdown;
 pub(crate) mod render;
 pub(crate) mod sources;
+pub(crate) mod span_map;
 pub(crate) mod static_files;
 pub(crate) mod toc;
 mod url_parts_builder;

src/librustdoc/html/render/context.rs

@@ -20,7 +20,7 @@ use tracing::info;
 
 use super::print_item::{full_path, print_item, print_item_path, print_ty_path};
 use super::sidebar::{ModuleLike, Sidebar, print_sidebar, sidebar_module_like};
-use super::{AllTypes, LinkFromSrc, StylePath, collect_spans_and_sources, scrape_examples_help};
+use super::{AllTypes, StylePath, scrape_examples_help};
 use crate::clean::types::ExternalLocation;
 use crate::clean::utils::has_doc_flag;
 use crate::clean::{self, ExternalCrate};
@@ -33,8 +33,8 @@ use crate::formats::item_type::ItemType;
 use crate::html::escape::Escape;
 use crate::html::macro_expansion::ExpandedCode;
 use crate::html::markdown::{self, ErrorCodes, IdMap, plain_text_summary};
-use crate::html::render::span_map::Span;
 use crate::html::render::write_shared::write_shared;
+use crate::html::span_map::{LinkFromSrc, Span, collect_spans_and_sources};
 use crate::html::url_parts_builder::UrlPartsBuilder;
 use crate::html::{layout, sources, static_files};
 use crate::scrape_examples::AllCallLocations;

src/librustdoc/html/render/mod.rs

@@ -36,7 +36,6 @@ mod ordered_json;
 mod print_item;
 pub(crate) mod sidebar;
 mod sorted_template;
-pub(crate) mod span_map;
 mod type_layout;
 mod write_shared;
 
@@ -64,7 +63,6 @@ use rustc_span::symbol::{Symbol, sym};
 use tracing::{debug, info};
 
 pub(crate) use self::context::*;
-pub(crate) use self::span_map::{LinkFromSrc, collect_spans_and_sources};
 pub(crate) use self::write_shared::*;
 use crate::clean::{self, Defaultness, Item, ItemId, RenderedLink};
 use crate::display::{Joined as _, MaybeDisplay as _};

src/tools/miri/miri-script/src/commands.rs

@@ -114,8 +114,8 @@ impl Command {
             Command::Check { features, flags } => Self::check(features, flags),
             Command::Test { bless, target, coverage, features, flags } =>
                 Self::test(bless, target, coverage, features, flags),
-            Command::Run { dep, quiet, target, edition, features, flags } =>
-                Self::run(dep, quiet, target, edition, features, flags),
+            Command::Run { dep, native, quiet, target, edition, features, flags } =>
+                Self::run(dep, native, quiet, target, edition, features, flags),
             Command::Doc { features, flags } => Self::doc(features, flags),
             Command::Fmt { flags } => Self::fmt(flags),
             Command::Clippy { features, flags } => Self::clippy(features, flags),
@@ -465,15 +465,18 @@ impl Command {
 
     fn run(
         dep: bool,
+        native: bool,
         quiet: bool,
         target: Option<String>,
         edition: Option<String>,
         features: Vec<String>,
         flags: Vec<String>,
     ) -> Result<()> {
         let mut e = MiriEnv::new()?;
+        let run_via_ui_test = dep || native;
 
         // Preparation: get a sysroot, and get the miri binary.
+        // We do this even for native run as it also builds Miri itself.
         let miri_sysroot =
             e.build_miri_sysroot(/* quiet */ quiet, target.as_deref(), &features)?;
         let miri_bin = e
@@ -484,44 +487,45 @@ impl Command {
         // (because `flags` may contain `--`).
         let mut early_flags = Vec::<OsString>::new();
 
-        // In `dep` mode, the target is already passed via `MIRI_TEST_TARGET`
-        if !dep {
+        // In ui_test mode, the target is already passed via `MIRI_TEST_TARGET`
+        if !run_via_ui_test {
             if let Some(target) = &target {
                 early_flags.push("--target".into());
                 early_flags.push(target.into());
             }
         }
         early_flags.push("--edition".into());
         early_flags.push(edition.as_deref().unwrap_or("2021").into());
-        early_flags.push("--sysroot".into());
-        early_flags.push(miri_sysroot.into());
+        if !native {
+            early_flags.push("--sysroot".into());
+            early_flags.push(miri_sysroot.into());
+        }
 
         // Compute flags.
         let miri_flags = e.sh.var("MIRIFLAGS").unwrap_or_default();
         let miri_flags = flagsplit(&miri_flags);
-        let quiet_flag = if quiet { Some("--quiet") } else { None };
 
         // Run Miri.
         // The basic command that executes the Miri driver.
-        let mut cmd = if dep {
+        let mut cmd = if run_via_ui_test {
             // We invoke the test suite as that has all the logic for running with dependencies.
-            e.cargo_cmd(".", "test", &features)
+            let mut cmd = e
+                .cargo_cmd(".", "test", &features)
                 .args(&["--test", "ui"])
-                .args(quiet_flag)
+                // This does not show anything useful so we always hide it.
+                .arg("--quiet")
                 .arg("--")
-                .args(&["--miri-run-dep-mode"])
+                .env("MIRI_RUN_MODE", if native { "native" } else { "1" });
+            if let Some(target) = &target {
+                cmd = cmd.env("MIRI_TEST_TARGET", target);
+            }
+            cmd
         } else {
             cmd!(e.sh, "{miri_bin}")
         };
         cmd.set_quiet(quiet);
         // Add Miri flags
-        let mut cmd = cmd.args(&miri_flags).args(&early_flags).args(&flags);
-        // For `--dep` we also need to set the target in the env var.
-        if dep {
-            if let Some(target) = &target {
-                cmd = cmd.env("MIRI_TEST_TARGET", target);
-            }
-        }
+        let cmd = cmd.args(&miri_flags).args(&early_flags).args(&flags);
         // Finally, run the thing.
         Ok(cmd.run()?)
     }

src/tools/miri/miri-script/src/main.rs

@@ -78,6 +78,10 @@ pub enum Command {
         /// Build the program with the dependencies declared in `tests/deps/Cargo.toml`.
         #[arg(long)]
         dep: bool,
+        /// Compile and run the program natively instead of via Miri. Implies `--dep`.
+        /// All flags are passed to rustc; there is currently no way to pass flags to the program.
+        #[arg(long)]
+        native: bool,
         /// Hide build progress.
         #[arg(long, short)]
         quiet: bool,

src/tools/miri/rust-version

@@ -1 +1 @@
-63b1dfc0e00fd6f8ad7cd8817fc712e7d9b7be59
+281c97c3240a9abd984ca0c6a2cd7389115e80d5

src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs

@@ -456,7 +456,7 @@ struct DisplayFmtWrapper {
 /// will show each permission line as
 /// ```text
 /// 0.. 1.. 2.. 3.. 4.. 5
-/// [Act|Res|Frz|Dis|___]
+/// [Unq|Res|Frz|Dis|___]
 /// ```
 struct DisplayFmtPermission {
     /// Text that starts the permission block.
@@ -467,7 +467,7 @@ struct DisplayFmtPermission {
     close: S,
     /// Text to show when a permission is not initialized.
     /// Should have the same width as a `Permission`'s `.short_name()`, i.e.
-    /// 3 if using the `Res/Act/Frz/Dis` notation.
+    /// 3 if using the `Res/Unq/Frz/Dis` notation.
     uninit: S,
     /// Text to separate the `start` and `end` values of a range.
     range_sep: S,
@@ -525,7 +525,7 @@ struct DisplayFmtPadding {
 /// ```
 /// will show states as
 /// ```text
-///  Act
+///  Unq
 /// ?Res
 /// ____
 /// ```
@@ -549,8 +549,8 @@ struct DisplayFmt {
 }
 impl DisplayFmt {
     /// Print the permission with the format
-    /// ` Res`/` Re*`/` Act`/` Frz`/` Dis` for accessed locations
-    /// and `?Res`/`?Re*`/`?Act`/`?Frz`/`?Dis` for unaccessed locations.
+    /// ` Res`/` Re*`/` Unq`/` Frz`/` Dis` for accessed locations
+    /// and `?Res`/`?Re*`/`?Unq`/`?Frz`/`?Dis` for unaccessed locations.
     fn print_perm(&self, perm: Option<LocationState>) -> String {
         if let Some(perm) = perm {
             format!(
@@ -801,7 +801,7 @@ impl DisplayRepr {
         ) {
             let mut line = String::new();
             // Format the permissions on each range.
-            // Looks like `| Act| Res| Res| Act|`.
+            // Looks like `| Unq| Res| Res| Unq|`.
             line.push_str(fmt.perm.open);
             for (i, (perm, &pad)) in tree.rperm.iter().zip(padding.iter()).enumerate() {
                 if i > 0 {

src/tools/miri/src/borrow_tracker/tree_borrows/perms.rs

@@ -462,7 +462,7 @@ pub mod diagnostics {
                 ReservedFrz { conflicted: false } => "Res ",
                 ReservedFrz { conflicted: true } => "ResC",
                 ReservedIM => "ReIM",
-                Unique => "Act ",
+                Unique => "Unq ",
                 Frozen => "Frz ",
                 Disabled => "Dis ",
             }

src/tools/miri/src/clock.rs

@@ -1,5 +1,7 @@
 use std::cell::Cell;
-use std::time::{Duration, Instant as StdInstant};
+use std::time::{Duration, Instant as StdInstant, SystemTime};
+
+use crate::MiriMachine;
 
 /// When using a virtual clock, this defines how many nanoseconds we pretend are passing for each
 /// basic block.
@@ -8,6 +10,7 @@ use std::time::{Duration, Instant as StdInstant};
 /// (See `tests/pass/shims/time-with-isolation*.rs`.)
 const NANOSECONDS_PER_BASIC_BLOCK: u128 = 5000;
 
+/// An instant (a fixed moment in time) in Miri's monotone clock.
 #[derive(Debug)]
 pub struct Instant {
     kind: InstantKind,
@@ -129,3 +132,79 @@ impl MonotonicClock {
         }
     }
 }
+
+/// A deadline for some event to occur.
+#[derive(Debug)]
+pub enum Deadline {
+    Monotonic(Instant),
+    RealTime(SystemTime),
+}
+
+impl From<Instant> for Deadline {
+    fn from(value: Instant) -> Self {
+        Deadline::Monotonic(value)
+    }
+}
+
+impl Deadline {
+    /// Will try to add `duration`, but if that overflows it may add less.
+    fn add_lossy(&self, duration: Duration) -> Self {
+        match self {
+            Deadline::Monotonic(i) => Deadline::Monotonic(i.add_lossy(duration)),
+            Deadline::RealTime(s) => {
+                // If this overflows, try adding just 1h and assume that will not overflow.
+                Deadline::RealTime(
+                    s.checked_add(duration)
+                        .unwrap_or_else(|| s.checked_add(Duration::from_secs(3600)).unwrap()),
+                )
+            }
+        }
+    }
+}
+
+/// The clock to use for the timeout you are asking for.
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum TimeoutClock {
+    /// The timeout is measured using the monotone clock.
+    Monotonic,
+    /// The timeout is measured using the host's system clock.
+    RealTime,
+}
+
+/// Whether the timeout is relative or absolute.
+#[derive(Debug, Copy, Clone)]
+pub enum TimeoutStyle {
+    /// The given duration is interpreted relative to "now" for the selected clock.
+    Relative,
+    /// The given duration is interpreted as an "absolute" time, i.e., relative to the epoch of the
+    /// selected clock.
+    Absolute,
+}
+
+impl MiriMachine<'_> {
+    /// Computes the deadline for a given timeout configuration and duration.
+    pub fn timeout(
+        &self,
+        clock: TimeoutClock,
+        style: TimeoutStyle,
+        duration: Duration,
+    ) -> Deadline {
+        // First let's figure out what "zero" means for the given clock and style.
+        let zero = match clock {
+            TimeoutClock::RealTime => {
+                assert!(self.communicate(), "cannot have `RealTime` timeout with isolation");
+                Deadline::RealTime(match style {
+                    TimeoutStyle::Absolute => SystemTime::UNIX_EPOCH,
+                    TimeoutStyle::Relative => SystemTime::now(),
+                })
+            }
+            TimeoutClock::Monotonic =>
+                Deadline::Monotonic(match style {
+                    TimeoutStyle::Absolute => self.monotonic_clock.epoch(),
+                    TimeoutStyle::Relative => self.monotonic_clock.now(),
+                }),
+        };
+        // Then add the given duration relative to that "zero".
+        zero.add_lossy(duration)
+    }
+}