Avoid intermediate strings in some StringBuilder formatting (#22111)

* Avoid intermediate strings in some StringBuilder formatting

Several appends to string builders are first creating strings and then appending those strings, and they're not using the existing Append(primitive) overloads because they want to customize the format string or provider as part of appending the value.  This fixes a few of those cases, using another internal AppendSpanFormattable overload on StringBuilder.

* Address PR feedback

Update CoreFx to preview.19070.3 (#22061)

Move Task factory type to shared partition (#22089)

Use List<T>.ToArray() in places (#22101)

* Use ReadOnlySpan.ToArray in places

* Use List.ToArray

* Don't take .Length in to local and use as loop condition

Cleanup array related FCalls (#22097)

* Cleanup Array FCalls

* Disable outdated CoreFX tests

https://github.com/dotnet/corefx/pull/34700

Fix CoreCLR build for changes in shared partition

Fix build for ProjectN/WinRTInterop Delete superfluous AsyncCausalityTracer arguments

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

Fix build

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

Update Newtonsoft.Json (#22060)

Cleanup: Remove MethodDesc::GetLoaderAllocatorForCode (#22067)

This function was recently changed to just return the
MethodDesc::GetLoaderAllocator. This is a cleanup that removes the
function completely and replaces all of its usages.

Removed unused 'Stack Walking' code (#22039)

As fair as I can tell `ECWGCFCrawlCallBack(..)` is not wired-up anywhere (I've successfully compiled CoreCLR locally with this change under `x86` and `x64`)

Strip symbols on unix in release builds (#22083)

Fixes https://github.com/dotnet/coreclr/issues/22082

Fix calling conventions on reverse PInvoke callbacks. (#22044)

Run Azure DevOps builds against pull requests in coreclr/master (#22051)

And disable Windows_NT and Ubuntu arm32 and arm64 default triggers in Jenkins CI

SuperPMI Collect/Replay/AsmDiff tool (#21252)

This change adds superpmi.py. The tool feature three modes, collection, replay, and asmdiffs.

Collection
The collection logic is very similar to the logic in our superpmi-collect test. Mostly it just allows running a script which will run managed code and it will produce a .mch which is clean to be run against. See superpmi.md for more information on specific usage and problems.

Replay
Replay will take an existing .mch file and run the current jit over the collection. If there is no .mch file on disk, the script will download the latest collection and run against that.

AsmDiffs
superpmi.md has the latest information on what platforms support asmdiffs. So far, I have an updated OSX and Windows collection that I have run against. If there are binary diffs, the tool will automatically generate base & diff folders with the asm under each one. Future work would include automatically running jit-analyze over those locations.

In addition, the tool has the option to automatically run and diff jit dumps, I have found this to be useful to looking into diffs created, as re-running superpmi with different jits to collect this same information is somewhat tedious.

Future work
This change is in no way the end of the work needed to leverage superpmi effectively. Instead, it is a good first step. Below are some suggestions for future superpmi work:

Automated collections
Add pmi collection support
Leverage some of the new corefx work to use superpmi shim for collections of corefx runs
To be added/changed
I will unset zapdisable being set by default, it creates too much data, although it is useful it should be opt in
Will include example usage in superpmi.md.

Move AsyncCausality to shared partition (#22062)

* Move AsyncCausality to shared partition

* Set FeatureAsyncCausalityTracer property

Re-enable signing of System.Private.CoreLib (#22068)

* Re-enable signing for System.Private.CoreLib

Now that https://github.com/dotnet/arcade/issues/1582 is fixed.
Addresses https://github.com/dotnet/coreclr/issues/21946.

* Use uppercase build config

For consistency with other builds. Doesn't impact functionality, but
will result in the build logs showing the bin directory with the
uppercase build config during this step.

* Override arcade version of SignTool package

Add Per-assembly Load Native Library callbacks (#21555)

Add Per-assembly Load Native Library callbacks

This Change implements the Native Library resolution
Call-backs proposed in https://github.com/dotnet/corefx/issues/32015

Update dependencies from dotnet/arcade (#22035)

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

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

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

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

Enable detection of HW intrinsics (dotnet/corert#6836)

I took the liberty of marking the types containing the hardware intrinsics as [Intrinsic] to avoid doing a name check on everything in the system module. It feels like we should take advantage of this attribute in CoreCLR too.

This doesn't actually enable the support because RyuJIT unconditionally disables HW intrinsics for prejit (both CoreRT and CPAOT are considered prejit). We might want to do something about this on the RyuJIT side to address that (for CPAOT, to be able to pregenerate best code possible ahead of time, assuming a fixed ISA; and for CoreRT without JIT, where the concerns about AVX-SSE penalty don't apply). See conversation in dotnet/coreclr#21603

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

Fix defines in TaskAwaiter (dotnet/corert#6846)

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

Handle complex constrained calls with default interface methods (#21978)

This adds handling for the interface dispatch corner case where:

* We have a constrained callsite to a method on a generic interface in shared code
* The callsite cannot be statically resolved because the result of dispatch depends on the generic context
* At runtime, the dispatch resolves to a default interface method

This would require us to have infrastructure to build "boxing thunks" - thunks that would box their first argument before dispatching to the default interface method implementation.

Since this is a corner case and the fix is actually quite involved, we're making the runtime just throw in this situation.

The test is written so that it should pass both if the runtime chooses to throw, or if the runtime makes the boxing thunk (we're not hardcoding the implementation limitation).

Use correct resolution scope when checking default implementations (#22036)

We need to use the module of the interface.

Fixes #22021.

Add comments on headers that gets parsed by Mono linker for whoever touches this next (#22054)

* Add comments on headers that gets parsed by Mono linker for whoever touches this next

* add more comments to the targets file

Move Environment to shared CoreLib (dotnet/corefx#34654)

Rather than having Environment partially live in corefx and call into an EnvironmentAugments type in CoreLib that in turn calls into an Environment type in CoreLib, we're just moving Environment to live in CoreLib.

To start that, this PR moves Environment and its dependencies from their current locations into the shared CoreLib.  Those changes will mirror over to coreclr.  After that, I'll fix it up to work in CoreLib. And once those changes are built and available back to corefx, I'll update System.Runtime.Extensions to just use the functionality from CoreLib and delete remaining unnecessary code from corefx.

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

Unify xplatform.h and platformdefines.h (#21389)

* Move most of xplatform.h into platformdefines.h and clean up the interop CMake files.

* Fix build-break off Windows.

* Fix typo.

* Fix another break off-Windows.

* Fix signed/unsigned mismatch

Unblock Azure DevOps-as-CI (#22042)

* Disable JIT.Methodical/doublearray/dblarray3_cs_do

* Disable readytorun.r2rdump/R2RDumpTest

* Disable RedHat.6.Amd64.Open queue

* Rename Creator coreclr/pulls -> coreclr-pulls

* IsExternal is deprecated as of https://github.com/dotnet/arcade build 20190115.6

* Increase timeout for all test jobs

Merge pull request #22002 from dotnet-maestro-bot/master-UpdateDependencies

Update BuildTools, CoreClr, CoreFx, PgoData to preview1-03617-02, preview-27316-02, preview.19066.1, master-20190116.5, respectively (master)

Remove ToString from RuntimeAssembly.GetManifestResourceStream (#22012)

* Remove ToString from RuntimeAssembly.GetManifestResourceStream

A small allocation we can avoid with the span-based string.Concat.

* Address PR feedback

Update BuildTools, CoreClr, CoreFx, PgoData to preview1-03617-02, preview-27316-02, preview.19066.1, master-20190116.5, respectively

Split ContractsBCL into separate classes and move them to shared CoreLib (#22006)

* Split up ContractsBCL into separate classes.

* Move remaining Contract, ContractHelper code to shared partition.

* Split ContractHelper to allow custom debugging experience in CoreRT.

* Simplify ContractHelper.InternalContractFailed.

* Use resource loading code from CoreRT.

* Remove unused parameter.

Clean up a few minor Span-related uses (#22038)

Some unnecessary Span to ReadOnlySpan casts.
Some places where new Span(...).Slice(...) can be replaced with AsSpan(...).
Etc.

Remove a few stale resource strings for ConcurrentStack (#22037)

Avoid allocations in Utf8Formatter.TryFormat(float/double, ...) (#22011)

* Avoid allocations in Utf8Formatter.TryFormat(float/double, ...)

Currently every call to Utf8Formatter.TryFormat for a float or a double allocates two strings, one for the format string and one for the resulting number.   This avoids those in the common case where we can use float/double.TryFormat and format directly into a stack buffer.  Also removes some unsafe code; the performance of StandardFormat.ToString isn't currently worth the extra nanoseconds gained by using unsafe code.

* Delete assert

There's a test that uses unsafe code to cause this to fail and validate that no exception is thrown.

Merge pull request #22022 from fiigii/reenabletest

Re-enable Avx.PermuteVar tests

Fix AsyncMethodBuilder build on Mono (#22034)

Fix CoreCLR build of AsyncMethodBuilder.

Add new members to AsyncCausalitySupport.
Remove file moved to shared partition.
Fix builds without FeatureCominterop.

Move AsyncMethodBuilder to shared. (dotnet/corert#6832)

* Move AsyncMethodBuilder to shared.

* Bring back PROJECTN.

* #if-out TrackAsyncMethodCompletion for CoreRT.

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

Re-enable Avx.PermuteVar tests

Update dependencies from https://github.com/dotnet/arcade build 20190115.6 (#22007)

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

Merge pull request #21997 from BruceForstall/FixFpRelativeInstructions

Fix two cases of FP-relative immediate offsets possibly not encodable

Reduce steps for string.Contains(string value) (#22008)

Update linux/OSX build instructions (#21679)

* Update linux/OSX build instructions

* Update based on feedback

* Address PR feedback

* Update to address feedback

 Fix imm-operand encoding for SSE/AVX instructions (#21999)

* Move more SSE2 tests to the template

* Improve Insert test template to involve more codegen situations

* Fix imm-operand encoding for SSE/AVX instructions

Fix generate_layout_only (#21996)

* Fix generate_layout_only

* Correctly add all opons

* Clean run for cross built device

Enable BenchmarksGame when BuildTestsAgainstPackages (see #21554) in tests/issues.targets

Make JIT\superpmi\superpmicollect compatible with Helix

Related issue: https://github.com/dotnet/coreclr/issues/21698

String -> string

Delete files moved to shared partition

Move more COM exceptions to shared partition (dotnet/corert#6829)

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

WIP: Re-enable ObjectStackAllocationTests for arm32

Use MSBuild to generate __TestEnv files (#21966)

Fix two cases of FP-relative immediate offsets not being checked for encodability

For ARM32/ARM64, the immediate offsets in addressing modes have
limited range that varies by instruction. A couple cases were not
checking for that range, leading to generating potentially
un-encodable instruction.

In particular, the test case shows a case where a very large frame in a function
with a stored generic context would fail on ARM64.

There are no code diffs from this change for ARM64, except we sometimes get
better assembly comments where the local variable referenced is annotated on
the store instruction. For ARM32, the "secret stub param" is now stored using
SP-relative addressing, not FP-relative, if possible (which we generally prefer
in main function bodies).

On SIGTERM default to a non-zero exit code (#21300)

* On SIGTERM default to a non-zero exit code

* Fix Windows builds

* Improve SIG_DFL/SIG_IGN handling

* Remove PAL_GetTerminationExitCode

* Use sa_handler/sa_sigaction based on SA_SIGINFO; remove HAVE_SIGINFO_T.

* configure.cmake: remove siginfo_t check

* Move restore_signal_and_resend so OSX can use it; add function documentation

* Fix OSX build: include pal/process.h for gPID

* Check SIG_IGN and SIG_DFL against sa_handler

* Don't use sa_handler when SA_SIGINFO is set

* Fix equality check

* Swap order of checking SA_SIGINFO and SIG_IGN/SIG_DFL

Merge pull request #21963 from BrianBohe/master

Remove unreachable code

Add freebsd official build (#21988)

* Enable freebsd build

Two different environment variables are used to tell either buildtools or arcade to use an existing SDK instead of trying to restore one. The package build project is pure msbuild (it doesn't do platform detection in any wrapper .sh files), and we don't have FreeBSD detected in msbuild, so pass the __BuildOS in from the caller.

allocate the right number of slots for the handle table when number of processors > 64 (#21992)

Update CoreClr, CoreFx, PgoData to preview-27312-01, preview.19063.1, master-20190111.1, respectively (master) (#21954)

* Update CoreClr, CoreFx, PgoData to preview-27312-01, preview.19063.1, master-20190111.1, respectively

* Disable invalid test

fix the help message for runtest.sh so the gcstress instructions aren't split across multiple lines (#21989)

Large version bubble Support (#21727)

* Preliminary Changes

* Module Index Resolution

* Change infoModule encoding

* Change referencing module in R2R

* Pre-condition Check

* Virtual Method Module Resolution

* Remove Workarounds and add conditional import loading

* Add signature kind module override

* Add ELEMENT_TYPE_MODULE_ZAPSIG

* Add switch to enable large version bubble

* Cleanup

* Change Native header check

* Add large version bubble test

* Add Large Version Bubble Checks

* Cleanup

* Revert unnecessary check

* Change EncodeMethod Version Bubble Condition

* Add Large Version Bubble asserts

* Cleanup

* Add default argument to runtests.py

* Change test PreCommands

* Revert whitespace changes

* Change breaking conditional check

* Streamline Version Bubble test

* Address PR Feedback

* Address PR Feedback #2

* Remove dead code

* Add crossgen-time ifdef

Finding Standalone GC and CoreDisTools in non-standard host testing (#21983)

* Use GetInternalSystemDirectory() as the directory for standalone GC

* Use GetInternalSystemDirectory() as the directory for coredistools

Improvements for object stack allocation.

This change enables object stack allocation for more cases.

1. Objects with gc fields can now be stack-allocated.
2. Object stack allocation is enabled for x86.

ObjectAllocator updates the types of trees containing references
to possibly-stack-allocated objects to TYP_BYREF or TYP_I_IMPL as appropriate.
That allows us to remove the hacks in gcencode.cpp and refine reporting of pointers:
the pointer is not reported when we can prove that it always points to a stack-allocated object or is null (typed as TYP_I_IMPL);
the pointer is reported as an interior pointer when it may point to either a stack-allocated object or a heap-allocated object (typed as TYP_BYREF);
the pointer is reported as a normal pointer when it points to a heap-allocated object (typed as TYP_REF).

ObjectAllocator also adds flags to indirections:
GTF_IND_TGTANYWHERE when the indirection may be the heap or the stack
(that results in checked write barriers used for writes)
or the new GTF_IND_TGT_NOT_HEAP when the indirection is null or stack memory
(that results in no barrier used for writes).

Add test calling a NativeCallable via an unmanaged calli. (#21984)

Removing noisy R2R compilation outputs, and putting them under the /verbose switch (#21987)

Custom Marshalers in custom-ALC-loaded assemblies results in types loaded from crossing ALCs (#21606)

* Create repro for dotnet/coreclr#19654

* Update ICustomMarshaler.csproj

* Update ICustomMarshaler.csproj

* Clean up repro per feedback.

* Add test case for different assemblies with the same CustomMarshaler name.

* Move EEMarshalingData cache from AppDomain to LoaderAllocator. This fixes the custom-marshaler conflict when using unloadable assembly contexts.

* Internalize the LoaderHeap* parameter.

* Add the pointer to the requesting assembly to the hashtable key.

* Fix linux-musl build break.

* Move Crst out of FEATURE_COMINTEROP block.

* Make sure to copy over the assembly pointer to the key that's actually stored in the hash table.

* Add comment for m_invokingAssembly.

* Move all usages of EEMarshallingData to hang off the correct loader allocator instead of always the global one.

* Change to m_InteropDataCrst since this EEMarshallingData can be used in preemptive GC mode.

* Always init m_InteropDataCrst (since it's used by EEMarshallingData as well as COM).

* PR Feedback.

* Remove extraneous inlines.

Fix TimeSpan parsing (#21968)

* Fix TimeSpan parsing

* Temporary disabling the failed CI tests

Fix TaskCompletionSource to avoid capturing ExecutionContext (#21981)

When a TaskCompletionSource is constructed without any arguments, it simply creates a Task using a simple Task constructor that sets a few fields and is done.  When it's constructed with options, though, those options are validated, and then it calls into a shared routine that configures based on those options.  A previous set of changes resulted in erroneously doing the ExecutionContext.Capture for the task inside of that shared routine, rather than only doing it for tasks that actually have a delegate to be executed.  The net effect of this is that, while TaskCompletionSources created with the parameterless constructor correctly did not capture ExecutionContext, TaskCompletionSources created with options erroneously did; this doesn't have a functional impact, because that ExecutionContext isn't used for anything, but it can have a performance impact, in particular for memory, if the resulting Task is cached, and if the captured ExecutionContext holds onto some expensive object from an AsyncLocal, such that the cached Task then does so, too.

The fix is simply to move the capture from the shared routine that's invoked in two places to instead be done only in the one caller that's for tasks with delegates.

Remove tizen jobs as valid pr jobs (#21982)

Making sure the nativeCodeVersion flowing change works with Rejit and EnC (#21961)

Add NativeLibrary Resolve Event (#21929)

This change adds the Native library resolving event, to be raised as the last attempt to resolve a native DLL in an AssemblyLoadContext.

With this change, the DllImport resolution sequence is as follows (stopping at any step with successful resolution):

* If the invoking-assembly is not in the default load context, call AssemblyLoadContext.LoadUnmanagedDll()
* Run the default load logic, try loading from:
    * AppDomain cache
    * NATIVE_DLL_SEARCH_DIRECTORIES
    * Invoking-assembly directory, System32, etc. based on DllImportSearchPaths
* Raise the ResolvingUnmanagedDll event

API Review: https://github.com/dotnet/corefx/issues/32850

The ResolveEventTests triggered a pre-existing bug in the exception handling code (#21964).
Disabling the test on ARM64 Windows until the issue is fixed.

Add System.Reflection.Emit.DynamicILInfo (#21945)

* Making DynamicILInfo and its API impls public

* Remove DynamicScope input from ctor args

Fix x64 CFI generation (#21955)

Patch vtable slots and similar when tiering is enabled (#21292)

Patch vtable slots and similar when tiering is enabled

For a method eligible for code versioning and vtable slot backpatch:
  - It does not have a precode (`HasPrecode()` returns false)
  - It does not have a stable entry point (`HasStableEntryPoint()` returns false)
  - A call to the method may be:
    - An indirect call through the `MethodTable`'s backpatchable vtable slot
    - A direct call to a backpatchable `FuncPtrStub`, perhaps through a `JumpStub`
    - For interface methods, an indirect call through the virtual stub dispatch (VSD) indirection cell to a backpatchable `DispatchStub` or a `ResolveStub` that refers to a backpatchable `ResolveCacheEntry`
  - The purpose is that typical calls to the method have no additional overhead when code versioning is enabled

Recording and backpatching slots:
  - In order for all vtable slots for the method to be backpatchable:
    - A vtable slot initially points to the `MethodDesc`'s temporary entry point, even when the method is inherited by a derived type (the slot's value is not copied from the parent)
    - The temporary entry point always points to the prestub and is never backpatched, in order to be able to discover new vtable slots through which the method may be called
    - The prestub, as part of `DoBackpatch()`, records any slots that are transitioned from the temporary entry point to the method's at-the-time current, non-prestub entry point
    - Any further changes to the method's entry point cause recorded slots to be backpatched in `BackpatchEntryPointSlots()`
  - In order for the `FuncPtrStub` to be backpatchable:
    - After the `FuncPtrStub` is created and exposed, it is patched to point to the method's at-the-time current entry point if necessary
    - Any further changes to the method's entry point cause the `FuncPtrStub` to be backpatched in `BackpatchEntryPointSlots()`
  - In order for VSD entities to be backpatchable:
    - A `DispatchStub`'s entry point target is aligned and recorded for backpatching in `BackpatchEntryPointSlots()`
      - The `DispatchStub` was modified on x86 and x64 such that the entry point target is aligned to a pointer to make it backpatchable
    - A `ResolveCacheEntry`'s entry point target is recorded for backpatching in `BackpatchEntryPointSlots()`

Slot lifetime and management of recorded slots:
  - A slot is recorded in the `LoaderAllocator` in which the slot is allocated, see `RecordAndBackpatchEntryPointSlot()`
  - An inherited slot that has a shorter lifetime than the `MethodDesc`, when recorded, needs to be accessible by the `MethodDesc` for backpatching, so the dependent `LoaderAllocator` with the slot to backpatch is also recorded in the `MethodDesc`'s `LoaderAllocator`, see `MethodDescBackpatchInfo::AddDependentLoaderAllocator_Locked()`
  - At the end of a `LoaderAllocator`'s lifetime, the `LoaderAllocator` is unregistered from dependency `LoaderAllocators`, see `MethodDescBackpatchInfoTracker::ClearDependencyMethodDescEntryPointSlots()`
  - When a `MethodDesc`'s entry point changes, backpatching also includes iterating over recorded dependent `LoaderAllocators` to backpatch the relevant slots recorded there, see `BackpatchEntryPointSlots()`

Synchronization between entry point changes and backpatching slots
  - A global lock is used to ensure that all recorded backpatchable slots corresponding to a `MethodDesc` point to the same entry point, see `DoBackpatch()` and `BackpatchEntryPointSlots()` for examples

Due to startup time perf issues:
  - `IsEligibleForTieredCompilation()` is called more frequently with this change and in hotter paths. I chose to use a `MethodDesc` flag to store that information for fast retreival. The flag is initialized by `DetermineAndSetIsEligibleForTieredCompilation()`.
  - Initially, I experimented with allowing a method versionable with vtable slot backpatch to have a precode, and allocated a new precode that would also be the stable entry point when a direct call is necessary. That also allows recording a new slot to be optional - in the event of an OOM, the slot may just point to the stable entry point. There are a large number of such methods and the allocations were slowing down startup perf. So, I had to eliminate precodes for methods versionable with vtable slot backpatch and that in turn means that recording slots is necessary for versionability.

Merge pull request #21795 from fiigii/fixGeneric

Remove unnecessary ThrowIfUnsupportedType calls and definitions

Generate non-null assertion for byrefs if we can't find corresponding refs.

When we have a non-null fact about a byref, we try to find the corresponding
ref and generate an assertion about the ref. Then it can be used on byrefs if the offset is not too big.
We use both trees and value numbers to find the ref. When the ref wasn't found we bailed on generating
the assertion.

I found that we get a number of good diffs if we generate assertions for byrefs when refs can't be found
so this change enables that.

Fix access token used for internal helix submissions (#21957)

Also specify the variable group using yaml syntax.

Share arg validation runtest and run-pmi-diff (#20812)

* Share arg validation runtest and run-pmi-diff

Use the same arg validation in runtests.py and run-pmi-diffs.py

* Add valid arches to ci_arch

Add missing overrides to SyncTextWriter (#21956)

Several recently added virtuals to TextWriter were missing overrides on SyncTextWriter.

We were missing overrides of the synchronous `Write(ReadOnlySpan<char>)` and `WriteLine(ReadOnlySpan<char>)` overloads.  The impact here is primarily performance, though it'll still be an observable change in corner-case scenarios: rather than using the base implementation which would copy the span to an array and then invoke the properly overridden array-based Write{Line} methods, it'll now just delegate to the wrapped span methods.  So it calls the correct overload now on the wrapped instance, and saves some cost in the process.

We were also missing overrides for the async `WriteLineAsync()`, `WriteAsync(ReadOnlyMemory<char>, CancellationToken)`, WriteLineAsync(ReadOnlyMemory<char>, CancellationToken)` overloads.  Fixing these doesn't change the overload that's invoked on the wrapped writer, but it does cause the calls to become synchronous rather than queue a task that in turn calls the synchronized overload.  Whether the new behavior is better is arguable, but it keeps it consistent with every other XxAsync method on SyncTextWriter, which in my opinion is more important... if we wanted to alter the behavior for all of the XxAsync methods, we should do it for all of them.

Also, in the StringBuilder-based overrides, we were ignoring cancellation.  And in the recently added DisposeAsync, we should follow-suit with the rest of the async APIs and make it synchronous.

Remove unreachable code

Enable returning more complex structures via PInvoke returns. (#21470)

* Add test verifying behavior in dotnet/coreclr#19676.

* Clean up test code.

* Test what happens if we enable returning structures by value.

* Use braced initializer.

* Update Decimal tests to expect that returning a decimal by LPStruct or Currency works.

* Change handle-in-struct marshalling to expect a NotSupportedException thrown at marshal time instead of expecting a MarshalDirectiveException at signature time.

* Update Decimal Reverse-PInvoke tests.

* Disable some previously disabled return marshalling types and add a nice comment block explaining why they're disabled.

* Enable marshalling DateTime return values and add a test.

* Rename IsUnuspportedValueTypeReturn

* Add return test for ArrayWithOffset

* Remove extraneous P/Invoke.

* Fix spelling.

* Add test for successfully returning a struct that has one field of a type that is return-type blocked.

* Add explicit struct return test.

* Clean up tests.

* Fix grammer.

* Add test for struct whose managed layout doesn't require a stdcall return buffer but whose native layout does.

* Add test verifying HandleRef behavior.

* Clean up IsUnsupportedTypedefReturn per PR feedback.

Remove the Smarty lst files from CoreCLR (#21962)

Use a blob feed specifically for coreclr (#21947)

This will reduce lock contention with other repos due to
https://github.com/dotnet/arcade/issues/1175.

Flowing the nativeCodeVersion to DebuggerJitInfo (#21925)

Add cleanup of the TypeIDMap at unload time (#21943)

The TypeIDMap is stored in the AppDomain and contains two hash maps -
id to MethodTable and MethodTable to id. We were missing removing
entries for MethodTables that belong to a LoaderAllocator that's being
destroyed. Thus we were leaking some memory, but also causing potential
issue. When at some point after the LoaderAllocator destruction a
MethodTable gets the same address as one of the MethodTables that was
destroyed in the past and was also recorded in the TypeIDMap, we would
incorrectly reuse the id. That is problematic in case the old
MethodTable didn't require fat id and the new does or vice versa.
I've hit assert due to that while running System.Numerics.Vectors.Tests
inside an unloadable AssemblyLoadContext.

The implementation of the fix is very primitive. It is expected that we
will be able to get rid of the TypeIDMap in a near future and so it is
not worth optimizing.

Merge pull request #21804 from briansull/fix-unbox-opt

Fix issue with devirtualization and tailcalls

Update CoreFx, PgoData to preview.19060.1, master-20190110.3, respectively (#21927)

Add WithCancellation for async enumerables (#21939)

Merge pull request #21928 from fiigii/fixMulx

Don't optimize MultiplyNoFlags away

JIT: fix byte range used by RangeCheck (#21915)

Range is -128 to 127, not -127 to 128.

Normalize a few more spin-wait loops (#21586)

Normalize a few more spin-wait loops

- Fixed a few more spin-waits to normalize the spin-wait duration between processors
- These spin-waits have so far not needed to be retuned to avoid unreasonably long spin-wait durations. They can be retuned as necessary in the future.
  - Added a version of YieldProcessorNormalized() that normalizes based on spin-wait counts tuned for pre-Skylake processors for spin-wait loops that have not been retuned.
- Moved some files around to make YieldProcessorNormalized() and the like available in more places. Initialization is still only done in the VM. Uses outside the VM will use the defaults, where there would be no significant change from before.
- Made YieldProcessor() private outside of the GC and added System_YieldProcessor() for when the system-defined implementation is intended to be used

Merge pull request #17733 from mikedn/cc-cond2

Expand GT_JCC/SETCC condition support

Merge pull request #21937 from BruceForstall/RemoveAltJitJobs

Remove altjit jobs in CI

Code Review feedback
Change test priority to 0

Don't optimize BMI2 MultiplyNoFlags away

disable dynamo test on arm32/64 (#21940)

New test for DevDiv_754566

Move public interface ISymDocumentWriter to shared location (#21931)

Move COMException to shared partition (dotnet/corert#6803)

* Move COMException to shared partition

* Review feedback

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

Merge pull request #21864 from fiigii/fixscalarmem

Fix CRC32 instruction encoding on containment form