Add more advanced SafeArray tests (dotnet/coreclr#21063)

* Port simple SafeArray tests over from .NET Framework's test suite.

* Clean up native calling conventions.

* Add basic field array -> field SAFEARRAY* tests.

* Fix some hiding stdcall calling convention decorators.

* PR Feedback.

* Rewrite native part of SafeArray tests

* Wrote the managed side of the tests. Non-passing ones are currently commented out.

* Fix up tests and enable marshalling a string[] as a SAFEARRAY of LPSTR or LPWSTR.

* Add blittable records test with a return parameter.

* Add returning non-blittable record safearray test.

* Fix which typedef we're using

* Clean up

* Fix/cleanup RecordNative

* Replace "" with <> for platformdefines.h include.

* Use macro for calling convention.

* PR Feedback.

* Remove residual "Helpers.h" include.

* Fix remaining incorrect calling conventions.

* One more calling convention fix.

Commit migrated from https://github.com/dotnet/coreclr/commit/93d3f4c1f7f8a27c94aad68837dc8dda30c19b02

Fix build parallelism on Windows with NUMA (dotnet/coreclr#21278)

When multiple NUMA nodes are enabled on the machine where coreclr is
built, we incorrectly detect the number of cores that we use for build
parallelism of the native part of the build (NumberOfCores) as only
a number in the last NUMA node.
The reason is that the `wmic cpu get NumberOfCores /value` returns
multiple lines, one per each NUMA node.
This change fixes it by summing values from all the lines.

Commit migrated from https://github.com/dotnet/coreclr/commit/0cc4b0c3e6207fcae9ffde81096f86c40d2634b4

Don't treat the Vector64/128/256<T> helper methods as intrinsic if featureSIMD is disabled (dotnet/coreclr#21274)

Commit migrated from https://github.com/dotnet/coreclr/commit/2c13fb067b511bfdd3d054b63314292fcb0eebc7

Merge pull request dotnet/coreclr#21267 from BruceForstall/FixExclusion

Fix ObjectStackAllocationTests on Linux under minopts

Commit migrated from https://github.com/dotnet/coreclr/commit/02349db7f651061127136443611276da31fcb272

publish symbols on FreeBSD (dotnet/coreclr#21179)

* enable build-id on FreeBSD

* start publishing symbols for freebsd

* enable FEATURE_PERFMAP on FreeBSD

Commit migrated from https://github.com/dotnet/coreclr/commit/6120021023647ff881d791a033dba38a94fd1c2c

Updating genSIMDZero to only use `xorps` (dotnet/coreclr#21249)

Commit migrated from https://github.com/dotnet/coreclr/commit/5feb0389f1e1ba715fba5560c979ac6362b1bcf8

Track single def locals in importer (dotnet/coreclr#21251)

* Defer setting lvSingleDef until lvaMarkLocalVars

Since this information isn't used early on in the jit, defer setting this bit
until later.

* Track single-def locals in the importer

and use this information to enable type updates during late devirtualization.
This gets some cases where the exact type materializes late (perhaps via a
chain of copies).

Commit migrated from https://github.com/dotnet/coreclr/commit/40bf810b5cb83ba45008f9f8c12a4e3d46eb6832

Fix dotnet/coreclr#21209 (dotnet/coreclr#21237)

This commit has two changes to Native Load Library Tests fix the failures in:
https://github.com/dotnet/coreclr/issues/21209

1) Windows: The test tried to load a DLL from Win32 directory which doesn't exist
   in Windows server 2016. So changed to use a file that exists.
2) Linux: Disable the test when run against packages -- because in this configuration
   the tests are built on Windows, and the native DLL is built separately and copied
   over to the CORE_ROOT directory instead of the test directory.
   [Several other tests are disabled with the comment "Issue building native DLL" on Linux]

Commit migrated from https://github.com/dotnet/coreclr/commit/0a0bcebae483b434c70875707c0eb1a493eb2e66

Add IsCollectible property to Memberinfo and MethodInfo (dotnet/coreclr#21155)

Commit migrated from https://github.com/dotnet/coreclr/commit/b53d00dcc24149ee84ad8cfa9c23b253d8cf65e0

Improve Enum.ToString perf for [Flags] enums (dotnet/coreclr#21254)

Two main changes:
- Rather than using a StringBuilder to insert the strings for all of the consistuent values, we track the constituent values in a span, summing the expected length, and then new up a string and copy the results directly into it.
- When there's a single value that matches the supplied value, we just return the cached string rather than allocating a new one.

Commit migrated from https://github.com/dotnet/coreclr/commit/effe7cafdb828fc90ec7bbd09ae8b3c259a76eb0

Remove obsolete assert (dotnet/coreclr#21260)

Commit migrated from https://github.com/dotnet/coreclr/commit/63b23cff8a93f834c61555960cbd724ba2276376

Delete code related to LoaderOptimization and SharedDomain (dotnet/coreclr#21031)

Commit migrated from https://github.com/dotnet/coreclr/commit/b6d47b3a1b5b05c25968701615707e381f35a7ce

Fix ObjectStackAllocationTests on Linux under minopts

Fix the capitalization of COMPlus_JITMinOpts variable, which
is case-sensitive on Linux.

Fixes dotnet/coreclr#21266

Commit migrated from https://github.com/dotnet/coreclr/commit/4f0429c2042c97e646695dcdf724a09dae439168

Queue ValueTaskAwaiter IAsyncStateMachineBox directly to ThreadPool (dotnet/coreclr#21159)

* Queue ValueTaskAwaiter IAsyncStateMachineBox directly to ThreadPool

* Invert the dependency

* Move to UnsafeQueueUserWorkItem

* MRVTSC queue null or Deafult EC to UnsafeQUWI

* Revert MRVTSC change

* Add comment and validation

* Use s_invokeAsyncStateMachineBox for AsTask

* nits

* nits 2

* Rever ValueTask

* nits

Commit migrated from https://github.com/dotnet/coreclr/commit/e7ead79fedc52e17f2cf9befd5c0f5091d70f909

Update Helix queues used for testing

Commit migrated from https://github.com/dotnet/coreclr/commit/204d2da615347cb540c5fd36989953536d77140a

Merge pull request dotnet/coreclr#21217 from AndyAyersMS/Fix21051

JIT: retype some return expressions

Commit migrated from https://github.com/dotnet/coreclr/commit/bd299c48e2dcf92c6eee19a9ab214000a1752bad

Merge pull request dotnet/coreclr#21226 from AndyAyersMS/HandleMoreGeneralIndirInJmpAddr

JIT: handle general indir case for GT_JMP address

Commit migrated from https://github.com/dotnet/coreclr/commit/86e45c8f293405fc3d7a248dde6d2574b4977f06

Switch to preemptive mode before calling COM (dotnet/coreclr#21238)

* Switch to preemptive mode before calling COM

COM can call back the runtime via RCW that leads to contract violations

Fixes dotnet/coreclr#20373

* Fix one places

Commit migrated from https://github.com/dotnet/coreclr/commit/4d4d028a67ac91b8b7c07d55b6376d16b1c512f2

 Delete test dev10_630880 (dotnet/coreclr#21239)

* Revert "Disable test Dev10_630880"

This reverts commit dotnet/coreclr@4fb76de35184fb80054f29779f51af82a4aa7ad8.

* Delete test dev10_630880

This test has been exercising internal CoreLib details that have been deleted.

Commit migrated from https://github.com/dotnet/coreclr/commit/f7c46a3847ded886135e055962e0d9136fdb77d9

Merge pull request dotnet/coreclr#21204 from briansull/issue_20185

Change VNUnpackExc to always write an exception set

Commit migrated from https://github.com/dotnet/coreclr/commit/841b61bf2c74ae00665295dfc53225e4a5fa91a5

exclude tests\src\Interop\COM\NativeClients\Primitives from GCStress runs. (dotnet/coreclr#21222)

* exclude tests\src\Interop\COM\NativeClients\Primitives.csproj from GCStress runs.

* fix alignment

Commit migrated from https://github.com/dotnet/coreclr/commit/76467c9bd38acdecc891148e24be10bda4327da0

Fixing up Utf8Parser.TryParseNumber to not fail for overly large exponents (dotnet/coreclr#21233)

Commit migrated from https://github.com/dotnet/coreclr/commit/e91cbf40efb743a859646e841ea168599dbd957e

Implement the S.R.I.VectorXXX `get_Zero` and `As` helper methods as JIT intrinsics (dotnet/coreclr#21198)

* Remove ARM64_SIMD_StaticCast intrinsic and the x86 TwoTypeGeneric flag

* Implementing the `S.R.Intrinsic.VectorXXX.As` methods as runtime intrinsics

* Implementing the get_Zero method on the S.R.Intrinsic.VectorXXX types as runtime intrinsics

Commit migrated from https://github.com/dotnet/coreclr/commit/42ac3d30b1d8310e13eab6f42cc754fa53c5a01d

Improve performance of cgroup access (dotnet/coreclr#21229)

Currently, we create a CGroup instance on each request for getting
used or total physical memory. This has an extra cost of finding
filesystem paths of the current cgroup files. I have found that
if we do the initialization just once, the performance of getting
the used or total memory in a tight loop improves 22 times.

Accidentally, I was also looking into a perf regression in the
ByteMark.BenchBitOps test that was observed in the past, seemingly
related to the recent change to the way we get the used memory.
And I've found that the benchmark results improve two fold with
the change in this commit.

This change was made both in PAL and in the standalone GC.

Commit migrated from https://github.com/dotnet/coreclr/commit/4a6753dcacf44df6a8e91b91029e4b7a4f12d917

Fix ILStubCache allocation for collectible assemblies (dotnet/coreclr#21188)

The ILStubCache was being allocated per domain unless the domain was a
compilation AppDomain. This is wrong for collectible assemblies, since
after an assembly is collected, the cache keeps stale entries referring
to already deleted MethodTables.
The fix is to make ILStubChange per LoaderAllocator instead (and keep
the per module instances for compilation AppDomain).

Commit migrated from https://github.com/dotnet/coreclr/commit/8aa0869eb9153429091fdba49469d89ec33092cb

Merge pull request dotnet/coreclr#21234 from BruceForstall/Disable630880

Disable test Dev10_630880

Commit migrated from https://github.com/dotnet/coreclr/commit/c7c166e33c807d938367d0364850fe7af1c7b835

Move all the math functions undef #ifndef PAL_STDCPP_COMPAT (dotnet/coreclr#21170)

Bug: 20786

Commit migrated from https://github.com/dotnet/coreclr/commit/8ec20d2b0d500ad62ea18373a7ab581945c9c655

Disable test Dev10_630880

It was made obsolete by https://github.com/dotnet/coreclr/pull/21157

Commit migrated from https://github.com/dotnet/coreclr/commit/4fb76de35184fb80054f29779f51af82a4aa7ad8

Code review feedback

Commit migrated from https://github.com/dotnet/coreclr/commit/cef6c7bd334583066ed28e4bf813f75c40b66dce

Disable failing Linux/arm32 corefx tests (dotnet/coreclr#21225)

* Disable failing Linux/arm32 corefx tests

Commit migrated from https://github.com/dotnet/coreclr/commit/8f16d66c9c6544f3cc2e234eda242e11ca4ad89d

Update changing-corelib.md (dotnet/coreclr#21220)

* Update changing-corelib.md

@jkotas

* Update changing-corelib.md

Commit migrated from https://github.com/dotnet/coreclr/commit/c98155df54da9247e598068cc956dfe9aede610e

Diff-able disassembly fixes (dotnet/coreclr#20863)

Commit migrated from https://github.com/dotnet/coreclr/commit/3766ae3f90fa8cb9bc5ae28370b45053ce85248b

JIT: handle general indir case for GT_JMP address

Some upcoming changes to reduce tiering overhead require that directly
invoked virtual methods be called indirectly via their slot, so that the
method body can be updated and callers patched up by patching the method
table slot.

Existing code for x64 implicitly assumes that a GT_JMP indirect target address
is near enough to the call site that a 32 bit RIP-relative displacement will
work. We can ensure this is true by always generating a reloc (and hence
potentially a jump stub) -- unless the target happens to fit in 32 bits and
so can be addressed absolutely.

Commit migrated from https://github.com/dotnet/coreclr/commit/8c6a9e003feffbd798d6cdbbb5f89b170d75e05d

remove workaround comments

Commit migrated from https://github.com/dotnet/coreclr/commit/441c3b8af2b80a7550bc3872d1105bca569a7471

Merge pull request dotnet/coreclr#21151 from CarolEidt/Fix21080

Use LclFld for full-width cpblk of different types

Commit migrated from https://github.com/dotnet/coreclr/commit/2fa65846af4b98293b407656fa7d0837c390215f

JIT: retype some return expressions

The jit is fairly tolerant of byref/native int mismatches for inline arguments
and return values. And some of the new unsafe helpers do this kind of
reinterpretation across call boundaries as well. This sometimes leads the jit
to lose track of byrefs.

A general fix for this is likely somewhat involved. For now we simply detect if
we're about to lose track of a byref when substituting a particular kind of
return expression, and retype the expression to a byref.

Fixes dotnet/coreclr#21051.

Commit migrated from https://github.com/dotnet/coreclr/commit/3bc2f7a800498135a1c1575b01d0f5d1113d9acd

Use local array in ConcurrentQueue<T> for small perf improvement (dotnet/coreclr#21192)

Enqueue/TryDequeue/TryPeek are all repeatedly accessing the same array from a readonly field.  Changing them to instead access that same array but from a cached local results in an ~10% throughput boost on a microbenchmark that does uncontended reads/writes of objects from/to the queue. (I also tried using a ref local to point directly to the target slot in the array, but that actually resulted in a measurable regression.)

Commit migrated from https://github.com/dotnet/coreclr/commit/e41401ed9c1070971d2062e971fed14d1747be78

Improve perf for Index based span indexers (dotnet/coreclr#21196)

First, evaluate the actual index before invoking the underlying int indexer,
so that the jit doesn't think the span is address taken.

Second, improve the jit's ability to remove some redundant comparisons like
those that arise in computing the actual index.

Commit migrated from https://github.com/dotnet/coreclr/commit/b01b2b8030f363368530b8a1395d604179e8d0e4

Fix a use after free for Managed Data BP (dotnet/coreclr#21205)

ShimProxyCallback::DataBreakpoint::DataBreakpointEvent was holding onto a bare
BYTE* for the CONTEXT rather than copying the buffer and taking ownership. Due to
lifetime, this resulted in a use after free. Apparently in retail code we got lucky
and this worked enough of the time that we never noticed it.

Commit migrated from https://github.com/dotnet/coreclr/commit/870267fac0b16ac246d6ba01f49ba4c6acd2319c

Fix Rune.ToUpper / ToLower under GlobalizationMode.Invariant (dotnet/coreclr#21203)

Commit migrated from https://github.com/dotnet/coreclr/commit/6af3c5dd51a2e6411d32fdbf2645ec0ea68b36ff

Disable noncollectible alc finalization (dotnet/coreclr#21189)

* Disable noncollectible AssemblyLoadContext finalization

The constructor of AssemblyLoadContext was missing a call to
GC.SuppressFinalize for non-collectible AssemblyLoadContext. That means
that the finalizer can be executed and unloading being initialized even
for non-collectible AssemblyLoadContext.
This change fixes that.

* SuppressFinalize non-collectible AssemblyLoadContext

The finalizer for the non-collectible AssemblyLoadContext is never
called and so it should not be in the finalization queue.

* Handle finalizer call without constructor executed

Check if the constructor was executed before we run the finalizer code.

Commit migrated from https://github.com/dotnet/coreclr/commit/ac732ffb6d2ff4d2bec72ac5ca0785ace4ace20a

Disable domain neutral loading (dotnet/coreclr#21156)

Commit migrated from https://github.com/dotnet/coreclr/commit/c928bf4f3cf411bc775d5ec5098a122eada48ba9

Deleting a format.patch file that got checked in (dotnet/coreclr#21202)

Commit migrated from https://github.com/dotnet/coreclr/commit/19b6763f5dd71aee1d99d129f6009aee398aaf60

Update documentation for changing CoreLib (dotnet/coreclr#21201)

Commit migrated from https://github.com/dotnet/coreclr/commit/355e1895793ced0583b1b688c5b0491074bfeafe

Use LclFld for full-width cpblk of different types

This issue arose because the source tree was a struct with a single double field, and the destination was a struct with a single long field. Copy prop replaced the lclVar in the source, which was under a `IND(ADDR)` with a lclVar that was not address taken, although it was marked `GTF_DONT_CSE`. Replacing the src tree with a `GT_LCL_FLD` addresses this issue.

Also, ensure that the target is marked `DoNotEnregister` if it isn't referenced as the same size/type.

Fix dotnet/coreclr#21080
Fix dotnet/coreclr#21064

Commit migrated from https://github.com/dotnet/coreclr/commit/0c08dc461f4dd7ac418a475264129d2c57536955

Merge pull request dotnet/coreclr#21184 from mikedn/load-norm

Fix normalize on load handling in assertion propagation

Commit migrated from https://github.com/dotnet/coreclr/commit/a04233f12ff63f99b7affe2936567c1157e6502e

Fix issue 20185
Change VNUnpackExc to always write an exception set to pvnx

Commit migrated from https://github.com/dotnet/coreclr/commit/0107b6cba52c55f18346b3730ac8a259af16721d

Fix Azure DevOps endpoint (dotnet/coreclr#21038)

* Delete incorrect resources section

Remove reference to arcade repo

Commit migrated from https://github.com/dotnet/coreclr/commit/c24e4767ab2435c7b032af6ed24fae9bcd03ff72

Updating runtest.py to support printing coredump information (dotnet/coreclr#21149)

* Updating runtest.py to support printing coredump information

* Adding some comments to the coredump collection methods in runtest.py

Commit migrated from https://github.com/dotnet/coreclr/commit/63cde8f0f419b45426bc9ba9aa06962ced03daf8

Fixing a few small issues with the SIMD vs SIMD HWIntrinsics (dotnet/coreclr#21097)

* Fixing the simdHandleCache to add entries for Vector64FloatHandle and Vector128FloatHandle

* Fixing two places that were calling just OperIsSIMD() rather than OperIsSIMDorSimdHWintrinsic()

Commit migrated from https://github.com/dotnet/coreclr/commit/570bda3870a8c3b479384b21e1e1bdd427fdd3a1

Merge pull request dotnet/coreclr#21194 from mmitche/fix-debug-checked

Don't attempt to sign xstate in debug/checked builds

Commit migrated from https://github.com/dotnet/coreclr/commit/e7d079a2533d226b1fad301a0fbf7ba3ab25d0de

Remove TypedReference.MakeTypedReference readonly restriction (dotnet/coreclr#21193)

TypedReference.MakeTypedReference validates that the fields aren't readonly, which limits our ability to make fields readonly in core while maintaining BinaryFormatter compatibility.  This restriction isn't useful for a variety of reasons, though: reflection allows readonly fields to be set, but more importantly, TypedReference.SetTypedReference has always thrown NotSupportedException, so it's not even actually usable.

This change just removes the readonly check from MakeTypedReference.

Commit migrated from https://github.com/dotnet/coreclr/commit/a6729dab35fde5d50fb12b06aeb77d3e1f3be872

Merge pull request dotnet/coreclr#21164 from kvochko/no_hw_intrinsics_x86

[x86] Do not support hardware intrinsics on x86 unix

Commit migrated from https://github.com/dotnet/coreclr/commit/4a9b5737d8e28093a14d885f735f3eb20722c8e2

Handle the remaining known issues (modulo snan) with the double/single parsing logic (dotnet/coreclr#21036)

* Fixing the double/single parser to return negative zero for `-0`

* Updating the Utf8Parser to allow exponents of arbitrary length

* Updating the double/single parser to support case-insensitive and signed infinity/nan

* Ensure TryParseAsSpecialFloatingPoint handles the case where we have an empty source

* Fixing the number parser to allow `-0` for decimal and to not parse '++infini'

Commit migrated from https://github.com/dotnet/coreclr/commit/1ebc1a9deb24bdb82a0a28afb2f6e853bfa0bf8f

Tar arm build outputs to workaround unicode issues (dotnet/coreclr#21127)

Commit migrated from https://github.com/dotnet/coreclr/commit/a1e65761b6cd64b391c2f0ee4da1b219f93c5d33

Don't attempt to sign xstate in debug/checked builds

Commit migrated from https://github.com/dotnet/coreclr/commit/119c45de4b2972e48bf642103fb502822a9d8bdd

Don't generate copy assertions for normalize on load variables

Commit migrated from https://github.com/dotnet/coreclr/commit/8e6fa5df402299d833f382679ecf31687f7237a2

Add test for 18867

Commit migrated from https://github.com/dotnet/coreclr/commit/8cfbd3381e658485477522ba47d00e19057e0d72

Fix Interop/PInvoke/Miscellaneous/HandleRef tests under GCStress (dotnet/coreclr#21131)

* Add GC.KeepAlive call in the IL stub when marshalling a HandleRef.

* Add a GC.KeepAlive call for the BoxedInt since it isn't kept alive when running GC Stress

* Reference HandleRef._handle via the binder instead of by field offset arithmetic

* Alignment

* Use Marshal.Alloc/FreeHGlobal instead of the weird no-pinning machinery that was failing before

* Update HandleRefTest.cs

Commit migrated from https://github.com/dotnet/coreclr/commit/d07633f53b51a30d294c4afe2b0b7ba5b563c134

Fixing typo (dotnet/coreclr#21081)

Commit migrated from https://github.com/dotnet/coreclr/commit/84a62b1925adee9b8979b36f52834d0cca5d0469

Refactor AppDomain.IsAppXModel and a few other AppDomain methods (dotnet/coreclr#21181)

Contributes to dotnet/coreclr#21028

Commit migrated from https://github.com/dotnet/coreclr/commit/5be7421c75b2bea031ecac44a9c8e304eb4d1850

Move AppDomain local data store to AppContext and cleanup AppContext (dotnet/coreclr#21180)

Contributes to dotnet/coreclr#21028

Commit migrated from https://github.com/dotnet/coreclr/commit/55d1363ac36735008dee4d11e10934b8ee94e80b

Don't assume objects don't escape in pure helpers.

We can't assume objects don't escape in helpers marked as pure for the following reasons:

1. The helpers may call user code that may make objects escape, e.g.,
https://github.com/dotnet/coreclr/blob/dotnet/coreclr@c94d8e68222d931d4bb1c4eb9a52b4b056e85f12/src/vm/jithelpers.cpp#L2371

2. The helpers usually protect gc pointers with GCPROTECT_BEGIN() so the pointers are reported as normal pointers to the gc.
Pointers to stack-allocated objects need to be reported as interior so they have to be protected with
GCPROTECT_BEGININTERIOR().

3. The helpers may cause these asserts in ValidateInner on stack-allocated objects:
https://github.com/dotnet/coreclr/blob/dotnet/coreclr@c94d8e68222d931d4bb1c4eb9a52b4b056e85f12/src/vm/object.cpp#L723
https://github.com/dotnet/coreclr/blob/dotnet/coreclr@c94d8e68222d931d4bb1c4eb9a52b4b056e85f12/src/vm/object.cpp#L730

Commit migrated from https://github.com/dotnet/coreclr/commit/65f88672f888e893a44f21b59ecfd87f4d17e499

Fix debugger collectible thread statics access (dotnet/coreclr#21175)

The CordbClass::GetStaticFieldValue2 was missing support for accessing
thread statics in collectible classes. Fortunately the fix was simple,
we can use the same code path as for non-collectible thread statics.

Commit migrated from https://github.com/dotnet/coreclr/commit/b5c9edd9ea63639328ec587003f97922b80ef029

Update CoreClr, CoreFx, CoreSetup, PgoData to preview-27123-02, preview.18573.2, preview-27123-01, master-20181123-0042, respectively (dotnet/coreclr#21158)

Commit migrated from https://github.com/dotnet/coreclr/commit/c385d44dcdc62118a4556f002516db1b5bdcdf37

Typos (dotnet/coreclr#21171)

* accesible -> accessible

* acheive -> achieve

* actutl -> actual

* appied -> applied

* apropriate -> appropriate

* aprox -> approx

* aquired -> acquired

* argumemts -> arguments

* Argumens -> Arguments

* argumetn -> argument

Commit migrated from https://github.com/dotnet/coreclr/commit/445f68f3668daa527adad6f2bdd1311f2607ca71

Delete System.AppDomainSetup (dotnet/coreclr#21157)

* Delete System.AppDomainSetup

Contributes to dotnet/coreclr#21028

* Add test hook for null entry assembly

* Validate that the binder paths are absolute

Commit migrated from https://github.com/dotnet/coreclr/commit/e54dffef08c22a94962aacd93d4793b377cac632

Mark the String.Empty field as Intrinsic (dotnet/coreclr#21162)

This is required so that the CPAOT compiler can recognize this field as a RyuJIT intrinsic.

Commit migrated from https://github.com/dotnet/coreclr/commit/f80f9d5435155cc7a36fbaefa3c8d7da7cc309aa

Narrow the assert in fgLateDevirtualization (dotnet/coreclr#21163)

As suggested by Andy in dotnet/corertdotnet/coreclr#6601.

Commit migrated from https://github.com/dotnet/coreclr/commit/00279ca6204b581fed9347a24929f28d74737384

Do not support HW intrinsics on x86 linux

Commit migrated from https://github.com/dotnet/coreclr/commit/7fb22aae05b15b8e3227d4349f1025b630bb86fb

Sequel to NativeLibrary API (dotnet/coreclr#21148)

Small changes to address furhter feedback:
 - Perform argument validation in the Marshall.cs instead of DllImport helpers
 - Improve doc comments.

Commit migrated from https://github.com/dotnet/coreclr/commit/5e4e286ea2bffa4a5cb2467721ed89f27959d253

Update CoreClr, CoreFx, CoreSetup to preview-27121-03, preview.18571.3, preview-27121-03, respectively (dotnet/coreclr#21142)

Commit migrated from https://github.com/dotnet/coreclr/commit/f572782d55b65f06306dfce7aed07c84e6671756

Single stepping out of the unsafe places (dotnet/coreclr#21135)

Commit migrated from https://github.com/dotnet/coreclr/commit/76bbf5c2b5732d31efac050f47f577c98675ff4a

Merge pull request dotnet/coreclr#21146 from AaronRobinsonMSFT/comtoclrworker_av

COMToCLRWorker AV

Commit migrated from https://github.com/dotnet/coreclr/commit/e96e4f75b2a3f67519d9419faee002be67cc8d95

Minor clean up in COMToCLRWorker

Commit migrated from https://github.com/dotnet/coreclr/commit/0f38161b1323d5fb20289290f0ef8e4d1b7188ce

Introduce Marshall.LoadLibrary API (dotnet/coreclr#20871)

Implement Native LoadLibrary API

This change commits the following changes:
1) Refactoring DllImport code to reuse LodLibrary by search for
   pInvoke and LoadLibrary cases
2) Implement the new Native Library API in System.Runtime.Interop.Marshall
3) Add tests for the new APIs

Commit migrated from https://github.com/dotnet/coreclr/commit/175ba1c0794958bb7d006544b87e00675de742fc

Disable object stack allocation verification under GCStress.

ObjectStackAllocationTests use GC.GetAllocatedBytesForCurrentThread to
verify object stack allocations. Under GCStress the vm may initiate additional
heap allocations in GCHeap::StressHeap (see the call to 'pGenGCHeap->allocate' below).

This change re-enables ObjectStackAllocationTests and updates then to not verify stack allocations under GCStress.
It's useful to run the tests even without the verification to catch crashes, gc asserts, etc.

```
if (Interlocked::Increment(&OneAtATime) == 0 &&
        !TrackAllocations()) // Messing with object sizes can confuse the profiler (see ICorProfilerInfo::GetObjectSize)
    {
        StringObject* str;

        // If the current string is used up
        if (HndFetchHandle(m_StressObjs[m_CurStressObj]) == 0)
        {
            // Populate handles with strings
            int i = m_CurStressObj;
            while(HndFetchHandle(m_StressObjs[i]) == 0)
            {
                _ASSERTE(m_StressObjs[i] != 0);
                unsigned strLen = (LARGE_OBJECT_SIZE - 32) / sizeof(WCHAR);
                unsigned strSize = PtrAlign(StringObject::GetSize(strLen));

                // update the cached type handle before allocating
                SetTypeHandleOnThreadForAlloc(TypeHandle(g_pStringClass));
                str = (StringObject*) pGenGCHeap->allocate (strSize, acontext);
                if (str)
                {
                    str->SetMethodTable (g_pStringClass);
                    str->SetStringLength (strLen);

                    HndAssignHandle(m_StressObjs[i], ObjectToOBJECTREF(str));
                }
                i = (i + 1) % NUM_HEAP_STRESS_OBJS;
                if (i == m_CurStressObj) break;
            }

            // advance the current handle to the next string
            m_CurStressObj = (m_CurStressObj + 1) % NUM_HEAP_STRESS_OBJS;
        }

        // Get the current string
        str = (StringObject*) OBJECTREFToObject(HndFetchHandle(m_StressObjs[m_CurStressObj]));
        if (str)
        {
            // Chop off the end of the string and form a new object out of it.
            // This will 'free' an object at the begining of the heap, which will
            // force data movement.  Note that we can only do this so many times.
            // before we have to move on to the next string.
            unsigned sizeOfNewObj = (unsigned)Align(min_obj_size * 31);
            if (str->GetStringLength() > sizeOfNewObj / sizeof(WCHAR))
            {
                unsigned sizeToNextObj = (unsigned)Align(size(str));
                uint8_t* freeObj = ((uint8_t*) str) + sizeToNextObj - sizeOfNewObj;
                pGenGCHeap->make_unused_array (freeObj, sizeOfNewObj);
                str->SetStringLength(str->GetStringLength() - (sizeOfNewObj / sizeof(WCHAR)));
            }
            else
            {
                // Let the string itself become garbage.
                // will be realloced next time around
                HndAssignHandle(m_StressObjs[m_CurStressObj], 0);
            }
        }
    }
    Interlocked::Decrement(&OneAtATime);
```

Commit migrated from https://github.com/dotnet/coreclr/commit/5ef00810b53dcb7cbc4f2cb152ca6af971284e82

Check for null on COM to CLR call if error occurs during thread instance get.

Commit migrated from https://github.com/dotnet/coreclr/commit/fac2d42c8c1546c87317675728e048961004a2ee

Change System.Object to ClassInterface.None (dotnet/coreclr#21137)

* Change System.Object to ClassInterface.None

Prevents .NET Framework legacy interfaces from leaking out.

Fixes https://github.com/dotnet/corefx/issues/33638

* Use AutoDispatch for System.Object

Commit migrated from https://github.com/dotnet/coreclr/commit/2079632dfbde7fd398375c201f37533209c4bc21

Fix Unix ARM JIT_MemCpy and JIT_MemSet (dotnet/coreclr#21141)

The functions were incorrectly using 4 byte loads to probe for
the address validity. While the comment on JIT_MemCpy requires
4 byte aligned address, it doesn't match the way JIT uses it and
the Windows version of the function works with unaligned addresses
too.
This bug was discovered as a crash in an application where the
JIT_MemCpy was called with count=2 and an address that was two
bytes below the end of a memory page where the following page
was not mapped.

Commit migrated from https://github.com/dotnet/coreclr/commit/9170c7f90a55befbd4b43db3a824479592a96eb7

Ensuring that gc_stress and gc_stress_c are marked global when writing, but not when reading (dotnet/coreclr#21128)

Commit migrated from https://github.com/dotnet/coreclr/commit/844aa45629e683d546e98e4a8bb5dd660f8dacae

Delete dead/unused code (dotnet/coreclr#21138)

Commit migrated from https://github.com/dotnet/coreclr/commit/c94d8e68222d931d4bb1c4eb9a52b4b056e85f12

Update CoreSetup, PgoData to preview-27121-02, master-20181121-0042, respectively (dotnet/coreclr#21136)

Commit migrated from https://github.com/dotnet/coreclr/commit/83e33a4f720fbee1ab5d64805092993ab2911abf

Update BuildTools, CoreClr, CoreFx, CoreSetup, IbcData, PgoData to preview1-03420-02, preview-27121-02, preview.18571.1, preview-27120-04, master-20181120-0045, master-20181120-0044, respectively (dotnet/coreclr#21045)

Commit migrated from https://github.com/dotnet/coreclr/commit/0197d4e9040c3081817d500150beb0f65cbc5672

Merge pull request dotnet/coreclr#21129 from mmitche/sign-xstat

Sign api-ms-win-core-xstate-l2-1-0.dll

Commit migrated from https://github.com/dotnet/coreclr/commit/510d09aeaa974c980c7fe797b1cfc03467a84612

Expose generic UnsafeQueueUserWorkItem (dotnet/coreclr#21125)

Commit migrated from https://github.com/dotnet/coreclr/commit/432cd0bc1410a1d2e721f729f93cbd27744ef354

Vectorize string.IndexOf(..., StringComparison.Ordinal) (dotnet/coreclr#21076)

* Vectorize string.IndexOf(..., StringComparison.Ordinal)

* Merge two IndexOf(..., int* matchLengthPtr)

* fix

2 callers expect value.Length == 0 to be tested first
3rd caller ReplaceCore doesn't allow a value.Length == 0 so moving it
first is ok

Commit migrated from https://github.com/dotnet/coreclr/commit/b526affff2190b05f3896933ea3dd3f6b02879dc

Vectorize Array.{Last}IndexOf<T>(...) for byte and char (dotnet/coreclr#21116)

* Vectorize Array.IndexOf<T>(...) for byte and char

* Also LastIndexOf

Commit migrated from https://github.com/dotnet/coreclr/commit/ba7d5ce44419bb419562d50ed1c720a3465dbf11

Merge pull request dotnet/coreclr#21058 from CarolEidt/FixVZeroUpper

Record AVX use for SIMD indirections

Commit migrated from https://github.com/dotnet/coreclr/commit/346167eac69662ff492e98429dc85d17fc117ee8

Sign api-ms-win-core-xstate-l2-1-0.dll
This file is only catalog signed in RS4.  Sign during the build. To achieve this copy the CRT binaries locally rather than referencing from the UCRT location directly.

Commit migrated from https://github.com/dotnet/coreclr/commit/557c8f0078b01a220077f02bc703c4a16c3e4e41

Remove remaining StringBuilder marshaling use from Corelib (dotnet/coreclr#21120)

* Remove remaining StringBuilder marshaling use from Corelib

- Unix globalization functions were using StringBuilder.  Replaced them with stackallocs, as the max sizes were all relatively small.
- Registry methods were declared to use StringBuilder, but these weren't actually used by corelib, and in fact, corefx isn't using StringBuilder with them either.  I've changed the definitions for now to use char[] instead (all the call sites are passing in null), and I'll fix up some corefx usage separately.
- Resource-related functions were using StringBuilder, and have been replaced with stackallocs, given reasonably small max buffer sizes.
- ExpandEnvironmentVariables was using a StringBuilder, but it's rewritten equivalent code in corefx is not.  For now I've copied the corefx function over to coreclr to replace the different implementation, but we can look at subsequently consolidating them into one.

* Address PR feedback

Commit migrated from https://github.com/dotnet/coreclr/commit/a9b57bd4fe194b30b3c6e9a85a316fc218f474be

Remove StringBuilder from HebrewNumber formatting (dotnet/coreclr#21122)

Rather than allocating a new StringBuilder, writing into that, getting its string, and then appending that string to another StringBuilder, we can just write directly to the original one.

Commit migrated from https://github.com/dotnet/coreclr/commit/5a0af055e4c39f4f49b7ff35141739dc3fda4f9f

Fix for dotnet/coreclr#21011: propagate GTF_DONT_CSE on comma returns

When a method returns a multi-reg struct, we set GTF_DONT_CSE on return local: https://github.com/dotnet/coreclr/blob/dotnet/coreclr@497419bf8f19c649d821295da7e225e55581cce9/src/jit/importer.cpp#L8783

Setting GTF_DONT_CSE blocks assertion propagation here:
https://github.com/dotnet/coreclr/blob/dotnet/coreclr@9d49bf1ec6f102b89e5c2885e8f9d3d77f2ec144/src/jit/assertionprop.cpp#L2845-L2848

In the test we have a synchronized method so we change the return node to
return a comma that include a call to HELPER.CORINFO_HELP_MON_EXIT.
If the rightmost comma expression doesn't have GTF_DONT_CSE,
assertion propagation is not blocked and we end up with this tree:

```
               [000040] -----+------                 /--*  CNS_INT   struct 0
               [000043] --C-G+------              /--*  COMMA     struct
               [000036] --C-G+------              |  \--*  CALL help void   HELPER.CORINFO_HELP_MON_EXIT
               [000032] L----+------ arg1 in x1   |     +--*  ADDR      long
               [000031] ----G+-N----              |     |  \--*  LCL_VAR   ubyte (AX) V03 tmp1
               [000033] -----+------ arg0 in x0   |     \--*  LCL_VAR   ref    V00 this
               [000041] -AC-G+------              *  COMMA     struct
               [000006] -----+-N----              |  /--*  LCL_VAR   struct V01 loc0
               [000039] -A---+------              \--*  ASG       struct (copy)
               [000037] D----+-N----                 \--*  LCL_VAR   struct V05 tmp3
```

Downstream phases can't handle struct zero return expressed as
```
               [000040] -----+------                 /--*  CNS_INT   struct 0
```

The fix is to propagate GTF_DONT_CSE to the rightmost comma expression
to block bad assertion propagation.

Fixes dotnet/coreclr#21011.

Commit migrated from https://github.com/dotnet/coreclr/commit/e80e04020c3281ec675817c4fff025a3e347353e

Fixing up some issues with the HWIntrinsic test templates (dotnet/coreclr#21104)

* Updating the VectorNotSupportedTest to throw on failure

* Updating the HWIntrinsic test templates to check success on a per-scenario basis

* Regenerating the templated HWIntrinsic tests

Commit migrated from https://github.com/dotnet/coreclr/commit/382874f3d574f256cda617cdc63916cecbf231aa

Replace custom AnsiToLower with more efficient ToLowerAsciiInvariant (dotnet/coreclr#21121)

Avoids all of the StringBuilder-related costs.

Commit migrated from https://github.com/dotnet/coreclr/commit/e5ff28022e99b391ca75867c1a378beee0e594f2

Delete CORCOMPILE_IMPORT_TABLE_ENTRY (dotnet/coreclr#21109)

Commit migrated from https://github.com/dotnet/coreclr/commit/cc5df16d722aa9ffed9f8e4f236a5077753f8ca0

Linux: FlushProcessWriteBuffers using membarrier when available (dotnet/coreclr#20949)

* Linux: FlushProcessWriteBuffers using membarrier when available

* Ensure __NR_membarrier is defined for x64 portable build.

* Define __NR_membarrier on all portable architectures

Commit migrated from https://github.com/dotnet/coreclr/commit/baee9b6c7c666a33e3f924a05a5f56eae134fe46

Adding some AggressiveInlining attributes to the Vector64/128/256 helper methods (dotnet/coreclr#21111)

Commit migrated from https://github.com/dotnet/coreclr/commit/dcc47ed99b31161c12b6ed51cf9f69e3116be6c1

Improve async iterator exception stack traces (dotnet/coreclr#21103)

- The current stack trace prettying logic assumes that a method only has one StateMachineAttribute, but that's no longer true with async iterators, which (at least with the current implementation) can have both an AsyncStateMachineAttribute and an IteratorStateMachineAttribute.  As such, we change the prettying logic to look through all StateMachineAttributes rather than stopping at the first one.
- ManualResetValueTaskSourceCore.GetResult is responsible for propagating exceptions, but it's infrastructure and isn't particularly meaningful in a call stack.   Hide it from the stack trace, as we do for other such GetResult methods in Task and ValueTask.

Commit migrated from https://github.com/dotnet/coreclr/commit/aa4197400ed4ea1d4ffb421e55712a01b40673fa

Make code in `getTargetMethodDesc` more reliable. (dotnet/coreclr#21101)

* Make code in `getTargetMethodDesc` more reliable.

Fixes DevDiv_723667.

* change the condition to make sure that we do not have false true cases.

Commit migrated from https://github.com/dotnet/coreclr/commit/417fea5c5b358a79c6d096a887a89c12ec3ece2e