`assembler label '' cannot be undefined` on Windows ARM

[NicholasLYang]

Whenever I try compiling turborepo on Windows ARM, I get the following error when rustc tries to build tokio:

error: assembler label '' can not be undefined

I'd expect this code to compile, since it works fine on other platforms (macOS/Linux/Windows x86).

Meta

rustc --version --verbose:

rustc 1.82.0-nightly (0d634185d 2024-08-29)
binary: rustc
commit-hash: 0d634185dfddefe09047881175f35c65d68dcff1
commit-date: 2024-08-29
host: aarch64-pc-windows-msvc
release: 1.82.0-nightly
LLVM version: 19.1.0

Backtrace

I don't seem to get a backtrace on Windows, even when setting via set RUST_BACKTRACE=1

Here's all I get:

error: assembler label '' can not be undefined
   Compiling hyper v1.4.1
   Compiling console v0.15.7
   Compiling proc-macro-crate v3.1.0
   Compiling async-graphql-parser v7.0.7
   Compiling crossterm v0.27.0
   Compiling turborepo-vercel-api v0.1.0 (C:\Users\nicholas\turbo\crates\turborepo-vercel-api)
   Compiling turborepo-ci v0.1.0 (C:\Users\nicholas\turbo\crates\turborepo-ci)
   Compiling itertools v0.12.0
   Compiling stability v0.1.1
   Compiling lru v0.12.2
   Compiling memoffset v0.7.1
   Compiling encoding_rs v0.8.32
error: could not compile `tokio` (lib) due to 1 previous error
warning: build failed, waiting for other jobs to finish...

[moxian]

Smaller, but far from minimal:

# Cargo.toml
[package]
name = "mycrate"
version = "0.1.0"
edition = "2018"

[dependencies]
tokio = {version= "=1.39.2", features = ["full", "time"] }

[profile.dev]
opt-level = 1

Invoke with cargo build --target aarch64-pc-windows-msvc.

[moxian]

This is thorny. It's not inline assembly misuse - it's some kind of codegen bug.
I've minimized the repro as much as I could, but it's still rather large.

Notably, it requires opt-level=1, incremental=false, codegen-units=<large number>, and being split across two source files.

# Cargo.toml
[package]
edition = "2021"
rust-version = "1.70"
name = "tokio"
version = "1.39.2"

[dependencies]

[profile.dev]
opt-level = 1
incremental = false
codegen-units=65535
# rustc 1.85.0-x86_64-pc-windows-msvc

lib.rs

// lib
#![allow(unused_variables, unreachable_code)]

pub(crate) mod harness;

use std::pin::Pin;
use std::task::{Context, Poll};

struct ArcFile();

impl std::io::Read for ArcFile {
    fn read(&mut self, bytes: &mut [u8]) -> std::io::Result<usize> {
        loop {}
    }
}

pub(crate) struct ChildStdio {
    io: Blocking<ArcFile>,
}

impl AsyncRead for ChildStdio {
    fn poll_read(mut self: Pin<&mut Self>, buf: &mut ReadBuf) -> Poll<std::io::Result<()>> {
        Pin::new(&mut self.io).poll_read(buf)
    }
}

#[inline(never)]
pub(crate) fn invent<T>() -> T {
    loop {}
}

pub(crate) struct Empty {}

#[derive(Clone, Copy)]
pub(crate) struct Id(pub(crate) u64);

pub(crate) trait AsyncRead {
    fn poll_read(self: Pin<&mut Self>, buf: &mut ReadBuf) -> Poll<std::io::Result<()>>;
}

pub(crate) struct Blocking<T> {
    state: main_State<T>,
}

pub(crate) struct Buf {}

enum main_State<T> {
    Idle(Option<Buf>),
    Busy(crate::JoinHandle<(usize, Buf, T)>),
}

