Bring back old array enumerator code (#88371)

This is a 0.3% size saving for Stage1. We not only allow array enumerators to be preinitialized again, but also avoid introducing many array `MethodTables` (looks like the new enumerators force array MethodTables for cases where we could have avoided them).

Fixes #82993.

Disable failing `simpleruntimeeventvalidation` test on mono. (#88500)

* Disable `simpleruntimeeventvalidation` test on mono.

Issue: https://github.com/dotnet/runtime/issues/88499

Failing with:
```
      Expected: True
      Actual:   False
      Stack Trace:
           at tracing_eventpipe._simpleruntimeeventvalidation_simpleruntimeeventvalidation_simpleruntimeeventvalidation_._simpleruntimeeventvalidation_simpleruntimeeventvalidation_simpleruntimeeventvalidation_sh()
           at System.RuntimeMethodHandle.InvokeMethod(Object target, Void** arguments, Signature sig, Boolean isConstructor)
           at System.Reflection.MethodInvoker.Invoke(Object obj, IntPtr* args, BindingFlags invokeAttr)
      Output:

        Return code:      1
        Raw output file:      /root/helix/work/workitem/uploads/Reports/tracing.eventpipe/simpleruntimeeventvalidation/simpleruntimeeventvalidation/simpleruntimeeventvalidation.output.txt
        Raw output:
        BEGIN EXECUTION
        /root/helix/work/correlation/corerun -p System.Reflection.Metadata.MetadataUpdater.IsSupported=false -p System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization=true simpleruntimeeventvalidation.dll ''
          0.0s: ==TEST STARTING==
          0.2s: Connecting to EventPipe...
          0.2s: Started sending sentinel events...
          0.4s: Creating EventPipeEventSource...
          0.4s: EventPipeEventSource created
          0.4s: Dynamic.All callback registered
          0.4s: Running optional trace validator
          0.4s: Finished running optional trace validator
          0.4s: Starting stream processing...
          0.6s: Saw sentinel event
          0.6s: Stopped sending sentinel events
          0.6s: Starting event generating action...
          0.6s: Called GC.Collect() 0 times...
          0.7s: Called GC.Collect() 10 times...
          0.7s: Called GC.Collect() 20 times...
          0.7s: Called GC.Collect() 30 times...
          0.7s: Called GC.Collect() 40 times...
          0.7s: Stopping event generating action
          0.7s: Sending StopTracing command...
          0.7s: Saw new provider 'Microsoft-DotNETCore-EventPipe'
          0.7s: Stopping stream processing
          0.7s: Dropped 0 events
          0.7s: Finished StopTracing command
          0.7s: Reader task finished
          0.8s: Test FAILED!
          0.8s: No events for provider "Microsoft-Windows-DotNETRuntime"
          0.8s: Configuration:
          0.8s: {
          0.8s: providers: [
          0.8s: ]
          0.8s: }

          0.8s: Expected:
          0.8s: {
          0.8s: "Microsoft-Windows-DotNETRuntime" = -1 +- -0
          0.8s: }

          0.8s: Actual:
          0.8s: {
          0.8s: "Microsoft-DotNETCore-EventPipe" = 1
          0.8s: }
          0.8s: ==TEST FINISHED: FAILED!==
        Expected: 100
        Actual: 255
        END EXECUTION - FAILED
        Test failed. Trying to see if dump file was created in /home/helixbot/dotnetbuild/dumps since 7/6/2023 11:55:21 PM
        Test Harness Exitcode is : 1
        To run the test:
        > set CORE_ROOT=/root/helix/work/correlation
        > /root/helix/work/workitem/e/tracing/eventpipe/simpleruntimeeventvalidation/simpleruntimeeventvalidation/simpleruntimeeventvalidation.sh
```

* Fix test name

[wasm] Disable runtime test dependent on creating a process (#88498)

`tracing/eventpipe/simpleruntimeeventvalidation`:

```
          Generated app bundle at /root/helix/work/workitem/e/tracing/eventpipe/simpleruntimeeventvalidation/simpleruntimeeventvalidation/WasmApp/
        Incoming arguments: --run simpleruntimeeventvalidation.dll
        Application arguments: --run simpleruntimeeventvalidation.dll
        console.info: Initializing dotnet version 8.0.0-ci commit hash f47b553f129cfa7f006cb1a2f2088112c5ca0112
          0.0s: ==TEST STARTING==
          0.1s: System.PlatformNotSupportedException: System.Diagnostics.Process is not supported on this platform.
           at System.Diagnostics.Process.GetCurrentProcess()
           at Tracing.Tests.Common.IpcTraceTest.Validate(Boolean enableRundownProvider)
           at Tracing.Tests.Common.IpcTraceTest.RunAndValidateEventCounts(Dictionary`2 expectedEventCounts, Action eventGeneratingAction, List`1 providers, Int32 circularBufferMB, Func`2 optionalTraceValidator, Boolean enableRundownProvider)
          0.1s: ==TEST FINISHED: FAILED!==
        test-main.js exiting simpleruntimeeventvalidation.dll with result -1
        console.info: WASM EXIT -1
```

This was added in https://github.com/dotnet/runtime/pull/87785, but got
merged on red.

Add missing compiler-generated attributes to corelib (#87857)

* Add IsUnmanaged, ScopedRef, and Nullable{Context/PublicOnly} attributes

* Update attributes and add docs / tests

* Skip test expecting NullableContextAttribute to be partially trimmed

* Update Moq to latest

* Preserve metadata for InterfaceMethodWithoutTargetInvocation

* Preserve metadata for InheritanceInvocationWithoutTarget

---------

Co-authored-by: Eric StJohn <ericstj@microsoft.com>

Update testing.md (#88364)

NativeAOT Watson changes for crashes/unhandled exceptions (#88273)

* NativeAOT Watson changes for crashes/unhandled exceptions

Adds simple JSON formatting to a static fixed triage buffer that is passed through RaiseFailFastException via
the exception record and special codes to the Watson analyzer.

The current approach is to try to fit as much of the crash and exception info into the static fixed buffer with fallbacks
when it doesn't fit:
   1) The header containing basic info about the crash should always fit
   2) Writes 500 stack frames and as many inner exceptions  as can fit
   3) If that still fails, limit the number of stack frames to 10
   4) if that still fails, limit the number of stack frames to 10 and the size of the frame method name to 100 bytes

These fallback policies are preliminary and will be adjusted for what is needed more by Watson. We also could go with
a completely different approach of resizing the triage buffer with some kind of low level memory allocation. Needs to
work across all our platforms.

I have gone out of my way to avoid GC allocations when rendering the JSON but there still are some strings, delegates/display class and StackTrace class instance allocations.

Escaped the JSON special chars.

Add the RhGetCrashInfoBuffer C++ helper

Cleaned up the RhFailFastReason enum.

Added COR_E_FAILFAST (and Furious) HRESULT.

Used Jan's suggestion of interlock and sleeping all the threads except the first one

Cleaned up RuntimeFailFast. May have took some liberties by only formatting the FailFast message that was there when there isn't an exception message. For unhandled exceptions, having a message for crash info header isn't necessary only for regular FailFasts.

Add module base address to stack frame. Watson is going to need it even though it is usually always the app exe name.

fix TLS resume with HttpClientHandler on Linux (#88214)

* fix TLS resume with HttpHandler

* update

* cleanup

* update

* net48

* fix spacing

Tar: use UtcDateTime when setting last write time. (#88462)

Using LocalDateTime converts the UTC time from the archive to a local
time, which is then converted back to UTC for the file system.

This removes the local time round-trip.

[mono] Add cmake check for HAVE_CLOCK_GETTIME (#88428)

Fixes an issue with missing method names when perf is used together with BenchmarkDotNet using Mono on Linux due to incorrect event order of the fork events and the mmap2 events.

Disable System.Diagnostics.Tests.EventLogMessagesTests.CanReadAndWriteMessages on Windows 11 (#88472)

Fixes blocking status for #88224

Enable reading process environment variables in EventPipe (#87771)

* Process Environment support

* using free to match malloc

* Add test to CI

* Fix FreeBSD build break

* Fix typo in OSX environ def

* FB

Inline TLS field access for linux/osx x64/arm64 (#87082)

* wip

* add __tls_get_addr() code in jitinterface

* working model

* linux rely on __tls_get_addr() value

* Add fields for both max/threadSTaticBlocks, have separate for GC/non-gc

* code cleanup

* code cleanup

* add comments

* jit format

* update guid

* review feedback

* fix the offset

* arm64: wip

* linux arm64 model

* arm64: offsetOfThreadStaticBlock adjustment

* Add mrs and tpid0 register

* arm64: use the new mrs/tpidr0

* fix arm64 build and offset calculation:

* arm64: working

* arm64: move to struct model

* arm64: fixed the struct model

* x64: move to struct model

* code refactoring

* #define for field access

* change mrs -> mrs_tpid0

* fix a bug

* remove unwanted method

* another fix

* Add entries in CorInfoType.cs

* Update the #ifdef

* fix the windows scenario:

* review feedback

* fix the data-type

* add osx-arm64 support

* fix osx-arm64 issues

* fix build error

* fix build error after merge

* add osx/x64 support

* fix errors

* fix the macos/x64

* disable for alpine linux

* Disable for R2R

* review feedback

* fix r2r check

* move windows to struct model

* review feedback

* fix the register clobbering in release bits

* Move the linux/x64 logic to .S file

* Use TargetOS::IsMacOS

* disable optimization for single file

* working for linux/x64

* fix some errors for osx/x64

* fix for osx x64/arm64

* fix for arm64 linux/osx

* try disable for musl/arm64

* rename variable

* Rename variable to tlsIndexObject

* Make offset variables as uint32_t

* change the type of indexObj/ftnAddr to void*

* replace ifdef(msc_ver) with ifdef(windows)

* Revert to JIT_TO_EE_TRANSITION_LEAF

* Move code to asmHelpers.S and rename method

* rename the methods per the platform

* fix osx builds

* fix build break

* fix some errors around osx

* rename some more methods

* review feedback

* review feedback

* delete the comment

* make methods static

* remove macos/x64 check

* fix the check for linux/x64

* detect early for single-file linux/x64

* move the assert

* review feedback

* misc fixup

* use fgMorphArgs()

* remove commented code

[RISC-V] Increase instruction group size (#88468)

Similar to ARM default IG size is not enough for prolog generation.

Optimize Ascii.Equals when widening (#87141)

* Optimize Ascii.Equals when widening

* add BoundedMemory tests to ensure that boundaries are respected

---------

Co-authored-by: Adam Sitnik <adam.sitnik@gmail.com>

Setup support for managed runtime events (#87785)

* preliminery managed runtime event support

* Linux fixes 1

* full portable threadpool support

* checkpoint before python script

* Additional GC event support

* NativeAOT to use sink threadpool file

* CI check

* Enable GC runtime tests

* Post main merge fixups

* change tests that run in CI

* Support native sinks for threading events

* Enable managed exceptions via eventpipe

* Move Exception event to EventPipe

* Add an empty exception event to disabled EventPipe

* make events do no-op in disabled eventpipe

* Update src/coreclr/nativeaot/Runtime/clretwallmain.h

Co-authored-by: Elinor Fung <elfung@microsoft.com>
* FB first stage

* Test change

* FB

* latest FB

* Pulled PR 88365

* FB

---------

Co-authored-by: Elinor Fung <elfung@microsoft.com>

[Android] Add NdkToolFinder task & Fix up AOT app build (#88210)

Since we bumped to NDK 23, having the aot compiler itself generate shared libraries stopped working. This is due to NDK 23 moving most of the toolchain into a common bin directory. AS was left over in each of these directories as an alias to bin/<triple>-as.

This change adds a task to collect all of the important NDK toolchain paths. It also fixes up the aot build when AOTWithLibraryFiles is set to true and we want the aot compiler to produce shared libraries.

[RISC-V] Fix floating point (#88311)

* [RISC-V] Fix: passing struct in regs

* Fix a typo in CallDescrWorkerInternal

* [RISC-V] Update floating points

Delete formatter test blob for `EqualityComparer<byte>.Default` (#88454)

A change was recently made that deleted the specialized type returned, so delete the dedicated formatting test as well.

Fix diagnostic message in ComInterfaceGenerator (#88450)

Fixes #88448

Fix unsafe walking of DacEnumerableHash (#88063)

Under the following set of conditions, it is possible for a lookup in the `DacEnumerableHash` to fail to find already present entries.

Given Thread A which is growing the table, and thread B which is attempting to perform a lookup.

1. Thread B reads an `VolatileEntry*` from a bucket in the hashtable. Let this be EntryB. EntryB will have a next pointer which points to EntryThatWeNeedToFind, but it will not yet read that pointer value from EntryB.
2. Thread A reads the pointer to EntryB from the same bucket in the hashtable.
3. Thread A adds EntryB to the new hashtable
4. Thread A sets the bucket in the old hashtable to point to EntryThatWeNeedToFind
5. Thread A sets the next pointer in EntryB to point to NULL.
6. Thread B reads the next pointer, sees that the next pointer is NULL, and falls back to looking in the "new" hashtable for any possible updates
7. Thread B looks in the appropriate bucket in the "new" hashtable. That bucket does not yet contain EntryThatWeNeedToFind, as it hasn't yet been moved from the old hashtable.
8. Thread B returns NULL __*INCORRECTLY*__, indicating that there are no entries with the matching in them.

This change adjust how these linked lists work, but giving each one a version number which can be checked as the linked list finishes reading. The fix allows finding entries from an earlier set of buckets (as those can be in the new list temporarily, and will not interfere with finding the correct result), but will actively detect walking entries in the new list when attempting to walk the old entries.

In addition, there is a drive by fix for an issue where if there are more than ~14,000,000 entries in the table, it allocates a full new list each time the list is added to.

Fixes #85688

Disable use of certains R2R data structures in the DAC (#88446)

- The ReadyToRun_EnclosingTypeMap, ReadyToRun_TypeGenericInfoMap, and ReadyToRun_MethodIsGenericMap provide optimization data which is already present in metadata
- They are not properly DACized
- Propertly DACizing these methods would not improve debugging, so instead they are disabled in the DAC

Fix which path is taken in Enumerable.Select for empty partition (#88425)

* Fix which path is taken in Enumerable.Select for empty partition

My recent changes to improve perf of some LINQ iterators by implementing `IList<T>` caused Select on an empty partition to start preferring a path that wasn't optimized for empty.  This fixes it.  I searched and don't see any other operators that would be similarly negatively affected.

* Use is check

Type equivalence support in Crossgen2 (#87899)

We currently have a small behavior hole on Windows where if a binary uses TypeEquivalence, it is technically possible to get crossgen2 to generate invalid code.

This fixes that by adding support for type equivalence to the managed type system, and adjusting crossgen2 to use it. This is complicated by the detail that this may generate some type references which cannot be referenced from an R2R file, so additional error checking was needed (this additional error checking is what fixes #67855).

However, while basic support for type equivalence has been added to the type system, support for actually performing type equivalent interface resolution has not been, so devirtualization of type equivalent interface calls is disabled. At this time, I do not expect to see a customer need for implementing that fairly complicated feature

Fixes #67855

Add consultants for some extensions areas (#88430)

* Add consultants for some extensions areas

* Update area-owners.md

---------

Co-authored-by: Dan Moseley <danmose@microsoft.com>

Add docs for AsyncInterfaces (#88432)

Dedup Task.WhenAll non-generic and generic implementations (#88154)

The generic implementation was calling the non-generic one and then using an additional continuation to extract the resulting `Task<TResult>` due to lack of covariance on classes.  We can instead just factor the shared implementation out into a generic with the type parameter constrained to be a Task.  This results in simpler code as well as avoiding an extra continuation in the generic case.

As part of cleaning this up:
- I changed code where we need to make a defensive copy of an input collection to use CopyTo; we were already doing this in some places but not others.  This saves on an enumerator allocation when enumerating the source collection, as well as multiple interface calls.
- I augmented WhenAny to also special-case `List<Task>`, as that's a common input and we can handle it a bit more efficiently, especially if the collection ends up containing just two tasks.
- I removed the `GenericDelegateCache<TAntecedentResult, TResult>`.  That was from a time before the C# compiler supported caching of generic lambdas. It would have needed to have been updated to handle the stronger type coming out of CommonCWAnyLogic, so I instead just got rid of it.  We're better off lazily-creating these rarely used delegates, anyway.

Make DoesConsoleSupportAnsi respect DOTNET_SYSTEM_CONSOLE_ALLOW_ANSI_COLOR_REDIRECTION (#88241)

Co-authored-by: Adam Sitnik <adam.sitnik@gmail.com>

Add gtNewGenericCon (#88440)

JIT: Always look for SIMD fields during promotion (#84122)

[mono] Fix sorting custom attributes in ILStrip (#88435)

The change in https://github.com/dotnet/runtime/pull/87923 was subtly wrong, the problem is that RID on a Cecil metadata token masks out the token type.
We actually have to reconstruct the custom attribute coded-index.

Add option to decrypt Quic traffic in debug builds (#83001)

* Add option to decrypt Quic traffic in debug builds

* feedback from review

* fixes & feedback

* feedback from review

Unify Default Comparer logic (#88006)

Unifies (Equality)Comparer.Default logic so that it matches between CoreCLR, NativeAOT, Mono in runtime and intrinsic implementations.

Fixes devirt behaviour around Nullable types.

Also enables devirt for non final types in CoreCLR and NativeAOT.

Required for #87579.
Fixes #87391.

Co-authored-by: Jan Kotas <jkotas@microsoft.com>

Fix AVX512 moves on X86 (#88421)

Extracted from #85875.

Fix Codespaces prebuild after CMake upgrade and set policy in Mono (#88410)

The prebuild on Codespaces broke after the minimum CMake version was bumped in https://github.com/dotnet/runtime/pull/86530 because the container was still using Ubuntu 20.04 (Focal) which only has CMake 3.16.1.

Upgrade to Ubuntu 22.04 (Jammy) so we have a new enough CMake.

Also fix a missing policy in the Mono CMakeLists.txt that was accidentally removed.

JIT: Compute BB weights with higher precision, use tolerance in if-conversion (#88385)

In https://github.com/dotnet/runtime/issues/88376#issuecomment-1620371447
I noticed a spurious diff in the System.Tests.Perf_Int32.ToStringHex
benchmark that looked like this:

```diff
 G_M62987_IG13:
        and      edi, esi
        mov      ebx, dword ptr [rbp+88H]
-       mov      ecx, 1
        test     ebx, ebx
-       cmovle   ebx, ecx
+       jg       SHORT G_M62987_IG15
+ ;; size=12 bbWeight=1.00 PerfScore 2.50
+G_M62987_IG14:
+       mov      ebx, 1
+ ;; size=5 bbWeight=0.98 PerfScore 0.24
+G_M62987_IG15:
```

Investigating, it turns out to be caused by a check in if-conversion for
detecting loops, that is using a very sharp boundary. It turns out that
the integral block weights are exactly the same (in both the base and
diff), but the floating point calculation ended up with exactly 1 and
very close to 1 in the base/diff cases respectively.

So two changes to address it:
* Switch getBBWeight to multiply by BB_UNITY_WEIGHT after dividing
* Switch if-conversion to have a 5% tolerance so that losing just a
  single count in the wrong place will not cause a decision change. Note
  that the check here is used as a cheap "is inside loop" check.

[main] Update dependencies from dnceng/internal/dotnet-optimization (#88132)

* Update dependencies from https://dev.azure.com/dnceng/internal/_git/dotnet-optimization build 20230627.5

optimization.linux-arm64.MIBC.Runtime , optimization.linux-x64.MIBC.Runtime , optimization.windows_nt-arm64.MIBC.Runtime , optimization.windows_nt-x64.MIBC.Runtime , optimization.windows_nt-x86.MIBC.Runtime , optimization.PGO.CoreCLR
 From Version 1.0.0-prerelease.23326.3 -> To Version 1.0.0-prerelease.23327.5

* Update dependencies from https://dev.azure.com/dnceng/internal/_git/dotnet-optimization build 20230628.5

optimization.linux-arm64.MIBC.Runtime , optimization.linux-x64.MIBC.Runtime , optimization.windows_nt-arm64.MIBC.Runtime , optimization.windows_nt-x64.MIBC.Runtime , optimization.windows_nt-x86.MIBC.Runtime , optimization.PGO.CoreCLR
 From Version 1.0.0-prerelease.23326.3 -> To Version 1.0.0-prerelease.23328.5

* Update dependencies from https://dev.azure.com/dnceng/internal/_git/dotnet-optimization build 20230629.5

optimization.linux-arm64.MIBC.Runtime , optimization.linux-x64.MIBC.Runtime , optimization.windows_nt-arm64.MIBC.Runtime , optimization.windows_nt-x64.MIBC.Runtime , optimization.windows_nt-x86.MIBC.Runtime , optimization.PGO.CoreCLR
 From Version 1.0.0-prerelease.23326.3 -> To Version 1.0.0-prerelease.23329.5

* Update dependencies from https://dev.azure.com/dnceng/internal/_git/dotnet-optimization build 20230630.5

optimization.linux-arm64.MIBC.Runtime , optimization.linux-x64.MIBC.Runtime , optimization.windows_nt-arm64.MIBC.Runtime , optimization.windows_nt-x64.MIBC.Runtime , optimization.windows_nt-x86.MIBC.Runtime , optimization.PGO.CoreCLR
 From Version 1.0.0-prerelease.23326.3 -> To Version 1.0.0-prerelease.23330.5

* Update dependencies from https://dev.azure.com/dnceng/internal/_git/dotnet-optimization build 20230701.5

optimization.linux-arm64.MIBC.Runtime , optimization.linux-x64.MIBC.Runtime , optimization.windows_nt-arm64.MIBC.Runtime , optimization.windows_nt-x64.MIBC.Runtime , optimization.windows_nt-x86.MIBC.Runtime , optimization.PGO.CoreCLR
 From Version 1.0.0-prerelease.23326.3 -> To Version 1.0.0-prerelease.23351.5

* Update dependencies from https://dev.azure.com/dnceng/internal/_git/dotnet-optimization build 20230704.4

optimization.linux-arm64.MIBC.Runtime , optimization.linux-x64.MIBC.Runtime , optimization.windows_nt-arm64.MIBC.Runtime , optimization.windows_nt-x64.MIBC.Runtime , optimization.windows_nt-x86.MIBC.Runtime , optimization.PGO.CoreCLR
 From Version 1.0.0-prerelease.23326.3 -> To Version 1.0.0-prerelease.23354.4

---------

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>

[mono] Fix InlineArrayAttribute access on big-endian platforms (#88417)

Use "guint32" instead of "gpointer" to access the length field in
InlineArrayAttribute; fixes serious regression after PR #88419.

Fix SIMD node DOT retType (#88363)

* Fix SIMD node DOT retType

* no need for lengthsquared

Suppress System.Drawing.Common dependency from System.Windows.Extensions (#88157)

* Suppress System.Drawing.Common dependency from System.Windows.Extensions

* Add Drawing reference to Windows.Extensions tests

Inline more helpers in RegexParser (#88392)

* inline RightCharMoveRight()

* inline Textpos()

* inline MoveLeft()

* inline MoveRight()

* Inline CharAt()

* Inline RightChar()

* Inline RightChar()

* Inline CharsRight()

* Inline Textto()

* rename _pattern and _currentPos

* cleanup Category table

* Cleanup ScanBlank()

* reorder <

* reorder - =

* reorder >=

* reorder - >

* more

* bool param name

* comments

* merge

[iOS] Add temp cindex attribute to build on xcode 15 (#88261)

Without CursorKind 437, the cross build for iOS/tvOS and iOS/tvOSSimulator will fail. This change adds a temporary attribute to avoid that.

JIT: Propagate multi-reg-index for upper-vector-restore ref positions (#88380)

`LinearScan::resolveRegisters` will write the register back to the IR
node for an upper-vector-restore RP, so without this propagation we
would overwrite the register assignment for an unrelated field.

For example, for IR like
```scala
N001 (  9,  6) [000090] m------N---                   t90 =    LCL_VAR   struct<JIT.HardwareIntrinsics.Arm._AdvSimd.SimpleTernaryOpTest__AbsoluteDifferenceWideningUpperAndAdd_Vector128_UInt32+TestStruct, 48>(P) V00 loc0
                                                            ▌    simd16 field V00._fld1 (fldOffset=0x0) -> V14 tmp10         (last use)
                                                            ▌    simd16 field V00._fld2 (fldOffset=0x10) -> V15 tmp11         (last use)
                                                            ▌    simd16 field V00._fld3 (fldOffset=0x20) -> V16 tmp12         (last use) $540
                                                            ┌──▌  t90    struct
N002 ( 10,  7) [000091] -----------                         ▌  RETURN    struct $VN.Void
```
we could build ref positions such as

```
[000091] 449.#639 U14  UVRs   UVRes    NA   │    │    │    │    │    │    │    │    │    │    │    │    │V16a│    │    │    │
         449.#640 d0   Fixd   Keep     d0   │    │    │    │    │    │    │    │    │    │    │    │    │V16a│    │    │    │
         449.#641 V14  Use *  ReLod    d0   │    │    │    │    │    │    │    │    │    │    │V14a│    │V16a│    │    │    │
                              Keep     d0   │    │    │    │    │    │    │    │    │    │    │V14i│    │V16a│    │    │    │
         449.#642 U15  UVRs   UVRes    NA   │    │    │    │    │    │    │    │    │    │    │    │    │V16a│    │    │    │
         449.#643 d1   Fixd   Keep     d1   │    │    │    │    │    │    │    │    │    │    │    │    │V16a│    │    │    │
         449.#644 V15  Use *  ReLod    d1   │    │    │    │    │    │    │    │    │    │    │    │V15a│V16a│    │    │    │
                              Keep     d1   │    │    │    │    │    │    │    │    │    │    │    │V15i│V16a│    │    │    │
         449.#645 d2   Fixd   Keep     d2   │    │    │    │    │    │    │    │    │    │    │    │    │V16a│    │    │    │
         449.#646 V16  Use *  Keep     d2   │    │    │    │    │    │    │    │    │    │    │    │    │V16i│    │    │    │
```

When writing back register assignments the upper-vector-restore at #642
ended up overwriting the assignment for the first field on [000090],
resulting in

```scala
N447 (  9,  6) [000090] m------N--z                   t90 =    LCL_VAR   struct<JIT.HardwareIntrinsics.Arm._AdvSimd.SimpleTernaryOpTest__AbsoluteDifferenceWideningUpperAndAdd_Vector128_UInt32+TestStruct, 48>(P) V00 loc0          NA
                                                            ▌    simd16 field V00._fld1 (fldOffset=0x0) -> V14 tmp10         (last use)
                                                            ▌    simd16 field V00._fld2 (fldOffset=0x10) -> V15 tmp11         (last use)
                                                            ▌    simd16 field V00._fld3 (fldOffset=0x20) -> V16 tmp12         d2 (last use) REG NA,d1,d2 $540
                                                            ┌──▌  t90    struct
N449 ( 10,  7) [000091] -----------                         ▌  RETURN    struct REG NA $VN.Void
```
(note the REG NA instead of REG d0).

Tar: set directory modification times while extracting. (#88231)

* Tar: set directory modification times while extracting.

* Extend test and change entry write order.

* Get rid of some enumeration allocations.

* test: check DateTime using InRange.

* Extend comment explaining the order of entries.

* Apply suggestions from code review

Co-authored-by: Dan Moseley <danmose@microsoft.com>
* Try including AltDirectorySeparatorChar.

* Revert "Try including AltDirectorySeparatorChar."

This reverts commit 086aac43a897826394156692bd82f79feb3eca9d.

* Try using Directory.SetLastWriteTime instead of File's.

* Tie up some ends.

---------

Co-authored-by: Dan Moseley <danmose@microsoft.com>

Localized file check-in by OneLocBuild Task: Build definition ID 679: Build ID 2214454 (#88399)

Implement JsonTypeInfoResolver.WithAddedModifier (#88255)

[mono][interp] Add vectorization for Vector4 (#87822)

* [mono][interp] Reuse vectorization for Vector4

Which is pretty much Vector<float>

* [mono][interp] Implement Vector.One for float gparam

* [mono][interp] Extract code to be reused later

* [mono][interp] Intrinsify Vector<T> ctor and Vector4 ctor

The constructors receive each element as an argument. This is the same as `Vector128.Create` so we reuse that code. This ends up generating a MINT_SIMD_V128_I*_CREATE opcode which receives each element value as an argument.

* [mono][interp] Track r4 var value during interpreter optimizations

Since it is common to instantiate Vector4 with constant values, add also support for tracking R4 values during optimizations. If all elements are constant, we generate instead a single MINT_SIMD_V128_LDC, which has the entire vector value embedded in the instruction stream.

* [mono][interp] Fix Vector ctor instrinsic when called explicitly

* [mono][interp] Replace ldloca + stobj.vt pair with mov.vt

* [mono][interp] Return early if vector_klass is not simd type

It is not marked as simd type if the generic param is not valid (ex not primitive type). Future checks are not expecting this scenario and can potentially crash.

Improve non-SIMD block copy/init codegen (#88393)

Add clr.tools subset to runtime-community (#88160)

Co-authored-by: Adeel Mujahid <3840695+am11@users.noreply.github.com>

Permit trailing data after PKCS12 (#88340)

Faster optimized frozen dictionary creation (6/6)  (#88093)

* don't use custom ToArray for small frozen collections, up to 50% gain for creation time for collections with <= 4 items

* for these types GetHashCode returns their value casted to int, so when we receive a Dictionary/HashSet where there are key we know that all hash codes are unique and we can avoid some work later

10-15% CPU time gain and 15-20% allocation reduction for FrozenDictionary and FrozenHashSet where TKey is uint, short, ushort, byte, sbyte

* move Length Buckets code to a dedicated helper type to reduce code duplication and decrease code size

* add tests for Frozen Dictionaries with key being uint, short, ushort, byte, sbyte, nint and nuint

* fix discovered bug: IntPtr started implementing IComparable<IntPtr> in .NET 5

Bump to libc++ without libatomic linkage (#88402)

Closes: https://github.com/dotnet/runtime/issues/88361

Move IMeterFactory to System.Diagnostics.DiagnosticSource (#88302)

[mono][llvm] Fix another crash when using opaque pointers. (#88397)

[mono] Respect KeepNativeSymbols when building cross compilers. (#88398)

change regex options tests to extension method (#88366)

* extension method for regexoptions

* Revert "extension method for regexoptions"

This reverts commit 95b05489f0245d23d6d265a2cad2fca2ae0975a0.

* Inline UseOption

[mono][interp] Extract simd create opcodes in separate methods (#88381)

Newer versions of clang allocate the local buffer repeatedly by bumping the stack. This behavior seems dubious, leading to stack overflows, but extracting the code outside the interp main loop is an improvement anyway for the interpreter.

[LoongArch64] Fix the NotImplementedException within R2RDump. (#88379)

JIT: Handle primitive-sized remainders overlapping padding/promotions in physical promotion (#88109)

The remainder may be separated by a bit of padding or other promoted fields but
still fit into a primitive; in this case it is still beneficial to copy it all
as a primitive, instead of falling back to a full block copy.

Example:
```csharp
private S _s;

void Foo()
{
    S s = new();
    s.A = 10;
    s.D = 20;
    s.F = 30; // A, D, F gets promoted
    _s = s;
}

private struct S
{
    public byte A;
    public byte B;
    public byte C;
    public byte D;
    public byte E;
    public byte F;
}
```

```diff
 Processing block operation [000018] that involves replacements
   dst+003 <- V04 (V01.[003..004)) (last use)
   dst+005 <- V05 (V01.[005..006)) (last use)
   Block op remainder: [001..003) [004..005)
-  => Remainder strategy: retain a full block op
+  => Remainder strategy: int at +001
```

```diff
 ;  V00 this         [V00,T01] (  3,  3   )     ref  ->  rcx         this class-hnd single-def
 ;* V01 loc0         [V01    ] (  0,  0   )  struct ( 8) zero-ref    do-not-enreg[SF] ld-addr-op
 ;# V02 OutArgs      [V02    ] (  1,  1   )  struct ( 0) [rsp+00H]   do-not-enreg[XS] addr-exposed "OutgoingArgSpace"
 ;* V03 tmp1         [V03    ] (  0,  0   )   ubyte  ->  zero-ref    "V01.[000..001)"
 ;* V04 tmp2         [V04    ] (  0,  0   )   ubyte  ->  zero-ref    "V01.[003..004)"
 ;* V05 tmp3         [V05    ] (  0,  0   )   ubyte  ->  zero-ref    "V01.[005..006)"
 ;  V06 tmp4         [V06,T00] (  5, 10   )   byref  ->  rcx         single-def "Spilling address for field-by-field copy"
 ;
 ; Lcl frame size = 0

 G_M52879_IG01:  ;; offset=0000H
  ;; size=0 bbWeight=1 PerfScore 0.00
 G_M52879_IG02:  ;; offset=0000H
        add      rcx, 8
        xor      eax, eax
-       mov      dword ptr [rcx], eax
-       mov      dword ptr [rcx+02H], eax
+       mov      dword ptr [rcx+01H], eax
        mov      byte  ptr [rcx], 10
        mov      byte  ptr [rcx+03H], 20
        mov      byte  ptr [rcx+05H], 30
- ;; size=22 bbWeight=1 PerfScore 5.50
-G_M52879_IG03:  ;; offset=0016H
+ ;; size=20 bbWeight=1 PerfScore 4.50
+G_M52879_IG03:  ;; offset=0014H
        ret
  ;; size=1 bbWeight=1 PerfScore 1.00

-; Total bytes of code 23, prolog size 0, PerfScore 8.80, instruction count 8, allocated bytes for code 23 (MethodHash=1da13170) for method Program:Foo():this (FullOpts)
+; Total bytes of code 21, prolog size 0, PerfScore 7.60, instruction count 7, allocated bytes for code 21 (MethodHash=1da13170) for method Program:Foo():this (FullOpts)
 ; ============================================================

```

We have to be careful, however, since the covering segment can now contain
promoted fields. If this happens we need to make sure we write the promoted
field _after_ the remainder.

JIT: Quirk a quirk in fgExpandVirtualVtableCallTarget (#88374)

Fix #88349

[mono] Reenable disabled tests as mono now respects non-public custom attributes in dynamic assemblies (#88322)

* Reenable disabled tests
* Disable Roslyn analyzer tests in the browser as Monitor.Wait / Monitor.Pulse are not supported on single-threaded WASM

Contributes to: https://github.com/dotnet/runtime/issues/60650

Email addresses in same domain not equal (#87721)

Different email addresses in same domain should not be equal.
UriComponents.UserInfo will compare also UserInfo from the Uris.

only log errors of Task/Promise marshaling (#88326)

Unified source file formatting (#88330)

[OSX] HybridGlobalization Workaround for  insufficiently sized destination buffer (#88184)

Workaround for insufficiently sized dest buffer

Remove conservative generic scanning logic (#88360)

@EgorBo's #88025 made it possible to undo conservative scanning logic added in dotnet/corert#7618.

Saves 0.4% in size for Stage1 and Stage2 apps.

Allow inlining array methods (#88367)

`CanInline` would return false to methods that implement generic interfaces on arrays because we didn't consider the magic `Array<T>` types constructed.

For:

```csharp
static int Main()
{
    IReadOnlyCollection<int> l = new int[] { 1, 2, 3 };
    return l.Count;
}
```

Before:

```
       sub      rsp, 40
                                                ;; size=4 bbWeight=1 PerfScore 0.25
G_M24375_IG02:  ;; offset=0004H
       lea      rcx, [(reloc 0x4000000000420a70)]      ; int[]
       mov      edx, 3
       call     CORINFO_HELP_NEWARR_1_VC
       lea      rcx, [(reloc 0x4000000000420aa8)]      ; const ptr
       mov      rdx, qword ptr [rcx]
       mov      qword ptr [rax+10H], rdx
       mov      rdx, qword ptr [rcx+04H]
       mov      qword ptr [rax+14H], rdx
       mov      rcx, rax
       call     System.Array`1[int]:get_Count():int:this
       nop
                                                ;; size=48 bbWeight=1 PerfScore 9.75
G_M24375_IG03:  ;; offset=0034H
       add      rsp, 40
       ret
```

After:

```
       sub      rsp, 40
                                                ;; size=4 bbWeight=1 PerfScore 0.25
G_M24375_IG02:  ;; offset=0004H
       lea      rcx, [(reloc 0x4000000000420a70)]      ; int[]
       mov      edx, 3
       call     CORINFO_HELP_NEWARR_1_VC
       lea      rcx, [(reloc 0x4000000000420aa8)]      ; const ptr
       mov      rdx, qword ptr [rcx]
       mov      qword ptr [rax+10H], rdx
       mov      rdx, qword ptr [rcx+04H]
       mov      qword ptr [rax+14H], rdx
       mov      eax, 3
                                                ;; size=44 bbWeight=1 PerfScore 8.50
G_M24375_IG03:  ;; offset=0030H
       add      rsp, 40
       ret
```

Remove empty files (#88362)

Fix libraries Windows test runner script (#88354)

Having HAS_TEST_RESULTS unset leads to a Windows CMD script
syntax error.

Clean up a few other things while there:
1. Explicitly set ENABLEEXTENSIONS
2. Set a variable to the test exit code. There's an unsafe assumption
currently that `%ERRORLEVEL%` doesn't change between the test run
and all of the subsequent uses.
3. Remove unnecessary quotes around setting `HAS_TEST_RESULTS=1`

Fixes #88353

Up Minimum CMake Version to 3.20 (#86530)

* Let's see what happens :)

* CMake 3.20 works on my machine???

* Upped the llibraries CMake version to 3.20

* Upped native libs CMake version to 3.20, and updated the requirements docs.

* Add CMake Policy to 3.17.0 for native libs because of wasm.

* Downgraded native libs CMake to 3.17.0 temporarily, while we figure out the funny troublemaker wasm.

* Added a couple notes regarding CMake on Linux and Windows, and upped the corehost and libunwind CMake versions to 3.20

* Reverted external native components CMake versions, and upped tests to 3.20. Only Mono remains now.

* Added mono to the 3.20 gang. Also, changed the condition for wasm.

* Had to condition mono's CMake version as well because of wasm.

* DEBUG-ONLY COMMIT: Added some CMake logging to help me figure out what is set for wasm to think of the appropriate conditional.

* DEBUG-ONLY COMMIT: I think I have the answer for wasm now/

* Restored the DEBUG-ONLY changes and set 3.20 as the universal CMake, as the missing machines have now been updated.

* Updated requirements doc with notes for Debian 11 and lower.

Improve LoggerFactory and Logger debugging (#88313)

Try adding cross-compilers for Musl (#87841)

* Add cross-compilers for Musl

* Fix LLVM linkage on Musl

Pass exact context to getMethodInfo (#88025)

* Modify JIT-EE API

Co-authored-by: Jan Kotas <jkotas@microsoft.com>

Shrink column width in `ilc --help` (#88356)

Fix condition for ENSURE_PRIMARY_STACK_SIZE (#88342)

Fixes #88339

 TcpListener should implement IDisposable (#88043)

* TcpListener should implement IDisposable

* lint

* Code review

* Update src/libraries/System.Net.Sockets/src/System/Net/Sockets/TCPListener.cs

Co-authored-by: Anton Firszov <antonfir@gmail.com>
* Update TCPListener.cs [EditorBrowsable(EditorBrowsableState.Never)]

* Code review

* lint

* Code review

---------

Co-authored-by: Anton Firszov <antonfir@gmail.com>

Fix incorrect sequence number used in NTLM signature calculation (#87998)

[mono] Remove mono_loader_save_bundled_library() (#88331)

Remove TODO from a comment in System.Guid.cs (#88337)

Localized file check-in by OneLocBuild Task: Build definition ID 679: Build ID 2213468 (#88301)

[Crossgen] Don't display list of enum values in help (#88324)

Upgrade to LLVM 16 & C++17, and bundle libc++ on Linux (#87190)

* Upgrade to LLVM 16, and stop focusing on C++11 ABi stuff from CentOS 7

Co-authored-by: Zoltan Varga <vargaz@gmail.com>

[mono] fix memfuncs for FreeBSD (#88300)

* fix memfuncs for FreeBSD

* match format

Improve Hosting debugging (#88308)

* Improve Hosting debugging

* Update

* Remove Logger

* PR feedback

Expose stack trace metadata stripping as a supported option (#88235)

Fix OptionsValidator source-gen to skip static and const members (#88254)

Co-authored-by: Nikita Balabaev <nbalabaev@microsoft.com>

Implement IList<T> on some LINQ iterators (#88249)

`ICollection<T>` provides both a Count and a CopyTo, and `IList<T>` an indexer, all of which can make various consumption mechanisms more efficient. We only implement the interfaces when the underlying collection has a fixed size and all of the interface implementations are side-effect free (in particular, while appealing to do so, we don't implement them on various Select iterators).

Some of the serialization tests need to be fixed as a result. The state of Queue's array is a bit different based on how its initialized, and such private details show up in BinaryFormatter output.  Rather than special-casing the output per framework and core, I've just changed the test itself to ensure Queue can't see the size of the input collection.

[wasm] Implement complete PackedSimd feature set in interpreter (#87903)

Implement all PackedSIMD APIs in wasm builds of the interpreter based on a table and auto-generated code
Implement most PackedSIMD APIs in jiterpreter
Detect constant simd arguments in jiterpreter and verify them
Simplify unused/temporary dregs in interp

Avoid reporting frozen segments in GetGenerationBounds (#85727)

Co-authored-by: Noah Falk <noahfalk@users.noreply.github.com>

Unify JIT interface getTypeLayout between VM and crossgen2; refine what is considered "significant padding" (#88238)

* Stop considering auto layout types to have significant padding in the VM. This was already the behavior in crossgen2. This fixes one of the points of #71711.
* Remove special case where we never considered structs with GC pointers to have significant padding. After the above change this has no additional diffs.
* Fix the inline array layout expansion; the numFields of the inline array node was computed incorrectly, and the parent indices of descendants were not updated correctly

Example C#:
```csharp
private (long, int) _tuple;

[MethodImpl(MethodImplOptions.NoInlining)]
private void Foo()
{
    _tuple = (5, 10);
}
```

Before:
```asm
;  V00 this         [V00,T00] (  3,  3   )     ref  ->  rcx         this class-hnd single-def
;# V01 OutArgs      [V01    ] (  1,  1   )  struct ( 0) [rsp+00H]   do-not-enreg[XS] addr-exposed "OutgoingArgSpace"
;  V02 tmp1         [V02    ] (  4,  8   )  struct (16) [rsp+08H]   do-not-enreg[SB] ld-addr-op "NewObj constructor temp"
;  V03 tmp2         [V03,T01] (  3,  5   )    long  ->  [rsp+08H]   do-not-enreg[] "field V02.Item1 (fldOffset=0x0)" P-DEP
;  V04 tmp3         [V04,T02] (  3,  5   )     int  ->  [rsp+10H]   do-not-enreg[] "field V02.Item2 (fldOffset=0x8)" P-DEP
;
; Lcl frame size = 24

G_M52879_IG01:  ;; offset=0000H
       sub      rsp, 24
       vzeroupper
;; size=7 bbWeight=1 PerfScore 1.25
G_M52879_IG02:  ;; offset=0007H
       vxorps   xmm0, xmm0, xmm0
       vmovups  xmmword ptr [rsp+08H], xmm0
       mov      qword ptr [rsp+08H], 5
       mov      dword ptr [rsp+10H], 10
       vmovups  xmm0, xmmword ptr [rsp+08H]
       vmovups  xmmword ptr [rcx+08H], xmm0
;; size=38 bbWeight=1 PerfScore 8.33
G_M52879_IG03:  ;; offset=002DH
       add      rsp, 24
       ret
;; size=5 bbWeight=1 PerfScore 1.25

; Total bytes of code 50, prolog size 7, PerfScore 15.83, instruction count 10, allocated bytes for code 50 (MethodHash=1da13170) for method Program:Foo():this (FullOpts)
```

After:
```asm
;  V00 this         [V00,T00] (  4,  4   )     ref  ->  rcx         this class-hnd single-def
;# V01 OutArgs      [V01    ] (  1,  1   )  struct ( 0) [rsp+00H]   do-not-enreg[XS] addr-exposed "OutgoingArgSpace"
;* V02 tmp1         [V02    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp"
;* V03 tmp2         [V03,T01] (  0,  0   )    long  ->  zero-ref    "field V02.Item1 (fldOffset=0x0)" P-INDEP
;* V04 tmp3         [V04,T02] (  0,  0   )     int  ->  zero-ref    "field V02.Item2 (fldOffset=0x8)" P-INDEP
;
; Lcl frame size = 0

G_M52879_IG01:  ;; offset=0000H
;; size=0 bbWeight=1 PerfScore 0.00
G_M52879_IG02:  ;; offset=0000H
       mov      qword ptr [rcx+08H], 5
       mov      dword ptr [rcx+10H], 10
;; size=15 bbWeight=1 PerfScore 2.00
G_M52879_IG03:  ;; offset=000FH
       ret
;; size=1 bbWeight=1 PerfScore 1.00

; Total bytes of code 16, prolog size 0, PerfScore 4.60, instruction count 3, allocated bytes for code 16 (MethodHash=1da13170) for method Program:Foo():this (FullOpts)
```

Fix make repro cli command (#88289)

JIT: Remove a quirk in regular promotion (#88130)

Also fix a bug in LSRA: if we undo promotion of one field of a multi-reg
struct and as a result undo for the other fields as well, we must also
clear out the largeVectorVars bitset to indicate these are no longer
candidates.

Apply a number of improvements and bugfixes to JsonNode (#88194)

* Avoid JsonElement torn read in a few JsonArray/JsonDocument and unify code patterns.

* Simplify and clean up JsonValue implementation -- fix DeepEquality bugs.

* Update src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonValueOfTPrimitive.cs

* Avoid delegate allocation in the JsonObject setter.

[wasm] Introduce <InvariantTimezone> build flag (#87284)

JIT: Don't set patchpoints in methods with CORINFO_DEBUG_CODE (#88227)

In #88199 the debugger is overriding some jit flags, but has left other flags set
that confuse the jit: both `TIER0` and `DEBUG_CODE` end uip set so one part of the jit
used logic appropriate for `TIER0` and another part did not.

The JIT ended up creating a patchpoint for OSR in a method with localloc and this
combination is not supported by OSR and lead to a crash.

Harden the jit so if the runtime asks for debuggable code, the jit will never
generate patchpoints.

Fix Out of memory with source gen tests (#88266)

Clean up Guid.DecodeByte (#88267)

Fix build failures when declaring a COM-style enumerable type (#88263)

[browser] Fix missing braces when resolving application culture (#88264)

Regression from https://github.com/dotnet/runtime/pull/86255.

Add IHostedLifecycleService (#87335)

Delete stale SkipOnTargetFramework attributes (and a few tests) (#88251)

These projects don't run tests on .NET Framework.