GT_START_NONGC has no kill set

It was mistakenly added to the `GT_PROF_HOOK` case in the recent LSRA changes.

Allow ILCodeVersion to fallback to default IL (#18322)

For compat with profilers that used our APIs in unexpected ways we can allow
the ILCodeVersion to fallback to the default IL code when no IL was explicitly
given.

Moves CurrentSystemTimeZone, ICastable, RegistryView and RegistryValueKind to shared (#18337)

* Moves CurrentSystemTimeZone to shared completely

* Moves ICastable to shared

* Moves RegistryView and RegistryValueKind to shared

* Moves ICastableHelpers to its own file

Force short date pattern to use yyyy on Linux (#18316)

* Force short date pattern to use yyyy on Linux

The default pattern we get is using yy which causes the years  to be displayed  as 2 digits. This is not acceptable for many users. The fix here is to force 4-digit year as a default and still keep the original pattern which has 2-digits year in the optional list

* Address the review feedback

Remove dead case from string.Compare (#18345)

Guard Windows code under PLATFORM_WINDOWS (#18344)

Fixed a couple of comments about ArgumentException on timeout parameters (#18335)

Remove a dead branch from __DTString (#18334)

All call sites to the ctor validate that the DateTimeFormatInfo has been created.

Delete FormatterConverter from CoreLib (#18336)

It's not used in the library.  The type is implemented/exposed from corefx.

Cross-bitness support in JitInterface (#18329)

* Replace sizeof(tailCallType) / sizeof(tailCallType[0]) with _countof(tailCallType)

* Remove TransparentProxyObject and RealProxyObject

* InlinedCallFrame::GetEEInfo should not be used for R2R compilation

* Hardcode constants used in CEEInfo::getEEInfo

* Thread fields should not be used for R2R compilation

* Zero pEEInfoOut->inlinedCallFrameInfo when compiling R2R code

* Rename OFFSETOF__PtrArray__m_Array to avoid compilation conflicts with asmconstants

* Add assertions enabled in every non-crossbitness scenario

* Define and use CROSSBITNESS_COMPILE macro

Fix ARM cast codegen (#18063)

* Fix ARM cast codegen

ARM cast codegen is rather convoluted and sometimes does the wrong thing by applying GTF_UNSIGNED to the destination type even though this flag is only about the source type.

* Add more conversion tests

These tests are intended to support casts with contained operands. They're also useful to catch issues caused by load nodes having small types and generally improve test coverage for casts.

Adding containment support for more x86 hardware intrinsics (#18297)

* Adding containment support to one-operand scalar HWIntrinsics (x86)

* Adding containment support to two-operand imm HWIntrinsics (x86)

* Adding containment support to three-operand imm HWIntrinsics (x86)

* Updating hwintrinsiccodegenxarch to properly mask Sse41.Insert for TYP_FLOAT

* Updating the Sse41.Insert tests for TYP_FLOAT

* Adding containment support for Sse2.CompareLessThan and BlendVariable (Sse41/Avx/Avx2)

* Fixing `genHWIntrinsic_R_RM_I` to call `emitIns_SIMD_R_R_I`, rather than `emitIns_R_R_I`

* Updating emitOutputSV to not modify the code for IF_RWR_RRD_SRD_CNS

* Cleaning up some of the emitxarch code.

* Moving roundps and roundpd into the IsDstSrcImm check

R2RDump - Unwind Info (#18248)

* Extract unwind info from image

* Use typeDef.Namespace to get full namespace, move to separate function

* Avoid passing R2RReader to R2RMethod and RuntimeFunction constructors

* Dump unwind info

* Changes to unwindInfo output format

Fix issue in Compiler::impImportStaticFieldAccess (#18328)

When CORINFO_FIELD_STATIC_SHARED_STATIC_HELPER accessor is being processed for
structs, the method creates a GT_IND node instead of GT_OBJ node. For structs
that can be normalized to a specific type (like TYP_SIMD8), it causes an assert
in Compiler::impNormStructVal in the switch case for GT_IND.

This change modifies the node creation to work the same way as in the default
case for accessors, creating GT_OBJ for structs and GT_IND otherwise.

JIT: implement assembly name dissassembly filtering (#18306)

Add `COMPlus_JitDisasmAssemblies` to specify a whitelist of assemblies
whose methods will be disassembled (also filters out order, EH, GC, and
unwind info dumps too).

Intended use is for PMI asm diffing. Since PMI runs in process, current
disassembly will dissassemble various methods in PMI itself as well
as framework methods that did not get prejitted.

With this new config option we can restrict disassembly to just the assemblies
that we're processing via PMI.

Moves FastResourceComparer and TaskAwaiter to shared (#18283)

* Reduces diff in BinaryReader

* Moves FastResourceComparer to shared

* Reduces diff in FileBasedResourceGroveler

* Minor comment diff in ManifestBasedResourceGroveler

* Reducing diff by removing extra blank lines in ResourceReader

* Reduces diff by renaming private fields in AssemblyName

* String to string and Object to object in AssemblyName

* Reduces diff in TaskAwaiter

* Moves TaskAwaiter to shared

* Apply code review feedback

* Fixes failure in corert

* Revert Renaming fields in AssemblyName

Increase timeout and log the result for some WaitAny tests that expect AbandonedMutexException (#18312)

Follow-up to https://github.com/dotnet/coreclr/pull/13298, missed a few cases.

Add instructions for making idl file changes (#18188)

Merge pull request #18313 from dotnet-bot/from-tfs

Merge changes from TFS

Merge pull request #18303 from mikedn/lockadd4

Use the actual type of LOCKADD's data operand

Fix a warning as error issue that causes a build break on the Desktop CLR

[tfs-changeset: 1702868]

Use sysconf(_SC_NPROCESSORS_CONF) instead of sysconf(_SC_NPROCESSORS_ONLN) in PAL and GC ONLY on ARM and ARM64 (#18289)

Fixed typos on readme (#18304)

Use the actual type of LOCKADD's data operand

The data operand can theoretically be a small int so we need to use its actual type to determine instruction size.

In practice this issue does not seem to happen as the importer is pretty insistent in spilling interlocked arguments to lclvars that have the proper type. Even when the data argument is already a small int lclvar (e.g. short method argument) this still doesn't cause problems because there's a cast between the method argument and LOCKADD.

Update SDK used to build jitutils to 2.1 RC (#18290)

In anticipation of taking a dependence on netcoreapp2.1 for the
forthcoming PMI work from jitutils.

Also make sure to shut down build servers before cleaning up the SDK.

Use WChar instead of char (#18294)

JIT: tolerate byref/nint return type mismatches during inlining (#18274)

Have the jit tolerate byref/nint return type mismatches for inlines
same way that it tolerates them for ret instructions.

Fixes #18270.

Adding function headers to the 'emitIns_SIMD_*' methods and clarifying comments on related code.

Updating the x86 HWIntrinsics to support containment for most one-operand intrinsics.

Fixing up ContainCheckHWIntrinsic to use intrinsicId and to switch on the category for 1/3 arg intrinsics

Fixing the name of the paramters in the emitIns_SIMD_* methods.

Merge pull request #18267 from mikedn/lockadd3

Cleanup LOCKADD handling

Make Encoding.Unicode.GetString faster on 64-bit platforms (#18263)

UnicodeEncoding was taking fast path only when both source and destination were 8-byte aligned. It was not
the case for Unicode.GetString.

The fix is to just check the source alignment as fast path precondition, and use unaligned write for destination.

Also removed alternative fast path that is not needed anymore, tweaked local variable assignments for better
register allocation, and fixed performance issue introduced by recent big endian portability fix.

R2RDump - Dump AvailableTypes section contents (#18227)

* Move R2RReader constructor to separate functions, parse READYTORUN_SECTION_AVAILABLE_TYPES

* Fix bug from merging, output formatting changes

* Rename availableTypes variables, save availableTypes as string instead of tuple

Cleanup LOCKADD handling

LOCKADD nodes are generated rather early and there's no reason for that:
* The CORINFO_INTRINSIC_InterlockedAdd32/64 intrinsics are not actually used. Even if they would be used we can still import them as XADD nodes and rely on lowering to generate LOCKADD when needed.
* gtExtractSideEffList transforms XADD into LOCKADD but this can be done in lowering. LOCKADD is an XARCH specific optimization after all.

Additionally:
* Avoid the need for special handling in LSRA by making GT_LOCKADD a "no value" oper.
* Split LOCKADD codegen from XADD/XCHG codegen, attempting to use the same code for all 3 just makes things more complex.
* The address is always in a register so there's no real need to create an indir node on the fly, the relevant emitter functions can be called directly.

The last point above is actually a CQ issue - we always generate `add [reg], imm`, more complex address modes are not used. Unfortunately this problem starts early, when the importer spills the address to a local variable. If that ever gets fixed then we'll could probably generate a contained LEA in lowering.

Fixed a couple of comments on TimeSpan.SecondsPerTick and Thread.SleepInternal (#18276)

* Fixed comment for TimeSpan.SecondsPerTick

* Fixed comment on Thread.SleepInternal

Optimise HtmlEncode to produce less garbage

do the same optimisation for HtmlDecode

remove now-unneeded reference

Add tests for new ValueStringBuilder methods

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

Flow EventSources to EventPipe on Windows (#18217)

Work in VM towards cross-bitness crossgen (#18245)

* Replace sizeof expressions with target-specific constants:

* sizeof(ObjHeader) -> OBJHEADER_SIZE
* sizeof(Object) -> OBJECT_SIZE
* ObjSizeOf(Object) -> OBJECT_BASESIZE
* sizeof(ArrayBase) -> ARRAYBASE_SIZE
* ObjSizeOf(ArrayBase) -> ARRAYBASE_BASESIZE

* Remove ObjSizeOf macro

* Use OBJECT_SIZE in ArrayBase::GetBoundsOffset

* Cast ppObj to CORCOMPILE_GCREFMAP_TOKENS* before dereferencing in FakePromote

* LOG2_PTRSIZE should depend on _TARGET_64BIT_

Fix error during compilation with /permissive- (#18272)

Be more aggressive with Partial NGen (#18240)

* Be more aggressive with partial ngen

In partial ngen, we only compile those methods that both have profile
data and have the ReadMethodCode flag set in the profile flags. That
means that we miss some functions that do have counts, which affects the
performance of assemblies crossgened with partial ngen. This change
makes partial ngen more aggressive by, in the cold path, first checking
to see if we already considered this method in the hot section, which
means that it has profile data, and only rejecting those methods that
were not already considered.

Merge pull request #18264 from luqunl/18192

Set GTF_RELOP_QMARK in gtNewQmarkNode

Fix build break (#18278) (#18279)

Delete unused file (#18271)

Typo (#18266)

* addres -> address

* depedant -> dependent

* gaurantee -> guarantee

* gaurantees -> guarantees

* lable -> label

* lazieness -> laziness

* lcoation -> location

* enquing -> enqueuing

* enregsitered -> enregistered

* ensurin -> ensuring

Warnings cleanup (#18260)

* Cleanup all disabled warnings that do not trigger

* Fix warning about line continuation in single line comment

* Eliminiate all unreferenced local variables and reenable warning

Set GTF_RELOP_QMARK in gtNewQmarkNode

Typo (#18261)

* accomodate -> accommodate

* accross -> across

* adddress -> address

* bookeeping -> bookkeeping

* arbitary -> arbitrary

* calulating -> calculating

* fromClas -> fromClass

* comand -> command

* comming -> coming

* comparisions -> comparisons

* configuiration -> configuration

* contraints -> constraints

* datastructures -> data structures

* defintely -> definitely

* defered -> deferred

* diassemble -> disassemble

* Emptry -> Empty

* everytime -> every time

* fragmetation -> fragmentation

* instaces -> instances

* interpretting -> interpreting

* intialize -> initialize

* loction -> location

Try to fix issues with Unicode on big endian OSes (#18254)

Mono had some patches in their fork of referencesource to resolve
issues on big endian. Essentially, compile-time endianness handling
is no good for big endian platforms, because they have to consume a
Monolite intended for all platforms in order to bootstrap. So then,
all big endian platforms are now consuming a bootstrap tarball made
on little endian systems, and bad things happen as a result.

This makes it so that endianness is checked at runtime by using
System.BitConverter.IsLittleEndian, not by a compiler definition.

This integrates mono/mono@1f9b218 and mono/mono@92cec46, which won't
apply cleanly to current CoreFX.

mono/mono#8679 may get fixed by this, but as the comments say,
there could be more patches missing. This just integrates the
patches known to me on UnicodeEncoding and UTF8Encoding.

Cleanup and remove unused parameters from genCreateAddrMode (#18258)

* Cleanup and remove unused parameters from genCreateAddrMode, fixes #18177

Enable tailcall_v4\smallFrame\smallFrame (#18246)

* the bad il was removed

PR #11316  removed the bad IL sequences from this test.

* reenable for linux

Merge BCryptGenRandom.cs (#18233)

Fixing some flags that were queried incorrectly.

Applying the formatting patch.

Updating the x86 HWIntrinsics to query flags via explicit methods.

Moving more methods to be static methods on HWIntrinsicInfo

Moving the simdSizeOfHWIntrinsic and numArgsOfHWIntrinsic methods to be static methods on HWIntrinsicInfo

Moving various x86 HWIntrinsicInfo lookup methods to be static methods on HWIntrinsicInfo

Moving the x86 lookupHWIntrinsic and lookupHWIntrinsicISA methods to be static methods on HWIntrinsicInfo

Moving the getHWIntrinsicInfo and getHWIntrinsicName methods to be static methods on HWIntrinsicInfo

Moving the xarch HWIntrtinsicInfo type into its own header file.

JIT: Eliminate RegTracker (#18179) (#18230)

* Replace regTracker.rsTrackRegTrash with regSet.verifyRegUsed

* Replace regTracker.rsTrackRegCopy with regSet.verifyRegUsed

* Replace regTracker.rsTrackRegIntCns with regSet.verifyRegUsed

* Replace regTracker.rsTrashRegSet with regSet.verifyRegistersUsed

* Move verifyReg* method implementation from header file to implementation file

* Replace regTracker.rsTrackRegLclVar with regSet.verifyRegistersUsed

* Eliminate RegTracker

* Fixed the funclet prolog special case

* Experiment - Changing the verification code to actually set the mask

* Adding function headers

* Removed a few trailing spaces

Implement corefx/#16619 Add FormattableString.CurrentCulture (#18253)

Enable Alpine cross build for arm and arm64 (#18234)

* Enable Alpine cross build for arm and arm64

This change enables cross build and rootfs creation for
Alpine Linux ARM / ARM64 targets.

Besides that, I've cleaned up the toolchain.cmake and got rid
of the explicit specification of GCC version specific include
and lib folders for all targets except of Tizen. Clang is able
to figure that out on its own the same way as it does when doing
regular non-cross builds, but it needed one more option for that.

I've also fixed a bug in the `add_compile_param` macro that caused
ignoring of parameters in cases where another parameter that was
a substring of the one being added was already present. So for example
if an option `-L${CMAKE_SYSROOT}/usr/lib/gcc` was already added,
attempt to add option `-L${CMAKE_SYSROOT}/usr/lib` would do nothing.

* Fix to  make it work with cmake 2.8 too

The older cmake that is still in use on Ubuntu 14.04 doesn't have
support for specifying sysroot and target via cmake variables.
So I've replaced those by explicit setting of the compiler / linker
options instead.

JIT: fix issue with zero-length stackalloc (#18183)

Defer calling `setNeedsGSSecurityCookie` until we know for sure that
the jit won't do the zero-length stackalloc optimization.

Closes #18176.

Adding more NoContainment flags to the x86 hwintrinsic list

Updating the x86 hwintrinsic code to better check for containment support.

Reduce race risk in MutexWaitOne2::PosTest4() (#18195)

Merge pull request #18059 from helloguo/fix18039

Fix issue18039: Add SSE2 intrinsic MoveScalar for type long and ulong

[arm64] Disable `a % b = a & (b - 1);` optimization. (#18206)

* Disable `a % b = a & (b - 1);` optimization on arm64

Morph can't relay on Lower optimization that it can't guarantee.

* improve checks in lower

We do not expect MOD/UMOD for integer/long types in lower for arm64.

Updating the HWIntrinsic codegen to ensure ival always fits in a byte.

Fix CoreRT build breaks in Stream moved to shared

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

Added disassembler CoreDisTools to dump runtime functions (#18180)

Remove obsolete targets

Remove unused NewDiffer function, fix error with uninitialized declaringTypeHandle

rebase

fix SSE2 intrinsic MoveScalar for type long and ulong

Native lib relative path (#18239)

* Typo in #define

* Don't add prefix for relative path to native images if the path contains a platform path delimiter

* Use already defined delimiter macro
Create max variation count variable

Fix GitHub_16041 test. (#18210)

* fix StructY size

This was doing a cpblk of 28 bytes (size of StructY) from StructX, but StructX was only 12 bytes big. Change StructY to 12.

* fix size

Mark JIT/Regression/JitBlue/GitHub_18056 as JitOptimizationSensitive (#18184)

R2RDump - Commandline interface (#18136)

* Use ReadCompressedData for NativeHashTable, fix ref signature types, save array dimension, use AppendLine to avoid line-ending problems

* Include System.CommandLine, arg parsing, read/write file

* Add commandline options to search sections/methods/runtimeFunctions, option to dump raw data

* Added comments, save cli options in global variables, renamed some functions

* Add DumpByte function to R2RSection and R2RHeader, indent raw bytes

* Change some cli option names, use DumpRuntimeFunction, return list of query matches, changes to ArgStringToInt

* Move DumpBytes to R2RDump, print method of runtime function

* Use writer object instead of Console

* Use TextWriter instead of own writer class

* Handle jagged arrays and other cases using MethodDefinition.DecodeSignature with a slightly modified DisassemblingTypeProvider

* Close the _writer in finally block

Merge pull request #18216 from vancem/FixThreadNameSet

Fix Managed Thread Name Setting

Moves Stream to shared location (#18142)

* Moves Stream to shared location

* Review tweaks

* Add NotImplementedException for SyncStream due to https://github.com/dotnet/corert/issues/3251

Fix SpanHelpers.ClearWithoutReferences alignment detection (#18222)

Review feedback

Merge pull request #18220 from sdmaclea/PR-HasPendingGCStressInstructionUpdate

Fix HasPendingGCStressInstructionUpdate CONSISTENCY_CHECK

Arm stepping fixes (#18129)

* Ensure thumb bit is set when initializing a code region.
* Use macro rather than manually setting thumb bit in debugger.cpp
* Ensure thumb bit is set when calling FindOrCreateInitAndAddJitInfo.
* Add an assert to FindOrCreateInitAndAddJitInfo when on arm to ensure the thumb bit is set

Add additional features to SOS DumpAsync command (#18213)

1. Computing GC roots is a relatively slow operation, and doing it for every state machine object found in a large heap can be time consuming.  Making it opt-in with -roots command-line flag.

2. Added -waiting command-line flag.  DumpAsync will now retrieve the <>1__state field from the StateMachine, and if -waiting is specified, it'll filter down to state machines that have a state value >= 0, meaning the state machines are waiting at an await point.  For example, given this program:
```C#
using System.Threading.Tasks;
class Program
{
    static async Task Main() { await MethodA(0); await MethodA(int.MaxValue); }
    static async Task MethodA(int delay) => await MethodB(delay);
    static async Task MethodB(int delay) { await Task.Yield(); await Task.Delay(delay); }
}
```
using `!DumpAsync` outputs:
```
         Address               MT     Size Name
#0
0000026848693438 00007ff88ea35e58      120  System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1+AsyncStateMachineBox`1[[System.Threading.Tasks.VoidTaskResult, System.Private.CoreLib],[Program+<MethodB>d__2, test]]
StateMachine: Program+<MethodB>d__2 (struct)
              MT    Field   Offset                 Type VT     Attr            Value Name
00007ff8e9bc4bc0  4000008        0         System.Int32  1 instance               -2 <>1__state
00007ff8e9bd82f8  4000009        8 ...TaskMethodBuilder  1 instance 0000026848693490 <>t__builder
00007ff8e9bc4bc0  400000a        4         System.Int32  1 instance                0 delay
00007ff8e9bee4d0  400000b       10 ...able+YieldAwaiter  1 instance 0000026848693498 <>u__1
00007ff8e9bcead0  400000c       18 ...vices.TaskAwaiter  1 instance 00000268486934a0 <>u__2
Continuation: 00000268486934b0 (System.Object)

#1
0000026848693e68 00007ff88ea36cc8      112  System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1+AsyncStateMachineBox`1[[System.Threading.Tasks.VoidTaskResult, System.Private.CoreLib],[Program+<MethodA>d__1, test]]
StateMachine: Program+<MethodA>d__1 (struct)
              MT    Field   Offset                 Type VT     Attr            Value Name
00007ff8e9bc4bc0  4000004        0         System.Int32  1 instance               -2 <>1__state
00007ff8e9bd82f8  4000005        8 ...TaskMethodBuilder  1 instance 0000026848693ec0 <>t__builder
00007ff8e9bc4bc0  4000006        4         System.Int32  1 instance                0 delay
00007ff8e9bcead0  4000007       10 ...vices.TaskAwaiter  1 instance 0000026848693ec8 <>u__1
Continuation: 00000268486934b0 (System.Object)

#2
0000026848693ed8 00007ff88ea37188      112  System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1+AsyncStateMachineBox`1[[System.Threading.Tasks.VoidTaskResult, System.Private.CoreLib],[Program+<Main>d__0, test]]
StateMachine: Program+<Main>d__0 (struct)
              MT    Field   Offset                 Type VT     Attr            Value Name
00007ff8e9bc4bc0  4000001        0         System.Int32  1 instance                1 <>1__state
00007ff8e9bd82f8  4000002        8 ...TaskMethodBuilder  1 instance 0000026848693f30 <>t__builder
00007ff8e9bcead0  4000003       10 ...vices.TaskAwaiter  1 instance 0000026848693f38 <>u__1
Continuation: 0000026848693f48 (System.Threading.Tasks.Task+SetOnInvokeMres)

#3
0000026848695d30 00007ff88ea35e58      120  System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1+AsyncStateMachineBox`1[[System.Threading.Tasks.VoidTaskResult, System.Private.CoreLib],[Program+<MethodB>d__2, test]]
StateMachine: Program+<MethodB>d__2 (struct)
              MT    Field   Offset                 Type VT     Attr            Value Name
00007ff8e9bc4bc0  4000008        0         System.Int32  1 instance                1 <>1__state
00007ff8e9bd82f8  4000009        8 ...TaskMethodBuilder  1 instance 0000026848695d88 <>t__builder
00007ff8e9bc4bc0  400000a        4         System.Int32  1 instance       2147483647 delay
00007ff8e9bee4d0  400000b       10 ...able+YieldAwaiter  1 instance 0000026848695d90 <>u__1
00007ff8e9bcead0  400000c       18 ...vices.TaskAwaiter  1 instance 0000026848695d98 <>u__2
Continuation: 0000026848695dd0 (System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1+AsyncStateMachineBox`1[[System.Threading.Tasks.VoidTaskResult, System.Private.CoreLib],[Program+<MethodA>d__1, test]])

#4
0000026848695dd0 00007ff88ea36cc8      112  System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1+AsyncStateMachineBox`1[[System.Threading.Tasks.VoidTaskResult, System.Private.CoreLib],[Program+<MethodA>d__1, test]]
StateMachine: Program+<MethodA>d__1 (struct)
              MT    Field   Offset                 Type VT     Attr            Value Name
00007ff8e9bc4bc0  4000004        0         System.Int32  1 instance                0 <>1__state
00007ff8e9bd82f8  4000005        8 ...TaskMethodBuilder  1 instance 0000026848695e28 <>t__builder
00007ff8e9bc4bc0  4000006        4         System.Int32  1 instance       2147483647 delay
00007ff8e9bcead0  4000007       10 ...vices.TaskAwaiter  1 instance 0000026848695e30 <>u__1
Continuation: 0000026848693ed8 (System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1+AsyncStateMachineBox`1[[System.Threading.Tasks.VoidTaskResult, System.Private.CoreLib],[Program+<Main>d__0, test]])

Found 5 state machines.
```
while using `!DumpAsync -waiting` outputs only:
```
         Address               MT     Size Name
#0
0000026848693ed8 00007ff88ea37188      112  System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1+AsyncStateMachineBox`1[[System.Threading.Tasks.VoidTaskResult, System.Private.CoreLib],[Program+<Main>d__0, test]]
StateMachine: Program+<Main>d__0 (struct)
              MT    Field   Offset                 Type VT     Attr            Value Name
00007ff8e9bc4bc0  4000001        0         System.Int32  1 instance                1 <>1__state
00007ff8e9bd82f8  4000002        8 ...TaskMethodBuilder  1 instance 0000026848693f30 <>t__builder
00007ff8e9bcead0  4000003       10 ...vices.TaskAwaiter  1 instance 0000026848693f38 <>u__1
Continuation: 0000026848693f48 (System.Threading.Tasks.Task+SetOnInvokeMres)

#1
0000026848695d30 00007ff88ea35e58      120  System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1+AsyncStateMachineBox`1[[System.Threading.Tasks.VoidTaskResult, System.Private.CoreLib],[Program+<MethodB>d__2, test]]
StateMachine: Program+<MethodB>d__2 (struct)
              MT    Field   Offset                 Type VT     Attr            Value Name
00007ff8e9bc4bc0  4000008        0         System.Int32  1 instance                1 <>1__state
00007ff8e9bd82f8  4000009        8 ...TaskMethodBuilder  1 instance 0000026848695d88 <>t__builder
00007ff8e9bc4bc0  400000a        4         System.Int32  1 instance       2147483647 delay
00007ff8e9bee4d0  400000b       10 ...able+YieldAwaiter  1 instance 0000026848695d90 <>u__1
00007ff8e9bcead0  400000c       18 ...vices.TaskAwaiter  1 instance 0000026848695d98 <>u__2
Continuation: 0000026848695dd0 (System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1+AsyncStateMachineBox`1[[System.Threading.Tasks.VoidTaskResult, System.Private.CoreLib],[Program+<MethodA>d__1, test]])

#2
0000026848695dd0 00007ff88ea36cc8      112  System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1+AsyncStateMachineBox`1[[System.Threading.Tasks.VoidTaskResult, System.Private.CoreLib],[Program+<MethodA>d__1, test]]
StateMachine: Program+<MethodA>d__1 (struct)
              MT    Field   Offset                 Type VT     Attr            Value Name
00007ff8e9bc4bc0  4000004        0         System.Int32  1 instance                0 <>1__state
00007ff8e9bd82f8  4000005        8 ...TaskMethodBuilder  1 instance 0000026848695e28 <>t__builder
00007ff8e9bc4bc0  4000006        4         System.Int32  1 instance       2147483647 delay
00007ff8e9bcead0  4000007       10 ...vices.TaskAwaiter  1 instance 0000026848695e30 <>u__1
Continuation: 0000026848693ed8 (System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1+AsyncStateMachineBox`1[[System.Threading.Tasks.VoidTaskResult, System.Private.CoreLib],[Program+<Main>d__0, test]])

Found 3 state machines.
```
skipping the two state machines that have a `<>1__state` field value of -2 (meaning it's completed).  Note that this change has the somewhat unfortunate impact of taking a dependency on what's effectively an implementation detail of Roslyn, but the value the filtering provides is deemed to be worth it.  This design is unlikely to change in the future, and as with other diagnostic/debugging features that rely on such details, it can be updated if Roslyn ever changes its scheme.  In the meantime, the code will output a warning message if it can't find the state field.

3. If a state machine is found to have 0 roots but also to have a <>1__state value >= 0, that suggests it was dropped without having been completed, which is likely a sign of an application bug.  The command now prints out an information message to highlight that state.  For example, this program:
```C#
using System;
using System.Threading.Tasks;
class Program
{
    static void Main()
    {
        Task.Run(async () => await new TaskCompletionSource<bool>().Task);
        Console.ReadLine();
    }
}
```
when processed with `!DumpAsync -roots` results in:
```
         Address               MT     Size Name
#0
0000020787fb5b30 00007ff88ea1afe8      112  System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1+AsyncStateMachineBox`1[[System.Boolean, System.Private.CoreLib],[Program+<>c+<<Main>b__0_0>d, test]]
StateMachine: Program+<>c+<<Main>b__0_0>d (struct)
              MT    Field   Offset                 Type VT     Attr            Value Name
00007ff8e9bc4bc0  4000003        0         System.Int32  1 instance                0 <>1__state
00007ff8e9bd0b88  4000004        8 ...Private.CoreLib]]  1 instance 0000020787fb5b88 <>t__builder
00007ff8e9bffd58  4000005       10 ...Private.CoreLib]]  1 instance 0000020787fb5b90 <>u__1
Continuation: 0000020787fb3fc8 (System.Threading.Tasks.UnwrapPromise`1[[System.Boolean, System.Private.CoreLib]])
GC roots:
Incomplete state machine (<>1__state == 0) with 0 roots.

Found 1 state machines.
```

Review feedback

Fix number formatting exception with empty NumberGroupSizes array (#18221)

[Arm64] Implement genZeroInitFltRegs for float (#18200)

Review feedback

Review feedback

Fixed misspelling

Review feedback (avoid passing out unpinned managed pointers).

Add test case for optimized box vector assert (#18163)

Test case for issue #18043 was left out of #18046. Adding it now.

Merge pull request #18191 from BruceForstall/RemoveUnusedDefines

Remove unused defines

Support new Japanese calendar eras (#18209)

Japan is going to introduce the new era next year 2019, this new era will be added to the Japanese calendar. This new era would affect anyone converting, formatting or parsing dates using the Japanese calendar.
Users who formatted future dates before introducing the new era and then try to parse these dates after introducing the new era will fail and get parsing exception. The reason is the year number will not be valid in the old era anymore because the new era set a year limit to the old era.

Here is an example:

Format a date like "平成 32年2月1日" which saying year 32 in the era "平成". after we introduce the new era, the old era "平成" will be limited up to and including year 31 so year 32 is exceeding the era end.

The fix is to allow the parser succeeds with such dates and have a config switch which can be used to for anyone want the old behavior.

Fix HasPendingGCStressInstructionUpdate CONSISTENCY_CHECK

Moving MissingFieldException (fully) and MissingMethodException (partially) to shared (#18207)

Expose Exception.set_HResult as Public (#18203)

* Expose Exception.set_HResult as Public

* Remove internal Exception.SetErrorCode

Fix Managed Thread Name Setting

System.Thread has a  'Name' Property that will call the Windows OS SetThreadDescription that will give the thread that friendly name for debuggers and profilers.   However this code was broken in a couple ways.

First, it actually calls the  SetThreadDescription  with a null name when a thread is created (even if later the name is set.   Secondly, if the Thread.Name is set before the thread is actually started, then SetThreadDescription is not called at all.

This change fixes both of these issues.   First, when a thread is created it uses the Name property if it is set.   Second if the name property is set, it does not call SetThreadDescription if the Thread has not been created.   Third, it skips calls to SetThreadDescription if the name is null.