nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-05-12 09:57:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #133905 - jhpratt:rollup-iho8sl1, r=jhpratt

Browse Source 
Rollup of 6 pull requests

Successful merges:

 - #127565 (Teach rustc about the Xtensa VaListImpl)
 - #133844 (clarify simd_relaxed_fma non-determinism)
 - #133867 (Fix "std" support status of some tier 3 targets)
 - #133882 (Improve comments for the default backtrace printer)
 - #133888 (Improve bootstrap job objects)
 - #133898 (skip `setup::Hook` on non-git sources)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2024-12-05 17:54:18 +00:00
commit c94848c046
31 changed files with 200 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
compiler/rustc_codegen_llvm/src/va_arg.rs
View File

@ -10,6 +10,15 @@ use crate::type_::Type;
use crate::type_of::LayoutLlvmExt;
use crate::value::Value;
fn round_up_to_alignment<'ll>(
bx: &mut Builder<'_, 'll, '_>,
mut value: &'ll Value,
align: Align,
) -> &'ll Value {
value = bx.add(value, bx.cx().const_i32(align.bytes() as i32 - 1));
return bx.and(value, bx.cx().const_i32(-(align.bytes() as i32)));
}
fn round_pointer_up_to_alignment<'ll>(
bx: &mut Builder<'_, 'll, '_>,
addr: &'ll Value,
@ -17,8 +26,7 @@ fn round_pointer_up_to_alignment<'ll>(
ptr_ty: &'ll Type,
) -> &'ll Value {
let mut ptr_as_int = bx.ptrtoint(addr, bx.cx().type_isize());
ptr_as_int = bx.add(ptr_as_int, bx.cx().const_i32(align.bytes() as i32 - 1));
ptr_as_int = bx.and(ptr_as_int, bx.cx().const_i32(-(align.bytes() as i32)));
ptr_as_int = round_up_to_alignment(bx, ptr_as_int, align);
bx.inttoptr(ptr_as_int, ptr_ty)
}
@ -270,6 +278,106 @@ fn emit_s390x_va_arg<'ll, 'tcx>(
bx.load(val_type, val_addr, layout.align.abi)
}
fn emit_xtensa_va_arg<'ll, 'tcx>(
bx: &mut Builder<'_, 'll, 'tcx>,
list: OperandRef<'tcx, &'ll Value>,
target_ty: Ty<'tcx>,
) -> &'ll Value {
// Implementation of va_arg for Xtensa. There doesn't seem to be an authoritative source for
// this, other than "what GCC does".
//
// The va_list type has three fields:
// struct __va_list_tag {
// int32_t *va_stk; // Arguments passed on the stack
// int32_t *va_reg; // Arguments passed in registers, saved to memory by the prologue.
// int32_t va_ndx; // Offset into the arguments, in bytes
// };
//
// The first 24 bytes (equivalent to 6 registers) come from va_reg, the rest from va_stk.
// Thus if va_ndx is less than 24, the next va_arg *may* read from va_reg,
// otherwise it must come from va_stk.
//
// Primitive arguments are never split between registers and the stack. For example, if loading an 8 byte
// primitive value and va_ndx = 20, we instead bump the offset and read everything from va_stk.
let va_list_addr = list.immediate();
// FIXME: handle multi-field structs that split across regsave/stack?
let layout = bx.cx.layout_of(target_ty);
let from_stack = bx.append_sibling_block("va_arg.from_stack");
let from_regsave = bx.append_sibling_block("va_arg.from_regsave");
let end = bx.append_sibling_block("va_arg.end");
// (*va).va_ndx
let va_reg_offset = 4;
let va_ndx_offset = va_reg_offset + 4;
let offset_ptr =
bx.inbounds_gep(bx.type_i8(), va_list_addr, &[bx.cx.const_usize(va_ndx_offset)]);
let offset = bx.load(bx.type_i32(), offset_ptr, bx.tcx().data_layout.i32_align.abi);
let offset = round_up_to_alignment(bx, offset, layout.align.abi);
let slot_size = layout.size.align_to(Align::from_bytes(4).unwrap()).bytes() as i32;
// Update the offset in va_list, by adding the slot's size.
let offset_next = bx.add(offset, bx.const_i32(slot_size));
// Figure out where to look for our value. We do that by checking the end of our slot (offset_next).
// If that is within the regsave area, then load from there. Otherwise load from the stack area.
let regsave_size = bx.const_i32(24);
let use_regsave = bx.icmp(IntPredicate::IntULE, offset_next, regsave_size);
bx.cond_br(use_regsave, from_regsave, from_stack);
bx.switch_to_block(from_regsave);
// update va_ndx
bx.store(offset_next, offset_ptr, bx.tcx().data_layout.pointer_align.abi);
// (*va).va_reg
let regsave_area_ptr =
bx.inbounds_gep(bx.type_i8(), va_list_addr, &[bx.cx.const_usize(va_reg_offset)]);
let regsave_area =
bx.load(bx.type_ptr(), regsave_area_ptr, bx.tcx().data_layout.pointer_align.abi);
let regsave_value_ptr = bx.inbounds_gep(bx.type_i8(), regsave_area, &[offset]);
bx.br(end);
bx.switch_to_block(from_stack);
// The first time we switch from regsave to stack we needs to adjust our offsets a bit.
// va_stk is set up such that the first stack argument is always at va_stk + 32.
// The corrected offset is written back into the va_list struct.
// let offset_corrected = cmp::max(offset, 32);
let stack_offset_start = bx.const_i32(32);
let needs_correction = bx.icmp(IntPredicate::IntULE, offset, stack_offset_start);
let offset_corrected = bx.select(needs_correction, stack_offset_start, offset);
// let offset_next_corrected = offset_corrected + slot_size;
// va_ndx = offset_next_corrected;
let offset_next_corrected = bx.add(offset_next, bx.const_i32(slot_size));
// update va_ndx
bx.store(offset_next_corrected, offset_ptr, bx.tcx().data_layout.pointer_align.abi);
// let stack_value_ptr = unsafe { (*va).va_stk.byte_add(offset_corrected) };
let stack_area_ptr = bx.inbounds_gep(bx.type_i8(), va_list_addr, &[bx.cx.const_usize(0)]);
let stack_area = bx.load(bx.type_ptr(), stack_area_ptr, bx.tcx().data_layout.pointer_align.abi);
let stack_value_ptr = bx.inbounds_gep(bx.type_i8(), stack_area, &[offset_corrected]);
bx.br(end);
bx.switch_to_block(end);
// On big-endian, for values smaller than the slot size we'd have to align the read to the end
// of the slot rather than the start. While the ISA and GCC support big-endian, all the Xtensa
// targets supported by rustc are litte-endian so don't worry about it.
// if from_regsave {
// unsafe { *regsave_value_ptr }
// } else {
// unsafe { *stack_value_ptr }
// }
assert!(bx.tcx().sess.target.endian == Endian::Little);
let value_ptr =
bx.phi(bx.type_ptr(), &[regsave_value_ptr, stack_value_ptr], &[from_regsave, from_stack]);
return bx.load(layout.llvm_type(bx), value_ptr, layout.align.abi);
}
pub(super) fn emit_va_arg<'ll, 'tcx>(
bx: &mut Builder<'_, 'll, 'tcx>,
addr: OperandRef<'tcx, &'ll Value>,
@ -302,6 +410,7 @@ pub(super) fn emit_va_arg<'ll, 'tcx>(
let indirect: bool = target_ty_size > 8 || !target_ty_size.is_power_of_two();
emit_ptr_va_arg(bx, addr, target_ty, indirect, Align::from_bytes(8).unwrap(), false)
}
"xtensa" => emit_xtensa_va_arg(bx, addr, target_ty),
// For all other architecture/OS combinations fall back to using
// the LLVM va_arg instruction.
// https://llvm.org/docs/LangRef.html#va-arg-instruction

2
compiler/rustc_target/src/spec/targets/armv4t_unknown_linux_gnueabi.rs
View File

@ -7,7 +7,7 @@ pub(crate) fn target() -> Target {
description: Some("Armv4T Linux".into()),
tier: Some(3),
host_tools: Some(false),
std: None, // ?
std: Some(true),
},
pointer_width: 32,
data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),

