nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 06:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

rustbuild: Enable WebAssembly backend by default

Browse Source 
This commit alters how we compile LLVM by default enabling the WebAssembly
backend. This then also adds the wasm32-unknown-unknown target to get compiled
on the `cross` builder and distributed through rustup. Tests are not yet enabled
for this target but that should hopefully be coming soon!
This commit is contained in:
Alex Crichton 2017-11-20 06:22:17 -08:00
parent cc6b88ccb2
commit 48996f9e75
12 changed files with 140 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
config.toml.example
View File

@ -60,10 +60,9 @@
# LLVM experimental targets to build support for. These targets are specified in
# the same format as above, but since these targets are experimental, they are
# not built by default and the experimental Rust compilation targets that depend
# on them will not work unless the user opts in to building them. Possible
# experimental LLVM targets include WebAssembly for the
# wasm32-experimental-emscripten Rust target.
#experimental-targets = ""
# on them will not work unless the user opts in to building them. By default the
# `WebAssembly` target is enabled when compiling LLVM from scratch.
#experimental-targets = "WebAssembly"
# Cap the number of parallel linker invocations when compiling LLVM.
# This can be useful when building LLVM with debug info, which significantly

5
src/bootstrap/config.rs
View File

@ -76,7 +76,7 @@ pub struct Config {
pub llvm_static_stdcpp: bool,
pub llvm_link_shared: bool,
pub llvm_targets: Option<String>,
pub llvm_experimental_targets: Option<String>,
pub llvm_experimental_targets: String,
pub llvm_link_jobs: Option<u32>,
// rust codegen options
@ -447,7 +447,8 @@ impl Config {
set(&mut config.llvm_static_stdcpp, llvm.static_libstdcpp);
set(&mut config.llvm_link_shared, llvm.link_shared);
config.llvm_targets = llvm.targets.clone();
config.llvm_experimental_targets = llvm.experimental_targets.clone();
config.llvm_experimental_targets = llvm.experimental_targets.clone()
.unwrap_or("WebAssembly".to_string());
config.llvm_link_jobs = llvm.link_jobs;
}

5
src/bootstrap/native.rs
View File

@ -110,10 +110,7 @@ impl Step for Llvm {
None => "X86;ARM;AArch64;Mips;PowerPC;SystemZ;JSBackend;MSP430;Sparc;NVPTX;Hexagon",
};
let llvm_exp_targets = match build.config.llvm_experimental_targets {
Some(ref s) => s,
None => "",
};
let llvm_exp_targets = &build.config.llvm_experimental_targets;
let assertions = if build.config.llvm_assertions {"ON"} else {"OFF"};

1
src/ci/docker/cross2/Dockerfile
View File

@ -47,6 +47,7 @@ ENV \
ENV TARGETS=x86_64-unknown-fuchsia
ENV TARGETS=$TARGETS,aarch64-unknown-fuchsia
ENV TARGETS=$TARGETS,sparcv9-sun-solaris
ENV TARGETS=$TARGETS,wasm32-unknown-unknown
ENV TARGETS=$TARGETS,x86_64-sun-solaris
ENV TARGETS=$TARGETS,x86_64-unknown-linux-gnux32

8
src/librustc_driver/driver.rs
View File

@ -56,6 +56,7 @@ use std::sync::mpsc;
use syntax::{ast, diagnostics, visit};
use syntax::attr;
use syntax::ext::base::ExtCtxt;
use syntax::fold::Folder;
use syntax::parse::{self, PResult};
use syntax::util::node_count::NodeCounter;
use syntax;
@ -63,6 +64,7 @@ use syntax_ext;
use arena::DroplessArena;
use derive_registrar;
use pretty::ReplaceBodyWithLoop;
use profile;
@ -809,6 +811,12 @@ pub fn phase_2_configure_and_expand<F>(sess: &Session,
sess.diagnostic())
});
// If we're actually rustdoc then there's no need to actually compile
// anything, so switch everything to just looping
if sess.opts.actually_rustdoc {
krate = ReplaceBodyWithLoop::new(sess).fold_crate(krate);
}
// If we're in rustdoc we're always compiling as an rlib, but that'll trip a
// bunch of checks in the `modify` function below. For now just skip this
// step entirely if we're rustdoc as it's not too useful anyway.

6
src/librustc_driver/lib.rs
View File