impl<T> AsyncRead for Blocking<T>
where
    T: std::io::Read + Unpin + Send + 'static,
{
    fn poll_read(mut self: Pin<&mut Self>, dst: &mut ReadBuf) -> Poll<std::io::Result<()>> {
        loop {
            match self.state {
                main_State::Idle(ref mut buf_cell) => {
                    self.state = main_State::Busy(crate::spawn_blocking(move || loop {}));
                }
                main_State::Busy(ref mut rx) => loop {},
            }
        }
    }
}

pub(crate) type ReadBuf = crate::Empty;

struct runtime_Context {
    current_task_id: std::cell::Cell<Option<Id>>,
}

::std::thread_local! {
    static CONTEXT: runtime_Context = const {
        runtime_Context { current_task_id: std::cell::Cell::new(None) }
    }
}

pub(crate) fn set_current_task_id(id: Option<Id>) -> Option<Id> {
    CONTEXT
        .try_with(|ctx| ctx.current_task_id.replace(id))
        .unwrap_or(None)
}

pub(crate) struct BlockingTask<T> {
    func: T,
}

impl<T, R> std::future::Future for BlockingTask<T>
where
    T: FnOnce() -> R + Send + 'static,
    R: Send + 'static,
{
    type Output = R;

    fn poll(mut self: Pin<&mut Self>, _cx: &mut std::task::Context<'_>) -> Poll<R> {
        loop {}
    }
}

pub(crate) fn spawn_blocking<F, R>(func: F) -> JoinHandle<R>
where
    F: FnOnce() -> R + Send + 'static,
    R: Send + 'static,
{
    let join_handle = if std::mem::size_of::<F>() > 2048 {
        spawn_blocking_inner(Box::new(func))
    } else {
        spawn_blocking_inner(func)
    };
    join_handle
}

pub(crate) fn spawn_blocking_inner<F, R>(func: F) -> JoinHandle<R>
where
    F: FnOnce() -> R + Send + 'static,
    R: Send + 'static,
{
    let fut: BlockingTask<F> = crate::invent();
    let (task, handle) = crate::unowned(fut, crate::invent());
    handle
}

use crate::harness::Harness;
use std::future::Future;
use std::marker::PhantomData;

pub(crate) struct Task<S: 'static> {
    raw: RawTask,
    _p: PhantomData<S>,
}

pub(crate) struct Notified<S: 'static>(Task<S>);

pub(crate) struct UnownedTask<S: 'static> {
    raw: RawTask,
    _p: PhantomData<S>,
}

pub(crate) type join_Result<T> = std::result::Result<T, JoinError>;

pub(crate) struct BlockingSchedule {}

fn new_task<T>(task: T) -> (Task<Empty>, Notified<Empty>, JoinHandle<T::Output>)
where
    T: Future + 'static,
    T::Output: 'static,
{
    let raw = RawTask::new::<T>(task, Empty {});
    let task = Task {
        raw,
        _p: PhantomData,
    };
    let notified = Notified(Task {
        raw,
        _p: PhantomData,
    });
    let join = crate::invent();
    (task, notified, join)
}

pub(crate) fn unowned<T>(
    task: T,
    scheduler: BlockingSchedule,
) -> (UnownedTask<BlockingSchedule>, JoinHandle<T::Output>)
where
    T: Send + Future + 'static,
    T::Output: Send + 'static,
{
    let (task, notified, join) = new_task(task);
    let unowned = UnownedTask {
        raw: task.raw,
        _p: PhantomData,
    };
    std::mem::forget(task);
    std::mem::forget(notified);
    (unowned, join)
}

pub(crate) struct JoinHandle<T> {
    _p: PhantomData<T>,
}

use std::any::Any;

pub(crate) struct SyncWrapper<T> {
    value: T,
}

impl<T> SyncWrapper<T> {
    pub(crate) fn new(value: T) -> Self {
        Self { value }
    }
}

pub(crate) struct JoinError {
    repr: Repr,
    id: Id,
}