2
compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_uclibceabi.rs
View File

@ -7,7 +7,7 @@ pub(crate) fn target() -> Target {
description: Some("Armv5TE Linux with uClibc".into()),
tier: Some(3),
host_tools: Some(false),
std: None, // ?
std: Some(true),
},
pointer_width: 32,
data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),

2
compiler/rustc_target/src/spec/targets/m68k_unknown_linux_gnu.rs
View File

@ -12,7 +12,7 @@ pub(crate) fn target() -> Target {
description: Some("Motorola 680x0 Linux".into()),
tier: Some(3),
host_tools: Some(false),
std: None, // ?
std: Some(true),
},
pointer_width: 32,
data_layout: "E-m:e-p:32:16:32-i8:8:8-i16:16:16-i32:16:32-n8:16:32-a:0:16-S16".into(),

2
compiler/rustc_target/src/spec/targets/mips64_openwrt_linux_musl.rs
View File

@ -17,7 +17,7 @@ pub(crate) fn target() -> Target {
description: Some("MIPS64 for OpenWrt Linux musl 1.2.3".into()),
tier: Some(3),
host_tools: Some(false),
std: None, // ?
std: Some(true),
},
pointer_width: 64,
data_layout: "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),

2
compiler/rustc_target/src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs
View File

@ -8,7 +8,7 @@ pub(crate) fn target() -> Target {
description: Some("32-bit MIPS Release 6 Big Endian".into()),
tier: Some(3),
host_tools: Some(false),
std: None, // ?
std: Some(true),
},
pointer_width: 32,
data_layout: "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(),

