diff --git a/src/bootstrap/native.rs b/src/bootstrap/native.rs index 002044050f351..93292c658bad2 100644 --- a/src/bootstrap/native.rs +++ b/src/bootstrap/native.rs @@ -596,8 +596,10 @@ impl Step for Openssl { "arm-linux-androideabi" => "android", "arm-unknown-linux-gnueabi" => "linux-armv4", "arm-unknown-linux-gnueabihf" => "linux-armv4", + "armv6-unknown-netbsd-eabihf" => "BSD-generic32", "armv7-linux-androideabi" => "android-armv7", "armv7-unknown-linux-gnueabihf" => "linux-armv4", + "armv7-unknown-netbsd-eabihf" => "BSD-generic32", "i586-unknown-linux-gnu" => "linux-elf", "i586-unknown-linux-musl" => "linux-elf", "i686-apple-darwin" => "darwin-i386-cc", diff --git a/src/etc/rust-gdb b/src/etc/rust-gdb index 52601cd96f80d..6835d6aa90874 100755 --- a/src/etc/rust-gdb +++ b/src/etc/rust-gdb @@ -21,6 +21,6 @@ GDB_PYTHON_MODULE_DIRECTORY="$RUSTC_SYSROOT/lib/rustlib/etc" # different/specific command (defaults to `gdb`). RUST_GDB="${RUST_GDB:-gdb}" PYTHONPATH="$PYTHONPATH:$GDB_PYTHON_MODULE_DIRECTORY" ${RUST_GDB} \ - -d "$GDB_PYTHON_MODULE_DIRECTORY" \ + --directory="$GDB_PYTHON_MODULE_DIRECTORY" \ -iex "add-auto-load-safe-path $GDB_PYTHON_MODULE_DIRECTORY" \ "$@" diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index 70aaf10f4213e..13d808ede5f65 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -2246,13 +2246,11 @@ impl str { #[inline(always)] #[rustc_const_unstable(feature="const_str_as_bytes")] pub const fn as_bytes(&self) -> &[u8] { - unsafe { - union Slices<'a> { - str: &'a str, - slice: &'a [u8], - } - Slices { str: self }.slice + union Slices<'a> { + str: &'a str, + slice: &'a [u8], } + unsafe { Slices { str: self }.slice } } /// Converts a mutable string slice to a mutable byte slice. To convert the diff --git a/src/libpanic_unwind/gcc.rs b/src/libpanic_unwind/gcc.rs index eb6dc5b548869..06c264725a9bb 100644 --- a/src/libpanic_unwind/gcc.rs +++ b/src/libpanic_unwind/gcc.rs @@ -143,7 +143,7 @@ const UNWIND_DATA_REG: (i32, i32) = (24, 25); // I0, I1 // The personality routine for most of our targets, except ARM, which has a slightly different ABI // (however, iOS goes here as it uses SjLj unwinding). Also, the 64-bit Windows implementation // lives in seh64_gnu.rs -#[cfg(all(any(target_os = "ios", not(target_arch = "arm"))))] +#[cfg(all(any(target_os = "ios", target_os = "netbsd", not(target_arch = "arm"))))] #[lang = "eh_personality"] #[no_mangle] #[allow(unused)] @@ -184,7 +184,7 @@ unsafe extern "C" fn rust_eh_personality(version: c_int, // ARM EHABI personality routine. // http://infocenter.arm.com/help/topic/com.arm.doc.ihi0038b/IHI0038B_ehabi.pdf -#[cfg(all(target_arch = "arm", not(target_os = "ios")))] +#[cfg(all(target_arch = "arm", not(target_os = "ios"), not(target_os = "netbsd")))] #[lang = "eh_personality"] #[no_mangle] unsafe extern "C" fn rust_eh_personality(state: uw::_Unwind_State, diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 3db8c746713fd..ad39f48972f69 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -51,8 +51,8 @@ //! enclosing function. On the way down the tree, it identifies those AST //! nodes and variable IDs that will be needed for the liveness analysis //! and assigns them contiguous IDs. The liveness id for an AST node is -//! called a `live_node` (it's a newtype'd usize) and the id for a variable -//! is called a `variable` (another newtype'd usize). +//! called a `live_node` (it's a newtype'd u32) and the id for a variable +//! is called a `variable` (another newtype'd u32). //! //! On the way back up the tree, as we are about to exit from a function //! declaration we allocate a `liveness` instance. Now that we know @@ -112,7 +112,7 @@ use lint; use util::nodemap::{NodeMap, NodeSet}; use std::collections::VecDeque; -use std::{fmt, usize}; +use std::{fmt, u32}; use std::io::prelude::*; use std::io; use std::rc::Rc; @@ -134,23 +134,17 @@ enum LoopKind<'a> { } #[derive(Copy, Clone, PartialEq)] -struct Variable(usize); +struct Variable(u32); -#[derive(Copy, PartialEq)] -struct LiveNode(usize); +#[derive(Copy, Clone, PartialEq)] +struct LiveNode(u32); impl Variable { - fn get(&self) -> usize { let Variable(v) = *self; v } + fn get(&self) -> usize { self.0 as usize } } impl LiveNode { - fn get(&self) -> usize { let LiveNode(v) = *self; v } -} - -impl Clone for LiveNode { - fn clone(&self) -> LiveNode { - LiveNode(self.get()) - } + fn get(&self) -> usize { self.0 as usize } } #[derive(Copy, Clone, PartialEq, Debug)] @@ -233,11 +227,11 @@ impl fmt::Debug for Variable { impl LiveNode { fn is_valid(&self) -> bool { - self.get() != usize::MAX + self.0 != u32::MAX } } -fn invalid_node() -> LiveNode { LiveNode(usize::MAX) } +fn invalid_node() -> LiveNode { LiveNode(u32::MAX) } struct CaptureInfo { ln: LiveNode, @@ -285,7 +279,7 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> { } fn add_live_node(&mut self, lnk: LiveNodeKind) -> LiveNode { - let ln = LiveNode(self.num_live_nodes); + let ln = LiveNode(self.num_live_nodes as u32); self.lnks.push(lnk); self.num_live_nodes += 1; @@ -303,7 +297,7 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> { } fn add_variable(&mut self, vk: VarKind) -> Variable { - let v = Variable(self.num_vars); + let v = Variable(self.num_vars as u32); self.var_kinds.push(vk); self.num_vars += 1; @@ -708,7 +702,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { for var_idx in 0..self.ir.num_vars { let idx = node_base_idx + var_idx; if test(idx).is_valid() { - write!(wr, " {:?}", Variable(var_idx))?; + write!(wr, " {:?}", Variable(var_idx as u32))?; } } Ok(()) @@ -848,7 +842,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { debug!("^^ liveness computation results for body {} (entry={:?})", { for ln_idx in 0..self.ir.num_live_nodes { - debug!("{:?}", self.ln_str(LiveNode(ln_idx))); + debug!("{:?}", self.ln_str(LiveNode(ln_idx as u32))); } body.id }, diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 960bbfdd1ef71..b3f1b9c8e627c 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -1337,6 +1337,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options, "enable the experimental Chalk-based trait solving engine"), cross_lang_lto: CrossLangLto = (CrossLangLto::Disabled, parse_cross_lang_lto, [TRACKED], "generate build artifacts that are compatible with linker-based LTO."), + no_parallel_llvm: bool = (false, parse_bool, [UNTRACKED], + "don't run LLVM in parallel (while keeping codegen-units and ThinLTO)"), } pub fn default_lib_output() -> CrateType { diff --git a/src/librustc/ty/maps/plumbing.rs b/src/librustc/ty/maps/plumbing.rs index c43b7e95b35e3..4a9d44b7403b9 100644 --- a/src/librustc/ty/maps/plumbing.rs +++ b/src/librustc/ty/maps/plumbing.rs @@ -701,6 +701,16 @@ macro_rules! define_maps { })* } + // This module and the functions in it exist only to provide a + // predictable symbol name prefix for query providers. This is helpful + // for analyzing queries in profilers. + pub(super) mod __query_compute { + $(#[inline(never)] + pub fn $name R, R>(f: F) -> R { + f() + })* + } + $(impl<$tcx> QueryConfig<$tcx> for queries::$name<$tcx> { type Key = $K; type Value = $V; @@ -722,9 +732,12 @@ macro_rules! define_maps { DepNode::new(tcx, $node(*key)) } + #[inline] fn compute(tcx: TyCtxt<'_, 'tcx, '_>, key: Self::Key) -> Self::Value { - let provider = tcx.maps.providers[key.map_crate()].$name; - provider(tcx.global_tcx(), key) + __query_compute::$name(move || { + let provider = tcx.maps.providers[key.map_crate()].$name; + provider(tcx.global_tcx(), key) + }) } fn handle_cycle_error(tcx: TyCtxt<'_, 'tcx, '_>) -> Self::Value { diff --git a/src/librustc_codegen_llvm/back/write.rs b/src/librustc_codegen_llvm/back/write.rs index 1151e0131313d..baab3c618be58 100644 --- a/src/librustc_codegen_llvm/back/write.rs +++ b/src/librustc_codegen_llvm/back/write.rs @@ -1738,7 +1738,9 @@ fn start_executing_work(tcx: TyCtxt, .binary_search_by_key(&cost, |&(_, cost)| cost) .unwrap_or_else(|e| e); work_items.insert(insertion_index, (work, cost)); - helper.request_token(); + if !cgcx.opts.debugging_opts.no_parallel_llvm { + helper.request_token(); + } } } @@ -1842,7 +1844,9 @@ fn start_executing_work(tcx: TyCtxt, }; work_items.insert(insertion_index, (llvm_work_item, cost)); - helper.request_token(); + if !cgcx.opts.debugging_opts.no_parallel_llvm { + helper.request_token(); + } assert_eq!(main_thread_worker_state, MainThreadWorkerState::Codegenning); main_thread_worker_state = MainThreadWorkerState::Idle; diff --git a/src/librustc_target/spec/armv6_unknown_netbsd_eabihf.rs b/src/librustc_target/spec/armv6_unknown_netbsd_eabihf.rs new file mode 100644 index 0000000000000..38f0f34211daf --- /dev/null +++ b/src/librustc_target/spec/armv6_unknown_netbsd_eabihf.rs @@ -0,0 +1,34 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; + +pub fn target() -> TargetResult { + let mut base = super::netbsd_base::opts(); + base.max_atomic_width = Some(64); + Ok(Target { + llvm_target: "armv6-unknown-netbsdelf-eabihf".to_string(), + target_endian: "little".to_string(), + target_pointer_width: "32".to_string(), + target_c_int_width: "32".to_string(), + data_layout: "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64".to_string(), + arch: "arm".to_string(), + target_os: "netbsd".to_string(), + target_env: "eabihf".to_string(), + target_vendor: "unknown".to_string(), + linker_flavor: LinkerFlavor::Gcc, + + options: TargetOptions { + features: "+v6,+vfp2".to_string(), + abi_blacklist: super::arm_base::abi_blacklist(), + .. base + } + }) +} diff --git a/src/librustc_target/spec/armv7_unknown_netbsd_eabihf.rs b/src/librustc_target/spec/armv7_unknown_netbsd_eabihf.rs new file mode 100644 index 0000000000000..412c354611519 --- /dev/null +++ b/src/librustc_target/spec/armv7_unknown_netbsd_eabihf.rs @@ -0,0 +1,35 @@ +// Copyright 2016 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; + +pub fn target() -> TargetResult { + let base = super::netbsd_base::opts(); + Ok(Target { + llvm_target: "armv7-unknown-netbsdelf-eabihf".to_string(), + target_endian: "little".to_string(), + target_pointer_width: "32".to_string(), + target_c_int_width: "32".to_string(), + data_layout: "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64".to_string(), + arch: "arm".to_string(), + target_os: "netbsd".to_string(), + target_env: "eabihf".to_string(), + target_vendor: "unknown".to_string(), + linker_flavor: LinkerFlavor::Gcc, + + options: TargetOptions { + features: "+v7,+vfp3,+d16,+thumb2,-neon".to_string(), + cpu: "generic".to_string(), + max_atomic_width: Some(64), + abi_blacklist: super::arm_base::abi_blacklist(), + .. base + } + }) +} diff --git a/src/librustc_target/spec/mod.rs b/src/librustc_target/spec/mod.rs index be0860d96466c..a0cbfe2fefae0 100644 --- a/src/librustc_target/spec/mod.rs +++ b/src/librustc_target/spec/mod.rs @@ -317,6 +317,8 @@ supported_targets! { ("i686-unknown-openbsd", i686_unknown_openbsd), ("x86_64-unknown-openbsd", x86_64_unknown_openbsd), + ("armv6-unknown-netbsd-eabihf", armv6_unknown_netbsd_eabihf), + ("armv7-unknown-netbsd-eabihf", armv7_unknown_netbsd_eabihf), ("i686-unknown-netbsd", i686_unknown_netbsd), ("powerpc-unknown-netbsd", powerpc_unknown_netbsd), ("sparc64-unknown-netbsd", sparc64_unknown_netbsd), diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index da04068107d3f..f112f3ca2ae53 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -97,6 +97,9 @@ pub fn try_inline(cx: &DocContext, def: Def, name: ast::Name, visited: &mut FxHa record_extern_fqn(cx, did, clean::TypeKind::Const); clean::ConstantItem(build_const(cx, did)) } + // Macros are eagerly inlined back in visit_ast, don't show their export statements + // FIXME(50647): the eager inline does not take doc(hidden)/doc(no_inline) into account + Def::Macro(..) => return Some(Vec::new()), _ => return None, }; cx.renderinfo.borrow_mut().inlined.insert(did); diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index 6db02cc6cc105..8c2555c4b3de2 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -219,6 +219,8 @@ impl<'a, 'tcx, 'rcx> RustdocVisitor<'a, 'tcx, 'rcx> { if let Some(exports) = self.cx.tcx.module_exports(def_id) { for export in exports.iter().filter(|e| e.vis == Visibility::Public) { if let Def::Macro(def_id, ..) = export.def { + // FIXME(50647): this eager macro inlining does not take + // doc(hidden)/doc(no_inline) into account if def_id.krate == LOCAL_CRATE { continue // These are `krate.exported_macros`, handled in `self.visit()`. } @@ -237,6 +239,7 @@ impl<'a, 'tcx, 'rcx> RustdocVisitor<'a, 'tcx, 'rcx> { unreachable!() }; + debug!("inlining macro {}", def.ident.name); om.macros.push(Macro { def_id, attrs: def.attrs.clone().into(), @@ -561,6 +564,7 @@ impl<'a, 'tcx, 'rcx> RustdocVisitor<'a, 'tcx, 'rcx> { // convert each exported_macro into a doc item fn visit_local_macro(&self, def: &hir::MacroDef) -> Macro { + debug!("visit_local_macro: {}", def.name); let tts = def.body.trees().collect::>(); // Extract the spans of all matchers. They represent the "interface" of the macro. let matchers = tts.chunks(4).map(|arm| arm[0].span()).collect(); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 1429d881fe9bc..2e66896324019 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -1771,27 +1771,27 @@ impl<'a> Parser<'a> { pub fn parse_arg_general(&mut self, require_name: bool) -> PResult<'a, Arg> { maybe_whole!(self, NtArg, |x| x); - let pat = if require_name || self.is_named_argument() { + let (pat, ty) = if require_name || self.is_named_argument() { debug!("parse_arg_general parse_pat (require_name:{})", require_name); let pat = self.parse_pat()?; self.expect(&token::Colon)?; - pat + (pat, self.parse_ty()?) } else { debug!("parse_arg_general ident_to_pat"); let ident = Ident::new(keywords::Invalid.name(), self.prev_span); - P(Pat { + let ty = self.parse_ty()?; + let pat = P(Pat { id: ast::DUMMY_NODE_ID, node: PatKind::Ident(BindingMode::ByValue(Mutability::Immutable), ident, None), - span: ident.span, - }) + span: ty.span, + }); + (pat, ty) }; - let t = self.parse_ty()?; - Ok(Arg { - ty: t, + ty, pat, id: ast::DUMMY_NODE_ID, }) diff --git a/src/libunwind/libunwind.rs b/src/libunwind/libunwind.rs index a640a2b777537..73a259bd4438e 100644 --- a/src/libunwind/libunwind.rs +++ b/src/libunwind/libunwind.rs @@ -93,7 +93,7 @@ extern "C" { } cfg_if! { -if #[cfg(all(any(target_os = "ios", not(target_arch = "arm"))))] { +if #[cfg(all(any(target_os = "ios", target_os = "netbsd", not(target_arch = "arm"))))] { // Not ARM EHABI #[repr(C)] #[derive(Copy, Clone, PartialEq)] diff --git a/src/llvm b/src/llvm index 56c931901cfb8..9ad4b7e8d7d16 160000 --- a/src/llvm +++ b/src/llvm @@ -1 +1 @@ -Subproject commit 56c931901cfb85cd6f7ed44c7d7520a8de1edf97 +Subproject commit 9ad4b7e8d7d1618fc9686aa8d3d0b4de3b7a6f36 diff --git a/src/test/rustdoc/pub-use-extern-macros.rs b/src/test/rustdoc/pub-use-extern-macros.rs index 57d54585d84bc..a6e707cc2adea 100644 --- a/src/test/rustdoc/pub-use-extern-macros.rs +++ b/src/test/rustdoc/pub-use-extern-macros.rs @@ -15,14 +15,15 @@ extern crate macros; // @has pub_use_extern_macros/macro.bar.html +// @!has pub_use_extern_macros/index.html '//code' 'pub use macros::bar;' pub use macros::bar; // @has pub_use_extern_macros/macro.baz.html -// @!has pub_use_extern_macros/index.html 'pub use macros::baz;' +// @!has pub_use_extern_macros/index.html '//code' 'pub use macros::baz;' #[doc(inline)] pub use macros::baz; // @has pub_use_extern_macros/macro.quux.html -// @!has pub_use_extern_macros/index.html 'pub use macros::quux;' +// @!has pub_use_extern_macros/index.html '//code' 'pub use macros::quux;' #[doc(hidden)] pub use macros::quux;