enum Repr {
    Cancelled,
    Panic(SyncWrapper<Box<dyn Any + Send + 'static>>),
}

impl JoinError {
    pub(crate) fn cancelled(id: Id) -> JoinError {
        JoinError {
            repr: Repr::Cancelled,
            id,
        }
    }

    pub(crate) fn panic(id: Id, err: Box<dyn Any + Send + 'static>) -> JoinError {
        JoinError {
            repr: Repr::Panic(SyncWrapper::new(err)),
            id,
        }
    }
}

use std::ptr::NonNull;

pub(crate) struct Cell<T: Future> {
    pub(crate) core: Core<T>,
}

pub(crate) struct Core<T: Future> {
    pub(crate) task_id: Id,
    pub(crate) stage: std::sync::Mutex<Stage<T>>,
}

pub(crate) enum Stage<T: Future> {
    Running(T),
    Finished(join_Result<T::Output>),
    Consumed,
}

impl<T: Future> Cell<T> {
    pub(crate) fn new(future: T, scheduler: Empty) -> Box<Cell<T>> {
        let vtable = vtable::<T>();
        let result = crate::invent();
        result
    }
}

pub(crate) struct TaskIdGuard {
    parent_task_id: Option<Id>,
}

impl TaskIdGuard {
    fn enter(id: Id) -> Self {
        TaskIdGuard {
            parent_task_id: crate::set_current_task_id(Some(id)),
        }
    }
}

impl Drop for TaskIdGuard {
    fn drop(&mut self) {
        crate::set_current_task_id(self.parent_task_id);
    }
}

impl<T: Future> Core<T> {
    pub(crate) fn poll(&self, mut cx: Context<'_>) -> Poll<T::Output> {
        loop {}
    }
}

impl<T: Future> Core<T> {
    pub(crate) fn set_stage(&self, stage: Stage<T>) {
        let _guard = TaskIdGuard::enter(self.task_id);
        *self.stage.lock().unwrap() = stage
    }
}

use std::sync::atomic::Ordering::{AcqRel, Acquire};

pub(crate) struct task_State {
    val: std::sync::atomic::AtomicUsize,
}

#[derive(Copy, Clone)]
pub(crate) struct Snapshot(usize);

const RUNNING: usize = 0b0001;
const COMPLETE: usize = 0b0010;
const NOTIFIED: usize = 0b100;
const CANCELLED: usize = 0b100_000;

pub(crate) enum TransitionToRunning {
    Success,
    Cancelled,
    Failed,
    Dealloc,
}

impl task_State {
    pub(crate) fn load(&self) -> Snapshot {
        Snapshot(self.val.load(Acquire))
    }

    pub(crate) fn transition_to_running(&self) -> TransitionToRunning {
        self.fetch_update_action(|mut next| {
            let action;
            assert!(next.is_notified());
            if !next.is_idle() {
                loop {}
            } else {
                if next.is_cancelled() {
                    action = TransitionToRunning::Cancelled;
                } else {
                    action = TransitionToRunning::Success;
                }
            }
            (action, Some(next))
        })
    }

    fn fetch_update_action<F, T>(&self, mut f: F) -> T
    where
        F: FnMut(Snapshot) -> (T, Option<Snapshot>),
    {
        let mut curr = self.load();
        loop {
            let (output, next) = f(curr);
            let next = match next {
                Some(next) => next,
                None => return output,
            };
            let res = self.val.compare_exchange(curr.0, next.0, AcqRel, Acquire);
            match res {
                Ok(_) => return output,
                Err(actual) => curr = Snapshot(actual),
            }
        }
    }
}

impl Snapshot {
    pub(crate) fn is_idle(self) -> bool {
        self.0 & (RUNNING | COMPLETE) == 0
    }

    pub(crate) fn is_notified(self) -> bool {
        self.0 & NOTIFIED == NOTIFIED
    }

