Enable building/validating XML comments in CoreLib

Fix lots of malformed XML comments

These are causing errors in the source.dot.net build.  Turning on DocumentationFile and suppressing 1591, 1573, and 0419, Corelib builds clean after these changes.

Eliminate the requirement that abort requires no lock held on the current thread (#21206)

Update how CoreDisTools is discovered (#21261)

* Update Disassembler logic to search for CoreDisTools next to binary _or_ under the path specified by CORE_ROOT

* Update GCCover critical section

A few more Enum perf improvements (#21284)

* A few more Enum perf improvements

I started out to just remove the unnecessary boxing allocation that happens when you do enum.ToString("D") or, if the value doesn't map to a named enum entry, just enum.ToString() (there's an internal boxing of the value that happens in addition to any boxing that happens of the enum itself).  As part of that, I added a ValueToString method that replaces the GetValue().ToString() calls that appear several times, and in writing that ValueToString, I opted to avoid pinning, instead using Unsafe.As.  Once I did that, I then removed pinning everywhere else it was being done, standardizing on Unsafe.As.

* Address PR feedback

Update dependency files (#21211)

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

This change updates the following dependencies
- Microsoft.DotNet.Arcade.Sdk - 1.0.0-beta.18576.5
- Microsoft.DotNet.Helix.Sdk - 1.0.0-beta.18576.5

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

This change updates the following dependencies
- Microsoft.DotNet.Arcade.Sdk - 1.0.0-beta.18578.9
- Microsoft.DotNet.Helix.Sdk - 1.0.0-beta.18578.9

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

This change updates the following dependencies
- Microsoft.DotNet.Arcade.Sdk - 1.0.0-beta.18579.9
- Microsoft.DotNet.Helix.Sdk - 1.0.0-beta.18579.9

Fix perf issues with GetCurrentThreadHomeHeapNumber (#21150)

Disable TypeEquivalence tests due to flaky x86 build (#21294)

* Remove includes of SDK imports from prop and targets files

* Disable TypeEquivalence test due to failure on x86

Undo accidental change

Add EnumerateRunes() ref APIs and unit tests (dotnet/corefx#33504)

Signed-off-by: dotnet-bot <dotnet-bot@microsoft.com>

Delete CORECLR ifdef (dotnet/corert#6610)

This ifdef should not be needed anymore.

Signed-off-by: dotnet-bot <dotnet-bot@microsoft.com>

Typos (dotnet/corert#6605)

* accross -> across

* adress -> address

* Appartment -> Apartment

* persective -> perspective

* paramaterized -> parameterized

* Langage -> Language

* miminum -> minimum

* Curret -> Current

* currnet -> current

* definately -> definitely

Signed-off-by: dotnet-bot <dotnet-bot@microsoft.com>

Properly report intrinsic fields (dotnet/corert#6602)

* Properly report intrinsic fields

We were hitting an assert in RyuJIT because we were reporting IntPtr.Zero as an intrinsic even if we were not trying to `CORINFO_ACCESS_GET`.

I fixed that part and also went ahead to port the rest of getFieldIntrinsic from CoreCLR. We'll need this anyway.

* Add intrinsic fields

Signed-off-by: dotnet-bot <dotnet-bot@microsoft.com>

Merge pull request #21287 from hoyosjs/fix-tls-daccast

Properly DACize TLB access for thread local statics

Added TryParse to StandardFormat (#21216)

Defer Initialization of FrameworkEventSource During EventPipeController Initialization (#21255)

Update CoreClr, CoreFx, CoreSetup, PgoData to preview-27129-03, preview.18579.2, preview-27129-02, master-20181124-0042, respectively (#21178)

Properly DACize TLB access for thread local statics

Consolidate validation code in Enum.ToObject overloads (#21280)

Unnecessary duplication.  Moving it into a shared method has no measurable impact on ToObject performance, which is dominated by the boxing costs.

Improve performance of Enum.{Try}Parse (#21214)

* Improve performance of Enum.{Try}Parse

In particular for the generic overloads, where this avoids all per-operation allocations when commonly used underlying types are used (for example, this improves when the underlying enum type is int but not double).

* Address PR feedback

Enable type equivalence (#21265)

* Enable TypeEquivalence feature for Windows platform

* Basic test - verified test exercises TypeEquivalence code paths

Implement the Count property, the IEquatable and IFormattable interfaces, and the standard object overrides on Vector64/128/256<T> (#21259)

* Exposing the Count property on Vector64/128/256<T>

* Implementing IEquatable, IFormattable, and the object overrides on Vector64/128/256<T>

* Use StringBuilderCache, HashCode, and the provided format specifier

* Use StringBuilderCache.GetStringAndRelease and get the correct element when formatting Vector64/128/256<T>

Add more advanced SafeArray tests (#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.

Fix build parallelism on Windows with NUMA (#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.

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

Merge pull request #21267 from BruceForstall/FixExclusion

Fix ObjectStackAllocationTests on Linux under minopts

publish symbols on FreeBSD (#21179)

* enable build-id on FreeBSD

* start publishing symbols for freebsd

* enable FEATURE_PERFMAP on FreeBSD

Updating genSIMDZero to only use `xorps` (#21249)

Track single def locals in importer (#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).

Fix #21209 (#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]

Add IsCollectible property to Memberinfo and MethodInfo (#21155)

Improve Enum.ToString perf for [Flags] enums (#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.

Remove obsolete assert (#21260)

Delete code related to LoaderOptimization and SharedDomain (#21031)

Fix ObjectStackAllocationTests on Linux under minopts

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

Fixes #21266

Queue ValueTaskAwaiter IAsyncStateMachineBox directly to ThreadPool (#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

Update Helix queues used for testing

Merge pull request #21217 from AndyAyersMS/Fix21051

JIT: retype some return expressions

Merge pull request #21226 from AndyAyersMS/HandleMoreGeneralIndirInJmpAddr

JIT: handle general indir case for GT_JMP address

Switch to preemptive mode before calling COM (#21238)

* Switch to preemptive mode before calling COM

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

Fixes #20373

* Fix one places

 Delete test dev10_630880 (#21239)

* Revert "Disable test Dev10_630880"

This reverts commit 4fb76de35184fb80054f29779f51af82a4aa7ad8.

* Delete test dev10_630880

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

Merge pull request #21204 from briansull/issue_20185

Change VNUnpackExc to always write an exception set

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

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

* fix alignment

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

Implement the S.R.I.VectorXXX `get_Zero` and `As` helper methods as JIT intrinsics (#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

Improve performance of cgroup access (#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.

Fix ILStubCache allocation for collectible assemblies (#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).

Merge pull request #21234 from BruceForstall/Disable630880

Disable test Dev10_630880

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

Bug: 20786

Disable test Dev10_630880

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

Code review feedback

Disable failing Linux/arm32 corefx tests (#21225)

* Disable failing Linux/arm32 corefx tests

Update changing-corelib.md (#21220)

* Update changing-corelib.md

@jkotas

* Update changing-corelib.md

Diff-able disassembly fixes (#20863)

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.

remove workaround comments

Merge pull request #21151 from CarolEidt/Fix21080

Use LclFld for full-width cpblk of different types

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 #21051.

Use local array in ConcurrentQueue<T> for small perf improvement (#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.)

Improve perf for Index based span indexers (#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.

Fix a use after free for Managed Data BP (#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.

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

Disable noncollectible alc finalization (#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.

Disable domain neutral loading (#21156)

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

Update documentation for changing CoreLib (#21201)

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 #21080
Fix #21064

Merge pull request #21184 from mikedn/load-norm

Fix normalize on load handling in assertion propagation

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

Fix Azure DevOps endpoint (#21038)

* Delete incorrect resources section

Remove reference to arcade repo

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

* Updating runtest.py to support printing coredump information

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

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

* Fixing the simdHandleCache to add entries for Vector64FloatHandle and Vector128FloatHandle

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

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

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

Remove TypedReference.MakeTypedReference readonly restriction (#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.

Merge pull request #21164 from kvochko/no_hw_intrinsics_x86

[x86] Do not support hardware intrinsics on x86 unix

Handle the remaining known issues (modulo snan) with the double/single parsing logic (#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'

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

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

Don't generate copy assertions for normalize on load variables

Add test for 18867

Fix Interop/PInvoke/Miscellaneous/HandleRef tests under GCStress (#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

Fixing typo (#21081)

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

Contributes to #21028

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

Contributes to #21028

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/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/c94d8e68222d931d4bb1c4eb9a52b4b056e85f12/src/vm/object.cpp#L723
https://github.com/dotnet/coreclr/blob/c94d8e68222d931d4bb1c4eb9a52b4b056e85f12/src/vm/object.cpp#L730

Fix debugger collectible thread statics access (#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.

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

Typos (#21171)

* accesible -> accessible

* acheive -> achieve

* actutl -> actual

* appied -> applied

* apropriate -> appropriate

* aprox -> approx

* aquired -> acquired

* argumemts -> arguments

* Argumens -> Arguments

* argumetn -> argument

Delete System.AppDomainSetup (#21157)

* Delete System.AppDomainSetup

Contributes to #21028

* Add test hook for null entry assembly

* Validate that the binder paths are absolute

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

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

Narrow the assert in fgLateDevirtualization (#21163)

As suggested by Andy in dotnet/corert#6601.

Update dependencies from https://github.com/dotnet/arcade build 434 (#21166)

This change updates the following dependencies
- Microsoft.DotNet.Arcade.Sdk - 1.0.0-beta.18571.7
- Microsoft.DotNet.Helix.Sdk - 1.0.0-beta.18571.7

Do not support HW intrinsics on x86 linux

Sequel to NativeLibrary API (#21148)

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

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

Single stepping out of the unsafe places (#21135)

Merge pull request #21146 from AaronRobinsonMSFT/comtoclrworker_av

COMToCLRWorker AV

Minor clean up in COMToCLRWorker

Introduce Marshall.LoadLibrary API (#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

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);
```