Handle some rare scenarios in local morph (#71536)

Namely, cases where we cannot transform local indirections into local nodes:

1. Unused indirections - we simply remove them.
2. Volatile FIELDs - we mark the underlying local address-exposed.
3. Large offsets - likewise.

Overall this (as well as most other ADDR-related changes) works towards enabling the invariant that after local morph, every local access is either address-exposed, or transformed into LCL_VAR/LCL_FLD.

Updating a few BitConverter APIs to be intrinsic (#71567)

* Updating a few BitConverter APIs to be intrinsic

* Reacting to PR feedback

* Update src/coreclr/jit/valuenum.cpp

Co-authored-by: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>
* Update src/coreclr/jit/gentree.h

Co-authored-by: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>
* Apply formatting patch

* Ensure DoubleToInt64Bits and Int64BitsToDouble intrinsics only pop when appropriate

* Fix VNForBitCast to not handle exception set logic since its always a normal value now

* Applying formatting patch

Co-authored-by: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com>

Preparatory changes for enabling direct decomposition of promoted locals into `FIELD_LIST`s on ARM (#71726)

* Unify the "3-byte struct" ARM case with other targets

The only case when "structSize != passingSize" could be true is when we "upcast"
a "mis-sized" struct to a primitive.

For ARM, we never did that -- the relevant "#ifdef"s didn't include it, thus
"OperIs(GT_OBJ) && (structSize != passingSize)" was dead code. Instead, there
was bespoke handling for such structs: "if (structSize < TARGET_POINTER_SIZE)".

Delete the bespoke handling and the "#ifdef", unifying the handling.

* Update a comment

* Fix PUTARG_SPLIT codegen

We must use the "field type" for stores.

Example "struct { int a; byte b; byte c; }" is split between one register and
one stack slot, and both "b" and "c" become propagated constants, typed INT.

* Enable OBJ spilling for ARM

* Fold the last ARM-specific condition

* Do not convert large split args into FIELD_LISTs

We do not check the register requirements on the fields or their sizes (extents).

* Restructure support for "mis-sized" structs

Add a comment, simplify the code.

S.S.C.Cose: Add new MultiSign APIs and address API review feedback on existing ones (#71390)

* Make full assembly unsupported on browser

* Add new MultiSign APIs and address API review feedback on existing ones

* Add SignaturePadding tests and address #70189

* Address feedback (typos and leftover code)

* Add tests for CoseHeaderValue and wrap CborReader/Writer errors

* nits and line chopping

* Move alg. validations to CoseSigner and add remaining AddSignatureFor* APIs

Bump Intellisense package version to Preview5 (#71772)

Bump PreReleaseVersion to Preview7 (#71770)

Better error handling in SubtleCrypto workers (#71693)

* Better error handling in SubtleCrypto workers

Handle exceptions from SubtleCrypto by catching and logging exceptions coming from the crypto stack.

Reset web worker when a request fails.

Also, fix race conditions where the web worker can read its own response as part of the next request.

Contributes to #69740

Polyfill the incremental generator ForAttributeWithMetadataName from roslyn (for LoggingGenerator). (#71651)

* Polyfill the incremental generator ForAttributeWithMetadataName from roslyn (for LoggingGenerator).

* Simplify

* Fix project file

* Remove

* revert

Fix long latencies in `ReaderWriterLockSlim` lock operations due to `Sleep(1)` (#70165)

* Fix long latencies in `ReaderWriterLockSlim` lock operations due to `Sleep(1)`

- Removed usage of `Sleep(1)`
- Modified the spin-waiting scheme beyond the `Sleep(0)` threshold to avoid potentially long sequences of ineffective `Sleep(0)`s
- Retuned the threshold to reprioritize deprioritized spin-lock requests

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

Add note about Array.Initialize to ECMA-335 augments (#71766)

Fixes #71733

Close PGO data file when done with it reliably (#71744)

[Mono] Fix all remaining C4018 warnings and enable the check during build (#71269)

* 3rd round of fixing 4018 warnings

* Fix warnings on x86

* Fix remaining c4018 warnings and enable it for build

* Fix print format

* Fix type

* Fix warnings for LLVM

* Fix for wasm

* Fix for arm64

* Fix x86

* Iterator could be negative

* Fix a warning in decompose.c

* Fix warning for arm

* Fix warning for wasm only llvm code

* Correct a few iterator types

* Fix another incorrect iterator type

* Update src/mono/mono/mini/interp/transform.c

Co-authored-by: Aleksey Kliger (λgeek) <akliger@gmail.com>
* Update src/mono/mono/mini/mini-generic-sharing.c

Co-authored-by: Aleksey Kliger (λgeek) <akliger@gmail.com>
* Update src/mono/mono/mini/mini-generic-sharing.c

Co-authored-by: Aleksey Kliger (λgeek) <akliger@gmail.com>
* Update src/mono/mono/mini/mini-generic-sharing.c

Co-authored-by: Aleksey Kliger (λgeek) <akliger@gmail.com>
* Address review feedback

* Remove other fixed warning.

* Use more accurate types when possible

Co-authored-by: Aleksey Kliger (λgeek) <akliger@gmail.com>

[wasm] JSImport, JSExport and related API types for JavaScript interop (#71500)

- approved API
- xmldoc

Co-authored-by: Marek Fišera <mara@neptuo.com>
Co-authored-by: Katelyn Gadd <kg@luminance.org>

Unix arm64 atomics (#71512)

* Define_InterlockMethod macro

* compiler failure

* fix build errors

* Set g_arm64_atomics_present at common place

* Fix the missing declaration

* Change TARGET_ARM64 => HOST_ARM64

* Use LSE for InterlockedCompareExchange

* Attempt to fix osx-arm64 build issue

* Introduce LSE_INSTRUCTIONS_ENABLED_BY_DEFAULT

* Make sure that compiler knows that M1 has lse

Fix incoming arg struct splitting (#71701)

This change only affects Windows/arm64 with varargs.

For incoming structs split between register and stack, handle the splitting
correctly.

Fixes #57606

Move ICustomTypeMarshallingStrategy implementations into separate files (#71747)

* Move ICustomTypeMarshallingStrategy implementations into separate files
* Remove constructor args from V2 marshalling strategy

Add markdown readme for System.Collections.Immutable (#71247)

* Update System.Collections.Immutable.csproj

* Add README.md

* Add README.md

* Delete README.md

* Update PackageDescription

#37093 disable Reciprocal test only for Android x86 (#71541)

* #37093 disable Reciprocal test only for Android x86

Use ObjectDisposedException.ThrowIf in more places (#71546)

* Use ObjectDisposedException.ThrowIf in more places

* Update TarWriter.cs

Use scoped more in dotnet/runtime (#71589)

* Use scoped more in dotnet/runtime

This PR addresses a few issues:
- Exposes the new {ReadOnly}Span constructors that accept a ref.
- Uses those new constructors outside of corelib (they were previously internal and used only inside of corelib).
- Makes several members of Utf8JsonReader readonly in order to enable stackalloc'd spans to be used in ValueTextEquals calls.
- Makes several span arguments to SequenceReader scoped in order to enable stackalloc'd spans to be used with those calls.
- Removes all stackalloc T[0], replacing it with scoped locals.
- Removes some use of stackalloc'ing into a pointer and then manually wrapping into a span, instead directly stackalloc'ing into a span.  This is possible now in more cases due to the new language validation rules.
- Replaced some use of MemoryMarshal.GetReference(MemoryMarshal.CreateSpan(...)) with Unsafe.AsRef.

* Address PR feedback

[mono] Avoid calling mono_metadata_type_hash () on the container class in mono_generic_class_hash (). (#71734)

If a class inherits from a generic instance instantiated with itself, then its possible
for mono_generic_class_hash () to be called while the container class is not fully
initialized yet, i.e. byval_arg.type is 0. This would cause the generic class to change
its hash.

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

Reduce allocation overhead of Enumerable.Order{Descending} (#71564)

Enumerable.OrderBy{Descending} buffers the input into an array.  It then allocates a TKey[] from that input to store the keys, and allocates an int[] that's what's actually sorted based on those keys.  The enumerator uses that sorted int[] then to decide what element from the buffered input to yield next.  In the case of the new Order and OrderDescending methods, though, that TKey[] isn't required; it's just a copy of the buffered input, so we can avoid it.

Make things work for arrays of function pointers (#71749)

* Don't try to obtain type handles for fields of types of function pointer arrays
* Add function pointer support to name mangler. We still don't make EETypes for these, but debug info generation also needs mangled names. We currently generate debug info for function pointers as debug info for `void*`, but arrays of function pointers only partially go through that handling and still end up needing a mangled name for the function pointer.

Update ILToNativeMap event to include IL version (#71479)

* Update eventtrace.cpp

* Add native code ID and IL code ID

Improve objcopy detection (#71742)

Fixing public field order for System.Numerics types (#71728)

Ensure side effects get spilled for the various hwintrinsic and simdashwintrinsic nodes (#70054)

* Adding a regression test for #54956

* Ensure side effects get spilled for the various hwintrinsic and simdashwintrinsic nodes

* Applying formatting patch

* Don't mark Compiler::impSpillSideEffect as `inline` so clang can resolve it correctly

* Adding more tests for Runtime_54956

Handle stateless collection marshalling with non-blittable elements (#71724)

Using /unicode when running ildasm.exe roundtrip tests (#71163)

* Using /unicode when running ildasm.exe roundtrip tests

* Added /unicode flag

* Update issues.targets

TypedByReference should be treated as a normal valuetype for calling convention purposes (#71675)

TypedByReference should be treated as a normal valuetype for calling convention purposes
Add regression test for #42732

Add note about partition IV and V to ECMA-335 augments (#71737)

Fixes #71733

Leverage compiler attributes for snippets identification (#71729)

* Leverage compiler attributes for snippets identification

Check for V2 shapes on string marshallers (#71730)

Exclude AssemblyStripper from source-build (#71691)

Tests for creating recursive types (#71721)

On 64 bit platforms, "stelem.ref" and "ldelema" ignore the high bits of a native int index (#71571)

Add support for native int indices in stelem.ref and ldelema helper functions. This required changing the abi of these functions, which required bumping the major R2R version number. As we have already done that for .NET 7, this is a minor cost. Note that this is still broken on Mono, and that bug is #71656

Fixes #52817

Adjust weights of blocks with profile inside loops in non-profiled methods (#71659)

Fix debugging on Mac and iOS (#71436)

We need to set this:

`mini_get_debug_options ()->mdb_optimizations = TRUE;`
before initialize the interpreter, otherwise the interpreter optimizations will be turned on and we will not be able to see the correct variable values.

https://github.com/dotnet/runtime/blob/4adb1172658f74e6a513bece426005d7f2ba7a04/src/mono/mono/mini/interp/interp.c#L8123

Fixes https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1558698
Fixes https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1513227

Mark ILVerify as AnyCPU (#71695)

Fixes #70508

Re-create profile data on profile-use-only mode (#71420)

Activate multicorejit recorder to re-create the profile data
when the multicorejit player cannot be executed due to BADIMAGEFORMAT error on profile-use-only mode

Enable host.pkg subset in source-build (#60069) (#71690)

Allow UTF-8 BOM in BinaryData When Deserializing (#71457)

* Use ReadOnlyMemoryStream in ToObjectFromJson

* Slice the span instead

Integrate mibc mono config extension (#71657)

* [mono] Modify MonoImageLoadOptions field type for clarity

* [mono] Add mibc config check when adding methods from mibc

* [coreclr] Extend RuntimeSku with Mono runtime

* Address feedback

Polyfill the incremental generator ForAttributeWithMetadataName from roslyn (for JsonGenerator). (#71653)

* Polyfill the incremental generator ForAttributeWithMetadataName from roslyn (for JsonGenerator).

* Move common code to shared location

* Update projects

* Add back

* Update src/libraries/System.Text.Json/gen/System.Text.Json.SourceGeneration.Roslyn4.0.csproj

Fix S.R.InteropServices remarks (#71683)

Moved the triple slash seealso items outside of the remarks section, to prevent porting them to dotnet-api-docs, because they would show weird in MS Docs.

Use OS-provided RSA OAEP implementation for Android

Instead of using the managed OAEP implementatation, allow the OS to handle OAEP with SHA2 algorithms.

Android also supports algorithm identifiers like "RSA/ECB/OAEPwithSHA-256andMGF1Padding" which would make the code simpler, but it makes the hash algorithm used in MGF1 ambiguous. Since the MGF1 algorithm is always the same as the OAEP algorithm, we explicitly use the `OEAPParameterSpec` so that we can control both the MGF1 digest algorithm and the OAEP digest algorithm.

[wasm] WBT: Enable playwright based tests (#71602)

DefaultBinder named parameter support skipping default parameters (#71013)

Update design and expose new attributes for the CustomTypeMarshaller support (#71682)

Update dependencies from https://dev.azure.com/dnceng/internal/_git/dotnet-optimization build 20220705.3 (#71710)

[main] Update dependencies from dnceng/internal/dotnet-optimization

Simplify JsonPropertyInfo list implementation and expose IsExtensionData properties (#71650)

* Simplify JsonPropertyInfo list implementation.

* Replace PropertyTypeCanBeNull uses with default(T)

* Take properties with ExtensionDataProperty into account

* Update src/libraries/System.Text.Json/src/Resources/Strings.resx

* Update src/libraries/System.Text.Json/src/Resources/Strings.resx

* revert accidental change

* Fix race condition when initializing Property list

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

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

NativeAOT Re-enable Linux System.Reflection tests after fix (#71664)

Use in-tree ilasm to run test suite natively on s390x (#71326)

* There are no linux-s390x packages on nuget.org, so use in-tree
  built ilasm when running the test suite natively on s390x

JIT: Fix generating unrepresentable nullchecks on ARM64 (#71687)

The logic in lowering could in some struct and primitive type cases
generate an unrepresentable NULLCHECK node for ARM64/LA64 when there
was a contained address mode. We now transform unused indirections and
create address modes in the opposite order on non-xarch to avoid these
unrepresentable nullchecks.

Fix #71684

Don't set CORINFO_FLG_CUSTOMLAYOUT for auto-layout structs (#71673)

Simplify CEEInfo::getTypeForPrimitiveValueClass (#71686)

JIT: Avoid reordering operands in fgMorphModToSubMulDiv (#71615)

* JIT: Avoid reordering operands in fgMorphModToSubMulDiv

fgMorphModToSubMulDiv tries to check if it is ok to "clone" locals
instead of spilling them by checking for address exposure. This was
necessary because GTF_GLOB_REF is not up-to-date in preorder during
morph, which is when this runs. However, address exposure is not valid
for implicit byrefs at this point, so the check is not enough.

The logic is trying to figure out which of the operands need to be
spilled and which of them can be cloned. However, the logic was also
wrong in the face of potential embedded assignments. Thus, rework it to
be a bit more conservative but correct.

As part of this, remove fgIsSafeToClone and make fgMakeMultiUse less
conservative by avoiding checking for address exposure. This was
probably an attempt at some limited interference checks, but from what I
could see other uses do not need this.

Fix #65118

* Add a test

* Revert unnecessary change

* Switch to gtCloneExpr

Disable a test for ilasm roundtripping (#71634)

Use crypto.subtle for AES on Browser WASM (#71501)

* Use crypto.subtle for AES on Browser WASM

Implement the browser "native" portion for AES on Browser WASM.

There are two issues to solve .NET's Aes API on crypto.subtle:
1. The .NET API supports streaming while crypto.subtle only supports "one shot" APIs.
2. The .NET API supports multiple padding modes while crypto.subtle only supports PKCS7.

To solve these issues, we use the following approach:

1. We only invoke crypto.subtle with complete AES "blocks" of data. This allows us to make assumptions about the padding behavior.
2. To implement streaming, remember the last block of the previous cipher text to use as the IV for the next stream of data.
3. When encrypting, since we have a complete block of data and crypto.subtle uses PKCS7 padding, strip off the last block of cipher text which will always be a full block of padding.
4. When decrypting do the inverse of encrypting - append an encrypted block of padding to the cipher text so crypto.subtle will return the full message as plain text.

Other changes:
- Make a few refactoring / simplifications where necessary.
- SubtleCrypto doesn't support 192 bit AES keys, so no longer support AES-192 on Browser.

Contributes to #40074

* Use an empty array to create encrypted padding block.

Hold stop-go lock when requesting CCW (#71660)

Call stateless free for linear collection marshallers (#71669)

Do not spill "mis-sized" struct args passed on stack (#71399)

* Enable a test on Unix x64

* Handle mis-sized structs in LA PUTARG_STK codegen

* Handle mis-sized structs in LA PUTARG_SPLIT codegen

* MisSizedStructs_ArmSplit -> MisSizedStructs_ArmArch

* Add tests

* Do not spill mis-sized stack args

All backends support them.

Make getTypeForPrimitiveValueClass treat different signs as different types (#71633)

* Make getTypeForPrimitiveValueClass treat different sizes as different types

* Handle missing types

* Update jitinterface.cpp

* Test removing pointers

[main] Update dependencies from dotnet/runtime dotnet/icu dotnet/xharness dotnet/emsdk (#71533)

[main] Update dependencies from dotnet/runtime dotnet/icu dotnet/xharness dotnet/emsdk

Fix: using default value for nullable enum parameter throws ArgumentException (#71388)

Optimize multi-dimensional array access (#70271)

Currently, multi-dimensional (MD) array access operations are treated as opaque to most of
the JIT; they pass through the optimization pipeline untouched. Lowering expands the `GT_ARR_ELEM`
node (representing a `a[i,j]` operation, for example) to `GT_ARR_OFFSET` and `GT_ARR_INDEX` trees,
to expand the register requirements of the operation. These are then directly used to generate code.

This change moves the expansion of `GT_ARR_ELEM` to a new pass that follows loop optimization but precedes
Value Numbering, CSE, and the rest of the optimizer. This placement allows for future improvement to
loop cloning to support cloning loops with MD references, but allows the optimizer to kick in on the new
expansion. One nice feature of this change: there is no machine-dependent code required; all the nodes
get lowered to machine-independent nodes before code generation.

The MDBenchI and MDBenchF micro-benchmarks (very targeted to this work) improve about 10% to 60%, but there is
one significant CQ regression in MDMulMatrix of over 20%. Future loop cloning, CSE, and/or LSRA work will be needed to get that back.

In this change, `GT_ARR_ELEM` nodes are morphed to appropriate trees. Note that an MD array `Get`, `Set`, or `Address`
operation is imported as a call, and, if all required conditions are satisfied, is treated as an intrinsic
and replaced by IR nodes, especially `GT_ARR_ELEM` nodes, in `impArrayAccessIntrinsic()`.

For example, a simple 2-dimensional array access like `a[i,j]` looks like:

```
\--*  ARR_ELEM[,] byref
   +--*  LCL_VAR   ref    V00 arg0
   +--*  LCL_VAR   int    V01 arg1
   \--*  LCL_VAR   int    V02 arg2
```

This is replaced by:

```
&a + offset + elemSize * ((i - a.GetLowerBound(0)) * a.GetLength(1) + (j - a.GetLowerBound(1)))
```

plus the appropriate `i` and `j` bounds checks.

In IR, this is:

```
*  ADD       byref
+--*  ADD       long
|  +--*  MUL       long
|  |  +--*  CAST      long <- uint
|  |  |  \--*  ADD       int
|  |  |     +--*  MUL       int
|  |  |     |  +--*  COMMA     int
|  |  |     |  |  +--*  ASG       int
|  |  |     |  |  |  +--*  LCL_VAR   int    V04 tmp1
|  |  |     |  |  |  \--*  SUB       int
|  |  |     |  |  |     +--*  LCL_VAR   int    V01 arg1
|  |  |     |  |  |     \--*  MDARR_LOWER_BOUND int    (0)
|  |  |     |  |  |        \--*  LCL_VAR   ref    V00 arg0
|  |  |     |  |  \--*  COMMA     int
|  |  |     |  |     +--*  BOUNDS_CHECK_Rng void
|  |  |     |  |     |  +--*  LCL_VAR   int    V04 tmp1
|  |  |     |  |     |  \--*  MDARR_LENGTH int    (0)
|  |  |     |  |     |     \--*  LCL_VAR   ref    V00 arg0
|  |  |     |  |     \--*  LCL_VAR   int    V04 tmp1
|  |  |     |  \--*  MDARR_LENGTH int    (1)
|  |  |     |     \--*  LCL_VAR   ref    V00 arg0
|  |  |     \--*  COMMA     int
|  |  |        +--*  ASG       int
|  |  |        |  +--*  LCL_VAR   int    V05 tmp2
|  |  |        |  \--*  SUB       int
|  |  |        |     +--*  LCL_VAR   int    V02 arg2
|  |  |        |     \--*  MDARR_LOWER_BOUND int    (1)
|  |  |        |        \--*  LCL_VAR   ref    V00 arg0
|  |  |        \--*  COMMA     int
|  |  |           +--*  BOUNDS_CHECK_Rng void
|  |  |           |  +--*  LCL_VAR   int    V05 tmp2
|  |  |           |  \--*  MDARR_LENGTH int    (1)
|  |  |           |     \--*  LCL_VAR   ref    V00 arg0
|  |  |           \--*  LCL_VAR   int    V05 tmp2
|  |  \--*  CNS_INT   long   4
|  \--*  CNS_INT   long   32
\--*  LCL_VAR   ref    V00 arg0
```

before being morphed by the usual morph transformations.

Some things to consider:
1. MD arrays have both a lower bound and length for each dimension (even if very few MD arrays actually have a
   non-zero lower bound)
2. The new `GT_MDARR_LOWER_BOUND(dim)` node represents the lower-bound value for a particular array dimension. The "effective index" for a dimension is the index minus the lower bound.
3. The new `GT_MDARR_LENGTH(dim)` node represents the length value (number of elements in a dimension) for a particular array dimension.
4. The effective index is bounds checked against the dimension length.
5. The lower bound and length values are 32-bit signed integers (`TYP_INT`).
6. After constructing a "linearized index", the index is scaled by the array element size, and the offset from
   the array object to the beginning of the array data is added.
7. Much of the complexity above is simply to assign temps to the various values that are used subsequently.
8. The index expressions are used exactly once. However, if have side effects, they need to be copied, early,
   to preserve exception ordering.
9. Only the top-level operation adds the array object to the scaled, linearized index, to create the final
   address `byref`. As usual, we need to be careful to not create an illegal byref by adding any partial index.
   calculation.
10. To avoid doing unnecessary work, the importer sets the global `OMF_HAS_MDARRAYREF` flag if there are any
   MD array expressions to expand. Also, the block flag `BBF_HAS_MDARRAYREF` is set on blocks where these exist,
   so only those blocks are processed.

Remaining work:
1. Implement `optEarlyProp` support for MD arrays.
2. Implement loop cloning support for MD arrays.
3. (optionally) Remove old `GT_ARR_OFFSET` and `GT_ARR_INDEX` nodes and related code, as well as `GT_ARR_ELEM`
code used after the new expansion.
4. Implement improvements in CSE and LSRA to improve codegen for the MDMulMatrix benchmark.

The new early expansion is enabled by default. It can be disabled (even in Release, currently), by setting
`COMPlus_JitEarlyExpandMDArrays=0`. If disabled, it can be selectively enabled using
`COMPlus_JitEarlyExpandMDArraysFilter=<method_set>` (e.g., as specified for `JitDump`).

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

Exposing static bool IsSupported { get; } on Vector<T> and Vector64/128/256<T> (#71240)

* Exposing static bool IsSupported { get; } on Vector<T> and Vector64/128/256<T>

* Adding tests covering the new IsSupported API on Vector<T> and Vector64/128/256<T>

* Fix Mono JIT

* Fix warning on windows

* Let Vector64/128/256 IsSupported be handled by the fallback software implementation.

Co-authored-by: Fan Yang <yangfan@microsoft.com>

[mono][wasm] Add a minimal version of gsharedvt for llvmonly, enabled… (#70867)

* [mono][wasm] Add a minimal version of gsharedvt for llvmonly, enabled by default.

In this version, variable length arguments/locals are not supported. This means
that these compiled methods don't have the overhead of gsharedvt, i.e. wrappers,
dynamically allocated/copied locals, etc. They have similar performance to normal
generic sharing.

This can handle methods like List<T>.get_Item (), System.GC:AllocateArray<T>, etc.

* Fix gsharedvt returns on wasm.

* Allow byref gsharedvt types in gsharedvt in/out wrappers.

* Avoid setting both ctx->values and ctx->addresses for arguments of type LLVMArgGsharedvtFixedVtype.

* Fix support for gsharedvt+deopt.

* Disable UNBOX_ANY in gsharedvt_min mode.

* Fix llvmonly support for static methods with bound NULL first argument.

Some code paths can end up calling the general delegate invoke wrapper, which used
target!=NULL to decide whenever the call is bound, but the bound argument can be NULL.
So add a 'bound' field to Delegate and check it in the wrapper.

Some code paths might not set 'bound' so retain the target!=NULL check as well.

[mono][aot] Avoid inflating methods with instantiations with a wrong argument count when using profiled AOT. (#70926)

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

Blazor Hybrid iOS & Mac Catalyst Performance Profiling (#68685)

* [MAUI][Blazor][PERF] Add APK file usage for Android Maui Blazor SOD

* Update android_scenarios.proj

* Call ReportFullyDrawn

* Add  --use-fully-drawn-time --fully-drawn-extra-delay

* Add System.Console.WriteLine for non-android platforms

* Add 6 second delay

* Missing `;`

* Add back Directory.Build.{props, targets}

(cherry picked from commit 28d9ef3ab4ac53b947dd435e6494428238b4dea5)

* Fixes based on CI 1729796

https://dev.azure.com/dnceng/internal/_build/results?buildId=1729796&view=logs&j=4d93e3ae-0b8e-5532-bed2-af5c8a7c58d3&t=b13dec14-3eb2-5f1a-4501-8a9fdadb0e3a
(cherry picked from commit d470655576d3abe6a6fec478c221c4d9de698ba9)

* [REVERT THIS] Temporarily skip other jobs

(cherry picked from commit df51582df9e7bb9d1ca82759d664823c76823c29)

* [MAUI][Blazor][PERF] Add IPA file usage for iOS/MacCatalyst Maui Blazor SOD

(cherry picked from commit b1aaaf222e302c19ad6760eaa7cdb1f0e7ed364d)

* Remove / restore nuget.config

* Escape quotes

* Fix typo

* Replicate changes from https://github.com/dotnet/runtime/pull/67670

* use-fully-drawn-time

* Use akoeplinger/performance

* Fix misplaced quote character

* Revert "Use akoeplinger/performance"

This reverts commit 12358b6f024bd1727aee8bf5ad71576d69623734.

The change was merged to dotnet/performance.

* Add ` --startup-iterations 7`

* Revert "[REVERT THIS] Temporarily skip other jobs"

This reverts commit 54fa30d876e2be0fef82883033d8fb027de2a150.

* Remove SOD Startup Iterations

Co-authored-by: Alexander Köplinger <alex.koeplinger@outlook.com>

Release global lock before throwing exceptions from the Unix WaitSystem (#71626)

The exception throwing and handling can enter wait system recursively that will lead to deadlock.

Fixes #70010

Refactoring IShiftOperators to take a `TOther` (#71405)

* Refactoring IShiftOperators to take a `TOther`

* Break IShiftOperators typeloading cycle

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

Add Conditional nodes and Arm64 code generation (#71616)

[wasm][debugger]Fix debugging when it's using a external library without debug information (#71560)

* Fix debugging when it's using a external library without debug information.

* [wasm] Rationalize TypeInfo construction

* separating dynamic assemblies

* lazy-debugger-test-embedded should only be available to the tests on disk, but *not* the test app

* debugger-test.csproj: cleanup

* Fix metadata name for not only building project references

* Fixing not getting codeview information from assemblies that don't have this information.

* Adressing @radical comments.

Co-authored-by: Ankit Jain <radical@gmail.com>

Polyfill the incremental generator ForAttributeWithMetadataName from roslyn. (#70911)

* Add the initial roslyn files

* IN progress

* Builds

* Use api

* ifdef

* Move using outside namespace

* Move to debug assert

* Optimize common cases

* Explain if'defed regions

* Explain if'defed regions

* Update System.Text.RegularExpressions.Generator.csproj

* Port latest changes over

* Renames

* Update src/libraries/Common/src/Roslyn/CSharpSyntaxHelper.cs

* Simplify

* Dispose builders

* Dispose builders

* Simplify by removing support for nested attributes

* Simplify

Set utf-8 for mono on msvc (#70994)

Add a build lane for FreeBSD Mono. (#69715)

* Add a build lane for FreeBSD Mono.

No test build/run, as there's no Helix queue for it.

Update area-owners.md (#71639)

Add owner for area-Diagnostics-mono

Ensure JsonTypeInfo.Configure() is called once even when exceptions are thrown (#71630)

* Ensure JsonTypeInfo.Configure() is called once even when exceptions are thrown

* Add cached exception check in critical section

Ensure JsonPropertyInfo<T> matches property type and not the converter type (#71612)

[LoongArch64] Fixed the assert error "!tree->gtOp1->isContained()" (#71577)

within the "CodeGen::genCodeForNullCheck()"

Handle out-of-bounds access to locals in block morphing (#71617)

Get S.C.Immutable.Tests running with NativeAOT (#71527)

* The debugger type proxy tests use MakeGeneric to create the right proxy kind. We've been conditionally disabling all those tests. They don't make sense in NativeAOT currently.
* A couple test methods are generic and xUnit needs to MakeGeneric them. Supply RD.XML.

Throw protocol error returned by GoAway on HTTP/2 connection negotation (#71572)

[mono][eventpipe] Write primitive types and UTF-16 strings in little endian order (#68648)

* [mono][eventpipe] Add big-endian support.

Fix EventPipe profiler recursion in class_loading under full AOT. (#71610)

Happens in full AOT mode where methods have been compiled as direct calls
(happens within an assembly). In that case, the method is not known by
the runtime (not present in the JIT info table). When a new class is
loading, the class_loading profiler callback is called. The EventPipe
implementation of that callback will take a stackwalk
(inline with CoreCLR behavior), but taking a stackwalk will look
up each managed function on the callstack against the JIT info table,
if its not there it will load it, that in turn could case additional
recursive class_loading event to fire, that will again take the same
callstack, ending up in an infinite recursion.

The issue is even a little more problematic, since it turns out you
cannot do anything inside the class_loading callback that might end up
triggering a class load, since that might lead up to recursively loading
the same type, that in turn will assert when outer class_loading call
returns and tries to add it into the loaded class cache.

Fix will harden the stackwalking logic inside EventPipe to detect
recursive stackwalks (doing a stackwalk triggering another stackwalk)
and if that is the case, the stackwalk will be done using the
async_context stackwalking capabilities since that won't trigger
any additional profiler events, breaking recursion.

Fix also adds logic to the class_loading profiler callback in EventPipe
to prevent recursion making sure it won't trigger any additional profiler
events, leading up to potential issues loading the same class twice, that
will cause an assert inside the class loader logic.

For 1:1 mapping of old Mono profiler events issued into EventPipe,
they have been aligned with old Mono log profiler events callstack
behaviours, meaning it will only emit callstacks on a few limited
profiler events, mitigating the issues seen in the runtime profiler
provider.

Add Ubuntu 22.04 to libraries CI run (#67345)

This is to help catch OpenSSL 3.0 issues.

Refactor JsonPropertyInfo initialization infrastructure and implement JsonPropertyInfo.AttributeProvider (#71514)

* Implement JsonPropertyInfo.AttributeProvider and refactor initialization infrastructure

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

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

* _shouldSerializeIsExplicitlySet set to false when setting IgnoreCondition

* Reinstante _converterIsExternalAndPolymorphic

* Move unique attribute resolution logic to reflection extensions

* address feedback

Implement type loader support for thread statics (#71524)

We do threadstatics differently from .NET Native and this wasn't implemented.

Fixes #70878 that was reaching a failfast because we couldn't build the target of GVM dispatch at runtime due to unhandled dictionary cell.

I've homed the threadstatic bases under the type manager of the template type. We could potentially make a new type manager, but they currently use this one.

Deleted some more .NET Native leftovers.

Had to update the DynamicGeneric test RD.XML because the test was assuming .NET Native behavior where the ctors are always kept on types that escape the dataflow analysis.

[LoongArch64] Fixed the assert error "(regRecord->assignedInterval == nullptr)" (#71576)

Defer objcopy selection after alt. compiler check (#71554)

In the environment where `gcc` is auto-detected (during
`SetupOSSpecificProps` target execution), we should be selecting
binutils' `objcopy`, rather than `llvm-objcopy`.

We should return the error when there is one (#71585)

Consume Roslyn with `ref` fields support (#71498)

* Use C# ref field support
Update public APIs

* Create new ByReference to be used in Reflection and tailcall slow paths

* Limit net6.0 TFM in DiagnosticsSource to C# 10.

* Remove temporary LifetimeAnnotationAttribute
This is supplied by Roslyn.

* Update to Roslyn compiler with ref field support.

* Update comments with those approved in official docs.

* Handle byref field in interpreter

* Fix build break when DEBUG_INTERP defined.

Enable `TYP_STRUCT` `LCL_VAR/LCL_FLD` call args on LA (#71327)

* Support "PUTARG_STK/SPLIT(STRUCT LCL_VAR/LCL_FLD)" on LA

* LA: [local] morph

* Delete now-not-needed "OBJ(ADDR(LCL_VAR))" wrapping

JIT: Run optRedundantBranches twice and try to compute more accurate doms (#70907)

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

Added a new method to the GC API to Get the GC Configurations (#70514)

Reviewed by: @cshung  @jkotas  @AaronRobinsonMSFT @Maoni0
Co-authored-by: Aaron Robinson <arobins@microsoft.com>

Add `RequiresAssemblyFiles` onto `Marshal.GetHINSTANCE`. (#71531)

* Add `RequiresAssemblyFiles` onto `Marshal.GetHINSTANCE`.

The `GetHINSTANCE` only works on modules/assemblies which are loaded from a file on disk (must be loaded via `LoadLibrary` really), in single-file like scenarios lot of assemblies are loaded directly from memory. For such assemblies the API returns -1 which is not a valid handle.

* Add the attribute to ref assembly

* Add it on the non-implemented version

Implement Tar async APIs (#70574)

* ref: TarEntry.ExtractToFileAsync
* src: Implement TarEntry.ExtractToFileAsync
* ref: Add TarReader.GetNextEntryAsync
* src: Implement TarReader.GetNextEntryAsync
* ref: Add TarWriter.WriteEntryAsync
* src: Implement TarWriter.WriteEntryAsync
* ref: Add TarFile.CreateFromDirectoryAsync
* src: Implement TarFile.CreateFromDirectoryAsync
* ref: Add TarFile.ExtractToDirectoryAsync
* src: Implement TarFile.ExtractToDirectoryAsync
* ref: Add TarWriter.DisposeAsync
* src: Implement TarWriter.DisposeAsync
* ref: Add TarReader.DisposeAsync
* src: Implement TarReader.DisposeAsync
* tests: Async tests, analogous to the sync ones.

Various cryptographic allocation improvements

Add arm64 macOS cross-compilation instructions. (#71568)