mod tests;

extern "Rust" {

// These are the magic symbols to call the global allocator. rustc generates

// These are the magic symbols to call the global allocator. rustc generates

// them to call `__rg_alloc` etc. if there is a `#[global_allocator]` attribute

// (the code expanding that attribute macro generates those functions), or to call

// the default implementations in libstd (`__rdl_alloc` etc. in `library/std/src/alloc.rs`)

// the default implementations in std (`__rdl_alloc` etc. in `library/std/src/alloc.rs`)

// otherwise.

// The rustc fork of LLVM also special-cases these function names to be able to optimize them

// The rustc fork of LLVM 14 and earlier also special-cases these function names to be able to optimize them

// like `malloc`, `realloc`, and `free`, respectively.

#[rustc_allocator]

#[rustc_allocator_nounwind]

#[rustc_nounwind]

fn __rust_alloc(size: usize, align: usize) -> *mut u8;

#[rustc_allocator_nounwind]

#[rustc_deallocator]

#[rustc_nounwind]

fn __rust_dealloc(ptr: *mut u8, size: usize, align: usize);

#[rustc_allocator_nounwind]

#[rustc_reallocator]

#[rustc_nounwind]

fn __rust_realloc(ptr: *mut u8, old_size: usize, align: usize, new_size: usize) -> *mut u8;

#[rustc_allocator_nounwind]

#[rustc_allocator_zeroed]

#[rustc_nounwind]

fn __rust_alloc_zeroed(size: usize, align: usize) -> *mut u8;

}

/// # Examples

///

/// ```

/// use std::alloc::{alloc, dealloc, Layout};

/// use std::alloc::{alloc, dealloc, handle_alloc_error, Layout};

///

/// unsafe {

/// let layout = Layout::new::<u16>();

/// let ptr = alloc(layout);

/// if ptr.is_null() {

/// handle_alloc_error(layout);

/// }

///

/// *(ptr as *mut u16) = 42;

/// assert_eq!(*(ptr as *mut u16), 42);

#[cfg(not(no_global_oom_handling))]

extern "Rust" {

// This is the magic symbol to call the global alloc error handler. rustc generates

// This is the magic symbol to call the global alloc error handler. rustc generates

// it to call `__rg_oom` if there is a `#[alloc_error_handler]`, or to call the

// default implementations below (`__rdl_oom`) otherwise.

fn __rust_alloc_error_handler(size: usize, align: usize) -> !;

#[allow(unused_attributes)]

#[unstable(feature = "alloc_internals", issue = "none")]

pub mod __alloc_error_handler {

use crate::alloc::Layout;

// called via generated `__rust_alloc_error_handler`

// if there is no `#[alloc_error_handler]`

// called via generated `__rust_alloc_error_handler` if there is no

// `#[alloc_error_handler]`.

#[rustc_std_internal_symbol]

pub unsafe extern "C-unwind" fn __rdl_oom(size: usize, _align: usize) -> ! {

panic!("memory allocation of {size} bytes failed")

}

// if there is an `#[alloc_error_handler]`

#[rustc_std_internal_symbol]

pub unsafe extern "C-unwind" fn __rg_oom(size: usize, align: usize) -> ! {

let layout = unsafe { Layout::from_size_align_unchecked(size, align) };

pub unsafe fn __rdl_oom(size: usize, _align: usize) -> ! {

extern "Rust" {

#[lang = "oom"]

fn oom_impl(layout: Layout) -> !;

// This symbol is emitted by rustc next to __rust_alloc_error_handler.

// Its value depends on the -Zoom={panic,abort} compiler option.

static __rust_alloc_error_handler_should_panic: u8;

}

#[allow(unused_unsafe)]

if unsafe { __rust_alloc_error_handler_should_panic != 0 } {

panic!("memory allocation of {size} bytes failed")

} else {

core::panicking::panic_nounwind_fmt(format_args!(

"memory allocation of {size} bytes failed"

))

}

unsafe { oom_impl(layout) }

}

}