rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Auto merge of #138279 - matthiaskrgr:rollup-ndnoipr, r=matthiaskrgr

Browse Source 
Rollup of 7 pull requests

Successful merges:

 - #122790 (Apply dllimport in ThinLTO)
 - #137650 (Move `fs` into `sys`)
 - #138228 (Use `disjoint_bitor` inside `borrowing_sub`)
 - #138233 (Windows: Don't link std (and run-make) against advapi32, except on win7)
 - #138253 (Continue to check attr if meet empty repr for adt)
 - #138263 (Fix `repr128-dwarf` test)
 - #138276 (Lazy load NtOpenFile for UWP)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors
2025-03-09 18:32:36 +00:00
parent 385970f0c1 33530e4cb9
commit 3ea711f17e
43 changed files with 160 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
compiler/rustc_codegen_llvm/src/consts.rs
View File

@@ -16,7 +16,6 @@ use rustc_middle::mir::mono::MonoItem;
use rustc_middle::ty::Instance;
use rustc_middle::ty::layout::{HasTypingEnv, LayoutOf};
use rustc_middle::{bug, span_bug};
use rustc_session::config::Lto;
use tracing::{debug, instrument, trace};
use crate::common::{AsCCharPtr, CodegenCx};
@@ -344,11 +343,11 @@ impl<'ll> CodegenCx<'ll, '_> {
// Local definitions can never be imported, so we must not apply
// the DLLImport annotation.
&& !dso_local
// ThinLTO can't handle this workaround in all cases, so we don't
// emit the attrs. Instead we make them unnecessary by disallowing
// dynamic linking when linker plugin based LTO is enabled.
&& !self.tcx.sess.opts.cg.linker_plugin_lto.enabled()
&& self.tcx.sess.lto() != Lto::Thin;
// Linker plugin ThinLTO doesn't create the self-dllimport Rust uses for rlibs
// as the code generation happens out of process. Instead we assume static linkage
// and disallow dynamic linking when linker plugin based LTO is enabled.
// Regular in-process ThinLTO doesn't need this workaround.
&& !self.tcx.sess.opts.cg.linker_plugin_lto.enabled();
// If this assertion triggers, there's something wrong with commandline
// argument validation.

2
compiler/rustc_passes/src/check_attr.rs
View File

