add support for unwinding function fragments in the dac (#53765)

[libraries] Fix metadata name following arcade change to stop supporting multiple targets in helix sdk (#53828)

Co-authored-by: Mitchell Hwang <mitchell.hwang@microsoft.com>

[main] Update dependencies from dotnet/runtime dotnet/hotreload-utils dotnet/xharness (#53787)

[main] Update dependencies from dotnet/runtime dotnet/hotreload-utils dotnet/xharness

Add more iterators to JIT (#52515)

Add more iterators compatible with range-based `for` syntax for various data structures. These iterators all assume (and some check) that the underlying data structures determining the iteration are not changed during the iteration. For example, don't use these to iterate over the predecessor edges if you are changing the order or contents of the predecessor edge list.

- BasicBlock: iterate over all blocks in the function, a subset starting not at the first block, or a specified range of blocks. Removed uses of the `foreach_block` macro. E.g.:
```
for (BasicBlock* const block : Blocks()) // all blocks in function
for (BasicBlock* const block : BasicBlockSimpleList(fgFirstBB->bbNext)) // all blocks starting at fgFirstBB->bbNext
for (BasicBlock* const testBlock : BasicBlockRangeList(firstNonLoopBlock, lastNonLoopBlock)) // all blocks in range (inclusive)
```

- block predecessors: iterate over all predecessor edges, or all predecessor blocks, e.g.:
```
for (flowList* const edge : block->PredEdges())
for (BasicBlock* const predBlock : block->PredBlocks())
```

- block successors: iterate over all block successors using the `NumSucc()/GetSucc()`, or `NumSucc(Compiler*)/GetSucc(Compiler*)` pairs, e.g.:
```
for (BasicBlock* const succ : Succs())
for (BasicBlock* const succ : Succs(compiler))
```
Note that there already exists the "AllSuccessorsIter" which iterates over block successors including possible EH successors, e.g.:
```
for (BasicBlock* succ : block->GetAllSuccs(m_pCompiler))
```

- switch targets, (namely, the successors of `BBJ_SWITCH` blocks), e.g.:
```
for (BasicBlock* const bTarget : block->SwitchTargets())
```

- loops blocks: iterate over all the blocks in a loop, e.g.:
```
for (BasicBlock* const blk : optLoopTable[loopInd].LoopBlocks())
```

- Statements: added an iterator shortcut for the non-phi statements, e.g.:
```
for (Statement* const stmt : block->NonPhiStatements())
```
Note that there already exists an iterator over all statements, e.g.:
```
for (Statement* const stmt : block->Statements())
```

- EH clauses, e.g.:
```
for (EHblkDsc* const HBtab : EHClauses(this))
```

- GenTree in linear order (but not LIR, which already has an iterator), namely, using the `gtNext` links, e.g.:
```
for (GenTree* const call : stmt->TreeList())
```

This is a no-diff change.

[mono][wasm] Avoid AOTing methods with clauses, use the interpreter instead. (#52883)

Resolving ILLink warnings on Microsoft.Extensions.Options.ConfigurationManager (#53552)

* Resolving ILLink warnings on Microsoft.Extensions.Options.ConfigurationManager

* Fix message

* Addressing messages feedback

* Update src/libraries/Microsoft.Extensions.Logging.Configuration/ref/Microsoft.Extensions.Logging.Configuration.cs

Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>
* Update remaining messages with suggestion.

Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>

Fix superpmi.py/jitrollingbuild.py to handle large REST results (#53750)

The Azure Storage REST API returns a maximum of 5000 results in
a single query. We have more results in the JIT rolling build set,
so we weren't finding queried git_hash values.

Generalize the query to loop using the "marker" continuation functionality.

We currently have about 800 superpmi collections results, but update
the superpmi.py script similarly for future proofing.

I also changed the query used by jitrollingbuild.py to specify a prefix,
to avoid requiring so many results. Probably should do the same thing for
SuperPMI collections. The downside is the REST api doesn't have a facility
for the prefix to be case-insensitive. I think it's ok to be case-sensitive,
but we'd need to verify that.

Throw ArgumentNull instead of NullReference for null requests (#53742)

* Throw ArgumentNull instead of NullReference for null requests

* Don't use Send on browser

Add PlatformNeutralAssembly property for targeted builds of cross platform assembly (#53626)

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

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

Create Sdk.props in AOT compilers with a template (#53685)

* Create Sdk.props in AOT compilers with a template

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

Example:

```
sudo cat Sdk/Sdk.props
<Project>
  <ItemGroup>
    <MonoAotCrossCompilerPath Include="$(MSBuildThisFileDirectory)..\tools\mono-aot-cross" RuntimeIdentifier="iossimulator-arm64" />
  </ItemGroup>
</Project>
```

Implement descr_generations_to_profiler for regions (#53706)

Add string.ReplaceLineEndings and MemoryExtensions.EnumerateLines (#53115)

Remove HarvestVersionValidation from pkg testing (#53818)

* Remove HarvestVersionValidation from pkg testing

As packages assets aren't redistributed anymore, harvesting doesn't need to rely on exact versions and thus the task isn't necessary anymore.

Change package testing to use RuntimeTargets rather than RID-specific restore (#53575)

* Change package testing to use RuntimeTargets rather than RID-specific restore

* Upload binlogs for package testing

* Address feedback

Simplify outer build of package tests to just use InnerTargets extension point.

Use Helix's work-item isolated packages folder

Give a better name to binlogs

* Cleanup old suppressions

* Use ReferenceCopyLocalPaths for runtime testing

This item will be conflict-resolved whereas RuntimeCopyLocalItems was not.

Also fix the case where a package intentionally provides no assets (yet installs)

* Don't include runtime dependencies when reference was excluded by conflict resolution

* Fix import conventions in outer build

* Workaround conflict resolution on .NETStandard runtime

.NETStandard doesn't conflict resolve runtime assets.
Workaround by feeding .NETStandard references as runtime for purposes of conflict resolution.

[mono] Avoid some unnecessary null checks in wrappers using the .no opcode prefix. (#53817)

Update the Compatibility package for Cng (#53816)

The `System.Security.Cryptography.Cng` package doesn't built live anymore.

Add runtime test logs to HELIX_WORKITEM_UPLOAD_ROOT (#53798)

Add ChannelReader<T>.CanPeek/TryPeek (#53436)

Use HMAC one-shot where appropriate

Alt-Svc tests enabled and fixed for H/3 (#53786)

* Alt-Svc tests enabled and fixed for H/3

* Addressed feedback.

Added some logic to include rcwrefcache references required by feature_comwrappers (#53503)

* Set rcwrefcache related references only for feature_comwrappers

Co-authored-by: Ubuntu <creditsuisse@BuildVM.hqykqmymov3ebcqudt35mscinc.ax.internal.cloudapp.net>

Revert "Reenable a disabled test. (#53779)" (#53791)

This reverts commit 2e7e66d3be35861e39c2043f8be921622bc05ec8.

Fixed copy-paste error. (#53801)

allow late certificate with disabled renegotiation (#53719)

[mono] Disable null checks in ghsaredvt wrappers, they are not needed, (#53775)

and they take up a lot of space since these wrappers are very common.

[mono] Disable the remove empty finally pass, it still causes failures. (#53799)

Eliminate intermediate casts to double on ARM64 (#53748)

* Eliminate intermediate casts to double on ARM64

Enables the same optimization that has been there for
a while for AArch32 for AArch64 too.

* Fix a typo

[main] Update dependencies from mono/linker (#53596)

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

Optimize constant localloc on x64 (#53755)

* Optimize constant localloc on x64

Avoid popping off the outgoing arg space just to push it back later,
for constant size localloc. This typically removes two `sub rsp`
instructions per case, although we don't do the `push 0` "optimization",
so sometimes there are more instructions removed.

* Fix clang build error

Add HttpHeaders.NonValidated (#53555)

This adds an HttpHeaders.NonValidated property, which returns a type that provides a non-validating / non-parsing / non-allocating view of headers in the collection.  Querying the resulting collection does not force parsing or validation on the contents of the headers, handing back exactly the raw data that it contains; if a header doesn't contain a raw value but instead contains an already parsed value, a string representation of that header value(s) is returned.  When using the strongly-typed members, querying and enumeration is allocation-free, unless strings need to be created to represent already parsed values.

Add issues.targets entry for the GitHub_13822 test to make CI green (#53789)

Fix for bug #53520, Entry point not found (#53772)

Manish investigated this issue and he found out that the problem
is caused by the fact that in the method

Newtonsoft.Json.Utilities.ReflectionUtils.GetFields

Crossgen2 produces a NewObject fixup for the incorrect type

System.Collections.Generic.List`1<System.Type>

instead of the right type

System.Collections.Generic.List`1<System.Reflection.MemberInfo>

This was caused by a bug in the token harvesting logic; at some
point resolveToken was asked to resolve the token 0x0A02BA,

string [System.Runtime/*23000001*/]System.Type/*01000019*/::get_Name() /* 0A0002BA */

As part of the token harvesting logic we looked at the
MethodReference.Parent (01000019) and stored it in the harvesting
table along with the OwningType of the method. The problem is
that the translation of the MemberReference to MethodDesc
resolves the method on a base class,

string [System.Reflection/*23000009*/]System.Reflection.MemberInfo/*01000076*/::get_Name() /* 0A0002B5 */

As a result we were storing the incorrect [token - type] pair
[01000019 - System.Reflection.MemberInfo] into the type token
translation table and that confused the signature encoder because
01000019 is System.Type.

The trivial solution is to separately translate the memberref
parent entity handle to the owning type entity instead than
extracting it from the MethodDesc. I have verified using R2RDump
that I now see the correct NewObject fixup getting generated
in the method.

Thanks

Tomas

Reenable a disabled test. (#53779)

Create dotnet symlink during RPM install (#53705)

QUIC stream limits (#52704)

Implements the 3rd option Allowing the caller to perform their own wait from #32079 (comment)
Adds WaitForAvailable(Bidi|Uni)rectionalStreamsAsync:
- triggered by peer announcement about new streams (QUIC_CONNECTION_EVENT_TYPE.STREAMS_AVAILABLE)
- if the connection is closed/disposed, the method throws QuicConnectionAbortedException which fitted our H3 better than boolean (can be changed)
Changes stream limit type to int

Disable diagnostics support as default in Android sample app. (#53716)

Add Invariant check to DateTimeParse tokens codepaths (#53717)

Cuts about 7k for invariant mode

[mono] Check for `Vector{64,128,256}<T>` element type validity before emitting unchecked intrinsic IR for `AsByte` etc. (#53707)

[main] Update dependencies from dotnet/arcade dotnet/hotreload-utils (#53766)

* Update dependencies from https://github.com/dotnet/arcade build 20210604.1

Microsoft.DotNet.XUnitExtensions , Microsoft.DotNet.VersionTools.Tasks , Microsoft.DotNet.Build.Tasks.TargetFramework.Sdk , Microsoft.DotNet.Build.Tasks.Packaging , Microsoft.DotNet.Build.Tasks.Installers , Microsoft.DotNet.Build.Tasks.Feed , Microsoft.DotNet.CodeAnalysis , Microsoft.DotNet.Build.Tasks.Archives , Microsoft.DotNet.Arcade.Sdk , Microsoft.DotNet.ApiCompat , Microsoft.DotNet.XUnitConsoleRunner , Microsoft.DotNet.GenFacades , Microsoft.DotNet.GenAPI , Microsoft.DotNet.RemoteExecutor , Microsoft.DotNet.PackageTesting , Microsoft.DotNet.Helix.Sdk , Microsoft.DotNet.SharedFramework.Sdk
 From Version 6.0.0-beta.21303.2 -> To Version 6.0.0-beta.21304.1

* Update dependencies from https://github.com/dotnet/hotreload-utils build 20210604.1

Microsoft.DotNet.HotReload.Utils.Generator.BuildTool
 From Version 1.0.1-alpha.0.21303.1 -> To Version 1.0.1-alpha.0.21304.1

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

[mono] Fix the remove finally pass. (#53738)

Instead of checking whenever the generated IR is empty, do the checking
in the front end, and save the result into bb->flags.

Fixing a regression compiling VT arrays (#53760)

* Fixing a regression compiling VT arrays

* Update src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs

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

Add GCHandle in native default ALC at creation (#53308)

This lets embedders have a handle to fetch and pass before the runtime is properly started up and the managed default ALC is not yet created. Once the managed counterpart is initialized, the handle's target is changed, but the handle stays the same.

Eliminate redundant test instruction (#53214)

* Correctly track how x86 instructions read/write flags

* For GT_EQ/GT_NE, reuse flag

* Explicit flags for jcc, setcc, comvcc

* Add reset flags

* remove duplicate enum

* Handle cases where shift-amount is 0

* Add helper method for Resets OF/CF flags

* Rename methods

* one more rename

* review feedback

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

[main] Update dependencies from dotnet/arcade dotnet/runtime-assets dotnet/hotreload-utils dotnet/xharness (#53595)

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

Socket: don't assign right endpoint until the connect is successful. (#53581)

* Socket: don't assign right endpoint until the connect is successful.

'Right endpoint' must match the address family of the Socket or
we can't serialize the LocalEndPoint and RemoteEndPoint.

When multiple connect attempts are made against a DualMode Socket with
both IPv4 and IPv6 addresses, a failed attempt must not set 'right
endpoint'.

* SocketTaskExtensionsTest.EnsureMethodsAreCallable: update expected exceptions

* PR feedback

* EnsureMethodsAreCallable: move ReceiveFromAsync before ConnectAsync to avoid wildcard bind on Windows that leads to a different exception

Minor corrections to BotR intro chapter (#53746)

Just fixing up a couple of missing words I noticed in the intro chapter:
Missing "to" in "(more code that does not seem do much)"
Missing "a" in "This results in big productivity boost."

Build clr/libs dependencies of test build locally (#53696)

* Build clr/libs dependencies of test build locally
- Stop relying on the actual product build for these
- Should reduce long pole of running coreclr tests by removing need to wait for coreclr/libraries product builds to complete before test build can begin
- Evidence shows that the native lib build can also be elided, but that requires more complex build work

Remove some unused defines and functions (#53724)

* Remove some unused defines and functions

* Delete the _CROSS_COMPILER_ define

It is also unused.

* Also fix a typo while I am here

* Delete #define DUMPER

* Delete #include's under #ifdef ICECAP

* Delete MAX/MIN_SHORT_AS_INT defines

Add background type preloading based on multicorejit (#52595)

* Add background type preloading based on multicorejit

This is a second part of #48326 change, which enables handling of methods loaded from r2r images. Background thread of multicorejit now not only jits methods but also loads methods from R2R images. This allows to load types in background thread.

This is required as part of https://github.com/dotnet/runtime/issues/45748 change (specifically, https://github.com/dotnet/runtime/issues/45748#issuecomment-750889697), goal of which is to enable background type preloading using multicorejit.

Fix mono corelib path in build script (#53731)

Remove the unused AEADBCryptHandles.cs file

Spanify some Linux SslStreamPal internals and refactor EncryptDecryptHelper (#53512)

* Spanify some SslStreamPal internals and refactor EncryptDecryptHelper

Co-authored-by: Geoffrey Kizer <geoffrek@windows.microsoft.com>

Add static one-shot methods for HMAC algorithms

Include LSRA block sequence progress in JitDump (#53714)

* Print LSRA block sequence progress

* review comment

[mono][wasm] Exit with a nonzero exit code on asserts. (#53734)

Update comments in type system tests (#53718)

These numbers changed in #53424. One of the reasons why I'm not a huge fan of too much commenting...

[mono] Disable the remove empty finally pass for now. (#53710)

It cannot determine whenever the finally clause is really empty, i.e. whenever
it can affect the rest of the program.

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

Implement generic IEnumerable on various X509 collection types

X509Certificate2Collection gets it, X509CertificateCollection doesn't.

We don't really want people using the older collection type, and we have inheritance, and being both
`IEnumerable<X509Certificate>` and `IEnumerable<X509Certificate2>` makes some things weird.

AOTCompilerTask: use assembly name to build the aot linking symbols (#53659)

`System.Runtime.Loader.DefaultContext.Tests` fail with `wasm+aot`
Fixes https://github.com/dotnet/runtime/issues/52383

From the issue:

```
[10:39:59] info: * Assertion at /__w/1/s/src/mono/mono/mini/aot-runtime.c:2330, condition `<disabled>' not met
[10:39:59] info:
[10:39:59] info: ABORT: undefined
[10:39:59] info: Stacktrace:
[10:39:59] info:
[10:39:59] info: Error
[10:39:59] info:     at Object.onAbort (runtime.js:217:13)
[10:39:59] info:     at abort (dotnet.js:1233:22)
[10:39:59] info:     at _abort (dotnet.js:5561:7)
[10:39:59] info:     at monoeg_assert_abort (<anonymous>:wasm-function[5943]:0xdadad)
[10:39:59] info:     at monoeg_log_default_handler (<anonymous>:wasm-function[5960]:0xdb0c8)
[10:39:59] info:     at monoeg_g_logstr (<anonymous>:wasm-function[5953]:0xdaf76)
[10:39:59] info:     at monoeg_g_logv_nofree (<anonymous>:wasm-function[5951]:0xdaf28)
[10:39:59] info:     at monoeg_assertion_message (<anonymous>:wasm-function[5956]:0xdaff2)
[10:39:59] info:     at mono_assertion_message (<anonymous>:wasm-function[5958]:0xdb035)
[10:39:59] info:     at mono_assertion_message_disabled (<anonymous>:wasm-function[5957]:0xdb008)
[10:39:59] info:     at mono_aot_register_module (<anonymous>:wasm-function[5045]:0xbb12a)
[10:39:59] info:     at register_aot_modules (<anonymous>:wasm-function[59156]:0x12f4753)
```

vargaz: This actually happens because the generated AOT linking symbol in driver-gen.c is not correct.
Its generated from the filename, which is System.Runtime.Loader.Noop.Assembly_test.dll, but the assembly name is System.Runtime.Loader.Noop.Assembly. So linking the final app should fail, but emscripten doesn't notice the missing symbol because of https://github.com/emscripten-core/emscripten/issues/14106 .
So this turns into a runtime assertion.

- Also, enable the tests.

Possible leak of a weak handle in `Gen2GcCallback` (#53701)

Adapt more Mono profiler events into NativeRuntimeEvents. (#53677)

[QUIC] Stream write cancellation (#53304)

Add tests to check write cancellation behavior, fix pre-cancelled writes and fix mock stream.
Add throwing on msquic returning write canceled status.

Fixes #32077

Add better description of what to pass to `hostfxr_initialize_for_dotnet_command_line` (#53678)

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

46239 v2 (no runtime layout changes) (#53424)

The regression test

<code>src\tests\JIT\Regressions\JitBlue\Runtime_46239</code>

exercises various interesting corner cases of type layout that
weren't handled properly in Crossgen2 on x86 and ARM[32]. This
change fixes the remaining deficiencies and it also adds
provisions for better runtime logging upon type layout mismatches.

With this change, the only remaining pipelines using Crossgen1 are
"r2r.yml", "r2r-extra.yml" and "release-tests.yml". I haven't yet
identified the pipeline running the "release-tests.yml" script;
for the "r2r*.yml", these now remain the only pipelines exercising
Crossgen1. I don't think it makes sense to switch them over to
CG2 as we already have their CG2 counterparts; my expectation is
that, once CG1 is finally decommissioned, they will be just deleted.

Thanks

Tomas

Reduce worst-case alg complexity of MemoryExtensions.IndexOfAny (#53652)

Fix large object allocation (#53589)

* Fix the issue that with regions we are unable to allocate objects larger than 32 MB.

Method gc_heap::get_segment_for_uoh gets passed a size, but drops it on the floor in the region case.

The fix is simply to pass the size parameter through the various methods we call for allocating a large region, and to allocate a properly sized region in region_allocator::allocate_large_region.

Retype calls as SIMD when applicable. (#53578)

* add a repro

* passed spmi.

* update comment.

* update the test

* improve the check.

* fix a stressfailure

* fix x64 unix diff

Replace remaining constants to Array.MaxLength (#53664)

* Replace constants to Array.MaxLength.

* Add comment for places can't be replaced.

* Mention SZArray in MaxLength docs.

Update feature-switches.md (#53639)

[mono] LLVM 11: Explicitly zero the unused bits of the result register for AddPairwiseScalar (#53694)

LLVM 11 and above optimize

    %9 = extractelement <2 x float> %arm64_ld1, i32 0
    %10 = extractelement <2 x float> %arm64_ld1, i32 1
    %arm64_faddp_scalar = fadd float %9, %10
    %11 = insertelement <2 x float> undef, float %arm64_faddp_scalar, i32 0

(which is translated to scalar `faddp`)

into

    %shift = shufflevector <2 x float> %arm64_ld1, <2 x float> undef, <2 x i32> <i32 1, i32 undef>
    %10 = fadd <2 x float> %arm64_ld1, %shift
    %11 = shufflevector <2 x float> %10, <2 x float> undef, <2 x i32> <i32 0, i32 undef>

(which is translated to a sequence of `dup` and vector `fadd`).

This change works around this by explicitly zeroing the unused bits of the
results of `AddPairwiseScalar`; the generated code is noisier, but the
semantics are correct. The "Arm Architecture Reference Manual Armv8, for
Armv8-A architecture profile" version G.a calls out the zero-extending
semantics of scalar operations that use SIMD registers (see
"aarch64/functions/registers/V") but judging by the generated code it doesn't
look like LLVM exploits this for optimization.

This also affects `vpadds_f32` in Clang.

Add System.Runtime.CompilerServices.Unsafe.dll to the list of dlls not part of the composite image to make roslyn work with the composite build (#53691)

Missing `Dispose` after `RemoteExecutor.Invoke` (#53700)

Disable BundleExtractToSpecificPath tests on Linux due to same problems (#53690)

Resolving most of ILLink warnings on Microsoft.Extensions.Hosting (#53646)

* Resolving most of ILLink warnings on Microsoft.Extensions.Hosting

* Fix indentation issues

Specify kSecUseDataProtectionKeychain when generating RSA/ECC keys on macOS/iOS

[iOS] Fix AppleAppBuilder to work w/ AOT+LLVM  (#53651)

When LLVM is enabled, this change makes sure we're linking in the .ddl-llvm.o files

disable a test (#53661)

Improve ENC logging. (#53695)

Fix assert in CMiniMdRW::GetTableForToken.  g_TblIndex entries for MethodImpl and NestedClass needed token values.

[iOS] Fix null dereference in AppleCryptoNative_SslIsHostnameMatch

Fix for null pointer bug found by UBSAN (#53686)

Fix for null-pointer bug found with Clang's undefined-behavior-sanitizer using `-fsanitize=null`

https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html

Co-authored-by: jbcoe <jbcoe@users.noreply.github.com>

[mono][llvm] Replace all remaining uses of SimdOp with the INTRINS_ enumeration. (#52593)

Add support for TLS and connectionless LDAP connections on Linux (#52904)

* Set LDAP version with pointers on Linux

* Replace deprecated OpenLDAP methods

In OpenLDAP, ldap_simple_bind_s is deprecated in favor of
ldap_sasl_bind_s with the LDAP_SASL_SIMPLE auth method[1][].
Similarly, ldap_init is deprecated in favor of ldap_initialize[2][].
The newer APIs also allows us to specify a URI to use TLS with OpenLDAP.

[1]: https://git.openldap.org/openldap/openldap/-/blob/OPENLDAP_REL_ENG_2_4_58/include/ldap.h#L1278
[2]: https://git.openldap.org/openldap/openldap//blob/OPENLDAP_REL_ENG_2_4_58/include/ldap.h#L1513

* Add TLS and connectionless LDAP support to Linux

This commit manually specifies the LDAP URI option during connect
(but before binding). This is necessary because in order to know the
correct scheme, we need access to SessionOptions, which is not available
until after initialization.

Finally, it removes the PlatformUnsupportedException from the
SessionOptions.SecureSocketLayer property.

This makes it possible to use LDAP over TLS and connectionless (UDP)
LDAP.

* Add test configuration for LDAP TLS server

use QUIC_ADDRESS_FAMILY enum for assigning socket family (#53673)

Fixing the GetInterfaceMap tests for mono in the runtime repo. (#52566)

Addressing 4 issues for GetInterfaceMap and default interface methods
 - Only methods marked as virtual on on interface should be added to the
   interface map. (no static or instance)
 - If the found target method is ambiguous (a diamond) the target is
   null.
 - If the found target method's class in an interface, then the target
   class is the interface class, else it is the class of the RuntimeType
   (aka this)
 - If the found target method is abstract (reabstraction) then the
   target is null.

Fixes #34389

Integrate changes from NativeAOT branch (#53650)

* Integrate changes from NativeAOT branch

Includes faster virtual method enumerator that should help crossgen2 too

* Fix tests

Add Execution Checkpoint EventPipe event used to track runtime init on Mono. (#53024)

Add MemoryMarshal.GetArrayDataReference(Array) (#53562)

StringSegment: more AsSpan overloads (#53463)

* Defined API

* Added tests

* Implementation

* Remove some branches

* PR Feedback

* Don't use default argument in ThrowInvalidArguments

Add remarks to /// comments for TimeOnly.IsBetween (#53620)

Co-authored-by: Stephen Toub <stoub@microsoft.com>

Fix SuperPMI dumping for replay. (#53649)

* Fix `SetShimDebugVariables` for counter and simple.

* fix dumps for replays

Relax a threading related assert (#53445)

Fix Culture Native and Display Names (#53468)

* Fix Culture Native and Display Names

* fix mono break

* Address the feedback

* Address more feedback

* Use ThreadCultureChange in the tests

* Exclude the test on  mobile platfoms

Avoid setting the brick of the next region during sweep in plan (#53446)

Unix: Additional check if the RSA key is external.

Currently we are checking the RSA_METHOD to see if an RSA key "external",
where the private key material may not be exportable. This may not work
because the RSA key itself can declare if it is external or not.

This also checks the flags of the RSA key object itself so attempting
to export the private key is not performed.

Remove some unnecessary string copies in hosting layer (#53631)

Add test for EventListener consuming ThreadPool events  (#48487)

[mono][aot] Compile llvm object files with -fPIC on android. (#53618)

Delete obsolete libraries package settings files (#53610)

Deleting package settings files as the package isn't produced anymore
or because the workaround was resolved (i.e. .NETStandard downgrades).

JIT: relax immediate dominator check for jump threading (#53613)

When jump threading, we had been insisting that the redundant branch be
the immediate dominator (idom) of the branch being optimized. But now that we
are doing exact reachability checks, we can consider threading based on
redundant branches higher in the (original) dominator tree, provided that the
in-between branches have also been optimized.

This situation arises when there are repeated redundant branches in if-then
or if-then-else chains. Say there are 3 such branches. The algorithm works
top-down in the original dominator tree. To begin with, the second branch
in the chain is jump-threaded since it redundant to the first. As part
of this the second branch's block is modified to fall through. Now the
third branch's idom is the block that held the second branch, but this block
no longer ends with a branch. So the nearest redundant dominating branch is the
first branch in the chain. And this arrangement blocks jump-threading the third
branch as the redundant branch block is not in the idom block.

Jump threading will work correctly so long as there are unique paths from the
redundant branch outcomes to the branch being optimized. So we have appropriate
safety checks and can consider threading based on higher dominating branches.

Resolves #53501.