x.py build --stage 1 library/std --target hexagon-unknown-qurt fails: libunwind requires link.h; std then fails due to missing libc/platform items

[aviad-kardome]

Summary

Building library/std for hexagon-unknown-qurt from the current rust-lang/rust master (using a custom bootstrap.toml for Hexagon/QURT toolchain) fails. I hit a sequence of failures (libunwind headers, then libc target support), and even after switching to a local libc fork + allowing warnings, std still fails with many missing libc symbols/types and missing platform modules.

Steps to reproduce (Command used)

1. Clone Rust:

   git clone https://github.com/rust-lang/rust.git
   cd rust

   • rust git rev-parse HEAD: 7704328ba5ae8d6ce0ac303c9d5a1a1605906766

2. Create bootstrap.toml (example below) and point it at the Hexagon toolchain.

3. Clean and build std for Hexagon/QURT:

   ./x.py clean
   ./x.py build --stage 1 library/std --target hexagon-unknown-qurt

Expected behaviour

./x.py build --stage 1 library/std --target hexagon-unknown-qurt succeeds (or fails with a clear “target unsupported” message if this target is not expected to build std).

Actual behaviour

1. Baseline: build from current Rust git + recommended-ish bootstrap.toml
   Command:

   ./x.py build --stage 1 library/std --target hexagon-unknown-qurt

   Failure (libunwind build step) (terminal_output_ver1.txt):

   • While building libunwind.a for hexagon-unknown-qurt, compilation fails because link.h is missing:

   .../libunwind/src/AddressSpace.hpp: fatal error: 'link.h' file not found
   

2. Tried disabling libunwind
   Change:

   • Set llvm-libunwind = "no" and backtrace = false.

   Result terminal_output_ver2.txt:

   • This allowed progress past the libunwind failure, but the build later failed in libc/std compilation:
     • error[E0432]: unresolved import 'unistd' (coming from libc internals for the target).

3. Switched to local libc (fork/path override)
   Attempted:

   • cargo update -p libc (updated libc version in the lockfile, but did not resolve the target issue).
   • Switched to a local libc checkout/fork (path override) based on rust-lang/libc with QURT/hexagon adjustments.
   • clib git rev-parse HEAD: 4b38c69e31afadbead63af49794850b5a41f7dc4

   Result terminal_output_ver3.txt:

   • Build aborted due to “warnings are denied …” (warnings treated as errors).

4. Tried allowing warnings
   Attempt:

   • Added deny-warnings = false in bootstrap.toml.

   Result terminal_output_ver4.txt:

   • The build moved forward using the local libc, but then generated many libc-related issues:

     • lots of missing libc functions/constants/types (open, pread, pwrite, fcntl, O_*, socket constants, signals, etc.).
     • and additional errors where libc items are present but not publicly exported as expected (private type aliases/modules).

   • In addition, std fails with missing platform modules for unix paths (e.g. cannot find platform::fs / platform::raw).

Bootstrap configuration (bootstrap.toml)

[build]
build-stage = 1
host = ["x86_64-unknown-linux-gnu"]
target = ["x86_64-unknown-linux-gnu", "hexagon-unknown-qurt"]

[target.hexagon-unknown-qurt]
cc = "/home/user/Projects/qualcomm/5.5.2.0/tools/HEXAGON_Tools/8.7.06/Tools/bin/hexagon-clang"
cxx = "/home/user/Projects/qualcomm/5.5.2.0/tools/HEXAGON_Tools/8.7.06/Tools/bin/hexagon-clang++"
ar = "llvm-ar"
ranlib = "llvm-ranlib"
llvm-libunwind = 'in-tree'

Also tried:

[rust]
backtrace = false

[target.hexagon-unknown-qurt]
llvm-libunwind = "no"

And:

[rust]
deny-warnings = false

Operating system

• Host: x86_64-unknown-linux-gnu (Linux VM)
• Target: hexagon-unknown-qurt
• Hexagon toolchain: hexagon-clang/clang++ from Qualcomm HEXAGON Tools (8.7.06) (paths in bootstrap.toml)
• Build command:

