Auto merge of #51023 - kennytm:rollup, r=kennytm

Rollup of 9 pull requests

Successful merges:

 - #50864 (Add NetBSD/arm target specs)
 - #50956 (rust-gdb: work around the re-used -d argument in cgdb)
 - #50964 (Make sure that queries have predictable symbol names.)
 - #50965 (Update LLVM to pull in another wasm fix)
 - #50972 (Add -Z no-parallel-llvm flag)
 - #50979 (Fix span for type-only arguments)
 - #50981 (Shrink `LiveNode`.)
 - #50995 (move type out of unsafe block)
 - #51011 ( rustdoc: hide macro export statements from docs)

Failed merges:

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",

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" \
   "$@"

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

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,

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
                },

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 {

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<F: FnOnce() -> 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 {

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;

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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, 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
+        }
+    })
+}

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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, 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
+        }
+    })
+}

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),

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);

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::<Vec<_>>();
         // Extract the spans of all matchers. They represent the "interface" of the macro.
         let matchers = tts.chunks(4).map(|arm| arm[0].span()).collect();

src/libsyntax/parse/parser.rs

@@ -1772,27 +1772,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,
         })

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)]

src/llvm

@@ -1 +1 @@
-Subproject commit 56c931901cfb85cd6f7ed44c7d7520a8de1edf97
+Subproject commit 9ad4b7e8d7d1618fc9686aa8d3d0b4de3b7a6f36

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;