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

format spmi sources (dotnet/coreclr#21094)

We do not do it automatically because we do not change it often.

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

 Cleanup System.Reflection.Emit code and delete dead code (dotnet/coreclr#21086)

* Cleanup System.Reflection.Emit code

* Delete dead code from System.Reflection.Emit

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

Update xunit version to match corefx (dotnet/coreclr#21098)

* Update xunit version to match corefx

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

* Disabled outdated test

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

Add asserts for the types of the Span indexers. (dotnet/coreclr#21037)

Also, add a test for dotnet/coreclr#20958

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

Fix search for headers and libraries via LLVM_HOME (dotnet/coreclr#21084)

Commit b89e2305 (PR dotnet/coreclr#18873) renamed WITH_LLDB_LIBS to LLDB_LIB_DIR and
WITH_LLDB_INCLUDES to LLDB_INCLUDE_DIR. But it forgot to update the
usage of these variables in some find_library and find_path calls.

As a result, setting LLVM_HOME is no longer enough to compile coreclr on
platforms with non-standard locations for lldb. This commit fixes that.

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

Fix Getting Max Japanese Era (dotnet/coreclr#21087)

We were using the ICU API ucal_getLimit and askin gto get the maximum value of the Japanese eras. it looks this API is just return the era matching the current system clock which prevent returning any future defined era in the system (which ICU 63.1 can support with some environment variable).
We raised the issue to the ICU owners but would be better just to get the era of Gregorian year 9999 which always should return the max era anyway.

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

Disable stale sockets test (dotnet/coreclr#21083)

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

Cleanup RtType.cs code

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

Fix Type.GetInterface for null namespace and non-null interface namespace

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

Add headers to crossgen, cee_crossgen, corzap_crossgen vcxproj files (dotnet/coreclr#20082)

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

Make type comparisons more general purpose (dotnet/coreclr#20940)

This has two parts:

## Part 1
CoreRT represents native type handles differently from CoreCLR - on CoreCLR, `RuntimeTypeHandle` is a wrapper over `RuntimeType` and RyuJIT is aware of that. On CoreRT, `RuntimeTypeHandle` wraps the native type handle, not a `RuntimeType`.

The knowledge is hardcoded in importer when importing the sequence "ldtoken foo / call Type.GetTypeFromHandle" - importer just removes the call and bashes the result of ldtoken to be a reference type. CoreRT had to avoid reporting `Type.GetTypeFromHandle` as an intrinsic because of that.

I'm adding another helper that lets RyuJIT avoid hardcoding that knowledge. Instead of just bashing the return type, we swap the helper call.

## Part 2

Native type handle equality checks need to go through a helper, unless the EE side says it's okay to compare native type handles directly.

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

Single pass Vectorize Span<byte>.IndexOfAny(..., ReadOnlySpan<byte>) for 2,3 lengths (dotnet/coreclr#20738)

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

Add headers to all md*, v3binder*, and ceefgen vcxproj (dotnet/coreclr#20163)

Work toward dotnet/coreclr#14884

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

Add ICustomMarshaler tests (dotnet/coreclr#19195)

* Add ICustomMarshaler tests

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

 Fix incorrect exception thrown in Marshal.ReleaseComObject(null) (dotnet/coreclr#21072)

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

Removing the legacy helper intrinsics and adding tests for their replacements (dotnet/coreclr#20994)

* Removing helper intrinsics from the x86 APIs in S.P.Corelib

* Removing JIT support for the removed x86 helper intrinsics

* Removing the x86 HardwareIntrinsics tests for the removed helper APIs

* Fixing up existing usages to no longer use the removed x86 helper intrinsics

* Skip CoreFX tests dependent on the removed x86 helper intrinsics

* Adding a GenerateTests.csx and templates for the new shared helper intrinsics

* Generating the new shared helper intrinsics from their templates

* Disabling some tests for arm and arm64 that are failing due to an assert

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

Force Unicode in test_location parameter in delete_existing_wrappers() (dotnet/coreclr#21056)

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

Optimization: Further reduce allocations in GetCustomAtttributes() paths (dotnet/coreclr#20795)

* Remove PseudoCustomAttribute allocations

Inside CustomAttribute, PseudoCustomAttribute is the mechanism used to return Attribute instances for what are really flags and such underneath in most cases. This is just an implentation detail, but this detail creates an intermediate array just for passing things around inside CustomAttribute...that's not necessary. This replaces the Attribute[] allocations with the ListBuilder<Attribute> struct for accumulating and relaying this attributes to parent methods.

Many overloads had a lot of duplicate coalescing code on this path as well...DRYed up that series of methods.

This change reduces allocation overhead for all calls by 40 bytes. In the case of a miss where none would be returned (e.g. .GetCustomAttributes<Attribute>() on a non-attributed class), this reduces allocations down to zero.

* CustomAttribute: split GetCustomAttributes into total and additive use cases

The split here was simple, but allocated an extra intermediate array for each parent type when searching for attributes in the inheritance case. Instead of doing that, we now move that to the second use case exclusively (which uses/returns the array created). The other use case adds to the ListBuilder<object> struct to accumulate through the inheritance hierarchy crawl (rather than an after-the-fact copy).

Note some parameter removals on the filter side...those weren't used already (and got in the way of this change).

* CustomAttributes: Cleanup of unused ops

Just removing the cruft that isn't actually used in here anymore (some of it in quite some time). Trivial amounts of speed gain, but every little bit helps!

* Param typo and red passing for GetCombinedList()

* Assume zero pseudo attributes by default (the most likely case)

Thsi eats the resize on the > 1 case, but that's so rare it's a net win to start with 0 here.

* Pseudo attributes: use out instead of return

A bit if a performance boost from the struct copy removal

* Pseudo attributes: switch to out everywhere and remove uneeded code paths

In relation to dotnet/coreclr#20795, these old calls seem to be for consistency but they're not likely to change and a comment (I think) accomplishes the same goal with less code...so here's a commit demonstrating it.

* Comment spacing for pseudo attribute fetching

Make it clear that pseudo attributes are a distinct thing (e.g. why not in *this* method) than the return line.

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

Exclude GC stress failure test. (dotnet/coreclr#21059)

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

Exclude tests from GCStress failing due to 21044 (dotnet/coreclr#21060)

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

Merge pull request dotnet/coreclr#21004 from BruceForstall/UpdateRuntestHelp

Update help output of runtest.cmd/sh

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

Add PInvoke/Decimal tests (dotnet/coreclr#19301)

* Add PInvoke/Decimal Tests

* Remove tests that fail on both .NET Framework and .NET Core.

* Refactor away the Windows-only headers.

* Make Decimal tests build on Linux.

* Remove some dead code.

* Clean up formatting.

* Don't run Decimal <--> Currency tests off-Windows.

* Make calling conventions and parameter/return marshalling more explicit

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

Delete unnecessary StackCrawlMarks in RtFieldInfo (dotnet/coreclr#21054)

Left over from Code Access Security

Fixes dotnet/coreclr#20965

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

Fix unloadability races (dotnet/coreclr#21024)

* Fix LoaderAllocator::AllocateHandle

When another thread wins the race in growing the handle table, the code
was not refreshing the slotsUsed local to the new up to date value. This
was leading to overwriting / reusing a live handle.
This change fixes it.

* Embed ThreadLocalBlock in Thread

Instead of allocating ThreadLocalBlock dynamically, embed it in the
Thread. That solves race issue between thread destruction and
LoaderAllocator destruction. The ThreadLocalBlock could have been
deleted during Thread shutdown while the LoaderAllocator's destruction
would be working with it.

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

Fix Formatting Japanese First Year on Linux (dotnet/coreclr#21039)

When formatting the first year with Gannen symbol we are checking if the year is followed by single quote which this is the case on Windows but it is not neccessay the case on Linux

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

Record AVX use for SIMD indirections

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

Add workaround for https://github.com/dotnet/coreclr/issues/21051

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

Add explicit signatures for Span indexer

Fixes dotnet/coreclr#21032 and dotnet/coreclr#20958

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

Eliminate CMAKE dependency when not required (dotnet/coreclr#21040)

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

Add simple tests for ArrayWithOffset marshaling. (dotnet/coreclr#21013)

* Add simple tests for ArrayWithOffset marshaling.

* PR Feedback.

* Fix visibility

* Fix DllImport library name

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

Add Interop/PInvoke/Attributes tests (dotnet/coreclr#19107)

* Add Interop/PInvoke/Attributes tests

* Fix PR comments

* Fix compile warnings

* Remove comment

* Clean up test files to match current build system.

* Fix up test and make it windows only (as FEATURE_LCID is only enabled on Windows)

* Fixed string const issues.

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

Add PInvoke/CriticalHandles tests (dotnet/coreclr#19297)

* Add PInvoke/CreticalHandles tests

* Bring up to current infrastructure.

* Fix ReverseTest.

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

Delete HAS_FLS_SUPPORT and related code (dotnet/coreclr#21035)

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

Fixed signatures of ref readonly methods in JIT ETW events (dotnet/coreclr#20981)

* fixed ETW method signature of ref readonly methods

* added type token

* extract method for printing classes

* fixed optional_modifier, use CorSigUncompressToken_EndPtr

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

Add PInvoke/SafeHandles tests (dotnet/coreclr#19330)

* Add PInvoke/SafeHandles tests

* Fix compile warnings - include header file with relative path

* Run SafeHandle tests only on Windows. The tests are very Windows-centric, so we'd have to do quite a bit of a re-write to get them working xplat.

* Fix CMake project references.

* Fix interface CMakeLists project reference.

* Add casts for string literals.

* Use LPOLESTR and the W macro instead of OLECHAR* cast and L prefix.

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

Add Tests for VBByRefStr marshalling (dotnet/coreclr#20982)

* Add tests for VBByRefStr marshalling.

* Compile native for VBByRefStr on all platforms.

* Fix encoding.

* PR Feedback.

* Fix PInvokeDefs file.

* Fix visibility

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

Add tests for marshalling as VARIANT_BOOL or VARIANT (dotnet/coreclr#20856)

* Add native side impl for VARIANT_BOOL test.

* More bool native code.

* Add VariantBool marshalling tests.

* Add infrastructure for tests for object -> VARIANT marshalling.

* Add variant tests for all built-in types.

* Clean up Variant tests.

* Add test for passing custom structure as object.

* Add test for VARIANT_BOOL byref.

* Added byref tests for VARIANT marshalling.

* Add field marshalling tests for VARIANT.

* Move ByValue tests to not have two sources of truth.

* Make managed code the one source of truth.

* Clean up formatting/unused methods.

* Clean up some whitespace issues.

* Add tests for BStrWrapper and CurrencyWrapper marshalling.

* Add UnknownWrapper tests.

* Add a test for VariantWrapper and PInvoke.

* PR Feedback.

* Remove ToString.

* Fix visibility

* Fix MSBuild import path.

* Clean up Variant tests.

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

Update BuildTools, CoreClr, CoreFx, CoreSetup, IbcData, PgoData to preview1-03415-01, preview-27115-03, preview.18565.4, preview-27115-04, master-20181115-0045, master-20181115-0044, respectively (dotnet/coreclr#21005)

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

Add PInvoke/SizeParamIndex tests (dotnet/coreclr#19348)

* Add PInvoke/SizeParamIndex tests

* Fix compile warnings

* First pass cleaning up native code.

* Get ParamSizeIndex tests working xplat (excluding the BSTR array tests)

* Fix incorrect definition of ULONG off-windows.

* Disable reverse-PInvoke throwing test off-Windows.

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

Stop using Hostx86/arm crossgen in crossgen_comparison scenario (dotnet/coreclr#21021)

* And also create Linux arm64 crossgen_comparison scenarios in netci.groovy

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

Add PInvoke/DllImportpath tests (dotnet/coreclr#19270)

* Add PInvoke/DllImportpath tests

* Refactor test to current toolset and remove Windows-only Path API searching.

* Remove explicit calling convention from managed and add correct convention to test.

* Get environment test passing on Unix.

* Update test to pass off-Windows.

* Include feature/platform defines in tests.

* Fix environment test (again).

* Remove zero-width character that's breaking CI

* Fix zero-width character I missed.

* Remove invalid parens around LD_LIBRARY_PATH

* Ensure the path added to the LD_LIBRARY_PATH exists before the test starts.

* Combine all DllImportPath CMakeLists.txt files into one file.

* Include clr.coreclr.props when also including clr.defines.targets so we get the feature defines correctly as well.

* Disable unicode test for our OSX 10.12 CI builds.

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

Add tests for ANSI BSTRs (dotnet/coreclr#20985)

* Add tests for ANSI BSTRs

* Fix signed/unsigned mismatch in comparisons. Add xplatform include

* Use regular memcpy

* Enable ANSI BSTR off-windows.

* Also enable UnmanagedType.TBStr off-Windows since both BStr variants are available off-Windows.

* Make sure the AnsiBSTR marshaller is hooked up off-Windows.

* Remove a few more ifdefs I missed.

* remove ifdefs around binder definitions and the C# stub helpers.

* PR Feedback.

* Add xplat ARRAYSIZE macro

* Move xplat ARRAYSIZE to platformdefines.h

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

Merge pull request dotnet/coreclr#21008 from briansull/new-toolset

Fix warnings from the new toolset

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

Fixes for Azure DevOps official build (dotnet/coreclr#21017)

* Fix endpoint for internal jobs

 Fix external vs internal queues

 Properly quote scenarios argument to msbuild

 Increase queue timeout since most P1 jobs couldn't finish in time

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

Allow rune enumeration from string and ROS<char> (dotnet/coreclr#21007)

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

Add PInvoke/Array tests (dotnet/coreclr#19266)

* Add PInvoke/Array tests

* Fix compile warnings

* Get tests passing on Windows again.

* Change error_t type to work xplat.

* Change error_t in types.h as well

* Clean up build slightly.

* PR feedback and native test code refactoring.

* Clean up header.

* Add a xplat implementation of _itoa_s for our tests.

* CHAR -> char

* Make calling convention cdecl to avoid stdcall mangling.

* Make return test native code cdecl as well (missed it before).

* Fix bug in platformdefines _itoa_s

* Return early in TP_itoX_s when num == 0

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

Update CrstTypeTool to produce spaces (dotnet/coreclr#21029)

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

Changed back to use m_filtered

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

Code Review feedback

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

Combine ExcludeList in AltJit scenarios for both host and altjit archs (dotnet/coreclr#21018)

* Add -altjitarch command line argument in tests/runtest.cmd and -altjit_arch in tests/runtest.py

* Specify altjitarch in for x86_arm_altjit and x64_arm64_altjit jobs in netci.groovy

* Use AltJitArch MSBuild variable in tests/issues.targets to exclude tests based on either BuildArch or AltJitArch since both two JITs are running in altjit scenarios

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

Add PInvoke/Miscellaneous tests (dotnet/coreclr#19326)

* Add PInvoke/Miscellaneous tests

* Clean up HandleRef test.

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

Update Unicode data and optimize CharUnicodeInfo indexes (dotnet/coreclr#20983)

* Update Unicode data and optimize CharUnicodeInfo indexes

* Add new GenUnicodeProp to tools

* Add licence headers

* Add big-endian support

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

Allow supressing exceptions in diamond inheritance cases (dotnet/coreclr#20458)

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

Re-enable optimizations in interop helper functions. (dotnet/coreclr#21016)

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

Fix invalid tests for COM native server (dotnet/coreclr#21012)

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

Disable COM tests being CrossGen'd (dotnet/coreclr#21010)

* Disable running CrossGen on COM tests since the CrossGen tool doesn't support app manifests on Windows.

* Update ObjectStackAllocation test to use MSBuild property to disable CrossGen support.

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

Add test for marshalling ArgIterators on Windows (dotnet/coreclr#20888)

* Add (windows-only) tests for __arglist and ArgIterator marshalling.

* Add explicit calling convention notation to pinvokes.

* Add license header

* Update VarargsTest.cs

* Fix calling conventions.

* PR Feedback

* Add explicit calling convention.

* Update VarargsNative.cpp

* Don't reference System.Private.Corelib directly

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

Use correct printf type specifier

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

Jit changes from the desktop Toolset Update

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

Update CoreFX-in-CoreCLR testing instructions (dotnet/coreclr#21002)

Update to reflect changes in the repo, and fix various formatting issues.

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

Fix arm64 PUTARG_STK(contained OBJ(contained LCL_FLD_ADDR)). (dotnet/coreclr#20995)

* add a repro test

* Fix the issue.

Do not mark `GT_OBJ` as containned for arm64.
We already do the same in `NewPutArg`.

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

Fix warnings because of Bool incompatibality

Fix a compile warning because of bool vs BOOL incompatibality.
Fixes a build break in the new VS compiler.

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

Update help output of runtest.cmd/sh

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

Cleanup on the new Math APIs (dotnet/coreclr#20993)

* Updating the cached HAVE_COMPATIBLE_ILOGB0_EXITCODE and HAVE_COMPATIBLE_ILOGBNAN_EXITCODE to 1

* Fixing MaxMagnitude and MinMagnitude to correctly handle the case when ax and ay are equal

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

Update CoreClr, CoreFx, CoreSetup, IbcData, PgoData to preview-27113-06, preview.18563.5, preview-27114-01, master-20181114-0045, master-20181114-0044, respectively (dotnet/coreclr#20950)

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

Merge pull request dotnet/coreclr#20961 from briansull/const-eval-fix

Improve CanEvalForConstantArgs

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

Undo a workaround added in dotnet/coreclr#20442.

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

Fix for bug 20499.

When the jit is copying a struct-typed return to the return local in a synchronous method on arm64,
it ends up invoking an importer utility outside the importer, where impTreeLast is not set.

The call sequence is
fgMorphBlocks --> gtNewTempAssign --> impAssignStruct --> impAssignStructPtr --> impAppendTree

When impAssignStructPtr sees GT_COMMA src nodes, it unwraps them and inserts additional statements.
The fix is to pass an insertion point statement through this call chain to prevent impAssignStruct
and impAssignStructPtr from calling impAppendTree outside of the importer.

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

Disable R2R for object stack allocation tests.

Object stack allocation currently doesn't work in R2R mode
because we lower R2R allocations to helper calls in the importer.
That will be fixed but for now we need to disable R2R for these tests.

Fixes dotnet/coreclr#20977.

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

Initial commit for System.Text.Rune (dotnet/coreclr#20935)

This type represents a Unicode scalar value ([ U+0000..U+D7FF ], inclusive; and [ U+E000..U+10FFFF ], inclusive). The primary scenario is for having a consistent representation of Unicode data regardless of the underlying input encoding type, including abstracting away surrogate code points.

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

Fix CanEvalForConstantArgs(VNFunc vnf)

Change the default return value for new GenTree nodes to false

This allows new nodes to be added without immediately implementing
the compile time folding logic.

Added method header comment for CanEvalForConstantArgs

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

n_heaps needs to be initialized before init_static_data is called (dotnet/coreclr#20968)

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