    pub(crate) fn is_cancelled(self) -> bool {
        self.0 & CANCELLED == CANCELLED
    }
}

#[derive(Clone)]
pub(crate) struct RawTask {
    ptr: std::ptr::NonNull<Empty>,
}

pub(crate) struct Vtable {
    pub(crate) poll: fn(NonNull<Empty>),
    pub(crate) id_offset: usize,
}

pub(crate) fn vtable<T: Future>() -> &'static Vtable {
    &Vtable {
        poll: poll::<T, Empty>,
        id_offset: OffsetHelper::ID_OFFSET,
    }
}
struct OffsetHelper;

impl OffsetHelper {
    const ID_OFFSET: usize = std::mem::size_of::<Empty>();
}

impl RawTask {
    pub(crate) fn new<T>(task: T, scheduler: Empty) -> RawTask
    where
        T: Future,
    {
        let ptr = Box::into_raw(Cell::<_>::new(task, scheduler));
        let ptr = NonNull::new(ptr.cast()).unwrap();
        RawTask { ptr }
    }
}

impl Copy for RawTask {}

fn poll<T: Future, S>(ptr: NonNull<Empty>) {
    let harness: Harness<T> = crate::invent();
    harness.poll();
}

fn dummy<T: Future>(ptr: NonNull<Empty>) {
    loop {}
}

harness.rs

// harness.rs
use crate::task_State;
use crate::Id;
use crate::JoinError;
use crate::{Cell, Core};

pub(crate) struct Harness<T: std::future::Future> {
    cell: std::ptr::NonNull<Cell<T>>,
}

impl<T> Harness<T>
where
    T: std::future::Future,
{
    fn state(&self) -> &task_State {
        crate::invent()
    }

    fn core(&self) -> &Core<T> {
        crate::invent()
    }
}

impl<T> Harness<T>
where
    T: std::future::Future,
{
    pub(crate) fn poll(self) {
        match self.poll_inner() {
            PollFuture::Notified => loop {},
            _ => loop {},
        }
    }

    fn poll_inner(&self) -> PollFuture {
        use crate::{TransitionToRunning};

        match self.state().transition_to_running() {
            TransitionToRunning::Success => {
                fn transition_result_to_poll_future(result: TransitionToRunning) -> PollFuture {
                    match result {
                        TransitionToRunning::Cancelled => PollFuture::Complete,
                        _ => PollFuture::Done,
                    }
                }

                let res: std::task::Poll<()> = crate::invent();
                if res == std::task::Poll::Ready(()) {
                    return PollFuture::Complete;
                }
                let transition_res = self.state().transition_to_running();
                if let TransitionToRunning::Cancelled = transition_res {
                    cancel_task(self.core());
                }
                transition_result_to_poll_future(transition_res)
            }
            TransitionToRunning::Cancelled => {
                cancel_task(self.core());
                PollFuture::Complete
            }
            TransitionToRunning::Failed => PollFuture::Done,
            TransitionToRunning::Dealloc => PollFuture::Dealloc,
        }
    }
}

enum PollFuture {
    Complete,
    Notified,
    Done,
    Dealloc,
}

fn cancel_task<T: std::future::Future>(core: &Core<T>) {
    let res = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        core.set_stage(crate::Stage::Consumed);
    }));

    core.set_stage(crate::Stage::Finished(Err(panic_result_to_join_error(
        core.task_id,
        res,
    ))));
}

fn panic_result_to_join_error(
    task_id: Id,
    res: Result<(), Box<dyn std::any::Any + Send + 'static>>,
) -> JoinError {
    match res {
        Ok(()) => JoinError::cancelled(task_id),
        Err(panic) => JoinError::panic(task_id, panic),
    }
}

I want to stress that there is no inline asm in here and even no unsafe at all. Which makes me suspicious this might be a miscompilation of sorts.

I'm really struggling to get it much smaller than this, but I'm also not quite sure how else to approach this.

