* [mono] Add HAVE_PTHREAD_JIT_WRITE_PROTECT_NP to cmake config.h.in

Otherwise mono_codeman_enable_write is a no-op

Should fix jiting on Apple ARM64

* [cmake] Use check_symbol_exists(pthread_jit_write_protect_np)

   check_function_exists doesn't look at the headers, only at linking, so it can't detect functions marked unavailable in Apple headers.

Fixes #49042

* Don't have gtAuxiliaryJitType and gtOtherReg share a union

* Applying formatting patch

The by the SDK default included netframework reference assembly are used instead of the old microsoft.netframework.targetingpack. Removing the stale property.

Fixes #2262

Lazy init of ThreadWaitInfo in Thread.Mono.cs to prevent crash on external attached threads. (#51483)

* Init ThreadWaitInfo to prevent crash on external attached threads.

Commit https://github.com/dotnet/runtime/commit/457f58cd30082c9de0be9ca62e64fa179c37dab3
added a new managed object into Mono's managed thread object, _waitInfo.

This new object was initialized in Thread managed constructor, problem
with that is for all threads that gets their thread object created in
native code, create_thread_object, that code did the same thing as
constructor before commit, since managed constructor called down into
native code calling the same native method as create_thread_object meaning
a thread object created from managed or native would be initialized
identical.

After above commit this is no longer true, meaning that all managed thread
objects created in native code (like attached external threads) won't
get _waitInfo initialized and that leads to a crash when OnThreadExiting
gets called from Finalizer thread.

Fix is to make sure _waitInfo get initialize regardless of thread object
gets created from managed or native code.

This fix implements a lazy init as part of property access, I tested a
native version of the fix, calling back into managed to init managed
parts of thread when tread gets created in native, but turns out that
such a fix gets a little complicated, since some of the threads are
created early when it's not possible to run managed code, so that in turn
needed additional changes into the init order, that in turn has bigger
impact and could cause other unwanted side effects.

Fixing it in managed using lazy/on demand init is simpler/cleaner approach
but might come with a small performance hit for callers of WaitInfo property
(will add volatile read and conditional branch), but looking at callers
of the property, they appear in functions with rather high "cost",
like Sleep, NewMutex, Wait, SignalAndWait, Interrupt and
RelinquishOwnership.

Nuget package for ILCompiler.Reflection.ReadyToRun
Co-authored-by: NMichal Strehovský <MichalStrehovsky@users.noreply.github.com>

* Simplify non-generic ArrayEnumerator

* Implement GetFlattenedIndex for Mono

Rework the inlinee profile scale computations so that all scaling happens
during the profile incorporation phase, rather than sometimes deferring
the scaling until inlining. Because of this we no longer need to record
the scale on the inline info.

Toss out profile data if all counts are zero.

Update the edge profile solver to handle a special case where no return block
was executed, but edges within the method had counts. In such cases the entry
block count can end up zero and blocking proper scaling computations. For this
case, try and deduce a plausible count in this case from nearby blocks and edges.

Fix the edge weight computations to tolerate inconsistent data rather than
to assert.

Disable the tests for values are not guaranteed to roundtrip depending on the GC settings. We have more extensive test coverage for the latency modes under runtime tests.

The Apple API offers significant performance improvements (an order of a magnitude) over
reading from /dev/urandom.

Records of this type are created when class profile histograms in dynamic PGO
data are summarized by the static PGO tooling.

These records can appear in both prejit and jit schemas when the static PGO data is
passed back to the jit.

There appeared to be two issues, where the config.GetReloadToken().RegisterChangeCallback was registered after the updates were made.

This forces the llvm backend to allocate a stack location for them, so they
get GC tracking.

* [wasm] Set runtime pack directory to the nuget path, if not set

* Update src/mono/wasm/build/WasmApp.targets
Co-authored-by: NLarry Ewing <lewing@microsoft.com>
Co-authored-by: NLarry Ewing <lewing@microsoft.com>

[JSON source gen 3/3] Add new methods to JsonSerializer and System.Net.Http.Json APIs that take type metadata (#51528)

* Add new methods to JsonSerializer and System.Net.Http.Json APIs that take type metadata

* Address review feedback

[main] Update dependencies from dotnet/runtime dotnet/arcade dotnet/icu dotnet/xharness dotnet/llvm-project dotnet/runtime-assets (#51488)

[main] Update dependencies from dotnet/runtime dotnet/arcade dotnet/icu dotnet/xharness dotnet/llvm-project dotnet/runtime-assets

* Disable source generators from binplacing

* Ensure APICompat doesn't run for non-Source projects

It's 14 hours of lectures about how .NET GC is implemented.

Use adjusted parent layout size to handle a non-zero-sized class inheriting from a zero-sized class that inherits from another zero-sized class. (#50861)

* Remove pinning in BufferedFileStreamStrategy

* Simplify code/synchronization in ValueTaskSource

* Add metadata update handler to System.ComponentModel.TypeConverter

* Update src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/ReflectTypeDescriptionProvider.cs

* fix zero byte send on linux and update tests
Co-authored-by: NGeoffrey Kizer <geoffrek@windows.microsoft.com>

Also change the storage model to SafeEvpPKeyHandle,
only import and export use legacy SafeRsaHandle.

Mono runtime component infrastructure including EventPipe/DiagnosticsServer as a Mono runtime component. (#50837)

Implementation of Mono runtime component infrastructure, https://github.com/dotnet/runtime/blob/main/docs/design/mono/components.md.

This commit also includes a port of Mono EventPipe/DiagnosticsServer library over to new runtime component infrastructure.

Before all packaging/deploy have been fixed for platforms that will switch over to hosting components as shared libraries, all components will be build and linked using the static linkage scenario outline in document above. Once package and deploy is resolved for dynamic linking scenarios, we will switch this for corresponding platforms in follow up commits.

* eh fix

* test change that inadvertently got checked in earlier

* Suppresses the trimmer warning on TypeAnalysis ctor

* Incorporating FB

* Update src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/DiagnosticSourceEventSource.cs
Co-authored-by: NEric Erhardt <eric.erhardt@microsoft.com>

* Update src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/DiagnosticSourceEventSource.cs
Co-authored-by: NEric Erhardt <eric.erhardt@microsoft.com>

* Update src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventSource.cs
Co-authored-by: NEric Erhardt <eric.erhardt@microsoft.com>

* Fix DynamicDependency as per PR feedback

* an earlier change got reverted

* fixed proj file netcore app condition check

* fixed NETCORE_ENGINEERING_TELEMETRY build failures

* fixeing another NETCORE_ENGINEERING_TELEMETRY build failures

* Adding RequiresUnreferencedCode to TypeAnalysis ctor instead of suppressing the warning to get FB, not fully fixed

* PR FB and suppressing warnings for safe calls

* propagated the warning all the way up

* CI build break fix for one file

* excluding NativeRTEventSrc from being build in a project

* Missed couple of supppressions on NativeRTEventSrc

* build break fixes

* Trimmer warning fix related to EventSource manifest creation

* incorporate fb

* fix build break in some configs

* comment feedback

* build break
Co-authored-by: NEric Erhardt <eric.erhardt@microsoft.com>

Annotated public System.Console APIs throwing PNSE on Android.  

Part of #47911.

SPMI wasn't capturing enough data for PGO schemas that had class profiles,
leading to replay failures.