./x.py build --stage 1 library/std --target hexagon-unknown-qurt

HEAD

rust git rev-parse HEAD: 7704328ba5ae8d6ce0ac303c9d5a1a1605906766
clib git rev-parse HEAD: 4b38c69e31afadbead63af49794850b5a41f7dc4

Additional context

• Is hexagon-unknown-qurt expected to support building std in-tree?
  • It seems like it suggests/targets std support based on:
    • rust-lang/rust target support PR: Add support for hexagon-unknown-qurt target #147173.
    • rust-lang/libc QuRT support commit: rust-lang/libc@8ecae6c.
    • target documentation (mentions std): https://doc.rust-lang.org/nightly/rustc/platform-support/hexagon-unknown-qurt.html.
• If yes: what is the intended libc + unwind setup for this target (in-tree libunwind vs SDK/unwindless, libc source/version/branch)?
• If no: is there an official stance / tracking issue for core/alloc-only vs std support for this target?

[bjorn3]

Updating the libc crate won't have any effect here. It only contains rust bindings to libc. It doesn't contain C header files or the actual libc.

The first question is does llvm libunwind support hexagon at all? And if so is there a specific libc it needs?

[aviad-kardome]

Update: the initial failure when building in-tree LLVM libunwind for hexagon-unknown-qurt was that src/llvm-project/libunwind/src/AddressSpace.hpp includes <link.h>, which wasn’t found with my QuRT/Hexagon SDK header setup.

Since I noticed link.h exists in the Qualcomm bundle under the Android NDK sysroot, I tried injecting that NDK sysroot via a hexagon-clang++ wrapper to test whether this was “just” a sysroot/include-path issue. That gets past the missing link.h, but libunwind then fails while compiling against NDK headers:

linux/types.h includes <asm/types.h>, which is not found for --target=hexagon-unknown-qurt.

The NDK sysroot has asm/types.h only under per-arch include dirs for {i686,x86_64,aarch64,arm}-linux-android, and there don’t appear to be any Hexagon-specific headers (find ... -path '*hexagon*' returns nothing). So using the NDK sysroot to satisfy link.h doesn’t seem viable for Hexagon/QuRT, and it suggests the in-tree libunwind build is pulling in Linux/Android header assumptions that don’t match this target.

cc @androm3da in case you have context: is LLVM libunwind expected to be supported for hexagon-unknown-qurt? If so, what sysroot/libc/header environment is it intended to be built against?

[androm3da]

is LLVM libunwind expected to be supported for hexagon-unknown-qurt? If so, what sysroot/libc/header environment is it intended to be built against?

I was hoping it would be the case but I've yet to investigate it.

Based on your investigation it looks like it's not the case. We will likely have to use libc_eh instead (it resembles the libgcc_eh IIRC). I'll put it on my todo list - or if you decide to take a look, please let me know how I can help.

[androm3da]

I'll put it on my todo list - or if you decide to take a look, please let me know how I can help.

You can assign this issue to me if you like.

[androm3da]

Is hexagon-unknown-qurt expected to support building std in-tree?

Also a WIP, not quite there yet. I may have made some errors/omissions in my recent libc work for QuRT.

[aviad-kardome]

More toolchain details: Qualcomm’s Hexagon SDK provides the unwinder and personality in separate libs (tested on v66).

• libc_eh.a (Hexagon DSP6) defines the standard _Unwind_* APIs (e.g. _Unwind_RaiseException, _Unwind_Resume, etc.).

• The personality routine is __gxx_personality_v0 (not __gcc_personality_v0) and is provided by the C++ runtime libraries (libc++abi.a / libstdc++.a; nm shows __gxx_personality_v0).

This seems to support the idea that hexagon-unknown-qurt should use the vendor EH runtime (-lc_eh / libc_eh) instead of building in-tree LLVM libunwind (which currently fails on <link.h> / Linux header assumptions).