2
compiler/rustc_target/src/spec/targets/mipsisa32r6el_unknown_linux_gnu.rs
View File

@ -7,7 +7,7 @@ pub(crate) fn target() -> Target {
description: Some("32-bit MIPS Release 6 Little Endian".into()),
tier: Some(3),
host_tools: Some(false),
std: None, // ?
std: Some(true),
},
pointer_width: 32,
data_layout: "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(),

2
compiler/rustc_target/src/spec/targets/mipsisa64r6_unknown_linux_gnuabi64.rs
View File

@ -8,7 +8,7 @@ pub(crate) fn target() -> Target {
description: Some("64-bit MIPS Release 6 Big Endian".into()),
tier: Some(3),
host_tools: Some(false),
std: None, // ?
std: Some(true),
},
pointer_width: 64,
data_layout: "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),

2
compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs
View File

@ -14,7 +14,7 @@ pub(crate) fn target() -> Target {
description: Some("64-bit PowerPC Linux with musl 1.2.3".into()),
tier: Some(3),
host_tools: Some(false),
std: None, // ?
std: Some(true),
},
pointer_width: 64,
data_layout: "E-m:e-Fn32-i64:64-n32:64-S128-v256:256:256-v512:512:512".into(),

4
compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs
View File

@ -12,8 +12,8 @@ pub(crate) fn target() -> Target {
metadata: crate::spec::TargetMetadata {
description: Some("PPC64LE FreeBSD".into()),
tier: Some(3),
host_tools: Some(false),
std: Some(false),
host_tools: Some(true),
std: Some(true),
},
pointer_width: 64,
data_layout: "e-m:e-Fn32-i64:64-n32:64".into(),

2
compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs
View File

@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
description: Some("64-bit PowerPC Linux with musl 1.2.3, Little Endian".into()),
tier: Some(3),
host_tools: Some(false),
std: None, // ?
std: Some(true),
},
pointer_width: 64,
data_layout: "e-m:e-Fn32-i64:64-n32:64-S128-v256:256:256-v512:512:512".into(),

