Support remaining Sha1 intrinsics on Arm (#48413)

* Add support for Sha1 API with vector64 arguments

* Promote return to vector64

* Return a 2 x i32 instead of i64

* Update src/mono/mono/mini/mini-llvm.c

* Fix format

Co-authored-by: imhameed <imhameed@microsoft.com>

Fix all remaining System.Security.Cryptography.Algorithms test suite crashes. (#48432)

* Fix all remaining System.Security.Cryptography.Algorithms test suite crashes.

With this + PR #48348, the test suite runs to completion and reports the following results:

> Tests run: 2527 Passed: 1285 Inconclusive: 0 Failed: 1227 Ignored: 7

So we've got a ways to go to get things passing, but now we can easily track it at least for this assembly.

* PR Feedback.

[coop] Enter GC Unsafe mode in mono_gc_init_finalizer_thread (#48465)

when lazy thread creation is used, this external API function is called
from a thread in GC Safe mode, so enter GC Unsafe before calling runtime
functions.

Fixes a double transition to GC Safe in mono_gc_pthread_create.

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

Improve SuperPMI asserts (#48449)

Include `GetIndex` method calls in the assert message, to distinguish
the different assert cases in error output. E.g., the asserts
change from:

```
'index != -1' failed ...
```

(which was identical for several cases), to:

```
'GetClassAttribs->GetIndex(CastHandle(classHandle)) != -1' failed ...
```

This makes it easier to know where the problem is without debugging the failure.

Display more SuperPMI details in log file (#48448)

In particular, display missing info asserts, which give some hint
about what change might have caused the missing info to be requested.

Fix SuperPMI SEH exception handling (#48447)

Capture data in the filter; don't save a PEXCEPTION_POINTERS
that points to data that is is transient to the filter.

Run dotnet.sh/cmd script before running dotnet restore (#48375)

* Fix SuperPMI Linux collections

1. Run dotnet for jitutils with jitutils dir as the current working dir.
2. Run dotnet.sh/cmd script before running bootstrap (and `dotnet restore`)
to ensure `.dotnet` directory exists.

Fix PerfMap file naming in Crossgen2 to match Crossgen1 (#48426)

For single-file builds, PerfMap file name is expected to have
the file name <output file>.ni.{managed assembly MVID}.map.
This change fixes Crossgen2 to conform to that naming style.

Thanks

Tomas

Support profiler activation for same bitness architectures (x64+arm64 and x86+arm) on Windows ARM64 and macOS Apple Silicon. #39699 (#46868)

Fix usage of relative path on bundle extraction (#47200)

* Don't append boolean

* Set working dir for the command only
Test different bunddle options when extracting to relative path

* Add error message
Use bundleOption parameter

* Normalize extraction dir path
Look for expected extracted files

* Only test for bundle options that extract files to disk
Update GetExtractedFiles

* Don't change value of env var

* On windows, forward slashes should be converted to standard dir sep

* Set COREHOST_TRACE in test

* Fixup path after appending rel path
Remove COREHOST_TRACE

* Add extension

* Remove netcoreappcompatmode test with backslash

* Don't modify dir sep

* Update GetFilesNeverExtracted
Skip 'foo/bar' in Windows

Fix issue #48345 (#48391)

Fix issue #48345: Return value marshaling was incorrect for bound methods

Implemented abs saturate, absolute compare intrinsics. (#48361)

Co-authored-by: Nathan Ricci <naricc@xam-emag-01.redmond.corp.microsoft.com>

Add tvOS functional tests (#48331)

Fix OOB src project configurations (#48318)

* Fix OOB src project configurations

* Optimize netstandard2.1 DI assembly

* Move netcoreapp3.0 tfm to netstandard2.1

* Remove NetCoreAppCurrent config from M.E.DI

Delete a few lines of dead code in ListDictionaryInternal (#48404)

Improve error message when bundler fails due to duplicate entries (#48336)

There are multiple possible cases which will make the bundler fail with duplicate entries. Currently there's no indication of which entries caused the problem, making it really hard to diagnose these failures.

This change prints out the source file paths and the colliding relative bundle path in the error message. This should help with diagnosing the failures.

Fix ILLink descriptors filename (#48430)

Check that rsp is within stack limits when redirecting a thread. (#48433)

* Check that rsp is within stack limits when redirecting a thread.

* move the check after/if SetThreadContext has failed

* just return  FALSE after failed SetThreadContext

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

Clarify the behavior of FilePatternMatch Path and Stem (#48093)

* Add theories that illustrate globbing Path/Stem behavior

* Update Path/Stem docs for FilePatternMatch

* Apply suggestions from code review

Co-authored-by: Carlos Sanchez <1175054+carlossanlop@users.noreply.github.com>
Co-authored-by: Carlos Sanchez <1175054+carlossanlop@users.noreply.github.com>

Add option to ignore reference cycles on serialization (#46101)

* Add option to ignore reference cycles on serialization

* Fix whitespace

* Combine IsValueType check on WriteCoreAsObject

* Add missing null-forgiving operator

* Fix perf regression by using ReferenceHandlerStrategy field in JsonSerializerOptions

* Address suggestions

* Rename API to IgnoreCycles

* Add missing letter to test class name

* Fix CI issue with nullable annotation

Setting Thread.Name sets the native thread name on MacOS. (#47465)

* Setting Thread.Name sets the native thread name on MacOS.

Setting Thread.Name will now set the name of the native thread
on MacOS - due to API constraints this will not work cross thread.

Fix #47087

* adding tests and formatting fixes

Adjust logic in cor.h, corhdr.h, corinfo.h, corjit.h and such so that they may be included without the PAL (#46055)

This was done via simple substitution of the standard sized integer types, and dealing with the fallout. It is tested by using the ICorJitInfo interface directly within the crossgen2 jitinterface thunk library.

Effort was made to use a minimum number of casts, as casts in such a large change are likely to be wrong somewhere.
- Exceptions are the use of casting to handle some calls to the existing internal metadata api and around use of char16_t.

In addition, a small amount of logic from the PAL headers were pulled into the proper header to allow compilation in the presence of some SAL annotation, and other small details.

Add debug checking of the loop table (#48060)

* Add fgDebugCheckLoopTable()

* Minify some logging

* Add checking of the loop table to some phases

* Ignore removed loops in fgDebugCheckLoopTable

Remove libraries test build from AndroidCrypto staging job (#48422)

Update SuperPMI license headers (#48417)

Fix parsing of trailing zeros: TryParseNumber (#47666)

* Fix parsing of numbers to detect trailing zeros

* sq

* Typo

* Fix a bug

Calculate number of trailing zeros only when number.Digits is updated

* Test case should be culture agnostic

* Address feedback

* More unit tests

* Bug fix and unit tests

* sq

* Address feedback.

* Get more debug info to track down build break

* Turn off consistency check at 1 spot

* Skip consistency check for decimal

* Turn off trailing zero check

Fix various test crashes and asserts when running the Algorithms test suite with the Android Crypto PAL (#48370)

* Fix various test crashes and asserts when running the Algorithms test suite.

* Replace the key/iv if it is initialized multiple times.

[RyuJIT] Track exact class for special intrinsics (EqulityComparer, Comparer) (#48279)

Add Eager Options Validation: ValidateOnStart API (#47821)

Fix PInvoke GenericTest (#48382)

[mono] Developer convenience MSBuild property (#48381)

Adds a property, named `MonoCMakeExtraArgs`, which is passed through to the CMake configure command invocation.

Example usage:
```
MonoCMakeExtraArgs="-DCMAKE_EXE_LINKER_FLAGS=-fuse-ld=$HOME/clang-9.x/out/bin/ld.lld -DCMAKE_SHARED_LINKER_FLAGS=-fuse-ld=$HOME/clang-9.x/out/bin/ld.lld -DCMAKE_LINKER=$HOME/clang-9.x/out/bin/ld.lld -DCMAKE_AR=$HOME/clang-9.x/out/bin/llvm-ar -DCMAKE_RANLIB=$HOME/clang-9.x/out/bin/llvm-ranlib" \
./build.sh
    -configuration Release \
    --subset mono \
    /p:MonoLLVMUseCxx11Abi=true /p:MonoEnableLLVM=true \
    /p:MonoLLVMDir="$LLVM_PREFIX"
```

`touch src/mono/mono/mini/mini-llvm.c && time ninja -C artifacts/obj/mono/Linux.x64.Release` reports 5.3 seconds when using lld, llvm-ar, and llvm-ranlib; this takes 18 seconds when using GNU tools.

Note that GCC doesn't support full paths for fuse-ld, [unlike Clang](https://reviews.llvm.org/D17952).

Add MCS verb to dump jit flags histogram (#48281)

Useful for determining what sorts of jit compilations are found in an SPMI
collection.

Further fixes for s390x that correct some test suite failures (#48196)

## Further s390x Fixes

This set up patches enables s390x to pass more of the test suite.

### 1. Mono array layout

The array "raw data" layout is defined in two places, one for the Mono C++ code, and one for C# code (which should match!):
```
struct _MonoArray {
    MonoObject obj;
    /* bounds is NULL for szarrays */
    MonoArrayBounds *bounds;
    /* total number of elements of the array */
    mono_array_size_t max_length;
    /* we use mono_64bitaligned_t to ensure proper alignment on platforms that need it */
    mono_64bitaligned_t vector [MONO_ZERO_LEN_ARRAY];
};
```
vs.
```
private class RawData
{
    public IntPtr Bounds;
    public IntPtr Count;
    public byte Data;
}
```
However, this only actually matches perfectly on 32-bit platforms if `MONO_BIG_ARRAYS` is false and 64-bit platforms if `MONO_BIG_ARRAYS` is true. In the dotnet build, `MONO_BIG_ARRAYS` is false, so we have a problem on 64-bit platforms. On little-endian 64-bit platforms the mismatch is mostly harmless, but on big-endian 64-bit platforms this causes test case failures in `System.Tests.ArrayTests.Clear_Invalid`.

The patch fixes this for s390x, but it should be possible to implement this in a cleaner way ...

### 2. Tail call implementation

There were actually two bugs here. First of all, the `tailcall_reg` instruction was not marked in `cpu-s390x.md` to have an sreg1 input, which meant that the target address was never actually loaded up.

More problematically, the way the tailcall implementation handles call-saved argument registers was fundamentally broken. This is a problem on s390x with the r6 register, which is call-saved even though it is also used as argument register. This is a problem for tail calls, because you have to restore the old value before performing the tail call, which conflicts with loading the required argument value. The same problem also applies for the RGCTX/IMT register, which is likewise both call-saved and used to hold an _implicit_ argument.

The current Mono code simply does not restore the old value and only loads the argument value. But that is an ABI break and may cause failures in a caller higher up on the stack once the tail-called routine finally returns. Consider three functions A, B, C where
#### A:
```
[...]
define R6
call B (does not use R6 as argument)
use R6
[...]
```
##### B:
```
save R6
[...]
load R6 with argument value
tail call C (uses R6 as argument)
```
#### C:
```
save R6
[...]
use R6 argument value
[...]
restore R6
return
```
Once C finally returns to A, the value in R6 will be the value it had on entry to C, not that on entry to B, which is what the code in A relies on.

The following patch fixes this by disabling tail calls in those cases where R6 is used as argument register, as well as in all cases where the RGCTX/IMT register is used.

Note that it might be possible to re-enable the latter cases by using a call-clobbered register as RGCTX/IMT register. One option might be `%r1`, which is also used by GCC as the static chain pointer for nested functions (which is a somewhat similar purpose). This would also match what x86_64 is doing: they likewise use the static chain register for RGCTX/IMT.

I haven't implemented this since there might be a problem with other intervening trampolines clobbering %r1 -- this would need careful review and possibly some reshuffling. I guess this can be done later as an optimization.

### 3. Crashes due to corrupted sigaltstack

When sigaltstack is enabled, the kernel provides the address of the alternate stack to signal handlers in the `uc_stack.ss_sp` field. More importantly, the kernel also *reads* out that field once the signal handler returns and updates its notion of what alternate stack is to be used for future signals! This is a problem with current Mono code, which writes the user-code stack pointer into `ss_sp` -- causing the kernel to attempt to use that part of the user stack as alternate stack for the next signal. If that then overlaps then regular stack (which is likely), the kernel will consider this value corrupted and deliver a SIGSEGV instead.

Looking into this, I'm not really sure why Mono (the s390x code only) even writes to `ss_sp` in the first place. This is apparently read out in just one place, where we actually want to know the user stack, so I guess we can just use r15 directly instead.

#### 4. Codegen problem with floating-point to integer conversions

The Mono back-end uses `cegbr`/`cdgbr` (64-bit int to float conversion instructions) even in the case where the source is actually a 32-bit integer. It really should be using `cefbr`/`cdfbr` in those cases, which is what the following patch implements.

Note that I'm a bit unclear about the intention of the original code here: there appears to be some effort made to hold 32-bit integers in 64-bit sign-extended form in registers, in which case the `cegbr`/`cdgbr` would probably be also correct (but still not really preferable). However, this doesn't seem to be done consistently.

#### 5. Codegen problems with integer overflow detection

There were two separate bugs with properly detecting integer overflows. First of all, the `OP_IADD_OVF_UN` implementation used the 64-bit `algr` instead of the 32-bit `alr` instruction. While the (32-bit) numerical result is of course the same, the detected overflow is incorrect.

More problematic is the overflow detection for signed multiplication. The code seems to only verify whether the sign of the result matches the product of the signs of the inputs -- but this doesn't reliably detect overflow! While of course there must have been an overflow if the sign doesn't match, there can still be an overflow if the sign *does* match, for example in the case from the test suite: 1.000.000.000 * 10

Now, on recent machines we have hardware support to detect overflow: `msgrkc` and `msrkc`. While Mono was already using `msgrkc` (so the problem doesn't occur for 64-bit multiplication) it didn't use `msrkc`. The following patch just adds that case. Note that this still only fixes the problem on z14 on higher; the code for older machines really also ought to be fixed at some point.

#### 6. Codegen problems with interlocked add

Finally, there is a subtle problem with the code currently generated for the interlocked add primitives, if the machine supports the laa(g) instruction. Those handle the whole interlocked-add operation in hardware, so the only thing Mono codegen needs to handle in addition is the proper return value. The laa(g) instructions return the value the memory location had *before* the addition, while the Mono interlocked-add primitive is specified to return the value the memory location has *after* the addition.

To fix this discrepancy, the code generated by Mono will perform another load from the memory location immediately after the laa(g). This usually returns the correct value, but it creates a race condition: in between the laa(g) and the load, another thread might have changed the value! This violates the atomicity guarantee of the interlocked-add primitive.

To fix this, the following patch instead uses the (atomically loaded) result of the laa(g) instruction and then simply performs the original addition a second time in registers.

[master] Update dependencies from dotnet/xharness dotnet/llvm-project dotnet/icu (#48333)

[master] Update dependencies from dotnet/xharness dotnet/llvm-project dotnet/icu

Clean up libraries trimming illink configuration (#48153)

Fix issue 41928 (#48295)

Details:

The issue was that verify_heap called copy_brick_card_table while another thread was growing these tables, so we ended up with a mark_array where the sections for a new segment were not committed, leading to an AV in bgc_verify_mark_array_cleared.

The fix is to take the gc_lock *before* calling veriy_heap. To avoid a deadlock, the lock has to be taken before we suspend the EE. This only affects the end of a background GC, the verify_heap at the start of a background GC already happens under the gc_lock.

I factored out common code into new methods enter_gc_lock_for_verify_heap and leave_gc_lock_for_verify_heap.

Add default linker substitutions for ios like targets (#48215)

Update NonVersionableAttribute attribute trimming (#48213)

SPMI fixes for missing info. (#48360)

* SPMI hacks/fixes.

* review response.

Update comment and add test for Marshal.GetDelegateForFunctionPointer (#48362)

* Update comment and fix test for Marshal.GetDelegateForFunctionPointer argument validation

* Disable test on Mono

Add staging job to build Android using native crypto instead of OpenSSL (#48373)

* Fix x86 build

Add intepretation of MOV ESP, EBX to unwindLazyState (#45906)

PriorityQueue: Apply Comparer<T>.Default optimization (#48346)

* PriorityQueue: inline Comparer<T>.Default.Compare calls

* address feedback

* Update src/libraries/System.Collections/src/System/Collections/Generic/PriorityQueue.cs

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

* Update src/libraries/System.Collections/src/System/Collections/Generic/PriorityQueue.cs

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

Rename LargeHeapHandle* to PinnedHeapHandle* to reflect what it actually does (#48371)

Add initial support for Vector64 on Arm64 and Amd64 (#47618)

Contributes to #42350

This change:

- Conditionally marks Vector64<T> as a SIMD type. Vector64<T> is treated as a
SIMD type on amd64 and arm64 only when the LLVM backend is in use. Vector128<T>
continues to be supported with both LLVM and mini on amd64, as before; on arm64,
it continues to only be supported with LLVM.

- Checks vector widths for compatibility when bitcasting.

- Slightly cleans up return value handling for SIMD value types--conversion
from an aggregate to an LLVM vector-typed value now happens in one location.

- Removes a 128-bit SIMD assumption in the lowering code for OP_SETRET.

- Renames `emit_vector128` to `emit_sri_vector` and makes it width-agnostic.

- Improves the generated IR for non-broadcasting Vector64/Vector128.Create; the
resulting code works entirely in registers and does not depend on temporary
stack storage for writing values into individual vector lanes.

Co-authored-by: Imran Hameed <imhameed@microsoft.com>

Fix using .NET COM server with `dynamic` keyword  (#48037)

Update incremental servicing condition for pkgs (#48330)

* Update incremental servicing condition for pkgs

Switch over framework packaging to use Crossgen2 (#47349)

Fix build errors with Android crypto native (#48359)

Remove net5 feeds (#41620)

https://github.com/dotnet/runtime/issues/41593

Set *ppIndirection to NULL in MethodContext::repGetAddrOfCaptureThreadGlobal() if there is corresponding GetAddrOfCaptureThreadGlobal LWM (#48260)

RyuJIT: Fix logic to test bits in a constant vector (Vector256) (#47385)

Co-authored-by: Sergey Andreenko <seandree@microsoft.com>

Fix undisposed enumerators (#48322)

-Fix converters not disposing enumerators (issue #46349)
-Add tests

Remove some duplicated installer.tasks tasks (#48339)

* Remove some duplicated installer.tasks tasks

in favor of Arcade's implementation.

Don't assume result is non-NULL if its type is not TYPE_VOID when tracing. (#48335)

On a CEE_MONO_ICALL set to **mono_threads_detach_coop** (from native to managed), the profile code is always emitted without a return value, since it's not at a ret. This means it's never set, even if there actually is a return type (other than TYPE_VOID). When tracing, it's assumed that valid result types other than TYPE_VOID can be dereferenced, even though in this case no result has been set. This causes a null dereference fault.

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

fix task doc typo (#48332)

[mono] Bump emscripten to 2.0.12 (#48334)

Throw instead of returning null in XNodeReader.GetAttribute(int) (#44589)

* Throw exception on non-interactive mode and invalid index instead of returning null

* Adapt unit tests to exceptions

* Move tests from XCMLReaderAttrTest to XNodeReaderAttributeTests.

Remove these test cases from FunctionTests' children

* Migrate attribute tests toward XUnit

* Remove migrated tests and distinguish between int and string indexer

* Throw ArgumentOutOfRangeException when index is above upper bound and update tests

Multiple s390x fixes (#48329)

Update dependencies from https://github.com/mono/linker build 20210216.1 (#48327)

[master] Update dependencies from mono/linker

Fix IndexOutOfRangeException in PriorityQueue.EnqueueDequeue (#48323)

Avoid nulling out in PriorityQueue.Remove if it's not needed (#48324)

Use live dependencies for netcoreapp3.0 depencies (#48176)

* Use live dependencies for netcoreapp3.0 deps

AssemblyLoadContext.CurrentContextualReflectionContext and instantiating AssemblyBuilder (#48072)

Added the ability to use AssemblyLoadContext.CurrentContextualReflectionContext when instantiating AssemblyBuilder

[mono] Adjust wasm gitignore (#48325)

- move the responsibility of ignoring wasm files to the mono/wasm .gitignore

Trim assembly level attributes which are not useful and can contain (#48301)

very long string value

Update runparallel.sh for Apple Silicon bringup (#46935)

Use syntax available on OSX

Stabilize counting

Simplify termination logic

Simplify polling intermediate results

JIT: allow inlinee profile scale-up (#48280)

We can't always be sure that callee entry counts will be greater than or equal
to call site counts. For example a callee could be tiered up before a caller,
and so have relatively smaller counts.

So, when computing inline scale, allow callee counts to be scaled up as well as
scaled down.

Remove some code duplication in System.Net.Http.Headers (#48297)

* Remove some code duplication in System.Net.Http.Headers

* Update src/libraries/System.Net.Http/tests/UnitTests/Headers/NameValueHeaderValueTest.cs

Co-authored-by: Karel Zikmund <karelz@microsoft.com>
* Apply suggestions from code review

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

Add missing XML comments on PriorityQueue public API (#48316)

Avoid QueueUserWorkItem allocation in rare Channel race condition (#48313)

Fix typo endinanness -> endianness (#48319)

Simplify PriorityQueue enumerator, and fix tuple element names (#48315)

- Rewritten to match `List<T>.Enumerator` line for line
- Tuples, according to our guidelines, use PascalCased element names

Expand Virtual Call targets earlier in Morph and allow CSE of the indirections (#47808)

* Added GTF_CALL_M_EXPANDED_EARLY to flag virtual calls that should be expanded early during fgMorph
Added COMPlus_JitExpandCallsEarly variable to enable virtual calls to be expanded early on a per method basis
Set opts.compExpandCallsEarly to true when we are optimizing and have COMPlus_JitExpandCallsEarly enabled
Update gtSetEvalOrder to also include the call->gtControlExpr
Update morph to call fgExpandVirtualVtableCallTarget when we are expanding early
Update lower to not call LowerVirtualVtableCall when we have already expanded it early
Modify CheckTreeId to print the duplicated gtTreeID before it asserts.

All tests are passing when using COMPLUS_JitExpandCallsEarly=*

Expand the Virtual Call target after we morph the args
Fix an inadvertent change in the GT_CALL weights

* Changed the default for Virtual calls to be expanded early in Morph
Use COMPlus_JitExpandCallsEarly=0 to disable and use old behavior

* Code Review feedback
Added comment stating the the isRelative code path is never executed

* Fixes for propagating gtControlExpr->gtFlags

* Fix a few code size regressions when we perform a tail call

* Tailcall lower fix

* Code Review changes

* Fixes for the TAILCALL_HELPER path for x86

* Address the Arm/Linux failure

Allow the icu native code to be linked out when invariant globalization is enabled. (#48120)

* Disable the dynamic loading of icu functions on WASM.

* Preserve GetICUVersion using a DynamicDependency attribute so its only preserved for the tests which need it.

* Add GetICUVersion to .LibraryBuild.xml so its retained during the class libs build.

* Set InvariantGlobalization based on WasmInvariantGlobalization.

* Fix the framework build.

* Avoid linking in the libicu libraries on wasm in invariant mode.

* Move ICU tests dependency to libraries build descriptor file

* Hook up the shared file in the build

* Fix conditionals.

* Remove WasmInvariantGlobalization msbuild variable.

Co-authored-by: Marek Safar <marek.safar@gmail.com>

[master] Update dependencies from dotnet/runtime dotnet/xharness (#48303)

[master] Update dependencies from dotnet/runtime dotnet/xharness

Add PriorityQueue to System.Collections.Generic (#43957) (#46009)

* Add PriorityQueue to System.Collections.Generic (#43957)

This commit adds a new data structure, priority queue.

Fixes #43957

* (draft step, to squash) Modify API reference

In this commit, I modified the API reference using [these guidelines](https://github.com/dotnet/runtime/blob/4d784693ebc5f91c7eede32170046355ef3969b2/docs/coding-guidelines/updating-ref-source.md), following the advice from @danmosemsft.

The automatically generated code (with `dotnet msbuild /t:GenerateReferenceAssemblySource`) didn't build out of the box and I tweaked it manually.

* (draft step, to squash) Add tests for PriorityQueue

Added generic tests for <int, int> and <string, string>. Removed non-generic tests.

* (draft step, to squash) Add initial implementation

This commit adds the core of the heap implementation for the priority queue.

It doesn't implement the method `EnqueueDequeue`, as I'm not convinced by it. It also doesn't implement the method `CopyTo(Array array, int index)`, leaving this one for later.

* (draft step, to squash) Rename parameters

* (draft step, to squash) Replace `this.nodes` with `_nodes`

* (draft step, to squash) Use an array and handle sizing ourselves

* (draft step, to squash) Create UnorderedItemsCollection lazily

* (draft step, to squash) Deduplicate constructors

* (draft step, to squash) Replace excessive `var` with explicit types

* (draft step, to squash) Remove `this.` in front of methods

* (draft step, to squash) Improve out-of-range-argument exceptions

* (draft step, to squash) Use error messages from .resx

* (draft step, to squash) Use positive case first in try methods

* (draft step, to squash) Implement UnorderedItemsCollection.CopyTo

* (draft step, to squash) Optimize expressions involving Arity

* (draft step, to squash) Adjust implementation to be consistent with reference

* (draft step, to squash) Implement method `EnqueueDequeue`

* (draft step, to squash) Make EnsureCapacity return int

* (draft step, to squash) Simplify lazy initialization of _unorderedItems

* (draft step, to squash) Use `out _` discard for unused properties

* (draft step, to squash) Relax null checks on elements and priorities

* (draft step, to squash) Simplify method SetCapacity

* (draft step, to squash) Remove MethodImplOptions.AggressiveInlining attributed

* (draft step, to squash) Use Array.Empty if the initial capacity is zero

* (draft step, to squash) Simplify UnorderedItemsCollection.Enumerator declaration

* (draft step, to squash) Simplify GetEnumerator methods

* (draft step, to squash) Optimize EnqueueRange methods

* (draft step, to squash) Capitalize members of (TElement, TPriority)[]

* (draft step, to squash) Improve resize constants

* (draft step, to squash) Remove redundant `.this`

* (draft step, to squash) Optimize EnqueueDequeue

* (draft step, to squash) Reduce indentation

* (draft step, to squash) Simplify math expressions

* (draft step, to squash) Remove the PutAt helper method

* (draft step, to squash) Make the UnorderedItemsCollection constructor internal

* (draft step, to squash) Clear last node slot on removal

* (draft step, to squash) Improve next growth capacity computation

* (draft step, to squash) Optimize Enqueue method

* (draft step, to squash) Make UnorderedItemsCollection.CopyTo implemented explicitly on ICollection

* (draft step, to squash) Improve priority queue tests

* (draft step, to squash) Drop redundant casting

* (draft step, to squash) Cosmetic improvements

* (draft step, to squash) Change signature of UnorderedItemsCollection

* (draft step, to squash) Add test PriorityQueue_Generic_EnqueueDequeue_EqualToMin

* (draft step, to squash) Add tests of enqueue null functionality

* (draft step, to squash) Add test PriorityQueue_Generic_EnsureCapacity_Negative

* (draft step, to squash) Check underlying buffer length in tests with reflection

* (draft step, to squash) Check enumeration invalidation

* (draft step, to squash) Simplify code and improve documentation

Add Enumerable.TryGetNonEnumeratedCount (Implements #27183) (#48239)

* implement Enumerable.TryGetEnumeratingCount

* address feedback

* update consistency tests

* Replace EnumerableHelpers.TryGetCount with new method

* Rename to method name as approved

* make method is renamed in all projects

[browser][build] Synchronize emsdk version with build tools docker version (#48300)

- version specified here:  https://github.com/dotnet/dotnet-buildtools-prereqs-docker/blob/master/src/ubuntu/18.04/webassembly/Dockerfile#L19

[master] Update dependencies from mono/linker (#48298)

[master] Update dependencies from mono/linker

Follow-up to Enumerable.Min/Max Comparer<T>.Default optimization (#48289)

I didn't notice the same pattern was employed in the `Func<TSource, TResult>` overloads, so changing them, too.

Update dependencies from https://github.com/dotnet/xharness build 20210215.1 (#48299)

[master] Update dependencies from dotnet/xharness

map Interop.Sys.LockType to distro-specific values (#47994)

* the managed enum Interop.Sys.LockType has no 1:1 mapping with corresponding Unix values

which can be different per distro:
https://github.com/torvalds/linux/blob/fcadab740480e0e0e9fa9bd272acd409884d431a/arch/alpha/include/uapi/asm/fcntl.h#L48-L50
https://github.com/freebsd/freebsd-src/blob/fb8c2f743ab695f6004650b58bf96972e2535b20/sys/sys/fcntl.h#L277-L279

fixes #26726

Fix violation in System.Private.DataContractSerialization (#48274)

- Prefer 'AsSpan' over 'Substring' when span-based overloads are available.

Use 'AsSpan' over 'Substring' in 'System.Private.Xml' (#48277)

* Fix violation in System.Private.Xml

- Prefer 'AsSpan' over 'Substring' when span-based overloads are available.

* Update src/libraries/System.Private.Xml/src/System/Xml/Serialization/CodeIdentifier.cs

Apply suggested optimization.

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

Use size_t for hostfxr info count members (#48276)

Unset FEATURE_EVENTSOURCE_XPLAT in macOS builds (#48244)

SPMI: adjust near differ offset compare logic (#48245)

Add a clause that maps result1 and result2 offsets to a common base and
then compares that result.

This fixes some noisy diffs from instrumented Tier0 compiles, where the
probe addresses can vary from run to run.

Optimize Enumerable.Min/Max<T> with Comparer<T>.Default intrinsic (#48273)

Memorify DeflateManagedStream in System.IO.Compression (#48085)

Remove dead code (#48241)

* Remove unnecessary dead creds from S.DS.AM

* Remove hardcoded test cred from process

* remove invalid param

* Update src/libraries/System.Diagnostics.Process/tests/ProcessStartInfoTests.cs

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

skip SslStream_ClientCertificate_SendsChain test if chain is not valid (#48261)

* skip SslStream_ClientCertificate_SendsChain test if chain is not valid

* make test conditional

Update dependencies from https://github.com/dotnet/runtime-assets build 20210212.1 (#48268)

[master] Update dependencies from dotnet/runtime-assets

Move corehost under src/native (#48071)

* Move corehost under src/native

* Move content out of cli/ directory

* Update configurations post-move

* Update docs

[mono] Remove the unused attach support. (#48262)

[master] Update dependencies from mono/linker (#48231)

[master] Update dependencies from mono/linker

Add typeforwards for Stack<T> and Queue<T> to mscorlib shim (#48258)

Old Xamarin implemented these types in mscorlib so we need to add typeforwarders for them.

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

[wasm][bindings] Treat null string as null when converting (#47341)

* Treat null string as null objects

Mono: Remove remoting code. (#48227)

* Remove remoting code.

* Remove more unused code.

Add hostfxr_get_dotnet_environment_info API (#48097)

* Add hostfxr_get_dotnet_environment_info

* Change access modifiers in structs

* Remove unnecessary context local

* Use global install location if no dotnet_root is specified

* Add framework tests

* Update framework_info comparison

* Remove commented code

* Remove unnecessary marshaling
Export fn

* Add hostfxr_get_dotnet_environment_info to hostfxr exports

* Fail if result is nullptr
Validate size of structs
Test that result_context isn't modified

* Remove version_as_str
Update tests

* Add tests for invalid args