@@ -1998,7 +1998,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
// catch `repr()` with no arguments, applied to an item (i.e. not `#![repr()]`)
if item.is_some() {
match target {
Target::Struct | Target::Union | Target::Enum => {}
Target::Struct | Target::Union | Target::Enum => continue,
Target::Fn | Target::Method(_) => {
feature_err(
&self.tcx.sess,

11
library/core/src/num/uint_macros.rs
View File

@@ -2533,15 +2533,20 @@ macro_rules! uint_impl {
#[doc = concat!("assert_eq!((diff1, diff0), (3, ", stringify!($SelfT), "::MAX));")]
/// ```
#[unstable(feature = "bigint_helper_methods", issue = "85532")]
#[rustc_const_unstable(feature = "bigint_helper_methods", issue = "85532")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
pub const fn borrowing_sub(self, rhs: Self, borrow: bool) -> (Self, bool) {
// note: longer-term this should be done via an intrinsic, but this has been shown
// to generate optimal code for now, and LLVM doesn't have an equivalent intrinsic
let (a, b) = self.overflowing_sub(rhs);
let (c, d) = a.overflowing_sub(borrow as $SelfT);
(c, b | d)
let (a, c1) = self.overflowing_sub(rhs);
let (b, c2) = a.overflowing_sub(borrow as $SelfT);
// SAFETY: Only one of `c1` and `c2` can be set.
// For c1 to be set we need to have underflowed, but if we did then
// `a` is nonzero, which means that `c2` cannot possibly
// underflow because it's subtracting at most `1` (since it came from `bool`)
(b, unsafe { intrinsics::disjoint_bitor(c1, c2) })
}
/// Calculates `self` - `rhs` with a signed `rhs`

0
library/std/src/sys_common/fs.rs → library/std/src/sys/fs/common.rs
View File

12
library/std/src/sys/pal/hermit/fs.rs → library/std/src/sys/fs/hermit.rs
View File

@@ -1,18 +1,18 @@
use super::fd::FileDesc;
use super::hermit_abi::{
self, DT_DIR, DT_LNK, DT_REG, DT_UNKNOWN, O_APPEND, O_CREAT, O_DIRECTORY, O_EXCL, O_RDONLY,
O_RDWR, O_TRUNC, O_WRONLY, S_IFDIR, S_IFLNK, S_IFMT, S_IFREG, dirent64, stat as stat_struct,
};
use crate::ffi::{CStr, OsStr, OsString, c_char};
use crate::io::{self, BorrowedCursor, Error, ErrorKind, IoSlice, IoSliceMut, SeekFrom};
use crate::os::hermit::ffi::OsStringExt;
use crate::os::hermit::hermit_abi::{
self, DT_DIR, DT_LNK, DT_REG, DT_UNKNOWN, O_APPEND, O_CREAT, O_DIRECTORY, O_EXCL, O_RDONLY,
O_RDWR, O_TRUNC, O_WRONLY, S_IFDIR, S_IFLNK, S_IFMT, S_IFREG, dirent64, stat as stat_struct,
};
use crate::os::hermit::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
use crate::path::{Path, PathBuf};
use crate::sync::Arc;
use crate::sys::common::small_c_string::run_path_with_cstr;
pub use crate::sys::fs::common::{copy, exists};
use crate::sys::pal::fd::FileDesc;
use crate::sys::time::SystemTime;
use crate::sys::{cvt, unsupported};
pub use crate::sys_common::fs::{copy, exists};
use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
use crate::{fmt, mem};

28
library/std/src/sys/fs/mod.rs Normal file
View File

@@ -0,0 +1,28 @@
#![deny(unsafe_op_in_unsafe_fn)]
pub mod common;
cfg_if::cfg_if! {
if #[cfg(target_family = "unix")] {
mod unix;
pub use unix::*;
} else if #[cfg(target_os = "windows")] {
mod windows;
pub use windows::*;
} else if #[cfg(target_os = "hermit")] {
mod hermit;
pub use hermit::*;
} else if #[cfg(target_os = "solid_asp3")] {
mod solid;
pub use solid::*;
} else if #[cfg(target_os = "uefi")] {
mod uefi;
pub use uefi::*;
} else if #[cfg(target_os = "wasi")] {
mod wasi;
pub use wasi::*;
} else {
mod unsupported;
pub use unsupported::*;
}
}

6
library/std/src/sys/pal/solid/fs.rs → library/std/src/sys/fs/solid.rs
View File

@@ -1,4 +1,5 @@
use super::{abi, error};
#![allow(dead_code)]
use crate::ffi::{CStr, CString, OsStr, OsString};
use crate::fmt;
use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
@@ -7,9 +8,10 @@ use crate::os::raw::{c_int, c_short};
use crate::os::solid::ffi::OsStrExt;
use crate::path::{Path, PathBuf};
use crate::sync::Arc;
pub use crate::sys::fs::common::exists;
use crate::sys::pal::{abi, error};
use crate::sys::time::SystemTime;
use crate::sys::unsupported;
pub use crate::sys_common::fs::exists;
use crate::sys_common::ignore_notfound;
type CIntNotMinusOne = core::num::niche_types::NotAllOnes<c_int>;

0
library/std/src/sys/pal/uefi/fs.rs → library/std/src/sys/fs/uefi.rs
View File

14
library/std/src/sys/pal/unix/fs.rs → library/std/src/sys/fs/unix.rs
View File