2
compiler/rustc_target/src/spec/targets/powerpc_unknown_freebsd.rs
View File

@ -17,7 +17,7 @@ pub(crate) fn target() -> Target {
description: Some("PowerPC FreeBSD".into()),
tier: Some(3),
host_tools: Some(false),
std: Some(false),
std: Some(true),
},
pointer_width: 32,
data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(),

2
compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_musl.rs
View File

@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
description: Some("PowerPC Linux with musl 1.2.3".into()),
tier: Some(3),
host_tools: Some(false),
std: None, // ?
std: Some(true),
},
pointer_width: 32,
data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(),

2
compiler/rustc_target/src/spec/targets/powerpc_unknown_openbsd.rs
View File

@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
description: None,
tier: Some(3),
host_tools: Some(false),
std: None, // ?
std: Some(true),
},
pointer_width: 32,
data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(),

2
compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_gnu.rs
View File

@ -9,7 +9,7 @@ pub(crate) fn target() -> Target {
description: Some("RISC-V Linux (kernel 5.4, glibc 2.33)".into()),
tier: Some(3),
host_tools: Some(false),
std: Some(false),
std: Some(true),
},
pointer_width: 32,
data_layout: "e-m:e-p:32:32-i64:64-n32-S128".into(),

2
compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_musl.rs
View File

@ -11,7 +11,7 @@ pub(crate) fn target() -> Target {
),
tier: Some(3),
host_tools: Some(false),
std: Some(false),
std: Some(true),
},
pointer_width: 32,
data_layout: "e-m:e-p:32:32-i64:64-n32-S128".into(),

2
compiler/rustc_target/src/spec/targets/riscv64_linux_android.rs
View File

@ -9,7 +9,7 @@ pub(crate) fn target() -> Target {
description: Some("RISC-V 64-bit Android".into()),
tier: Some(3),
host_tools: Some(false),
std: Some(false),
std: Some(true),
},
pointer_width: 64,
data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(),

2
compiler/rustc_target/src/spec/targets/riscv64gc_unknown_freebsd.rs
View File

@ -7,7 +7,7 @@ pub(crate) fn target() -> Target {
description: Some("RISC-V FreeBSD".into()),
tier: Some(3),
host_tools: Some(false),
std: Some(false),
std: Some(true),
},
pointer_width: 64,
data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(),

2
compiler/rustc_target/src/spec/targets/riscv64gc_unknown_fuchsia.rs
View File

@ -7,7 +7,7 @@ pub(crate) fn target() -> Target {
description: Some("RISC-V Fuchsia".into()),
tier: Some(3),
host_tools: Some(false),
std: Some(false),
std: Some(true),
},
pointer_width: 64,
data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(),

2
compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_musl.rs
View File

@ -9,7 +9,7 @@ pub(crate) fn target() -> Target {
description: Some("RISC-V Linux (kernel 4.20, musl 1.2.3)".into()),
tier: Some(3),
host_tools: Some(false),
std: Some(false),
std: Some(true),
},
pointer_width: 64,
data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(),

2
compiler/rustc_target/src/spec/targets/s390x_unknown_linux_musl.rs
View File

@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
description: Some("S390x Linux (kernel 3.2, musl 1.2.3)".into()),
tier: Some(3),
host_tools: Some(false),
std: Some(false),
std: Some(true),
},
pointer_width: 64,
data_layout: "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64".into(),

2
compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_musleabihf.rs
View File

@ -16,7 +16,7 @@ pub(crate) fn target() -> Target {
description: Some("Thumb2-mode ARMv7-A Linux with NEON, musl 1.2.3".into()),
tier: Some(3),
host_tools: Some(false),
std: None, // ?
std: Some(true),
},
pointer_width: 32,
data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),

