Auto merge of #125164 - fmease:rollup-s5vwzlg, r=fmease

Rollup of 5 pull requests

Successful merges:

 - #125003 (avoid using aligned_alloc; posix_memalign is better-behaved)
 - #125142 (Migrate `run-make/rustdoc-themes` to new rmake.rs)
 - #125146 (Migrate `run-make/panic-impl-transitive` to `rmake`)
 - #125154 (Small improvements to the documentaion of FnAbi )
 - #125159 (Meta: Allow unauthenticated users to modify `L-*`, `PG-*` and `-Z*` labels)

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_target/src/abi/call/mod.rs

@@ -779,26 +779,31 @@ impl RiscvInterruptKind {
 /// Metadata describing how the arguments to a native function
 /// should be passed in order to respect the native ABI.
 ///
+/// The signature represented by this type may not match the MIR function signature.
+/// Certain attributes, like `#[track_caller]` can introduce additional arguments, which are present in [`FnAbi`], but not in `FnSig`.
+/// While this difference is rarely relevant, it should still be kept in mind.
+///
 /// I will do my best to describe this structure, but these
 /// comments are reverse-engineered and may be inaccurate. -NDM
 #[derive(Clone, PartialEq, Eq, Hash, HashStable_Generic)]
 pub struct FnAbi<'a, Ty> {
-    /// The LLVM types of each argument.
+    /// The type, layout, and information about how each argument is passed.
     pub args: Box<[ArgAbi<'a, Ty>]>,
 
-    /// LLVM return type.
+    /// The layout, type, and the way a value is returned from this function.
     pub ret: ArgAbi<'a, Ty>,
 
+    /// Marks this function as variadic (accepting a variable number of arguments).
     pub c_variadic: bool,
 
     /// The count of non-variadic arguments.
     ///
     /// Should only be different from args.len() when c_variadic is true.
     /// This can be used to know whether an argument is variadic or not.
     pub fixed_count: u32,
-
+    /// The calling convention of this function.
     pub conv: Conv,
-
+    /// Indicates if an unwind may happen across a call to this function.
     pub can_unwind: bool,
 }
 

library/std/src/sys/pal/unix/alloc.rs

@@ -87,21 +87,18 @@ cfg_if::cfg_if! {
             //                                       /memory/aligned_memory.cc
             libc::memalign(layout.align(), layout.size()) as *mut u8
         }
-    } else if #[cfg(target_os = "wasi")] {
-        #[inline]
-        unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 {
-            // C11 aligned_alloc requires that the size be a multiple of the alignment.
-            // Layout already checks that the size rounded up doesn't overflow isize::MAX.
-            let align = layout.align();
-            let size = layout.size().next_multiple_of(align);
-            libc::aligned_alloc(align, size) as *mut u8
-        }
     } else {
         #[inline]
         unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 {
             let mut out = ptr::null_mut();
-            // posix_memalign requires that the alignment be a multiple of `sizeof(void*)`.
-            // Since these are all powers of 2, we can just use max.
+            // We prefer posix_memalign over aligned_malloc since with aligned_malloc,
+            // implementations are making almost arbitrary choices for which alignments are
+            // "supported", making it hard to use. For instance, some implementations require the
+            // size to be a multiple of the alignment (wasi emmalloc), while others require the
+            // alignment to be at least the pointer size (Illumos, macOS) -- which may or may not be
+            // standards-compliant, but that does not help us.
+            // posix_memalign only has one, clear requirement: that the alignment be a multiple of
+            // `sizeof(void*)`. Since these are all powers of 2, we can just use max.
             let align = layout.align().max(crate::mem::size_of::<usize>());
             let ret = libc::posix_memalign(&mut out, align, layout.size());
             if ret != 0 { ptr::null_mut() } else { out as *mut u8 }

src/tools/run-make-support/src/lib.rs

@@ -64,6 +64,12 @@ pub fn python_command() -> Command {
     Command::new(python_path)
 }
 
+pub fn htmldocck() -> Command {
+    let mut python = python_command();
+    python.arg(source_path().join("/src/etc/htmldocck.py"));
+    python
+}
+
 pub fn source_path() -> PathBuf {
     std::env::var("S").expect("S variable does not exist").into()
 }

src/tools/tidy/src/allowed_run_make_makefiles.txt

@@ -190,7 +190,6 @@ run-make/output-with-hyphens/Makefile
 run-make/override-aliased-flags/Makefile
 run-make/overwrite-input/Makefile
 run-make/panic-abort-eh_frame/Makefile
-run-make/panic-impl-transitive/Makefile
 run-make/pass-linker-flags-flavor/Makefile
 run-make/pass-linker-flags-from-dep/Makefile
 run-make/pass-linker-flags/Makefile
@@ -243,7 +242,6 @@ run-make/rustdoc-scrape-examples-multiple/Makefile
 run-make/rustdoc-scrape-examples-remap/Makefile
 run-make/rustdoc-scrape-examples-test/Makefile
 run-make/rustdoc-scrape-examples-whitespace/Makefile
-run-make/rustdoc-themes/Makefile
 run-make/rustdoc-verify-output-files/Makefile
 run-make/rustdoc-with-out-dir-option/Makefile
 run-make/rustdoc-with-output-option/Makefile

tests/run-make/panic-impl-transitive/rmake.rs

@@ -0,0 +1,19 @@
+// In Rust programs where the standard library is unavailable (#![no_std]), we may be interested
+// in customizing how panics are handled. Here, the provider specifies that panics should be handled
+// by entering an infinite loop. This test checks that this panic implementation can be transitively
+// provided by an external crate.
+// --emit=llvm-ir is used to avoid running the linker, as linking will fail due to the lack of main
+// function in the crate.
+// See https://github.com/rust-lang/rust/pull/50338
+
+use run_make_support::{rustc, tmp_dir};
+
+fn main() {
+    rustc().input("panic-impl-provider.rs").run();
+    rustc()
+        .input("panic-impl-consumer.rs")
+        .panic("abort")
+        .emit("llvm-ir")
+        .library_search_path(tmp_dir())
+        .run();
+}

tests/run-make/rustdoc-scrape-examples-ordering/rmake.rs

@@ -1,4 +1,4 @@
-use run_make_support::{python_command, rustc, rustdoc, source_path, tmp_dir};
+use run_make_support::{htmldocck, rustc, rustdoc, source_path, tmp_dir};
 use std::fs::read_dir;
 use std::path::Path;
 
@@ -45,11 +45,5 @@ fn main() {
     }
     rustdoc.run();
 
-    python_command()
-        .arg(source_path().join("/src/etc/htmldocck.py"))
-        .arg(out_dir)
-        .arg("src/lib.rs")
-        .status()
-        .unwrap()
-        .success();
+    htmldocck().arg(out_dir).arg("src/lib.rs").status().unwrap().success();
 }

tests/run-make/rustdoc-themes/rmake.rs

@@ -0,0 +1,31 @@
+// Test that rustdoc will properly load in a theme file and display it in the theme selector.
+
+use run_make_support::{htmldocck, rustdoc, source_path, tmp_dir};
+
+fn main() {
+    let out_dir = tmp_dir().join("rustdoc-themes");
+    let test_css = out_dir.join("test.css");
+
+    let no_script =
+        std::fs::read_to_string(source_path().join("src/librustdoc/html/static/css/noscript.css"))
+            .unwrap();
+
+    let mut test_content = String::new();
+    let mut found_begin_light = false;
+    for line in no_script.split('\n') {
+        if line == "/* Begin theme: light */" {
+            found_begin_light = true;
+        } else if line == "/* End theme: light */" {
+            break;
+        } else if found_begin_light {
+            test_content.push_str(line);
+            test_content.push('\n');
+        }
+    }
+    assert!(!test_content.is_empty());
+    std::fs::create_dir_all(&out_dir).unwrap();
+    std::fs::write(&test_css, test_content).unwrap();
+
+    rustdoc().output(&out_dir).input("foo.rs").arg("--theme").arg(&test_css).run();
+    htmldocck().arg(out_dir).arg("foo.rs").status().unwrap().success();
+}

triagebot.toml

@@ -9,11 +9,14 @@ allow-unauthenticated = [
     "E-*",
     "F-*",
     "I-*",
+    "L-*",
     "NLL-*",
     "O-*",
+    "PG-*",
     "S-*",
     "T-*",
     "WG-*",
+    "-Z*",
     "beta-nominated",
     "const-hack",
     "llvm-*",