This is a follow-up of #64679 

I realized that one invocation of `clock_nanosleep` wasn't replaced with `g_clock_nanosleep`.

* Update library dependencies to the latest

* Update ILCompiler.Reflection.ReadyToRun.csproj

* Incorporate review feedback from
#64646

* Prevent trimming of unused CachingContext.Count method

* use correct syntax for nested types

* Use static abstract interface methods in Ssl/NegotiateStream adapters

* Remove unnecessary argument from a bunch of methods

It's only used to add duplicative information to an exception message, and in doing so it makes the async methods it's used in more expensive.

- For concatenations, we currently do two passes over its nodes: one that coalesces adjacent characters into strings, and one that coalesces adjacent loops.  This swaps the order so that we first coalesce adjacent loops.  We want to coalesce loops first so that we prioritize associating a One with an adjacent loop rather than with an adjacent string.  This is primarily beneficial later on for auto-atomicity.  Consider `a+ab` composed of a loop, a One 'a', and a One 'b'.  We're either going to make that into a loop `a{2,}` followed by `b` or into a loop `a+` followed by the multi `ab`.  We want to do the former, as then when we apply auto-atomicity to the `a{2,}`, we'll see that it's followed by something non-overlapping ('b'), and make the loop atomic.  In constrast, if we joined the `a` and `b`, then auto-atomicity for the `a+` would see it's followed by an `a` and it wouldn't be upgraded.
- Currently, the adjacent loop coalescing logic joins two individual One nodes with the same Ch value into a repeater.  That's actually a deoptimization, so this stops doing so.  We'd rather have `aa` be evaluated as a Multi of two characters rather than as an `a{2}` repeater, as we're able to apply better optimizations with multis, e.g. taking advantage of StartsWith for matching.
- Also in the adjacent loop logic, we're already checking for a loop followed by a one but we're not checking for a loop followed by a multi.  For the same auto-atomicity benefits discussed earlier, we want to shift any adjacent text from a multi following a loop back into the loop, as it makes it more likely we'll then be able to upgrade that loop to atomic. (We could also add logic for a multi followed by a loop, but the benefits there are less obvious.)
- When creating repeaters, we're actually better off creating multis, for the same reasons outlined earlier.  But we don't want to create massive strings in the super rare case where large repeaters for single chars are used, so we only do so up to a limit.
- When emitting generated code for a One repeater, which might be used to implement the required portion of other loops, emit it as a multi match for short enough repetitions.

Enables a handful of suites that were previously skipped due to https://github.com/dotnet/runtime/issues/51017

Cleanup: Remove BuildInParallel=false attributes which are the default setting.

* Enable rpm build for Linux_arm64

* New Arcade Installers infra with Linux packaging update

