Lazy compilation of libstd

[bstrie]

Updated (2016-09-21)

Blockers:

• Make Cargo aware of standard library dependencies rfcs#1133 make Cargo aware of std dependencies.
  • Implementation: Phase 1 of stdlib dependencies (RFC #1133) cargo#2768
• Error cargo building std as a dylib #36501 can't cargo build std because building libstd.dylib fails.
• can't bootstrap compiler from the rust-src component because of file permissions #36488 can't cargo build std with jemalloc enabled from the rust-src component on Linux.
  • I'm assuming that building std from the rust-src component will be the common case.

Non-blockers:

• LLVM assertion when cargo building std with panic=abort #37252 LLVM assertion when cargo building std with panic=abort
  • This is one of the main use cases
• compiler_builtins: base conditional compilation on the specification #36512 compiler_builtins: base conditional compilation on the specification of the target rather than on its triple
  • Should make it easier/possible to compile compiler_builtins for custom targets.
• Port compiler-rt intrinsics to Rust #35437 port compiler-rt intrinsics to Rust
  • Should make it easier to port compiler_builtins to new targets and to add new
    intrinsics for features like i128.
  • Initial work: https://github.com/japaric/rustc-builtins
  • Merging into rust-lang/rust metabug: rust-lang/rust integration metabug compiler-builtins#66

Food for thought:

• Escape hatch for compiling std on stable/beta.
• Stability of this feature? Stability of Cargo features exposed by std and other crates?

---

Original issue

@alexcrichton in #34400:

One of the major blockers of our dream to "lazily compile std" is to ensure that we have the ability to compile compiler-rt on-demand.
#34400 was sort of half-tracking this issue before being closed by #35021, whose PR message implies that the bit about lazy compilation is yet to be done.

(And I'm frankly not even sure what lazy compilation of libstd even entails, so I'll have to ask @alexcrichton to elaborate further.)

[retep998]

And I'm frankly not even sure what lazy compilation of libstd even entails

Lazy compilation of libstd entails compiling libstd on the developer's machine even though they installed a prebuilt rustc. It means libstd would be built with the same flags as all your cargo dependencies. It means being able to compile any C bits that libstd depends on on the developer's machine. It also means if the developer is using the stable version of Rust, rustc can still somehow build libstd despite its dependence on unstable features.

[japaric]

I've added related issues from the top of my head to the top comment (I hope you don't mind @bstrie).

cc @brson @Ericson2314

[Ericson2314]

Brief thoughts on building trusted unstable packages on stable: https://internals.rust-lang.org/t/brsons-someday-list/3948/10

[bstrie]

I'm unsure whether this issue is still relevant; if a member of the compiler team happens to take a look at this and decide that this no longer reflects the current thinking then I'd be fine closing this.

[Ericson2314]

I would say rust-lang/wg-cargo-std-aware#51 this is its moral equivalent

[jyn514]

This looks like cargo's -Z build-std feature which has plenty of tracking issues already; I'm going to close this one in favor of https://github.com/rust-lang/wg-cargo-std-aware.