2
compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_none.rs
View File

@ -14,7 +14,7 @@ pub(crate) fn target() -> Target {
description: None,
tier: None,
host_tools: None,
std: None,
std: Some(true),
},
pointer_width: 64,
data_layout:

1
library/core/Cargo.toml
View File

@ -43,6 +43,7 @@ check-cfg = [
'cfg(bootstrap)',
'cfg(no_fp_fmt_parse)',
'cfg(stdarch_intel_sde)',
'cfg(target_arch, values("xtensa"))',
# core use #[path] imports to portable-simd `core_simd` crate
# and to stdarch `core_arch` crate which messes-up with Cargo list
# of declared features, we therefor expect any feature cfg

19
library/core/src/ffi/va_list.rs
View File

@ -15,6 +15,7 @@ use crate::ops::{Deref, DerefMut};
not(target_arch = "aarch64"),
not(target_arch = "powerpc"),
not(target_arch = "s390x"),
not(target_arch = "xtensa"),
not(target_arch = "x86_64")
),
all(target_arch = "aarch64", target_vendor = "apple"),
@ -37,6 +38,7 @@ pub struct VaListImpl<'f> {
not(target_arch = "aarch64"),
not(target_arch = "powerpc"),
not(target_arch = "s390x"),
not(target_arch = "xtensa"),
not(target_arch = "x86_64")
),
all(target_arch = "aarch64", target_vendor = "apple"),
@ -113,6 +115,18 @@ pub struct VaListImpl<'f> {
_marker: PhantomData<&'f mut &'f c_void>,
}
/// Xtensa ABI implementation of a `va_list`.
#[cfg(target_arch = "xtensa")]
#[repr(C)]
#[derive(Debug)]
#[lang = "va_list"]
pub struct VaListImpl<'f> {
stk: *mut i32,
reg: *mut i32,
ndx: i32,
_marker: PhantomData<&'f mut &'f c_void>,
}
/// A wrapper for a `va_list`
#[repr(transparent)]
#[derive(Debug)]
@ -124,6 +138,7 @@ pub struct VaList<'a, 'f: 'a> {
not(target_arch = "s390x"),
not(target_arch = "x86_64")
),
target_arch = "xtensa",
all(target_arch = "aarch64", target_vendor = "apple"),
target_family = "wasm",
target_os = "uefi",
@ -138,6 +153,7 @@ pub struct VaList<'a, 'f: 'a> {
target_arch = "s390x",
target_arch = "x86_64"
),
not(target_arch = "xtensa"),
any(not(target_arch = "aarch64"), not(target_vendor = "apple")),
not(target_family = "wasm"),
not(target_os = "uefi"),
@ -155,6 +171,7 @@ pub struct VaList<'a, 'f: 'a> {
not(target_arch = "s390x"),
not(target_arch = "x86_64")
),
target_arch = "xtensa",
all(target_arch = "aarch64", target_vendor = "apple"),
target_family = "wasm",
target_os = "uefi",
@ -173,8 +190,10 @@ impl<'f> VaListImpl<'f> {
target_arch = "aarch64",
target_arch = "powerpc",
target_arch = "s390x",
target_arch = "xtensa",
target_arch = "x86_64"
),
not(target_arch = "xtensa"),
any(not(target_arch = "aarch64"), not(target_vendor = "apple")),
not(target_family = "wasm"),
not(target_os = "uefi"),

3
library/core/src/intrinsics/simd.rs
View File