* [LoongArch64] add the coreclr/pal and libunwind directory. (#59561)

* [LoongArch64] delete the libunwind for LoongArch64.
It will be commited within a new PR.

* [LoongArch64] add config files from #62889.

* [LoongArch64] revert some files when moved from #62889.

* [LoongArch64] compiling is sucessfully.

* [LoongArch64] delete the define IMAGE_FILE_MACHINE_LOONGARCH64 for #62886.

* [LoongArch64] exclude some files from pal directory.

* [LoongArch64] rename the `UNW_LOONGARCH_*` with `UNW_LOONGARCH64_*`

* [LoongArch64] update the version of the `LICENSE description`.

* [LoongArch64] revert the `pal/inc/rt/ntimage.h`.

* [LoongArch64] delete unused assert and update the `DAC_CS_NATIVE_DATA_SIZE`
Co-authored-by: Nqiaopengcheng <qiaopengcheng-hf@loongson.cn>

Backports changes introduced in the polymorphic deserialization prototype. JsonConverter.RuntimeType is an implementation detail stemming from interface support in collection converters, that has leaked into the JsonTypeInfo model. Removing it makes the contract model cleaner and makes the infrastructure compatible with polymorphic deserialization.

* Remove the concept of fat dispatch tokens and fat type ids from 64 bit platforms
- Phase 1 of removing locking from interface dispatch generation for generic dispatch
- We no longer need these due to changes to remove AppDomains from CoreCLR
- Phase 2 will likely remove the MethodTableWriteableData structure and merge the contents into the normal MethodTable

It's not needed and avoids accidentally including this assembly in places where we don't want it.

We don't want to ship it in the NuGet consumed by ILSpy.

Sometimes a process failing with stack overflow returns exit code
0x800703e9 (ERROR_STACK_OVERFLOW). This change updates the stack
overflow test to accept that code too.

Since #63572 no longer happens in CI, we can promote MacCatalyst templates from the runtime-staging to the runtime-extra-platforms pipeline.

For now we will keep MacCatalyst arm64 legs in runtime-staging as they are not stable on OSX 11.00 queues (see #64452 (comment)).
Co-authored-by: NSteve Pfister <steve.pfister@microsoft.com>
Co-authored-by: NAlexander Köplinger <alex.koeplinger@outlook.com>

* Do not run jit-cfg on macOS

jit-cfg includes a GCStress scenario which is not supported on macOS
x64. Rather than excluding it just there, just exclude all of macOS
since CFG is a Windows only feature anyway.

I am still keeping the Linux-x64/Linux-arm64 jobs as we produce
different IR for arguments on these ABIs and I want to keep the CFG
handling working in general for all the forms of IR we can produce
related to calls.

* Fix CFG dispatcher register in VM stub

* Change GS cookie check temp registers

These registers are trashed in the epilog on arm64 for GS cookie checks,
but x9 might conflict with the argument used by the dispatch helper.
Change the temp registers to ip0 and ip1 and add some debug checking to
get a nice assert in the future if this happens.

Adds a test that compiles with CFG enabled and then re-runs itself to crash in various ways.
Also fixes a minor RyuJIT issue discovered in the test.

* Validate IntPtr and byref field overlap

Effects on nothing leaves are now simplified away.
Enumerating TransitionsWithEffects will now ignore all transitions after
the first unconditionally nullable one.

I stared at these for a minute trying to rationalize how `e|f` could possibly become `ef`, and then I realized it of course doesn't, rather these branches are being eliminated entirely.

The RegexCompiler and source generator currently special-case strings < 64 chars in length and unroll the loop, using a series of ulong and uint comparisons where possible.  While efficient, this makes the generated code harder to read, and the source generator also has endianness issues when the compiled binary is then used on a machine with different endianness.  The JIT is going to start doing such unrolling as part of StartsWith, so we can leave the optimization up to it; it'll be able to do it better, anyway, with its optimization applying to more uses, using vectors where applicable, etc.

* [LoongArch64] Add LoongArch64 support in libunwind.

* [LoongArch64] add libunwind/src/CMakeLists.txt from #62889.

* [LoongArch64] add libunwind-version for LoongArch64.

* [LoongArch64] add unwinder/loongarch64/ directory.

* [LoongArch64] add unwind within the `inc/clrnt.h`.

* Revert "[LoongArch64] add unwinder/loongarch64/ directory."
This reverts commit a8fde8904c5ba50b9cf0c9dd8087ac3d5953f59b.

Revert "[LoongArch64] add unwind within the `inc/clrnt.h`."
This reverts commit c5e606d1b2fbc5cc4048d26431c257ae9b477eb7.

* [LoongArch64] Fixed the compiling error by
              https://github.com/libunwind/libunwind/pull/322.

* [LoongArch64] amend the "Apply info" for LoongArch64.
Co-authored-by: Nqiaopengcheng <qiaopengcheng-hf@loongson.cn>

Contributes to #64456 

1. Separate the public API headers from the mono implementation
2. Provide a foundation for refactoring the headers (as outlined in #64456) to be more useful for late binding scenarios

* Move public mono headers to src/native/public

* fix mono dbgshim and mscordbi builds

* Pass --nativedir=src/native to offsets-tool.py

* fix wasm build

* fix windows build

* Add a brief README for the public directory

This change started with the intent of changing the error code / message from an OpenSSL-based
exception from the most recent error in the queue to the oldest error that was produced after the
operation started. This was motivated mostly by EVP_PKEY2PKCS8(pkey) incorrectly indicating a
malloc failure after producing the original/correct error that pkey did not have a private key
portion.

Having fully developed the experiment, data showed that while for EVP_PKEY2PKCS8 the first (of
two) errors was the better one, for everything else with more than one error reported, the last
error was at least as good as, and often better, than the first error. With that data in hand, this
change now represents more consistently cleaning the error queue, and reducing the overhead
in producing the exception objects.
Co-authored-by: NKevin Jones <vcsjones@github.com>

* Use caching in Reflection.Emit member accessors

* Refactor JsonSerializerOptions caching & use shared caching contexts

* Update src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/ReflectionEmitCachingMemberAccessor.Cache.cs

* address feedback

* tweak cache eviction constants

* Update src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.Caching.cs

* minor refinements to cache eviction algorithm

* rename JsonSerializerOptions._context to _serializerContext

* ensure that the update handler clears the shared caching contexts

* fix remark

When there are loops or tailcalls in a function the JIT will check for
a dominating call that is a GC safepoint to figure out if the function
needs to be marked fully interruptible or not. Methods with the
InternalCall flag may turn into fcalls that are not hijackable and thus
not GC safepoints, so in this case JIT should still mark the function
fully interruptible, but was not doing so because crossgen2 was not
reporting this flag back.

Fix #64980

The dynamic method `klass` is just System.Object, so its image is always
corelib.  As a result, we incorrectly pick up the DisableRuntimeMarshalling
attribute from CoreLib.

Fixes https://github.com/dotnet/runtime/issues/65304

The corresponding change to the JIT+AOT was done in
https://github.com/dotnet/runtime/pull/64279/commits/ac825ab0678f07bfd6c161e4ea4413af84df9293

This field was a left-over artifact from conflicts between the commits:
- https://github.com/dotnet/runtime/commit/70c070e84c617de0700612d03c5886e548195bed
- https://github.com/dotnet/runtime/commit/e53e5430c199c210b7d6f7ce508fb5fabb5faeba

In profiling the startup of a Maui Android app, this initialization is pulling in UTF32 and Latin1 encodings. The profile indicates this accounts for 7ms (roughly 1%). Removing this unnecessary field eliminates 7ms in a Maui App's InitializeComponent.

Related to #43605

* Add SIMD intrinsics for Arm64

* Add check for architecture

* Another one currently only work on arm64

* Xor intrinsics only work on integer types

* Change the implementation for max/min

* fix build on non-arm

* Fix build on mobile platforms

* Fix fmax and fmin on Amd64

* Only intrinsify Vector64 methods on Arm64

* [wasm] Add memalign to exported functions

Fix https://github.com/dotnet/runtime/issues/64724 and https://github.com/dotnet/runtime/issues/64725

The tests were crashing because calling the memalign function, which was
not exported.

* Re-enable failing tests

* OP_[FR]CONV_TO_I should result in an 8-byte integer