// Configure platforms that have reliable basics but may have unreliable math.

// LLVM is currenlty adding missing routines, <https://github.com/llvm/llvm-project/issues/93566>

// LLVM is currently adding missing routines, <https://github.com/llvm/llvm-project/issues/93566>

let has_reliable_f16_math = has_reliable_f16

&& match (target_arch.as_str(), target_os.as_str()) {

// FIXME: Disabled on Miri as the intrinsics are not implemented yet.

#[test]

// Miri does not support signalling OOM

#[cfg_attr(miri, ignore)]

// 64-bit only to be sure the allocator will fail fast on an impossible to satsify size

// 64-bit only to be sure the allocator will fail fast on an impossible to satisfy size

#[cfg(target_pointer_width = "64")]

fn try_oom_error() {

let mut v = Vec::<u8>::new();

rtabort!("drop of the panic payload panicked");

});

panic::catch_unwind(cleanup).map_err(rt_abort)?;

// Guard against multple threads calling `libc::exit` concurrently.

// Guard against multiple threads calling `libc::exit` concurrently.

// See the documentation for `unique_thread_exit` for more information.

panic::catch_unwind(|| crate::sys::exit_guard::unique_thread_exit()).map_err(rt_abort)?;

ret_code

let mut head = self.head.index.load(Ordering::Acquire);

// The channel may be uninitialized, so we have to swap to avoid overwriting any sender's attempts

// to initalize the first block before noticing that the receivers disconnected. Late allocations

// to initialize the first block before noticing that the receivers disconnected. Late allocations

// will be deallocated by the sender in Drop.

let mut block = self.head.block.swap(ptr::null_mut(), Ordering::AcqRel);

let st_size = unsafe { (*self.st.as_ptr()).hdr.header_size as usize };

let mut crc32: u32 = 0;

// Set crc to 0 before calcuation

// Set crc to 0 before calculation

unsafe {

(*self.st.as_mut_ptr()).hdr.crc32 = 0;

}

_ => {

if cfg!(target_os = "vxworks") {

// VxWorks poll does not return POLLHUP or POLLERR in revents. Check if the

// connnection actually succeeded and return ok only when the socket is

// connection actually succeeded and return ok only when the socket is

// ready and no errors were found.

if let Some(e) = self.take_error()? {

return Err(e);