Of the "notable" features in the code we have one thread-local, one atomic, and a bunch of passing around of a Future.
Removing the former is straightforward and makes the error immediately go away.
Removing the other two is much more nuanced. Naive attempts to get rid of them also make the code compile, but perhaps there's a way to.. not.

@rustbot label: -A-inline-assembly +A-codegen +I-miscompile

[moxian]

Compiling with RUSTC_LOG set points fingers at LTO

log

> $env:RUSTC_LOG='info'
> rustc src\lib.rs -Z treat-err-as-bug=1 -Z eagerly-emit-delayed-bugs  --edition=2021  --crate-type rlib --emit=link -C opt-level=1 -C embed-bitcode=no -C codegen-units=123 --target aarch64-pc-windows-msvc --out-dir out -Zmir-opt-level=0 -A warnings 
warning: some trace filter directives would enable traces that are disabled statically
note: `debug` would enable the DEBUG level for all targets
note: the static max level is `info`
help: to enable DEBUG logging, remove the `max_level_info` feature from the `tracing` crate
<...>
  INFO rustc_codegen_llvm::back::lto 65 symbols to preserve in this crate
  INFO rustc_codegen_llvm::back::lto going for that thin, thin LTO
  INFO rustc_codegen_llvm::back::lto local module: 0 - lib.47ba4053ac1e3578-cgu.7
  INFO rustc_codegen_llvm::back::lto local module: 1 - lib.47ba4053ac1e3578-cgu.6
  INFO rustc_codegen_llvm::back::lto local module: 2 - lib.47ba4053ac1e3578-cgu.2
  INFO rustc_codegen_llvm::back::lto local module: 3 - lib.47ba4053ac1e3578-cgu.1
  INFO rustc_codegen_llvm::back::lto local module: 4 - lib.47ba4053ac1e3578-cgu.5
  INFO rustc_codegen_llvm::back::lto local module: 5 - lib.47ba4053ac1e3578-cgu.3
  INFO rustc_codegen_llvm::back::lto local module: 6 - lib.47ba4053ac1e3578-cgu.0
  INFO rustc_codegen_llvm::back::lto local module: 7 - lib.47ba4053ac1e3578-cgu.4
  INFO rustc_codegen_llvm::back::lto thin LTO data created
  INFO rustc_codegen_llvm::back::lto thin LTO cache key map loaded
  INFO rustc_codegen_llvm::back::lto prev_key_map: None
  INFO rustc_codegen_llvm::back::lto curr_key_map: ThinLTOKeysMap {
     keys: {},
 }
  INFO rustc_codegen_llvm::back::lto checking which modules can be-reused and which have to be re-optimized.
  INFO rustc_codegen_llvm::back::lto  - lib.47ba4053ac1e3578-cgu.7: re-compiled
  INFO rustc_codegen_llvm::back::lto  - lib.47ba4053ac1e3578-cgu.6: re-compiled
  INFO rustc_codegen_llvm::back::lto  - lib.47ba4053ac1e3578-cgu.2: re-compiled
  INFO rustc_codegen_llvm::back::lto  - lib.47ba4053ac1e3578-cgu.1: re-compiled
  INFO rustc_codegen_llvm::back::lto  - lib.47ba4053ac1e3578-cgu.5: re-compiled
  INFO rustc_codegen_llvm::back::lto  - lib.47ba4053ac1e3578-cgu.3: re-compiled
  INFO rustc_codegen_llvm::back::lto  - lib.47ba4053ac1e3578-cgu.0: re-compiled
  INFO rustc_codegen_llvm::back::lto  - lib.47ba4053ac1e3578-cgu.4: re-compiled
  INFO rustc_codegen_llvm::back::lto running thin lto passes over lib.47ba4053ac1e3578-cgu.3
  INFO rustc_codegen_llvm::back::lto running thin lto passes over lib.47ba4053ac1e3578-cgu.5
  INFO rustc_codegen_llvm::back::lto running thin lto passes over lib.47ba4053ac1e3578-cgu.1
  INFO rustc_codegen_llvm::back::lto running thin lto passes over lib.47ba4053ac1e3578-cgu.0
  INFO rustc_codegen_llvm::back::lto running thin lto passes over lib.47ba4053ac1e3578-cgu.4
  INFO rustc_codegen_llvm::back::lto running thin lto passes over lib.47ba4053ac1e3578-cgu.2
  INFO rustc_codegen_llvm::back::lto running thin lto passes over lib.47ba4053ac1e3578-cgu.7
  INFO rustc_codegen_llvm::back::lto running thin lto passes over lib.47ba4053ac1e3578-cgu.6
