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

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

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

Change System.Object to ClassInterface.None (#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

Fix Unix ARM JIT_MemCpy and JIT_MemSet (#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.

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

Delete dead/unused code (#21138)

Update dependencies from https://github.com/dotnet/arcade build 420 (#21140)

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

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

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 (#21045)

Merge pull request #21129 from mmitche/sign-xstat

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

Expose generic UnsafeQueueUserWorkItem (#21125)

Vectorize string.IndexOf(..., StringComparison.Ordinal) (#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

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

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

* Also LastIndexOf

Merge pull request #21058 from CarolEidt/FixVZeroUpper

Record AVX use for SIMD indirections

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.

Remove remaining StringBuilder marshaling use from Corelib (#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

Remove StringBuilder from HebrewNumber formatting (#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.

Fix for #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/497419bf8f19c649d821295da7e225e55581cce9/src/jit/importer.cpp#L8783

Setting GTF_DONT_CSE blocks assertion propagation here:
https://github.com/dotnet/coreclr/blob/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 #21011.

Fixing up some issues with the HWIntrinsic test templates (#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

Replace custom AnsiToLower with more efficient ToLowerAsciiInvariant (#21121)

Avoids all of the StringBuilder-related costs.

Delete CORCOMPILE_IMPORT_TABLE_ENTRY (#21109)

Linux: FlushProcessWriteBuffers using membarrier when available (#20949)

* Linux: FlushProcessWriteBuffers using membarrier when available

* Ensure __NR_membarrier is defined for x64 portable build.

* Define __NR_membarrier on all portable architectures

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

Update dependencies from https://github.com/dotnet/arcade build 402 (#21118)

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

Improve async iterator exception stack traces (#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.

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

* Make code in `getTargetMethodDesc` more reliable.

Fixes DevDiv_723667.

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

format spmi sources (#21094)

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

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

* Cleanup System.Reflection.Emit code

* Delete dead code from System.Reflection.Emit

Update xunit version to match corefx (#21098)

* Update xunit version to match corefx

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

* Disabled outdated test

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

Also, add a test for #20958

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

Commit b89e2305 (PR #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.

Fix Getting Max Japanese Era (#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.

Disable stale sockets test (#21083)

Cleanup RtType.cs code

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

Update dependencies from https://github.com/dotnet/arcade build 385 (#21082)

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

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

Make type comparisons more general purpose (#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.

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

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

Work toward #14884

Add ICustomMarshaler tests (#19195)

* Add ICustomMarshaler tests

Update dependency files (#21067)

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

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

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

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

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

Removing the legacy helper intrinsics and adding tests for their replacements (#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

Force Unicode in test_location parameter in delete_existing_wrappers() (#21056)

Optimization: Further reduce allocations in GetCustomAtttributes() paths (#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 #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.

Exclude GC stress failure test. (#21059)

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

Merge pull request #21004 from BruceForstall/UpdateRuntestHelp

Update help output of runtest.cmd/sh

Add PInvoke/Decimal tests (#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

Delete unnecessary StackCrawlMarks in RtFieldInfo (#21054)

Left over from Code Access Security

Fixes #20965

Fix unloadability races (#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.

Fix Formatting Japanese First Year on Linux (#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

Record AVX use for SIMD indirections

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

Add explicit signatures for Span indexer

Fixes #21032 and #20958

Eliminate CMAKE dependency when not required (#21040)

Update dependencies from https://github.com/dotnet/arcade build 365 (#21052)

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

Add simple tests for ArrayWithOffset marshaling. (#21013)

* Add simple tests for ArrayWithOffset marshaling.

* PR Feedback.

* Fix visibility

* Fix DllImport library name

Add Interop/PInvoke/Attributes tests (#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.

Add PInvoke/CriticalHandles tests (#19297)

* Add PInvoke/CreticalHandles tests

* Bring up to current infrastructure.

* Fix ReverseTest.

Delete HAS_FLS_SUPPORT and related code (#21035)

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

* fixed ETW method signature of ref readonly methods

* added type token

* extract method for printing classes

* fixed optional_modifier, use CorSigUncompressToken_EndPtr

Add PInvoke/SafeHandles tests (#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.

Add Tests for VBByRefStr marshalling (#20982)

* Add tests for VBByRefStr marshalling.

* Compile native for VBByRefStr on all platforms.

* Fix encoding.

* PR Feedback.

* Fix PInvokeDefs file.

* Fix visibility

Add tests for marshalling as VARIANT_BOOL or VARIANT (#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.

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 (#21005)

Add PInvoke/SizeParamIndex tests (#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.

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

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

Add PInvoke/DllImportpath tests (#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.

Add tests for ANSI BSTRs (#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

Merge pull request #21008 from briansull/new-toolset

Fix warnings from the new toolset

Fixes for Azure DevOps official build (#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