@@ -1,3 +1,5 @@
#![allow(nonstandard_style)]
#![allow(unsafe_op_in_unsafe_fn)]
// miri has some special hacks here that make things unused.
#![cfg_attr(miri, allow(unused))]
@@ -79,13 +81,13 @@ use crate::path::{Path, PathBuf};
use crate::sync::Arc;
use crate::sys::common::small_c_string::run_path_with_cstr;
use crate::sys::fd::FileDesc;
pub use crate::sys::fs::common::exists;
use crate::sys::time::SystemTime;
#[cfg(all(target_os = "linux", target_env = "gnu"))]
use crate::sys::weak::syscall;
#[cfg(target_os = "android")]
use crate::sys::weak::weak;
use crate::sys::{cvt, cvt_r};
pub use crate::sys_common::fs::exists;
use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
use crate::{mem, ptr};
@@ -699,6 +701,8 @@ impl Iterator for ReadDir {
target_os = "hurd",
))]
fn next(&mut self) -> Option<io::Result<DirEntry>> {
use crate::sys::os::{errno, set_errno};
if self.end_of_stream {
return None;
}
@@ -710,7 +714,7 @@ impl Iterator for ReadDir {
// with unlimited or variable NAME_MAX. Many modern platforms guarantee
// thread safety for readdir() as long an individual DIR* is not accessed
// concurrently, which is sufficient for Rust.
super::os::set_errno(0);
set_errno(0);
let entry_ptr: *const dirent64 = readdir64(self.inner.dirp.0);
if entry_ptr.is_null() {
// We either encountered an error, or reached the end. Either way,
@@ -719,7 +723,7 @@ impl Iterator for ReadDir {
// To distinguish between errors and end-of-directory, we had to clear
// errno beforehand to check for an error now.
return match super::os::errno() {
return match errno() {
0 => None,
e => Some(Err(Error::from_raw_os_error(e))),
};
@@ -1932,7 +1936,7 @@ pub fn canonicalize(p: &Path) -> io::Result<PathBuf> {
fn open_from(from: &Path) -> io::Result<(crate::fs::File, crate::fs::Metadata)> {
use crate::fs::File;
use crate::sys_common::fs::NOT_FILE_ERROR;
use crate::sys::fs::common::NOT_FILE_ERROR;
let reader = File::open(from)?;
let metadata = reader.metadata()?;
@@ -2151,7 +2155,7 @@ pub use remove_dir_impl::remove_dir_all;
miri
))]
mod remove_dir_impl {
pub use crate::sys_common::fs::remove_dir_all;
pub use crate::sys::fs::common::remove_dir_all;
}
// Modern implementation using openat(), unlinkat() and fdopendir()

2
library/std/src/sys/pal/unix/fs/tests.rs → library/std/src/sys/fs/unix/tests.rs
View File

@@ -1,4 +1,4 @@
use crate::sys::pal::unix::fs::FilePermissions;
use crate::sys::fs::FilePermissions;
#[test]
fn test_debug_permissions() {

0
library/std/src/sys/pal/unsupported/fs.rs → library/std/src/sys/fs/unsupported.rs
View File

6
library/std/src/sys/pal/wasi/fs.rs → library/std/src/sys/fs/wasi.rs
View File

@@ -1,6 +1,3 @@
#![forbid(unsafe_op_in_unsafe_fn)]
use super::fd::WasiFd;
use crate::ffi::{CStr, OsStr, OsString};
use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
use crate::mem::{self, ManuallyDrop};
@@ -10,9 +7,10 @@ use crate::os::wasi::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd
use crate::path::{Path, PathBuf};
use crate::sync::Arc;
use crate::sys::common::small_c_string::run_path_with_cstr;
use crate::sys::fd::WasiFd;
pub use crate::sys::fs::common::exists;
use crate::sys::time::SystemTime;
use crate::sys::unsupported;
pub use crate::sys_common::fs::exists;
use crate::sys_common::{AsInner, FromInner, IntoInner, ignore_notfound};
use crate::{fmt, iter, ptr};

12
library/std/src/sys/pal/windows/fs.rs → library/std/src/sys/fs/windows.rs
View File

@@ -1,5 +1,5 @@
use super::api::{self, WinError, set_file_information_by_handle};
use super::{IoResult, to_u16s};
#![allow(nonstandard_style)]
use crate::alloc::{Layout, alloc, dealloc};
use crate::borrow::Cow;
use crate::ffi::{OsStr, OsString, c_void};
@@ -10,6 +10,8 @@ use crate::os::windows::prelude::*;
use crate::path::{Path, PathBuf};
use crate::sync::Arc;
use crate::sys::handle::Handle;
use crate::sys::pal::api::{self, WinError, set_file_information_by_handle};
use crate::sys::pal::{IoResult, fill_utf16_buf, to_u16s, truncate_utf16_at_nul};
use crate::sys::path::maybe_verbatim;
use crate::sys::time::SystemTime;
use crate::sys::{Align8, c, cvt};
@@ -167,7 +169,7 @@ impl DirEntry {
}
pub fn file_name(&self) -> OsString {
let filename = super::truncate_utf16_at_nul(&self.data.cFileName);
let filename = truncate_utf16_at_nul(&self.data.cFileName);
OsString::from_wide(filename)
}
@@ -695,7 +697,7 @@ impl File {
// Turn `\??\` into `\\?\` (a verbatim path).
subst[1] = b'\\' as u16;
// Attempt to convert to a more user-friendly path.
let user = super::args::from_wide_to_user_path(
let user = crate::sys::args::from_wide_to_user_path(
subst.iter().copied().chain([0]).collect(),
)?;
Ok(PathBuf::from(OsString::from_wide(user.strip_suffix(&[0]).unwrap_or(&user))))
@@ -1492,7 +1494,7 @@ pub fn set_perm(p: &Path, perm: FilePermissions) -> io::Result<()> {
}
fn get_path(f: &File) -> io::Result<PathBuf> {
super::fill_utf16_buf(
fill_utf16_buf(
|buf, sz| unsafe {
c::GetFinalPathNameByHandleW(f.handle.as_raw_handle(), buf, sz, c::VOLUME_NAME_DOS)
},

2
library/std/src/sys/pal/windows/fs/remove_dir_all.rs → library/std/src/sys/fs/windows/remove_dir_all.rs
View File

@@ -33,7 +33,7 @@ use core::sync::atomic::{AtomicU32, Ordering};
use super::{AsRawHandle, DirBuff, File, FromRawHandle};
use crate::sys::c;
use crate::sys::pal::windows::api::WinError;
use crate::sys::pal::api::WinError;
use crate::thread;
// The maximum number of times to spin when waiting for deletes to complete.

1
library/std/src/sys/mod.rs
View File

@@ -12,6 +12,7 @@ pub mod anonymous_pipe;
pub mod backtrace;
pub mod cmath;
pub mod exit_guard;
pub mod fs;
pub mod io;
pub mod net;
pub mod os_str;

1
library/std/src/sys/pal/hermit/mod.rs
View File

@@ -21,7 +21,6 @@ use crate::os::raw::c_char;
pub mod args;
pub mod env;
pub mod fd;
pub mod fs;
pub mod futex;
pub mod os;
#[path = "../unsupported/pipe.rs"]

2
library/std/src/sys/pal/sgx/mod.rs
View File

@@ -12,8 +12,6 @@ pub mod abi;
pub mod args;
pub mod env;
pub mod fd;
#[path = "../unsupported/fs.rs"]
pub mod fs;
mod libunwind_integration;
pub mod os;
#[path = "../unsupported/pipe.rs"]

1
library/std/src/sys/pal/solid/mod.rs
View File

@@ -22,7 +22,6 @@ pub mod env;
// `error` is `pub(crate)` so that it can be accessed by `itron/error.rs` as
// `crate::sys::error`
pub(crate) mod error;
pub mod fs;
pub mod os;
#[path = "../unsupported/pipe.rs"]
pub mod pipe;

2
library/std/src/sys/pal/solid/time.rs
View File

@@ -35,7 +35,7 @@ impl SystemTime {
SystemTime(t)
}
pub(super) fn from_time_t(t: abi::time_t) -> Self {
pub fn from_time_t(t: abi::time_t) -> Self {
Self(t)
}

2
library/std/src/sys/pal/teeos/mod.rs
View File

@@ -11,8 +11,6 @@ pub mod args;
#[path = "../unsupported/env.rs"]
pub mod env;
//pub mod fd;
#[path = "../unsupported/fs.rs"]
pub mod fs;
pub mod os;
#[path = "../unsupported/pipe.rs"]
pub mod pipe;

1
library/std/src/sys/pal/uefi/mod.rs
View File

@@ -15,7 +15,6 @@
pub mod args;
pub mod env;
pub mod fs;
pub mod helpers;
pub mod os;
#[path = "../unsupported/pipe.rs"]

1
library/std/src/sys/pal/unix/mod.rs
View File

@@ -9,7 +9,6 @@ pub mod weak;
pub mod args;
pub mod env;
pub mod fd;
pub mod fs;
pub mod futex;
#[cfg(any(target_os = "linux", target_os = "android"))]
pub mod kernel_copy;

1
library/std/src/sys/pal/unsupported/mod.rs
View File

@@ -2,7 +2,6 @@
pub mod args;
pub mod env;
pub mod fs;
pub mod os;
pub mod pipe;
pub mod process;

1
library/std/src/sys/pal/wasi/mod.rs
View File

@@ -16,7 +16,6 @@
pub mod args;
pub mod env;
pub mod fd;
pub mod fs;
#[allow(unused)]
#[path = "../wasm/atomics/futex.rs"]
pub mod futex;

2
library/std/src/sys/pal/wasip2/mod.rs
View File

@@ -12,8 +12,6 @@ pub mod args;
pub mod env;
#[path = "../wasi/fd.rs"]
pub mod fd;
#[path = "../wasi/fs.rs"]
pub mod fs;
#[allow(unused)]
#[path = "../wasm/atomics/futex.rs"]
pub mod futex;

2
library/std/src/sys/pal/wasm/mod.rs
View File

@@ -19,8 +19,6 @@
#[path = "../unsupported/args.rs"]
pub mod args;
pub mod env;
#[path = "../unsupported/fs.rs"]
pub mod fs;
#[path = "../unsupported/os.rs"]
pub mod os;
#[path = "../unsupported/pipe.rs"]

11
library/std/src/sys/pal/windows/c.rs
View File

@@ -237,6 +237,17 @@ compat_fn_with_fallback! {
STATUS_NOT_IMPLEMENTED
}
#[cfg(target_vendor = "uwp")]
pub fn NtOpenFile(
filehandle: *mut HANDLE,
desiredaccess: u32,
objectattributes: *const OBJECT_ATTRIBUTES,
iostatusblock: *mut IO_STATUS_BLOCK,
shareaccess: u32,
openoptions: u32
) -> NTSTATUS {
STATUS_NOT_IMPLEMENTED
}
#[cfg(target_vendor = "uwp")]
pub fn NtReadFile(
filehandle: HANDLE,
event: HANDLE,

3
library/std/src/sys/pal/windows/mod.rs
View File

@@ -17,7 +17,6 @@ pub mod api;
pub mod args;
pub mod c;
pub mod env;
pub mod fs;
#[cfg(not(target_vendor = "win7"))]
pub mod futex;
pub mod handle;
@@ -37,7 +36,7 @@ cfg_if::cfg_if! {
}
/// Map a [`Result<T, WinError>`] to [`io::Result<T>`](crate::io::Result<T>).
trait IoResult<T> {
pub trait IoResult<T> {
fn io_result(self) -> crate::io::Result<T>;
}
impl<T> IoResult<T> for Result<T, api::WinError> {

2
library/std/src/sys/pal/xous/mod.rs
View File

@@ -3,8 +3,6 @@
pub mod args;
#[path = "../unsupported/env.rs"]
pub mod env;
#[path = "../unsupported/fs.rs"]
pub mod fs;
pub mod os;
#[path = "../unsupported/pipe.rs"]
pub mod pipe;

2
library/std/src/sys/pal/zkvm/mod.rs
View File

@@ -14,8 +14,6 @@ pub mod abi;
#[path = "../zkvm/args.rs"]
pub mod args;
pub mod env;
#[path = "../unsupported/fs.rs"]
pub mod fs;
pub mod os;
#[path = "../unsupported/pipe.rs"]
pub mod pipe;

1
library/std/src/sys_common/mod.rs
View File

@@ -20,7 +20,6 @@
#[cfg(test)]
mod tests;
pub mod fs;
pub mod process;
pub mod wstr;
pub mod wtf8;

2
library/windows_targets/src/lib.rs
View File

@@ -34,7 +34,7 @@ pub macro link {
}
#[cfg(not(feature = "windows_raw_dylib"))]
#[link(name = "advapi32")]
#[cfg_attr(target_vendor = "win7", link(name = "advapi32"))]
#[link(name = "ntdll")]
#[link(name = "userenv")]
#[link(name = "ws2_32")]

6
src/bootstrap/src/core/build_steps/dist.rs
View File

@@ -230,8 +230,10 @@ fn make_win_dist(
"libiconv.a",
"libmoldname.a",
"libpthread.a",
//Windows import libs
//This should contain only the set of libraries necessary to link the standard library.
// Windows import libs
// This *should* contain only the set of libraries necessary to link the standard library,
// however we've had problems with people accidentally depending on extra libs being here,
// so we can't easily remove entries.
"libadvapi32.a",
"libbcrypt.a",
"libcomctl32.a",

18
src/tools/miri/tests/fail/shims/fs/isolated_file.stderr
View File

@@ -1,5 +1,5 @@
error: unsupported operation: `open` not available when isolation is enabled
--> RUSTLIB/std/src/sys/pal/PLATFORM/fs.rs:LL:CC
--> RUSTLIB/std/src/sys/fs/PLATFORM.rs:LL:CC
|
LL | let fd = cvt_r(|| unsafe { open64(path.as_ptr(), flags, opts.mode as c_int) })?;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `open` not available when isolation is enabled
@@ -7,14 +7,14 @@ LL | let fd = cvt_r(|| unsafe { open64(path.as_ptr(), flags, opts.mode a
= help: set `MIRIFLAGS=-Zmiri-disable-isolation` to disable isolation;
= help: or set `MIRIFLAGS=-Zmiri-isolation-error=warn` to make Miri return an error code from isolated operations (if supported for that operation) and continue with a warning
= note: BACKTRACE:
= note: inside closure at RUSTLIB/std/src/sys/pal/PLATFORM/fs.rs:LL:CC
= note: inside `std::sys::pal::PLATFORM::cvt_r::<i32, {closure@std::sys::pal::PLATFORM::fs::File::open_c::{closure#0}}>` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
= note: inside `std::sys::pal::PLATFORM::fs::File::open_c` at RUSTLIB/std/src/sys/pal/PLATFORM/fs.rs:LL:CC
= note: inside closure at RUSTLIB/std/src/sys/pal/PLATFORM/fs.rs:LL:CC
= note: inside `std::sys::pal::PLATFORM::small_c_string::run_with_cstr_stack::<std::sys::pal::PLATFORM::fs::File>` at RUSTLIB/std/src/sys/pal/PLATFORM/small_c_string.rs:LL:CC
= note: inside `std::sys::pal::PLATFORM::small_c_string::run_with_cstr::<std::sys::pal::PLATFORM::fs::File>` at RUSTLIB/std/src/sys/pal/PLATFORM/small_c_string.rs:LL:CC
= note: inside `std::sys::pal::PLATFORM::small_c_string::run_path_with_cstr::<std::sys::pal::PLATFORM::fs::File>` at RUSTLIB/std/src/sys/pal/PLATFORM/small_c_string.rs:LL:CC
= note: inside `std::sys::pal::PLATFORM::fs::File::open` at RUSTLIB/std/src/sys/pal/PLATFORM/fs.rs:LL:CC
= note: inside closure at RUSTLIB/std/src/sys/fs/PLATFORM.rs:LL:CC
= note: inside `std::sys::pal::PLATFORM::cvt_r::<i32, {closure@std::sys::fs::PLATFORM::File::open_c::{closure#0}}>` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
= note: inside `std::sys::fs::PLATFORM::File::open_c` at RUSTLIB/std/src/sys/fs/PLATFORM.rs:LL:CC
= note: inside closure at RUSTLIB/std/src/sys/fs/PLATFORM.rs:LL:CC
= note: inside `std::sys::pal::PLATFORM::small_c_string::run_with_cstr_stack::<std::sys::fs::PLATFORM::File>` at RUSTLIB/std/src/sys/pal/PLATFORM/small_c_string.rs:LL:CC
= note: inside `std::sys::pal::PLATFORM::small_c_string::run_with_cstr::<std::sys::fs::PLATFORM::File>` at RUSTLIB/std/src/sys/pal/PLATFORM/small_c_string.rs:LL:CC
= note: inside `std::sys::pal::PLATFORM::small_c_string::run_path_with_cstr::<std::sys::fs::PLATFORM::File>` at RUSTLIB/std/src/sys/pal/PLATFORM/small_c_string.rs:LL:CC
= note: inside `std::sys::fs::PLATFORM::File::open` at RUSTLIB/std/src/sys/fs/PLATFORM.rs:LL:CC
= note: inside `std::fs::OpenOptions::_open` at RUSTLIB/std/src/fs.rs:LL:CC
= note: inside `std::fs::OpenOptions::open::<&std::path::Path>` at RUSTLIB/std/src/fs.rs:LL:CC
= note: inside `std::fs::File::open::<&str>` at RUSTLIB/std/src/fs.rs:LL:CC

4
src/tools/miri/tests/ui.rs
View File

@@ -270,13 +270,13 @@ regexes! {
// erase thread caller ids
r"call [0-9]+" => "call ID",
// erase platform module paths
"sys::pal::[a-z]+::" => "sys::pal::PLATFORM::",
r"\bsys::([a-z_]+)::[a-z]+::" => "sys::$1::PLATFORM::",
// Windows file paths
r"\\" => "/",
// erase Rust stdlib path
"[^ \n`]*/(rust[^/]*|checkout)/library/" => "RUSTLIB/",
// erase platform file paths
"sys/pal/[a-z]+/" => "sys/pal/PLATFORM/",
r"\bsys/([a-z_]+)/[a-z]+\b" => "sys/$1/PLATFORM",
// erase paths into the crate registry
r"[^ ]*/\.?cargo/registry/.*/(.*\.rs)" => "CARGO_REGISTRY/.../$1",
}

16
src/tools/run-make-support/src/external_deps/c_cxx_compiler/extras.rs
View File

@@ -1,17 +1,15 @@
use crate::{is_msvc, is_windows, uname};
use crate::{is_msvc, is_win7, is_windows, uname};
/// `EXTRACFLAGS`
pub fn extra_c_flags() -> Vec<&'static str> {
if is_windows() {
if is_msvc() {
vec![
"ws2_32.lib",
"userenv.lib",
"advapi32.lib",
"bcrypt.lib",
"ntdll.lib",
"synchronization.lib",
]
let mut libs =
vec!["ws2_32.lib", "userenv.lib", "bcrypt.lib", "ntdll.lib", "synchronization.lib"];
if is_win7() {
libs.push("advapi32.lib");
}
libs
} else {
vec!["-lws2_32", "-luserenv", "-lbcrypt", "-lntdll", "-lsynchronization"]
}

2
src/tools/run-make-support/src/lib.rs
View File

@@ -84,7 +84,7 @@ pub use run::{cmd, run, run_fail, run_with_args};
/// Helpers for checking target information.
pub use targets::{
apple_os, is_aix, is_darwin, is_msvc, is_windows, is_windows_gnu, llvm_components_contain,
apple_os, is_aix, is_darwin, is_msvc, is_windows, is_windows_gnu, is_win7, llvm_components_contain,
target, uname,
};

6
src/tools/run-make-support/src/targets.rs
View File

@@ -28,6 +28,12 @@ pub fn is_windows_gnu() -> bool {
target().ends_with("windows-gnu")
}
/// Check if target is win7.
#[must_use]
pub fn is_win7() -> bool {
target().contains("win7")
}
/// Check if target uses macOS.
#[must_use]
pub fn is_darwin() -> bool {

13
tests/codegen/issues/auxiliary/static_dllimport_aux.rs
View File

@@ -1,13 +0,0 @@
use std::sync::atomic::{AtomicPtr, Ordering};
#[inline(always)]
pub fn memrchr() {
fn detect() {}
static CROSS_CRATE_STATIC_ITEM: AtomicPtr<()> = AtomicPtr::new(detect as *mut ());
unsafe {
let fun = CROSS_CRATE_STATIC_ITEM.load(Ordering::SeqCst);
std::mem::transmute::<*mut (), fn()>(fun)()
}
}

15
tests/codegen/issues/issue-81408-dllimport-thinlto-windows.rs
View File

@@ -1,15 +0,0 @@
//@ compile-flags: -Copt-level=3 -C lto=thin -C prefer-dynamic=no
//@ only-windows
//@ aux-build:static_dllimport_aux.rs
// Test that on Windows, when performing ThinLTO, we do not mark cross-crate static items with
// dllimport because lld does not fix the symbol names for us.
extern crate static_dllimport_aux;
// CHECK-LABEL: @{{.+}}CROSS_CRATE_STATIC_ITEM{{.+}} =
// CHECK-SAME: external local_unnamed_addr global %"{{.+}}AtomicPtr
pub fn main() {
static_dllimport_aux::memrchr();
}

15
tests/run-make/repr128-dwarf/rmake.rs
View File

@@ -87,14 +87,15 @@ fn main() {
while let Some((_, entry)) = cursor.next_dfs().unwrap() {
match entry.tag() {
gimli::constants::DW_TAG_variant if !is_old_llvm => {
let value = match entry
.attr(gimli::constants::DW_AT_discr_value)
.unwrap()
.unwrap()
.value()
{
let Some(value) = entry.attr(gimli::constants::DW_AT_discr_value).unwrap()
else {
// `std` enums might have variants without `DW_AT_discr_value`.
continue;
};
let value = match value.value() {
AttributeValue::Block(value) => value.to_slice().unwrap().to_vec(),
value => panic!("unexpected DW_AT_discr_value of {value:?}"),
// `std` has non-repr128 enums which don't use `AttributeValue::Block`.
value => continue,
};
// The `DW_TAG_member` that is a child of `DW_TAG_variant` will contain the
// variant's name.

9
tests/ui/repr/repr-empty-packed.rs Normal file
View File

@@ -0,0 +1,9 @@
//@ compile-flags: --crate-type=lib
#![deny(unused_attributes)]
#[repr()] //~ ERROR unused attribute
#[repr(packed)] //~ ERROR attribute should be applied to a struct or union
pub enum Foo {
Bar,
Baz(i32),
}

27
tests/ui/repr/repr-empty-packed.stderr Normal file
View File

@@ -0,0 +1,27 @@
error: unused attribute
--> $DIR/repr-empty-packed.rs:4:1
|
LL | #[repr()]
| ^^^^^^^^^ help: remove this attribute
|
= note: attribute `repr` with an empty list has no effect
note: the lint level is defined here
--> $DIR/repr-empty-packed.rs:2:9
|
LL | #![deny(unused_attributes)]
| ^^^^^^^^^^^^^^^^^
error[E0517]: attribute should be applied to a struct or union
--> $DIR/repr-empty-packed.rs:5:8
|
LL | #[repr(packed)]
| ^^^^^^
LL | / pub enum Foo {
LL | | Bar,
LL | | Baz(i32),
LL | | }
| |_- not a struct or union
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0517`.