error: internal compiler error: assembler label '' can not be undefined


thread 'rustc' panicked at compiler\rustc_errors\src\lib.rs:1781:17:
aborting due to `-Z treat-err-as-bug=1`
stack backtrace:
   0:     0x7ffc0d3c01c1 - std::backtrace_rs::backtrace::dbghelp64::trace
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\std\src\..\..\backtrace\src\backtrace\dbghelp64.rs:91
   1:     0x7ffc0d3c01c1 - std::backtrace_rs::backtrace::trace_unsynchronized
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\std\src\..\..\backtrace\src\backtrace\mod.rs:66
   2:     0x7ffc0d3c01c1 - std::sys::backtrace::_print_fmt
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\std\src\sys\backtrace.rs:66
   3:     0x7ffc0d3c01c1 - std::sys::backtrace::impl$0::print::impl$0::fmt
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\std\src\sys\backtrace.rs:39
   4:     0x7ffc0d3f2cca - core::fmt::rt::Argument::fmt
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\core\src\fmt\rt.rs:177
   5:     0x7ffc0d3f2cca - core::fmt::write
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\core\src\fmt\mod.rs:1440
   6:     0x7ffc0d3b5b07 - std::io::Write::write_fmt<std::sys::pal::windows::stdio::Stderr>
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\std\src\io\mod.rs:1887
   7:     0x7ffc0d3c0005 - std::sys::backtrace::BacktraceLock::print
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\std\src\sys\backtrace.rs:42
   8:     0x7ffc0d3c2fad - std::panicking::default_hook::closure$1
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\std\src\panicking.rs:295
   9:     0x7ffc0d3c2d10 - std::panicking::default_hook
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\std\src\panicking.rs:322
  10:     0x7ffc0e9b533a - core[13dd8dac7b8322e0]::slice::sort::unstable::heapsort::heapsort::<((rustc_lint_defs[84e5be47eb57ee2d]::Level, &str), usize), <((rustc_lint_defs[84e5be47eb57ee2d]::Level, &str), usize) as core[13dd8dac7b8322e0]::cmp::PartialOrd>::lt>
  11:     0x7ffc0d3c389e - alloc::boxed::impl$30::call
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\alloc\src\boxed.rs:2007
  12:     0x7ffc0d3c389e - std::panicking::rust_panic_with_hook
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\std\src\panicking.rs:836
  13:     0x7ffc0d3c35c2 - std::panicking::begin_panic_handler::closure$0
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\std\src\panicking.rs:694
  14:     0x7ffc0d3c0c9f - std::sys::backtrace::__rust_end_short_backtrace<std::panicking::begin_panic_handler::closure_env$0,never$>
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\std\src\sys\backtrace.rs:168
  15:     0x7ffc0d3c31fe - std::panicking::begin_panic_handler
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\std\src\panicking.rs:692
  16:     0x7ffc10272e41 - core::panicking::panic_fmt
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\core\src\panicking.rs:75
  17:     0x7ffc1008ed7c - <rustc_errors[c54ef953fb698494]::DiagCtxtHandle>::set_must_produce_diag
  18:     0x7ffc0d334dc6 - <rustc_errors[c54ef953fb698494]::DiagCtxtHandle>::flush_delayed
  19:     0x7ffc0a3e8739 - <alloc[f42caee64323a5c9]::sync::Arc<std[791127b64b61979d]::sync::poison::mutex::Mutex<core[13dd8dac7b8322e0]::option::Option<()>>>>::drop_slow
  20:     0x7ffc0d33261d - <rustc_errors[c54ef953fb698494]::DiagCtxtHandle>::flush_delayed
  21:     0x7ffc0d331c29 - <rustc_errors[c54ef953fb698494]::DiagCtxtHandle>::emit_diagnostic
  22:     0x7ffc0d31cecc - <() as rustc_errors[c54ef953fb698494]::diagnostic::EmissionGuarantee>::emit_producing_guarantee
  23:     0x7ffc0d06546d - <rustc_codegen_ssa[3fc74d1e4610d817]::back::write::SharedEmitterMain>::check
  24:     0x7ffc0a49f426 - <rustc_codegen_llvm[41ba621bace2ee9a]::LlvmCodegenBackend as rustc_codegen_ssa[3fc74d1e4610d817]::traits::backend::CodegenBackend>::join_codegen
  25:     0x7ffc0a3fdac3 - <rustc_interface[891a09a0cea1e8ed]::queries::Linker>::link
  26:     0x7ffc0a3b6f3c - RINvNtNtCsaor5jccb5ur_3std3sys9backtrace28___rust_begin_short_backtraceNCNCNCINvMNtB6_6threadNtB1h_7Builder16spawn_unchecked_INtNtCskXJAKvAmGc7_5alloc5boxed3BoxDINtNtNtCs1HK5c7eE0eW_4core3ops8function6FnOnceuEp6OutputuNtNtB2G_6marker4SendEL_EuEs_000uECs13K
  27:     0x7ffc0a3afe09 - RINvNtNtCsaor5jccb5ur_3std3sys9backtrace28___rust_begin_short_backtraceNCNCINvNtCsbLMVCc8CHyP_15rustc_interface4util26run_in_thread_with_globalsNCINvB1e_31run_in_thread_pool_with_globalsNCINvNtB1g_9interface12run_compileruNCNvCs13KITJ2Zc2G_17rustc_driver_i
  28:     0x7ffc0a3c2ea5 - RINvNtNtCsaor5jccb5ur_3std3sys9backtrace28___rust_begin_short_backtraceNCNCNCINvMNtB6_6threadNtB1h_7Builder16spawn_unchecked_INtNtCskXJAKvAmGc7_5alloc5boxed3BoxDINtNtNtCs1HK5c7eE0eW_4core3ops8function6FnOnceuEp6OutputuNtNtB2G_6marker4SendEL_EuEs_000uECs13K
  29:     0x7ffc0d3d57cd - alloc::boxed::impl$28::call_once
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\alloc\src\boxed.rs:1993
  30:     0x7ffc0d3d57cd - alloc::boxed::impl$28::call_once
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\alloc\src\boxed.rs:1993
  31:     0x7ffc0d3d57cd - std::sys::pal::windows::thread::impl$0::new::thread_start
                               at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library\std\src\sys\pal\windows\thread.rs:56
  32:     0x7ffc8e077374 - BaseThreadInitThunk
  33:     0x7ffc8e25cc91 - RtlUserThreadStart

error: the compiler unexpectedly panicked. this is a bug.

Setting -C lto to anything at all (off, false, true, thin, fat, and even just -Clto with no value) makes the code compile successfully. And also stops rustc_codegen_llvm::back::lto from being emitted. This implies that it is the "thin local LTO" being at fault.

I was unable to reproduce the issue with stock clang/llvm, so I can't say with certainty whether it's llvm bug or rust's handling of it but, but I'll label it just in case.

@rustbot label: +A-LLVM +A-lto