Improve Microsoft.Extensions.Configuration debugging (#86624)

* Improve Microsoft.Extensions.Configuration debugging

* Clean up

* Clean up

* Clean up + tests

JIT: Use unsigned native return types for small structs (#86631)

Prefer the return type to be unsigned when small structs are returned in
registers. This causes the backend to use zero extension instead of sign
extension in a few cases, which has a smaller encoding on xarch.

Fix assert failure in grow_heap_segment in no GC region. (#86644)

This addresses issue #86612.

We won't actually decommit anything once we enter a no GC region, so the assert was overeager for this case, but it seems better to keep the assert and turn off the gradual_decommit_in_progress_p flag when we enter a no GC region.

Dynamic heap count (#86245)

This is an initial implementation for changing the GC heap count dynamically in response to changing load conditions.

Using more heaps will increase memory footprint, but in most cases also improve throughput because more GC work is parallelized, and lock contention on the allocation code path is reduced by spreading the load.

We try to keep the measured overhead from lock contention and GC pauses at 5% or below, and only reduce the heap count if the measured overhead is below 1% and we estimate a significant reduction in memory footprint. There is some more fine tuning for the cases where smaller reductions in either footprint or overhead are possible without impacting the other side of the equation too much.

Because the input data for GC pause etc. are quite noisy, we use a median of 3 filter before the data is used to make decisions. Preliminary data suggests this is effective, but we may need to do more filtering if gains in either direction appear to be small.

[mono][interp] Attempt to devirtualize call if we have type information about `this` (#85528)

* [mono][interp] Preserve klass information when generating MINT_CKNULL

This information will be useful to later devirtualize the call

* [mono][interp] Add more specific type information for EqualityComparer.Default

* [mono][interp] Devirtualize calls if we can find a final implementation

Remove asserts from mono_class_get_virtual_method so we can check a virtual method on any klass, returning NULL if no implementation is found.

* [mono][interp] Optimize out null check on ldloca

* [mono][interp] Constant fold unop conditionals applied to non null values

* [mono][interp] Optimize out unused MINT_BOX

* [mono] Remove duplicated code between interp and jit

* [mono][metadata] Allow method to be called for abstract classes

It will just return null if a concrete implementation wasn't found.

* [mono][interp] Don't populate wrong type information into the stack state

* [mono][interp] Don't devirtualize final methods

They can still be overriden

* [mono][interp] Ensure class is initialized before getting aot method

Fix Incorrect RequiresDynamicCode attribute message (#86602)

* Fix Incorrect RequiresDynamicCode attribute message

Replace GetEnumValues<TEnum> in the RequiresDynamicCode attribute message on System.Type.GetEnumValues, System.Reflection.SignatureType.GetEnumValues and System.Runtime.GetEnumValues with Enum.GetValues<T> with Enum.GetValues<T>

Fix #86585

* Update attribute message as suggested in PR

* Add warning suppression

[mono][AOT] Enabled tests which fail to JIT compile during AOT (#86581)

* Enabled 2 tests

Signed-off-by: Vlad - Alexandru Ionescu <vlad-alexandruionescu@Vlads-MacBook-Pro-5.local>
---------

Signed-off-by: Vlad - Alexandru Ionescu <vlad-alexandruionescu@Vlads-MacBook-Pro-5.local>
Co-authored-by: Vlad - Alexandru Ionescu <vlad-alexandruionescu@Vlads-MacBook-Pro-5.local>

[browser] Turn webcil off for .NET < 8.0 (#86505)

Unreachable filter end (#86492)

Fixes the problem described in https://github.com/dotnet/roslyn/issues/67494 for illink.

`endfilter` instruction must be kept if the filter block is kept, even if the instruction itself is unreachable - per the ECMA spec. Fix the branch removal code to preserve the instruction unconditionally.

Adds a test to validate the new behavior.

I also enabled the test to run on NativeAOT, since it has code to handle this as well. We only validate that the compiler will not crash/warn, the Kept validation is disabled, since we can't really inspect IL of the produced methods in AOT.

Also fixes a bug in the illink test infra where the `By` property on `SkipKeptItemsValidationAttribute` was ignored.

Fix endless loop in illink analyzer (#86449)

The root cause is the fact that `ArrayValue` is mutable, so it needs to be `DeepCopy` everywhere. So the first set of fixes is to make sure that even hoisted locals are correctly copied.
The second problem is that we use `HashSet` to store multiple values in `ValueSet`/`MultiValue`. HashSet assumes that items don't change identity (equality group) while they're stored inside. But `ArrayValue` does exactly that. So we can't rely on pure `HashSet` functionality to implement `Equals`.

Changes:
* Make Maybe<T> an IDeepCopyValue and make sure it deep copies its value - because it can store values which require a deep copy
* Make ValueSet<T> an IDeepCopyValue since it can store values which require a deep copy (this causes an effective rename of MultiValue.Clone to MultiValue.DeepCopy - lot of files touched)
* Modify ValueSet<T> to be careful when comparing for equality - we can't rely on immutability of values and since we store them in a hashset, the hashset itself effectively breaks. Maybe we should consider switching to a simple List? But then we want to to unify same values.
* Modify array equality comparison - previously it caused an allocation of a `HashSet` - we compare values quite a bit (in analyzer during multi-pass analysis). Currently we rely on values in arrays to be immutable.

Future looking:
The data flow analysis simply doesn't have a solution for mutable values (mostly mutable refence types, but I think similar set of problems might occur with structs as well). ILLink implements by-ref values, which are probably the closest approximation yet, but the full CFG data flow doesn't support those yet. And ultimately it's probably more complex then just by-ref values.
Proper fix is complex, and requires some design work first.

Note that we will want to backport this to .NET 7 very likely - I haven't looked yet how well it will port.

Allow overbudget for small methods (#86473)

Co-authored-by: Andy Ayers <andya@microsoft.com>

Add note about transient pointers to ECMA augments (#86622)

Fixes #62784

Abstract out System.Reflection.Emit.ILGenerator (#86594)

* Abstract out ILGenerator

* Finish up abstracting

* Remove protected abstract methods, use more public abstract instead

* Use RuntimeILGenerator for Linq test

Update GetElement and ToScalar to lower IND, LCL_FLD, and LCL_VAR specially (#86400)

* Update GetElement and ToScalar to lower IND, LCL_FLD, and LCL_VAR specially

* Ensure GetElement still correctly handles too large indices

* Only optimize to LCL_FLD for lvDoNotEnregister

* Account for an extreme edge case in offset overflow

* Use simdSize rather than maxSIMDStructBytes

[wasm] No longer discard jiterp inference information when crossing a branch (#86611)

* Discarding inferred state when crossing a branch is not strictly necessary and reduces performance
* Don't allow treating ldloca'd addresses as constant

Add a test for the first chance exception event (#86560)

Rename setting for using RID graph to System.Runtime.Loader.UseRidGraph (#86598)

Ensure Avx512Vbmi has [Intrinsic] on the right members (#86604)

* Ensure Avx512Vbmi has [Intrinsic] on the right members

* Ensure vpermb is covered

JIT: Switch basic block successors to a visitor pattern (#86543)

BasicBlock::GetAllSuccs seems to be very slow.

Switch physical promotion stress modes to only be enabled in checked builds (#86590)

Otherwise we may be running old preview 4 bits with physical promotion
enabled and running into issues that were already fixed.

Fix #86588

Avoid capturing diagnostic objects in Regex source generator incremental values (#86606)

It's mostly a non-issue given how we use it, but Diagnostic's message arguments are compared with reference equality rather than value equality.  Store the data into our own object instead, and only create the actual Diagnostic objects when we're about to report them.

Avoid capturing diagnostic objects in SG incremental values. (#86605)

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

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

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.23260.3 -> To Version 1.0.0-prerelease.23267.3

Dependency coherency updates

Microsoft.SourceLink.GitHub,Microsoft.DotNet.XliffTasks
 From Version 8.0.0-beta.23252.2 -> To Version 8.0.0-beta.23218.3 (parent: Microsoft.DotNet.Arcade.Sdk

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

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.23260.3 -> To Version 1.0.0-prerelease.23268.7

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

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.23260.3 -> To Version 1.0.0-prerelease.23269.15

* Update dependencies from https://dev.azure.com/dnceng/internal/_git/dotnet-optimization build 20230520.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.23260.3 -> To Version 1.0.0-prerelease.23270.4

* Require clang-16 for PGO optimization

* Update dependencies from https://dev.azure.com/dnceng/internal/_git/dotnet-optimization build 20230521.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.23260.3 -> To Version 1.0.0-prerelease.23271.4

* Revert sourcelink and xliff-tasks downgrades

---------

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>
Co-authored-by: Larry Ewing <lewing@microsoft.com>
Co-authored-by: Sven Boemer <sbomer@gmail.com>

Avoid ToString allocations for each ISpanFormattable value in string.Concat/Join(..., IEnumerable<T>) (#86521)

We can use a T's ISpanFormattable implementation to avoid the individual ToStrings. We also don't need to maintain a separate implementation for Concat; at the cost of one branch per value, we can just reuse the Join implementation and pick up all of its optimizations for Concat.

Vectorize IEnumerable<T>.Sum where possible (#84519)

* Vectorize IEnumerable<T>.Sum where possible

* Remove unnecessary CreateChecked and fix long test

* Add more assertions

* Improve comments, don't use Unsafe.Add, use T.MinValue

Apply the SourceWriter pattern to the STJ source generator. (#86526)

* Use the SourceWriter pattern in the STJ SG emitter.

* Make helper method static.

* Minimize the size of the generic helper method.

[LoongArch64] Fix some bugs in the test sets 'System.Runtime.Tests' and 'System.Linq.Expressions.Tests' for loongarch64. (#86435)

* Fix the error of the Truncate/Saturate convert from Float/Double NAN to UINT32/UINT64.
* fix some random failed testcases in System.Runtime.Tests.

* Update codegenloongarch64.cpp

Fix the RangeCheck bug of the TYP_INT case in CodeGen::genRangeCheck().

Rename a couple model specs for config binding generator (#86459)

Update createdumpwindows to not appear to succeed after getting ERROR_PARTIAL_COPY 5 times (#85462)

* Update createdumpwindows.cpp

create dump has same bug as documented and fixed in dotnet-dump (https://github.com/dotnet/diagnostics/issues/3829)

* Update createdumpwindows.cpp

changed retry count to 10 to match dotnet-dump

[mono] When creating an array type, don't do full initialization of the element type (#85828)

Consider code like this:

```csharp
public class Node<T>
{
    public Node<T>[][] Children;
}

Console.WriteLine (typeof(Node<int>));
```

In this case, when we're JITing ``ldtoken class Node`1<int32>`` we first have to parse the type ``Node`1<int32>`` and initialize it.
When we're initializing it, we need to resolve the types of all the fields in the class in order to to figure out if its instance size.

To resolve the field types we have to parse the types of all the fields, and we eventually end up parsing the type ``Node`1<!0>[][]`` which ends up here:

https://github.com/dotnet/runtime/blob/558345d16cf76525d0c7fdbafbfd3a2457142b39/src/mono/mono/metadata/metadata.c#L4023-L4027

When we get to line 4027 the second time (recursively), `etype` is ``Node`1<!0>`` as a `MonoType*`.  And we want to set `type->data.klass` to its corresponding `MonoClass*`.   That ends up calling `mono_class_from_mono_type_internal`, which does this:

https://github.com/dotnet/runtime/blob/558345d16cf76525d0c7fdbafbfd3a2457142b39/src/mono/mono/metadata/class.c#L2214-L2215

When we call `mono_class_create_array` we end up here:

https://github.com/dotnet/runtime/blob/558345d16cf76525d0c7fdbafbfd3a2457142b39/src/mono/mono/metadata/class-init.c#L1186-L1187

with `eclass` equal to ``Node`1<!0>` which we try to initialize and we get a TLE because we're going to try to initialize the same generic type definition ``Node`1`` twice.

Compare with this other class:

```csharp
public unsafe class Node2<T>
{
    public Node2<T>[] Children;
}
```

In this case we only end up calling `mono_class_from_mono_type_internal` on ``Node2`1<int32>`` (not an array).  And that branch does not do any initialization - it just returns `type->data.klass` (for ``Node2`1<!0>`` - which is seen as a gtd at this point) or `mono_class_create_generic_inst (type->data.generic_class)` (for ``Node2`1<int32>`` which is seen later when `ldtoken` inflates the gtd)) - without any extra initialization.

---

It seems the reason we get into trouble is because `mono_class_create_array` does more work than other `MonoClass` creation functions - it tries to initialize the `MonoClass` a little bit (for example by setting `MonoClass:has_references`) which needs at least a little bit of the element class to be initialized.

But note that the code has this:

https://github.com/dotnet/runtime/blob/558345d16cf76525d0c7fdbafbfd3a2457142b39/src/mono/mono/metadata/class-init.c#L1186-L1189

I feel fairly certain we don't need the full class initialization if we're going to immediately initialize the field size information.

Fixes #85821

Vectorize shorter buffers for CRC-32 on Intel (#86539)

disable JitOptimizationSensitive check on NativeAOT testing (#86523)

Lots of tweaks to FrozenDictionary/Set analysis and hashing (#86293)

- Some minor internal refactorings, e.g. changed the internal KeyAnalyzer.Analyze from being void returning with an out results to instead just return those results, and did some internal renaming.
- We were previously computing the min/max string length in KeyAnalyzer.Analyze twice, once in UseSubstring and then again after that in Analyze.  We were also computing it in the length buckets analyzer.  Changed the code to do the checks just once at the beginning and then pass that information around to everywhere that needs it.
- Once that information is passed in, AnalysisResults can then be made readonly, rather than being mutated to store the min/max after it was constructed.
- If the min length is 0, there's no point calling TryUseSubstring as it'll never find one, so skip the call to it entirely if there's an empty string in the mix.
- In TryUseSubstring, for a given substring length first check all the left justifications and then check all the right justifications, rather than intermingling them.  Left justifications are a bit cheaper to look up, plus we can avoid creating any objects related to checking right justification if we end up finding a left justification for a given substring length first.
- We can also avoid doing any right justification checks if all of the input strings are of the same length, as at that point there's nothing right justification could find that left justification couldn't.
- When constructing the HashSets for evaluating uniqueness, when targeting more recent .NET versions we can presize the HashSets to avoid the expansion as we add all the items.
- Importantly, set a limit on the maximum length of substring we'll consider.  This significantly curtails the worst-case analysis performance for very large inputs that don't yield any unique substrings.  While it's certainly possible to construct cases where this will then fail to find a substring when it otherwise could, it's much more rare, and the longer we're dealing with the less we're saving on the hashing costs, which is the only thing this is avoiding.
- For hashing, create dedicated branchless hash checks for each of lengths 0 to 4.
- When we're doing the ASCII check to see if we can use an ASCII-optimized comparer, if OrdinalIgnoreCase was used, we can also check to see if the substring contains any ASCII letters; if the only the thing the substrings contain are ASCII non-letters, then we can switch to being case-sensitive, as no casing will impact the comparisons.
- The ASCII check downlevel was erroneously including 0x7f as being non-ASCII. Fixed it to be 0x80 instead of 0x7f.
- Changed GetHashCodeOrdinalIgnoreCase to delegate to GetHashCodeOrdinal after doing its non-ASCII casing work.
- On .NET 6+, we can use GetValueRefOrAddDefault to avoid some dictionary lookups.
- For the length-bucketing implementation, we can do a quick up-front check to rule out applicability of many inputs where we know just based on the number of input strings and the min/max lengths whether some bucket will be forced to be too big.

[main] Update dependencies from dotnet/roslyn-analyzers (#86384)

* Update dependencies from https://github.com/dotnet/roslyn-analyzers build 20230516.2

Microsoft.CodeAnalysis.Analyzers , Microsoft.CodeAnalysis.NetAnalyzers
 From Version 3.3.5-beta1.23262.2 -> To Version 3.3.5-beta1.23266.2

* Update dependencies from https://github.com/dotnet/roslyn-analyzers build 20230518.1

Microsoft.CodeAnalysis.Analyzers , Microsoft.CodeAnalysis.NetAnalyzers
 From Version 3.3.5-beta1.23262.2 -> To Version 3.3.5-beta1.23268.1

* Update dependencies from https://github.com/dotnet/roslyn-analyzers build 20230519.1

Microsoft.CodeAnalysis.Analyzers , Microsoft.CodeAnalysis.NetAnalyzers
 From Version 3.3.5-beta1.23262.2 -> To Version 3.3.5-beta1.23269.1

* Update dependencies from https://github.com/dotnet/roslyn-analyzers build 20230520.2

Microsoft.CodeAnalysis.Analyzers , Microsoft.CodeAnalysis.NetAnalyzers
 From Version 3.3.5-beta1.23262.2 -> To Version 3.3.5-beta1.23270.2

---------

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

[main] Update dependencies from dotnet/roslyn (#86497)

* Update dependencies from https://github.com/dotnet/roslyn build 20230518.11

Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.7.0-1.23259.11 -> To Version 4.7.0-1.23268.11

* Update dependencies from https://github.com/dotnet/roslyn build 20230519.2

Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.7.0-1.23259.11 -> To Version 4.7.0-1.23269.2

---------

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

This fixes an issue with gradual decommit in scenarios where we have … (#84975)

This fixes an issue with gradual decommit in scenarios where we have almost exclusively background GCs.

The problem is that we turn off the gradual_decommit_in_progress_p flag and rely on the distribute_free_regions flag to turn it back on. If we only trigger a BGC however, distribute_free_regions won't get called and the flag will stay off, despite the global_regions_to_decommit list being non-empty.

This will cause regions to accumulate in the global_regions_to_decommit list, and eventual will cause the process to run out of memory.

The fix is to just test for the no gc region case in decommit_step. This will also turn off the gradual_decommit_in_progress_p flag for the no gc region case, but not for background GCs.

Use new queue for iOS arm64 device tests (#86575)

[mono][aot] Enabling AOT wrappers for virtual delegates (#85643)

* Adding AOT virtual delegates wrappers

Signed-off-by: Vlad - Alexandru Ionescu <vlad-alexandruionescu@Vlads-MacBook-Pro-5.local>
---------

Signed-off-by: Vlad - Alexandru Ionescu <vlad-alexandruionescu@Vlads-MacBook-Pro-5.local>
Co-authored-by: Vlad - Alexandru Ionescu <vlad-alexandruionescu@Vlads-MacBook-Pro-5.local>

Fix code coverage of corelib by updating coverlet (#86566)

[wasm] Refactor name convention (#86446)

* Change case type restricted to threading files.

* Feedback - preserve consistent naming.

* Fix

* @pavelsavara's fix for samples on Windows (not connected with refactoring).

[main] Update dependencies from 7 repositories (#85913)

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

Increase timeouts on perf-slow pipeline (because of current load on queues). (#86547)

Baseline a couple more JIT tests (#86429)

Add DebuggerDisplay for SearchValues (#86559)

Make merged test wrappers single file friendly (#86428)

Assembly.Location returns an empty string in single file.

Use VEX xorps to zero a zmm reg (#86555)

Co-authored-by: Tanner Gooding <tagoo@outlook.com>

Remove ZMM_RECOMMENDED_THRESHOLD workaround (#86552)

Stop using LocalizationResources within framework (#86430)

Fixes #81459.

I moved the messages to `EventAttribute.Message` which I believe should be equivalent, but I would appreciate if someone could double-check.
I also removed all the now-unused resource strings. I believe they all need to be prefixed by one of well-known prefixes. I would appreciate if someone could double-check.

NoGCRegion Callback (#82045)

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

avoid GCHandle in ConnectEx and SendTo on Windows (#86524)

* avoid GCHandle in ConnectEx and SendTo on Windows

* s/Span/ReadOnlySpan/ndd

PipeReader.CopyToAsync(Stream) should not perform zero-length writes (#85768)

* add failing test for zero-length write

* simplify test

* apply fix

Add new status code (#85841)

Clean up GenTreeCall's inline info (#86540)

fix(66229): Fix invalid processing of empty Dictionary node. (#86485)

Co-authored-by: Maksim Golev <mgolev@htc-cs.ru>

[LoongArch64] delete the rsGetRsvdReg() for LA64. (#86319)

* [LoongArch64] delete the rsGetRsvdReg() for LA64.

* delete dead code for CR.

[interp] Remove char element type support from transform-simd (#86534)

Remove char element type support from transform-simd
Also disable unusual types for packedsimd

Allow using active host context in hostfxr_get_runtime_delegate (#86460)

These changes allow for passing `nullptr` for the handle parameter of the `hostfxr_get_runtime_delegate` function. This allows in-process callers who do not have the real host context handle to invoke this function and get a runtime delegate for the primary runtime instance. Calling hostfxr_get_runtime_delegate without the handle will only work if there is an active host context, otherwise it will return StatusCode::HostInvalidState.

Remove references to P/Invokes and DllImport from resource strings. (#85178)

Make the RefreshMemoryLimit API public (#85549)

Ensure Vector2/3/4, Quaternion, and Plane don't have a false dependency on Vector<T> (#86481)

* Ensure Vector2/3/4, Quaternion, and Plane don't have a false dependency on Vector<T>

* Apply JIT formatting patch

* Fixing a build issue

* Handle an SPMI assert

Add marshallers for GeneratedComInterface-based types (#86177)

Refactor our linear collection marshalling implementation (#86519)

Co-authored-by: Jackson Schuster <36744439+jtschuster@users.noreply.github.com>

Ensure we use bytes, not bits (#86510)

Fix marking of saved assemblies (#86474)

This ensures the fix from
https://github.com/dotnet/runtime/pull/82197 works also for
assemblies which get the `save` action (which isn't supported
from the command-line, but may happen in custom steps).

It also ensures that `save` assemblies get fully marked
regardless of `DisableMarkingOfCopyAssemblies`.

---------

Co-authored-by: Jackson Schuster <36744439+jtschuster@users.noreply.github.com>

Remove fgMorphCastedBitwiseOp (#86491)

[wasm] CI: Fix firefox debugger tests failure (#86476)

Tests are failing with:

```
  Failed DebuggerTests.ArrayTests.InspectGenericValueTypeArrayLocals(line: 89, col: 8, method_name: "DebuggerTests.ArrayTestsClass.GenericValueTypeLoca"..., test_prev_frame: False, frame_idx: 0, use_cfo: True) [>
  Error Message:
   System.InvalidCastException : Cannot cast Newtonsoft.Json.Linq.JObject to Newtonsoft.Json.Linq.JToken.
  Stack Trace:
     at Newtonsoft.Json.Linq.Extensions.Convert[T,U](T token)
   at DebuggerTests.FirefoxInspectorClient.HandleMessage(String msg, CancellationToken token) in /_/src/mono/wasm/debugger/DebuggerTestSuite/FirefoxInspectorClient.cs:line 184
   at Microsoft.WebAssembly.Diagnostics.RunLoop.RunActualAsync(CancellationTokenSource x) in /_/src/mono/wasm/debugger/BrowserDebugProxy/Common/RunLoop.cs:line 142
   at Microsoft.WebAssembly.Diagnostics.RunLoop.<>c__DisplayClass20_0.<<RunAsync>b__0>d.MoveNext() in /_/src/mono/wasm/debugger/BrowserDebugProxy/Common/RunLoop.cs:line 54
--- End of stack trace from previous location ---
   at System.Threading.Channels.AsyncOperation`1.GetResult(Int16 token)
   at System.Threading.Tasks.ValueTask`1.ValueTaskSourceAsTask.<>c.<.cctor>b__4_0(Object state)
```

One of the arguments of the message is a `JObject`, and thus fails with
`.Value<string>()`.

The full message:
```json
{
   "from" : "server1.conn0.windowGlobal10737418242/windowGlobalTarget2",
   "resources" : [
      {
         "message" : {
            "arguments" : [
               "mono_wasm_debug_event_raised:aef14bca-5519-4dfe-b35a-f867abc123ae",
               {
                  "actor" : "server1.conn0.windowGlobal10737418242/longstractor35",
                  "initial" : "{\"eventName\":\"AssemblyLoaded\",\"assembly_name\":\"System.Private.CoreLib.dll\",\"assembly_b64\":\"V2JJTAAAAAADAAAACCAAAEgAAACYYj4AVAAAAPRDPgAAIAAAAEQ+AEwAAABMBAAAAIA+AAAGAABMRD4ADAAAAACgPgAAAgAATEo+ANBjPgAAAAAASAAAAAIABQDQ4RkAyIAkAAkAAAAAAAAAsFMUADjSAwBQ4RkAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHgIoJAIABipeAigkAgAGAheNogAAAiUWA5x9AQAABCo6AigkAgAGAgN9AQAABCo6AigkAgAGAgN9AgAABCo6AigkAgAGAgN9AwAABCoeAigDMAUAjQAAAAEAABEgAAIAAOD+DyAAAQAAcwEAAAoMCAoCBgMEBW8CAAAKCwctIg4EEgAWBhYoAQAAKygDAAAKDBIC/hYBAAAbb3cDAAZRFyoHGDM+IAAFAACNpAAAAigEAAAKCgIGAwQFbwIAAAotIg4EEgAWBhYoAQAAKygDAAAKDBIC/hYBAAAbb3cDAAZRFyoOBBRRFiomAgMEKA8AAAZ6RgIsDQIo6gAABgMEKAkAAAYqTgIWai8MKFcAAAYDBCgJAAAGAio2KFcAAAYUFigJAAAGKjICagMEKAsAAAYmAioDMAIAsgEAAAIAABEPAChSAAAGCwcgFAABADBJByAGAAEAMBsHIAIAAQA7zQAAAAcgBgABADsUAQAAOHcBAAAHIAgAAQA7sgAAAAcgCwABADsrAQAAByAUAAEAOzYBAAA4UQEAAAcgJQABADAbByAWAAEAOw4BAAAHICUAAQA7pwAAADguAQAAByAtAAEALhUHIDkAAQAuQAcgQgABAC5cOBEBAAAELTADLAgDKBMAAAYsJQMozwUABiwLKLsdAAZzUmwABioovB0ABgMo0RoABgNzVGwABioDK",
                  "length" : 7737462,
                  "type" : "longString"
               },
               "{}"
            ],
            "columnNumber" : 12734,
            "filename" : "http://localhost:9400/dotnet.runtime.js",
            "innerWindowID" : 10737418242,
            "level" : "debug",
            "lineNumber" : 3,
            "private" : true,
            "sourceId" : null,
            "timeStamp" : 1684452298362.82
         },
         "resourceType" : "console-message"
      }
   ],
   "type" : "resource-available-form"
}
```

We should not establish a heap hard limit for 32 bit platforms (#85844)

Upgrade gcc CI to use gcc13 (#86051)

* Upgrade gcc CI to use gcc13

* Fix a Wstrict-prototypes

JIT: Add a pass of liveness for the new locals inside physical promotion (#86043)

Used when decomposing stores to skip the fields that are dying and the remainder if it is dying. Also allows forward sub to kick in for the inserted replacement locals.

Fix async XsdValidatingReader to not use synchronious IO (#84888)

* Fix async XsdValidatingReader to use GetValueAsync

* Remove async on ProcessReaderEventAsync

* Change to local static functions

[wasm] Jiterpreter v128 misc optimizations (#86506)

* Use v128 opcodes when unrolling memsets/memmoves
* Introduce builder v128_const method
* v8 doesn't optimize splats so use the enormous encoding for v128 zero
* Fix fast memset for nonzero values

Upgrade build to use .NET 8 Preview 4 SDK (#86408)

Fix mapping of redeclared type parameters (#86353)

We were skipping the type parameter mapping of compiler-generated
types whose only generic parameters were those implicitly created
for the declaring type's type parameters.

For the testcase in question, the nested state machine inherited
a generic parameter from the display class. This was causing
unnecessary warnings in a field assignment that assigned
`this` (an instance of the display class) to a field on the state
machine. In IL, that assignment references a field type like
`DisplayClass<T>` where `T` is the generic parameter on the state
machine. Here we were properly mapping type parameters of the
display class back to the annotated enclosing method's type
parameters, so we could tell that the "target" required
`PublicMethods`. But the substituted `T` from the state machine
was not mapped, causing the mismatch.

Remove invalid assert in EvpPKeyDuplicate

EvpPKeyDuplicate has an invalid assert in it where it asserts that the handle it was passed is not IsInvalid. This may not be true in a multi-threaded scenario where an object is disposed by one thread while another thread is trying to use the resource.

Since we are marshaling the handle as a SafeHandle, just let it do the right thing of throwing an ObjectDisposedException when the marshaller attempts to add a reference to the handle.

Enable event pipe tests in NativeAOT CI run (#86389)

* Test check on EventPipe NativeAOT

* exclude more tracing tests

* FB

Use net6.0 SqlClient TFM under source-build (#84782)

See discussion in https://github.com/dotnet/source-build-reference-packages/pull/633 for more context.

[mono][debugger][docs] How we run debugger tests (#86495)

* Small fix.

[mono][jit] Enable Vector64 support on arm64 in jit mode. (#86188)

Vector64 is handled the same as the other SIMD types, only loads and stores
need to special case it.

[browser] Update Wasm SDK pack version in workload manifest (#86382)

Add ProcessStartInfo constructor that accepts IEnumerable<string> arguments (#86346)

enable TieredPGO by default (#86225)

[wasm] Generate jiterp feature detect modules dynamically (#86401)

Fixes dotnet/source-build#3442

remove [DebuggerDisplayAttribute] from ref assemblies (#86443)

FileConfigurationProvider.Dispose should dispose FileProvider when it ows it (#86455)

fixes #86146

Enable runtime tests on the Interpreter (#86375)

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

* Localized file check-in by OneLocBuild Task: Build definition ID 679: Build ID 2183518

* Localized file check-in by OneLocBuild Task: Build definition ID 679: Build ID 2183518

Remove getMaxIntrinsicSIMDVectorLength from the JIT/EE interface (#86479)

* Fixing a couple small typos

* Remove getMaxIntrinsicSIMDVectorLength from the JIT/EE interface

* Update src/coreclr/vm/methodtablebuilder.cpp

---------

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

[interp] Undo damage to the simd methods bsearch list; support vectors of char (#86475)

While inspecting the performance of some vectorized BCL code, I noticed that I accidentally damaged one of the binary search lists.
There also appear to be some cases where vectors of char are used, so I touched up the code to make sure that we will select the right intrinsic in that case if we already supported U2.

Move the GCC and CLR Tools Unit Tests legs to use the global build template (#86411)

* Move the GCC validation leg to use the global build job template instead of the CoreCLR build template.

* Move CLR Tools Unit Tests leg to use the global build job template instead of the CoreCLR build job template

* Add iltools for the CoreCLR tools unit tests job

* Pass -gcc flag to test build in GCC job.

* Update eng/pipelines/coreclr/templates/build-job.yml

Add debugging attributes to System.Security.Claims types (#86424)

* Add debugging attributes to System.Security.Claims types

* Update

* Update ref, add type proxies

* PR feedback

* PR feedback

[wasm] Implement I2 and I4 shuffles in the jiterpreter (#86469)

Implement a wasm lowering for V128_I2_SHUFFLE and V128_I4_SHUFFLE in the jiterpreter so BCL char operations won't be terribly slow

Exclude System.* reference assemblies in ILCompiler.Build.Tasks (#86423)

* Exclude System.* reference assemblies in ILCompiler.Build.Tasks

We expect the implementation of these assemblies to come as part of msbuild.

Fixes #83695

* Do not include any System.* assemblies as part of the task

* Delete custom resolver

Switch RhConfig from TCHAR to char (#86393)

- Hide away the details of reading the environment variable as `wchar` vs `char`
- Keep embedded variables as as ASCII (they are embedded as such already)
- Stop using `TCHAR` for the `RhConfig` APIs, which seemed to just be more confusing to consume

[wasm] Enable v128 and PackedSimd in the interpreter (#85920)

Fix the create scalar intrinsics in the jiterpreter
Fix trimming removing SIMD even if SIMD was enabled
Add wasm opcode mapping for extract msb
Fix some SN_ lists in transform-simd being ordered incorrectly
Due to mixed mode it is not possible to control interp SIMD with a runtime option, so remove the options
Disable linker substitutions for SIMD unless AOT is active, so the interp is responsible for the properties
Generate a MINT_NIY for unimplemented PackedSimd methods

[wasm] Update jiterpreter documentation (#86461)

* Add missing line breaks

* Update jiterpreter documentation with a sample annotated trace

* I love github flavored markdown

Make host look for RID-specific assets via a known list by default (#84100)

Remove workaround for fixed Roslyn bug (#86464)

Add an undocumented switch to allow controlling the preferred vector width emitted implicitly by the JIT (#86457)

* Add an undocumented switch to allow controlling the preferred vector width emitted implicitly by the JIT

* Resolving issues and responding to PR feedback

* Simplifying the xarch cpu info check

Remove noisy assert from Task (#86445)

Remove call to morph on hoisted trees (#86450)

It is unnecessary (this causes no diffs). And theoretically if it
did cause diffs, the morphed tree would then not match the tree
being hoisted, meaning CSE wouldn't "find" it and consider it a CSE.