@ -619,7 +619,8 @@ extern "rust-intrinsic" {
/// set has support for a fused operation, and that the fused operation is more efficient
/// than the equivalent, separate pair of mul and add instructions. It is unspecified
/// whether or not a fused operation is selected, and that may depend on optimization
/// level and context, for example.
/// level and context, for example. It may even be the case that some SIMD lanes get fused
/// and others do not.
///
/// `T` must be a vector of floats.
#[cfg(not(bootstrap))]

28
library/std/src/sys/backtrace.rs
View File

@ -58,8 +58,8 @@ unsafe fn _print_fmt(fmt: &mut fmt::Formatter<'_>, print_fmt: PrintFmt) -> fmt::
let mut res = Ok(());
let mut omitted_count: usize = 0;
let mut first_omit = true;
// Start immediately if we're not using a short backtrace.
let mut start = print_fmt != PrintFmt::Short;
// If we're using a short backtrace, ignore all frames until we're told to start printing.
let mut print = print_fmt != PrintFmt::Short;
set_image_base();
// SAFETY: we roll our own locking in this town
unsafe {
@ -72,27 +72,25 @@ unsafe fn _print_fmt(fmt: &mut fmt::Formatter<'_>, print_fmt: PrintFmt) -> fmt::
backtrace_rs::resolve_frame_unsynchronized(frame, |symbol| {
hit = true;
// Any frames between `__rust_begin_short_backtrace` and `__rust_end_short_backtrace`
// are omitted from the backtrace in short mode, `__rust_end_short_backtrace` will be
// called before the panic hook, so we won't ignore any frames if there is no
// invoke of `__rust_begin_short_backtrace`.
// `__rust_end_short_backtrace` means we are done hiding symbols
// for now. Print until we see `__rust_begin_short_backtrace`.
if print_fmt == PrintFmt::Short {
if let Some(sym) = symbol.name().and_then(|s| s.as_str()) {
if start && sym.contains("__rust_begin_short_backtrace") {
start = false;
return;
}
if sym.contains("__rust_end_short_backtrace") {
start = true;
print = true;
return;
}
if !start {
if print && sym.contains("__rust_begin_short_backtrace") {
print = false;
return;
}
if !print {
omitted_count += 1;
}
}
}
if start {
if print {
if omitted_count > 0 {
debug_assert!(print_fmt == PrintFmt::Short);
// only print the message between the middle of frames
@ -112,7 +110,7 @@ unsafe fn _print_fmt(fmt: &mut fmt::Formatter<'_>, print_fmt: PrintFmt) -> fmt::
});
#[cfg(target_os = "nto")]
if libc::__my_thread_exit as *mut libc::c_void == frame.ip() {
if !hit && start {
if !hit && print {
use crate::backtrace_rs::SymbolName;
res = bt_fmt.frame().print_raw(
frame.ip(),
@ -123,7 +121,7 @@ unsafe fn _print_fmt(fmt: &mut fmt::Formatter<'_>, print_fmt: PrintFmt) -> fmt::
}
return false;
}
if !hit && start {
if !hit && print {
res = bt_fmt.frame().print_raw(frame.ip(), None, None, None);
}

2
src/bootstrap/bootstrap.py
View File

@ -1184,6 +1184,8 @@ def bootstrap(args):
args = [build.bootstrap_binary()]
args.extend(sys.argv[1:])
env = os.environ.copy()
# The Python process ID is used when creating a Windows job object
# (see src\bootstrap\src\utils\job.rs)
env["BOOTSTRAP_PARENT_ID"] = str(os.getpid())
env["BOOTSTRAP_PYTHON"] = sys.executable
run(args, env=env, verbose=build.verbose, is_bootstrap=True)

10
src/bootstrap/src/core/build_steps/setup.rs
View File

@ -452,24 +452,26 @@ pub struct Hook;
impl Step for Hook {
type Output = ();
const DEFAULT: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
run.alias("hook")
}
fn make_run(run: RunConfig<'_>) {
if run.builder.config.dry_run() {
return;
}
if let [cmd] = &run.paths[..] {
if cmd.assert_single_path().path.as_path().as_os_str() == "hook" {
run.builder.ensure(Hook);
}
}
}
fn run(self, builder: &Builder<'_>) -> Self::Output {
let config = &builder.config;
if config.dry_run() {
if config.dry_run() || !config.rust_info.is_managed_git_subrepository() {
return;
}
t!(install_git_hook_maybe(builder, config));
}
}

41
src/bootstrap/src/utils/job.rs
View File

@ -15,11 +15,12 @@ pub unsafe fn setup(build: &mut crate::Build) {
///
/// Most of the time when you're running a build system (e.g., make) you expect
/// Ctrl-C or abnormal termination to actually terminate the entire tree of
/// process in play, not just the one at the top. This currently works "by
/// processes in play. This currently works "by
/// default" on Unix platforms because Ctrl-C actually sends a signal to the
/// *process group* rather than the parent process, so everything will get torn
/// down. On Windows, however, this does not happen and Ctrl-C just kills the
/// parent process.
/// *process group* so everything will get torn
/// down. On Windows, however, Ctrl-C is only sent to processes in the same console.
/// If a process is detached or attached to another console, it won't receive the
/// signal.
///
/// To achieve the same semantics on Windows we use Job Objects to ensure that
/// all processes die at the same time. Job objects have a mode of operation
@ -87,15 +88,7 @@ mod for_windows {
);
assert!(r.is_ok(), "{}", io::Error::last_os_error());
// Assign our process to this job object. Note that if this fails, one very
// likely reason is that we are ourselves already in a job object! This can
// happen on the build bots that we've got for Windows, or if just anyone
// else is instrumenting the build. In this case we just bail out
// immediately and assume that they take care of it.
//
// Also note that nested jobs (why this might fail) are supported in recent
// versions of Windows, but the version of Windows that our bots are running
// at least don't support nested job objects.
// Assign our process to this job object.
let r = AssignProcessToJobObject(job, GetCurrentProcess());
if r.is_err() {
CloseHandle(job).ok();
@ -124,14 +117,19 @@ mod for_windows {
// (only when wrongly setting the environmental variable),
// it might be better to improve the experience of the second case
// when users have interrupted the parent process and we haven't finish
// duplicating the handle yet. We just need close the job object if that occurs.
CloseHandle(job).ok();
// duplicating the handle yet.
return;
}
};
let mut parent_handle = HANDLE::default();
let r = DuplicateHandle(
// If this fails, well at least we tried! An example of DuplicateHandle
// failing in the past has been when the wrong python2 package spawned this
// build system (e.g., the `python2` package in MSYS instead of
// `mingw-w64-x86_64-python2`). Not sure why it failed, but the "failure
// mode" here is that we only clean everything up when the build system
// dies, not when the python parent does, so not too bad.
let _ = DuplicateHandle(
GetCurrentProcess(),
job,
parent,
@ -140,15 +138,6 @@ mod for_windows {
false,
DUPLICATE_SAME_ACCESS,
);
// If this failed, well at least we tried! An example of DuplicateHandle
// failing in the past has been when the wrong python2 package spawned this
// build system (e.g., the `python2` package in MSYS instead of
// `mingw-w64-x86_64-python2`). Not sure why it failed, but the "failure
// mode" here is that we only clean everything up when the build system
// dies, not when the python parent does, so not too bad.
if r.is_err() {
CloseHandle(job).ok();
}
CloseHandle(parent).ok();
}
}

16
src/doc/rustc/src/platform-support.md
View File

@ -344,15 +344,15 @@ target | std | host | notes
[`powerpc-wrs-vxworks-spe`](platform-support/vxworks.md) | ✓ | |
[`powerpc-wrs-vxworks`](platform-support/vxworks.md) | ✓ | |
`powerpc64-unknown-freebsd` | ✓ | ✓ | PPC64 FreeBSD (ELFv1 and ELFv2)
`powerpc64le-unknown-freebsd` | | | PPC64LE FreeBSD
`powerpc-unknown-freebsd` | | | PowerPC FreeBSD
`powerpc64le-unknown-freebsd` | ✓ | ✓ | PPC64LE FreeBSD
`powerpc-unknown-freebsd` | ? | | PowerPC FreeBSD
`powerpc64-unknown-linux-musl` | ? | | 64-bit PowerPC Linux with musl 1.2.3
[`powerpc64-wrs-vxworks`](platform-support/vxworks.md) | ✓ | |
`powerpc64le-unknown-linux-musl` | ? | | 64-bit PowerPC Linux with musl 1.2.3, Little Endian
[`powerpc64-unknown-openbsd`](platform-support/openbsd.md) | ✓ | ✓ | OpenBSD/powerpc64
[`powerpc64-ibm-aix`](platform-support/aix.md) | ? | | 64-bit AIX (7.2 and newer)
`riscv32gc-unknown-linux-gnu` | | | RISC-V Linux (kernel 5.4, glibc 2.33)
`riscv32gc-unknown-linux-musl` | | | RISC-V Linux (kernel 5.4, musl 1.2.3 + RISCV32 support patches)
`riscv32gc-unknown-linux-gnu` | ✓ | | RISC-V Linux (kernel 5.4, glibc 2.33)
`riscv32gc-unknown-linux-musl` | ? | | RISC-V Linux (kernel 5.4, musl 1.2.3 + RISCV32 support patches)
[`riscv32im-risc0-zkvm-elf`](platform-support/riscv32im-risc0-zkvm-elf.md) | ? | | RISC Zero's zero-knowledge Virtual Machine (RV32IM ISA)
[`riscv32ima-unknown-none-elf`](platform-support/riscv32-unknown-none-elf.md) | * | | Bare RISC-V (RV32IMA ISA)
[`riscv32imac-unknown-xous-elf`](platform-support/riscv32imac-unknown-xous-elf.md) | ? | | RISC-V Xous (RV32IMAC ISA)
@ -361,13 +361,13 @@ target | std | host | notes
[`riscv32imafc-esp-espidf`](platform-support/esp-idf.md) | ✓ | | RISC-V ESP-IDF
[`riscv32-wrs-vxworks`](platform-support/vxworks.md) | ✓ | |
[`riscv64gc-unknown-hermit`](platform-support/hermit.md) | ✓ | | RISC-V Hermit
`riscv64gc-unknown-freebsd` | | | RISC-V FreeBSD
`riscv64gc-unknown-fuchsia` | | | RISC-V Fuchsia
`riscv64gc-unknown-freebsd` | ? | | RISC-V FreeBSD
`riscv64gc-unknown-fuchsia` | ? | | RISC-V Fuchsia
[`riscv64gc-unknown-netbsd`](platform-support/netbsd.md) | ✓ | ✓ | RISC-V NetBSD
[`riscv64gc-unknown-openbsd`](platform-support/openbsd.md) | ✓ | ✓ | OpenBSD/riscv64
[`riscv64-linux-android`](platform-support/android.md) | | | RISC-V 64-bit Android
[`riscv64-linux-android`](platform-support/android.md) | ? | | RISC-V 64-bit Android
[`riscv64-wrs-vxworks`](platform-support/vxworks.md) | ✓ | |
[`s390x-unknown-linux-musl`](platform-support/s390x-unknown-linux-musl.md) | | | S390x Linux (kernel 3.2, musl 1.2.3)
[`s390x-unknown-linux-musl`](platform-support/s390x-unknown-linux-musl.md) | ✓ | | S390x Linux (kernel 3.2, musl 1.2.3)
`sparc-unknown-linux-gnu` | ✓ | | 32-bit SPARC Linux
[`sparc-unknown-none-elf`](./platform-support/sparc-unknown-none-elf.md) | * | | Bare 32-bit SPARC V7+
[`sparc64-unknown-netbsd`](platform-support/netbsd.md) | ✓ | ✓ | NetBSD/sparc64