@ -565,7 +565,9 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
control.after_hir_lowering.stop = Compilation::Stop;
control.after_parse.callback = box move |state| {
state.krate = Some(pretty::fold_crate(state.krate.take().unwrap(), ppm));
state.krate = Some(pretty::fold_crate(state.session,
state.krate.take().unwrap(),
ppm));
};
control.after_hir_lowering.callback = box move |state| {
pretty::print_after_hir_lowering(state.session,
@ -587,7 +589,7 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
control.after_parse.stop = Compilation::Stop;
control.after_parse.callback = box move |state| {
let krate = pretty::fold_crate(state.krate.take().unwrap(), ppm);
let krate = pretty::fold_crate(state.session, state.krate.take().unwrap(), ppm);
pretty::print_after_parsing(state.session,
state.input,
&krate,

29
src/librustc_driver/pretty.rs
View File

@ -638,13 +638,14 @@ impl UserIdentifiedItem {
// ambitious form of the closed RFC #1637. See also [#34511].
//
// [#34511]: https://github.com/rust-lang/rust/issues/34511#issuecomment-322340401
pub struct ReplaceBodyWithLoop {
pub struct ReplaceBodyWithLoop<'a> {
within_static_or_const: bool,
sess: &'a Session,
}
impl ReplaceBodyWithLoop {
pub fn new() -> ReplaceBodyWithLoop {
ReplaceBodyWithLoop { within_static_or_const: false }
impl<'a> ReplaceBodyWithLoop<'a> {
pub fn new(sess: &'a Session) -> ReplaceBodyWithLoop<'a> {
ReplaceBodyWithLoop { within_static_or_const: false, sess }
}
fn run<R, F: FnOnce(&mut Self) -> R>(&mut self, is_const: bool, action: F) -> R {
@ -691,7 +692,7 @@ impl ReplaceBodyWithLoop {
}
}
impl fold::Folder for ReplaceBodyWithLoop {
impl<'a> fold::Folder for ReplaceBodyWithLoop<'a> {
fn fold_item_kind(&mut self, i: ast::ItemKind) -> ast::ItemKind {
let is_const = match i {
ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => true,
@ -723,11 +724,13 @@ impl fold::Folder for ReplaceBodyWithLoop {
}
fn fold_block(&mut self, b: P<ast::Block>) -> P<ast::Block> {
fn expr_to_block(rules: ast::BlockCheckMode, e: Option<P<ast::Expr>>) -> P<ast::Block> {
fn expr_to_block(rules: ast::BlockCheckMode,
e: Option<P<ast::Expr>>,
sess: &Session) -> P<ast::Block> {
P(ast::Block {
stmts: e.map(|e| {
ast::Stmt {
id: ast::DUMMY_NODE_ID,
id: sess.next_node_id(),
span: e.span,
node: ast::StmtKind::Expr(e),
}
@ -735,22 +738,22 @@ impl fold::Folder for ReplaceBodyWithLoop {
.into_iter()
.collect(),
rules,
id: ast::DUMMY_NODE_ID,
id: sess.next_node_id(),
span: syntax_pos::DUMMY_SP,
})
}
if !self.within_static_or_const {
let empty_block = expr_to_block(BlockCheckMode::Default, None);
let empty_block = expr_to_block(BlockCheckMode::Default, None, self.sess);
let loop_expr = P(ast::Expr {
node: ast::ExprKind::Loop(empty_block, None),
id: ast::DUMMY_NODE_ID,
id: self.sess.next_node_id(),
span: syntax_pos::DUMMY_SP,
attrs: ast::ThinVec::new(),
});
expr_to_block(b.rules, Some(loop_expr))
expr_to_block(b.rules, Some(loop_expr), self.sess)
} else {
fold::noop_fold_block(b, self)
@ -829,9 +832,9 @@ fn print_flowgraph<'a, 'tcx, W: Write>(variants: Vec<borrowck_dot::Variant>,
}
}
pub fn fold_crate(krate: ast::Crate, ppm: PpMode) -> ast::Crate {
pub fn fold_crate(sess: &Session, krate: ast::Crate, ppm: PpMode) -> ast::Crate {
if let PpmSource(PpmEveryBodyLoops) = ppm {
let mut fold = ReplaceBodyWithLoop::new();
let mut fold = ReplaceBodyWithLoop::new(sess);
fold.fold_crate(krate)
} else {
krate

3
src/librustdoc/core.rs
View File

@ -10,7 +10,6 @@
use rustc_lint;
use rustc_driver::{driver, target_features, abort_on_err};
use rustc_driver::pretty::ReplaceBodyWithLoop;
use rustc::session::{self, config};
use rustc::hir::def_id::DefId;
use rustc::hir::def::Def;
@ -26,7 +25,6 @@ use rustc_metadata::cstore::CStore;
use syntax::codemap;
use syntax::feature_gate::UnstableFeatures;
use syntax::fold::Folder;
use errors;
use errors::emitter::ColorConfig;
@ -157,7 +155,6 @@ pub fn run_core(search_paths: SearchPaths,
let control = &driver::CompileController::basic();
let krate = panictry!(driver::phase_1_parse_input(control, &sess, &input));
let krate = ReplaceBodyWithLoop::new().fold_crate(krate);
let name = link::find_crate_name(Some(&sess), &krate.attrs, &input);

3
src/librustdoc/test.rs
View File

@ -31,7 +31,6 @@ use rustc_back::dynamic_lib::DynamicLibrary;
use rustc_back::tempdir::TempDir;
use rustc_driver::{self, driver, Compilation};
use rustc_driver::driver::phase_2_configure_and_expand;
use rustc_driver::pretty::ReplaceBodyWithLoop;
use rustc_metadata::cstore::CStore;
use rustc_resolve::MakeGlobMap;
use rustc_trans;
@ -39,7 +38,6 @@ use rustc_trans::back::link;
use syntax::ast;
use syntax::codemap::CodeMap;
use syntax::feature_gate::UnstableFeatures;
use syntax::fold::Folder;
use syntax_pos::{BytePos, DUMMY_SP, Pos, Span};
use errors;
use errors::emitter::ColorConfig;
@ -97,7 +95,6 @@ pub fn run(input: &str,
let krate = panictry!(driver::phase_1_parse_input(&driver::CompileController::basic(),
&sess,
&input));
let krate = ReplaceBodyWithLoop::new().fold_crate(krate);
let driver::ExpansionResult { defs, mut hir_forest, .. } = {
phase_2_configure_and_expand(
&sess,

72
src/libstd/os/mod.rs
View File

@ -13,35 +13,53 @@
#![stable(feature = "os", since = "1.0.0")]
#![allow(missing_docs, bad_style, missing_debug_implementations)]
#[cfg(all(not(dox), any(target_os = "redox", unix)))]
#[stable(feature = "rust1", since = "1.0.0")]
pub use sys::ext as unix;
#[cfg(all(not(dox), windows))]
#[stable(feature = "rust1", since = "1.0.0")]
pub use sys::ext as windows;
cfg_if! {
if #[cfg(dox)] {
#[cfg(dox)]
#[stable(feature = "rust1", since = "1.0.0")]
pub use sys::unix_ext as unix;
#[cfg(dox)]
#[stable(feature = "rust1", since = "1.0.0")]
pub use sys::windows_ext as windows;
// When documenting libstd we want to show unix/windows/linux modules as
// these are the "main modules" that are used across platforms. This
// should help show platform-specific functionality in a hopefully
// cross-platform way in the documentation
#[cfg(any(dox, target_os = "linux", target_os = "l4re"))]
#[doc(cfg(target_os = "linux"))]
pub mod linux;
#[stable(feature = "rust1", since = "1.0.0")]
pub use sys::unix_ext as unix;
#[cfg(all(not(dox), target_os = "android"))] pub mod android;
#[cfg(all(not(dox), target_os = "bitrig"))] pub mod bitrig;
#[cfg(all(not(dox), target_os = "dragonfly"))] pub mod dragonfly;
#[cfg(all(not(dox), target_os = "freebsd"))] pub mod freebsd;
#[cfg(all(not(dox), target_os = "haiku"))] pub mod haiku;
#[cfg(all(not(dox), target_os = "ios"))] pub mod ios;
#[cfg(all(not(dox), target_os = "macos"))] pub mod macos;
#[cfg(all(not(dox), target_os = "netbsd"))] pub mod netbsd;
#[cfg(all(not(dox), target_os = "openbsd"))] pub mod openbsd;
#[cfg(all(not(dox), target_os = "solaris"))] pub mod solaris;
#[cfg(all(not(dox), target_os = "emscripten"))] pub mod emscripten;
#[cfg(all(not(dox), target_os = "fuchsia"))] pub mod fuchsia;
#[stable(feature = "rust1", since = "1.0.0")]
pub use sys::windows_ext as windows;
#[doc(cfg(target_os = "linux"))]
pub mod linux;
} else {
// If we're not documenting libstd then we just expose everything as we
// otherwise would.
#[cfg(target_os = "android")] pub mod android;
#[cfg(target_os = "bitrig")] pub mod bitrig;
#[cfg(target_os = "dragonfly")] pub mod dragonfly;
#[cfg(target_os = "freebsd")] pub mod freebsd;
#[cfg(target_os = "haiku")] pub mod haiku;
#[cfg(target_os = "ios")] pub mod ios;
#[cfg(target_os = "macos")] pub mod macos;
#[cfg(target_os = "netbsd")] pub mod netbsd;
#[cfg(target_os = "openbsd")] pub mod openbsd;
#[cfg(target_os = "solaris")] pub mod solaris;
#[cfg(target_os = "emscripten")] pub mod emscripten;
#[cfg(target_os = "fuchsia")] pub mod fuchsia;
#[cfg(any(target_os = "redox", unix))]
#[stable(feature = "rust1", since = "1.0.0")]
pub use sys::ext as unix;
#[cfg(windows)]
#[stable(feature = "rust1", since = "1.0.0")]
pub use sys::ext as windows;
#[cfg(any(target_os = "linux", target_os = "l4re"))]
pub mod linux;
}
}
pub mod raw;

99
src/libstd/sys/mod.rs
View File

@ -32,49 +32,66 @@
#![allow(missing_debug_implementations)]
pub use self::imp::*;
cfg_if! {
if #[cfg(unix)] {
mod unix;
pub use self::unix::*;
} else if #[cfg(windows)] {
mod windows;
pub use self::windows::*;
} else if #[cfg(target_os = "redox")] {
mod redox;
pub use self::redox::*;
} else if #[cfg(target_arch = "wasm32")] {
mod wasm;
pub use self::wasm::*;
} else {
compile_error!("libstd doesn't compile for this platform yet");
}
}
#[cfg(unix)]
#[path = "unix/mod.rs"]
mod imp;
// Import essential modules from both platforms when documenting. These are
// then later used in the `std::os` module when documenting, for example,
// Windows when we're compiling for Linux.
#[cfg(windows)]
#[path = "windows/mod.rs"]
mod imp;
#[cfg(dox)]
cfg_if! {
if #[cfg(any(unix, target_os = "redox"))] {
// On unix we'll document what's already available
pub use self::ext as unix_ext;
} else if #[cfg(target_arch = "wasm32")] {
// On wasm right now the module below doesn't compile (missing things
// in `libc` which is empty) so just omit everything with an empty module
#[unstable(issue = "0", feature = "std_internals")]
pub mod unix_ext {}
} else {
// On other platforms like Windows document the bare bones of unix
use os::linux as platform;
#[path = "unix/ext/mod.rs"]
pub mod unix_ext;
}
}
#[cfg(target_os = "redox")]
#[path = "redox/mod.rs"]
mod imp;
#[cfg(dox)]
cfg_if! {
if #[cfg(windows)] {
// On windows we'll just be documenting what's already available
pub use self::ext as windows_ext;
} else if #[cfg(target_arch = "wasm32")] {
// On wasm right now the shim below doesn't compile, so just omit it
#[unstable(issue = "0", feature = "std_internals")]
pub mod windows_ext {}
} else {
// On all other platforms (aka linux/osx/etc) then pull in a "minimal"
// amount of windows goop which ends up compiling
#[macro_use]
#[path = "windows/compat.rs"]
mod compat;
#[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
#[path = "wasm/mod.rs"]
mod imp;
#[path = "windows/c.rs"]
mod c;
// Import essential modules from both platforms when documenting.
#[cfg(all(dox, not(unix)))]
use os::linux as platform;
#[cfg(all(dox, not(any(unix, target_os = "redox"))))]
#[path = "unix/ext/mod.rs"]
pub mod unix_ext;
#[cfg(all(dox, any(unix, target_os = "redox")))]
pub use self::ext as unix_ext;
#[cfg(all(dox, not(windows)))]
#[macro_use]
#[path = "windows/compat.rs"]
mod compat;
#[cfg(all(dox, not(windows)))]
#[path = "windows/c.rs"]
mod c;
#[cfg(all(dox, not(windows)))]
#[path = "windows/ext/mod.rs"]
pub mod windows_ext;
#[cfg(all(dox, windows))]
pub use self::ext as windows_ext;
#[path = "windows/ext/mod.rs"]
pub mod windows_ext;
}
}

1
src/tools/build-manifest/src/main.rs
View File

@ -84,6 +84,7 @@ static TARGETS: &'static [&'static str] = &[
"sparc64-unknown-linux-gnu",
"sparcv9-sun-solaris",
"wasm32-unknown-emscripten",
"wasm32-unknown-unknown",
"x86_64-linux-android",
"x86_64-apple-darwin",
"x86_64-apple-ios",