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

}

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

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

}

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

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

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

}

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;

}

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

}

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

}

"E-*",

"F-*",

"I-*",

"L-*",

"NLL-*",

"O-*",

"PG-*",

"S-*",

"T-*",

"WG-*",

"-Z*",

"beta-nominated",

"const-hack",

"llvm-*",