add lib.miri.rs file for miri-test-libstd

This is a replacement for rust-lang/libm#290

This fixes crashes during compilations for targets that don't have math
symbols by default.

So, we will provide them libm symbols, but mark it as `weak` (if its
supported), so that the linker will choose the system builtin functions,
since those are sometimes more optimized.
If the linker couldn't find those, it will go with `libm`
implementation.

Always have math functions but with `weak` linking attribute if we can

Release 0.1.109

Trying to run testcrate on non-linux aarch64 currently hits a
compilation error. Make this test linux-only, to be consistent with the
`aarch64_linux` module that it depends on.

Additionally, enable the `aarch64_linux` module for `target_arch =
"arm64ec"` to be the same as these tests.

The Apple ARM silicon has been around for a while now and hopefully will
become Rust Tier 1 at some point. Add it to CI since it is distinct
enough from aarch64-linux and x86_86-darwin that there may be
differences.

Add a fix for aarch64-darwin and enable it in CI

Allow using the `rust-lang/rust:nightly` docker image to run tests in
cases where the host rust and cargo cannot be used, such as non-linux
hosts.

Add a way to test more targets on non-linux machines

Update status of 128-bit integers in README.md

This is a continuation/fix of 018616e. In that commit, we made it add
the math functions to all platforms (except apple-targets and windows),
and use `weak` linking, so that it can be used if the system doesn't
have those functions.

Didn't notice `mod math` was behind another set of `cfg`, so removed it
as well here.

The solution is not pretty, but not sure why we still get clippy
warning from one of the files in `libm` even though we use
`allow(clippy::all)`

Fix math libraries not being linked on some platforms

Add builtins for `f16`/`f128` float conversions

Removed the `weak-intrinsics` feature, so that all functions
will have the `weak` linkage attribute.

Also this fixed the bug in
rust-lang/rust#124042.

Before this commit, generated code will be
```rust
pub extern "C" fn <name>(...) -> ... {
        // code...
}
pub mod <name> {
    #[linkage = "weak"]
    #[no_mangle]
    pub extern "C" fn <name>(...) -> ... {
        super::<name>(...)
    }
}
```

The issue is that there is 2 `weak` linkage, the first one is not required.
Along refactoring `weak` attributes, this was fixed.

`weak` is only used with `no_mangle`

Don't generate the whole function if we are not going to use `no_mangle`, there is no point

Apply `weak` attributes to all intrinsics

Update reference to rustc-std-workspace-core

Release version 0.1.110

It looks like I've forgotten about them [back in 2023](rust-lang#527).

fix: Add `#[avr_skip]` for `__addsf3` & `__adddf3`

Release version 0.1.111

Enable chkstk/alloca intrinsics on i686-unknown-uefi

There are currently a lot of warnings printed in CI, mostly dead code.
Update CI to deny warnings.

See
<rust-lang#603 (comment)>

Deny warnings in CI and add check-cfg directives

Release 0.1.112

Fix paths for Windows arm64 build

`MinInt` contains the basic methods that are only needed by integers
involved in widening operations, i.e. big integers. `Int` retains all
other operations and convenience methods.

Change float test macros to fall back to testing against `rustc_apfloat`
when system implementations are not available, rather than just skipping
tests.

This allows for easier debugging where operations may not be supported.

PowerPC uses `kf` instead of `tf`:
<https://gcc.gnu.org/wiki/Ieee128PowerPC>

Add addition, subtraction, multiplication, and compare operations for `f128`

Currently, tests of the same kind are grouped together across all types
into a single function. This makes it difficult to understand exactly
what failed in CI.

Change test macros to create separate functions for separate types so
failures are more fine grained.

Rework the test crate to separate individual tests

Add tests for verbatim paths on windows builds

Deduplicate code used for float to integer conversions in order to make
adding `f128` conversion functions easier.

`as` casts are only allowed for primitives, doing the same operations
with `rustc_apfloat` requires using functions. Add a way to specify
these separately.

Add the following:

- `__fixtfsi`
- `__fixtfdi`
- `__fixtfti`
- `__fixunstfsi`
- `__fixunstfdi`
- `__fixunstfti`

Add `f128` float to integer conversion functions

PowerPC platforms use `kf` rather than `tf` for `f128`. Add a way to
alias this in the macro to make the code cleaner.

This also fixes the names of `fixunstf*` and `fixtf*` on Power PC
(`fixunskf*` and `fixkf*` are correct).

Add `ppc_alias` to the `intrinsics!` macro

Update examples/intrinsics.rs

Add Apple visionOS support

This adds comparisons among the compiler-builtins function, system
functions if available, and optionally handwritten assembly.

These also help us identify inconsistencies between this crate and
system functions, which may otherwise go unnoticed if intrinsics get
lowered to inline operations rather than library calls.

Add benchmarks for floating point math

Add CI caching

In <rust-lang#594>, symbols
for the Rust port of libm were made always weakly available. This seems
to be causing problems on platforms with ABI issues, as explained at
<rust-lang/rust#125016 (comment)>.

Disable Rust libm on x86 without sse2 to mitigate this.

Disable libm on x86 without sse2

__addkf3 and __mulkf3 seem to hit a nondescript SIGILL. This is probably
likely to just be another Qemu limitation.

Update the Ubuntu docker image to the latest version

These were preventing building via Docker locally.

Fix unset variables in the build script