Force byteable register for CMP if op2 is CNS_INT

On x86 we need to force byteable registers for compares not only when both
ops are typ_byte, but also when the first is of typ_byte and the second is
a constant int. The original condition for cmp only considered the first
case. This change adds the second condition.

Merge pull request #7514 from dotnet-bot/master-UpdateDependencies

Update CoreClr, CoreFx to beta-24607-02, beta-24607-03, respectively (master)

Merge pull request #7466 from adiaaida/fix7224

Force byteable registers for indir op source

Force byteable registers for indir op source

When we have a GT_STOREIND, we need to not only make sure that the
source and dest of the storeind are marked as requiring byteable
registers, but also the indirect op's source. For example:

```
GT_STOREIND(GT_ADD(TYP_INT, mem of TYP_BYTE, reg of TYP_INT or TYP_BYTE))
```

We need to make sure that the source reg of the GT_ADD is byteable.

This change fixes #7224.

Update CoreClr, CoreFx to beta-24607-02, beta-24607-03, respectively

Enable netstandard1.7 collations APIs (#7502)

* Enable netstandard1.7 collations APIs

This change is adding the netstandard 1.7 APIs to CompareInfo class and adding support to SortKey and SortVersion classes
The change include some support in cultureinfo and culturedata for locale Id's too which is used by CompareInfo class

* optimize the globalization data so we'll have faster initialization

* Remove security attributes

Restore some changes lost in a merge conflict (#7512)

Merge pull request #7490 from BruceForstall/EnableLegacy

Enable COMPlus_useLegacyJit=1 for CoreCLR for x86

Merge pull request #7507 from dotnet-bot/master-UpdateDependencies

Update CoreClr, CoreFx to beta-24606-03, beta-24606-02, respectively (master)

Merge pull request #7504 from pgavlin/NormalizeSpills

Always normalize stores when spilling lclVars.

Enable legacy JIT fallback for CoreCLR on Windows x86

This is to support the eventual case where RyuJIT/x86 becomes the default
x86 JIT, but we support fallback to the older, legacy JIT32/x86 (which
will be renamed compatjit.dll). This uses the same mechanism that was
built for .NET 4.6 when RyuJIT/x64 was shipped, and allowed fallback
to JIT64 as compatjit.dll.

However, we use a different configuration name to avoid conflicting
with the .NET 4.6 COMPlus_useLegacy name (and unintentionally causing
users to fall back to JIT64 with their .NET 4.6 apps).

The COMPlus variable is COMPlus_UseWindowsX86CoreLegacyJit=1. For the
dotnet.exe host, you can set `"System.JIT.UseWindowsX86CoreLegacyJit": true`
in the "configProperties" section of the app.runtimeconfig.json file.

There is a new COMPlus_RequireLegacyJit=1 option to aid testing JIT
fallback.

Fix a typo and a formatting issue.

Always normalize stores when spilling lclVars.

In order to support the semantics of the MSIL evaluation stack, RyuJIT
normalizes all "small" lclVars (i.e. lclVars with a non-struct
type that is smaller than an int32) from the actual type of the lclVar
to int32. This normalization may be performed in one of two ways:
- the lclVar's may be normalized when the lclVar is used (load
  normalization)
- at any point at which the value is defined, the value being stored to
  the lclVar is normalized (store normalization)

Store normalization must not be used if the lclVar is aliasable, since
the contents of the upper bytes for that lclVar's slot may be modified
by some other alias. Load normalization must be used if the lclVar is
a method parameter, as there is no guarantee that the caller has
properly nomralized the arguments it has passed. As such, any lclVar
that is either aliasable or is a method parameter is load-normalized,
and any other lclVar is store-normalized. lclVars that are
store-normalized are assumed to be represented as properly zero- or
sign-extended 4-byte values at all times, and so can simply be loaded
as int32s.

This picture becomes somewhat more subtle after register allocation,
however: once a lclVar has been enregistered, the contents of its
register are guaranteed to be properly zero- or sign-extended for the
purposes of store normalization, and in order for the lclVar to have
been enregistered in the first place, it must not have been aliasable.
As such, all enregistered variables may be store-normalized (as well as
load-normalized, if they represent method parameters). This has a
particularly significant impact on spills, as it implies that even if
the lclVar being spilled is not normally considered store-normalized, it
may be considered so for the purposes of the spill. This is advantageous
for architectures such as x86, as it allows a small lclVar to be
successfully spilled from a register that is not addressable at the size
of the lclVar's type. This change switches both LSRA and the code
generator to always use the actual type of a spilled lclVar for the
corresponding store rather than making this behavior conditional on
whether or not the lclVar is store-normalized.

Fixes #7236.

Update CoreClr, CoreFx to beta-24606-03, beta-24606-02, respectively

Fix incorrect index for localsDebug array (#7495)

Merge pull request #7505 from dotnet-bot/master-UpdateDependencies

Update CoreClr, CoreFx to beta-24606-02, beta-24606-01, respectively (master)

Update CoreClr, CoreFx to beta-24606-02, beta-24606-01, respectively

Merge pull request #7486 from CarolEidt/Fix7008

Support double-aligned frames for RyuJIT/x86

Merge pull request #7500 from mikedn/and-cmp-to-test

Fix and-cmp to test recognition

Support double-aligned frames for RyuJIT/x86

This factors out the analysis for when to use a double-aligned frame from the legacy backend.
Doing so exposed an assert for a case where we turn an intrinsic into a call in the Rationalizer, but don't update the frame requirements.
There may be some remaining tuning opportunities, given that the (pre-existing) algorithm doesn't attempt to create a double-aligned frame if we need an EBP-based frame for other reasons.

Fix #7008

Fix and-cmp to test recognition

Containment is used by TreeNodeInfoInitCmp to tell genCompareInt that a "and-cmp to test" pattern has been recognized.

Before LSRA added "reg optional" the result of isContained was solely determined by TreeNodeInfoInit. Now LSRA can make operands contained and then that happens genCompareInt wrongly believes that TreeNodeInfoInitCmp recognized the pattern.

To fix this genCompareInt needs to recognize (x and c) == 0 in addition to checking isContained.

Merge pull request #7498 from dotnet-bot/master-UpdateDependencies

Update CoreClr to beta-24605-03 (master)

Update CoreClr to beta-24605-03

Merge pull request #7492 from dotnet-bot/master-UpdateDependencies

Update CoreClr to beta-24605-02 (master)

Delete mscorlib from CoreCLR targeting pack (#7494)

Update CoreClr to beta-24605-02

Merge pull request #7472 from dotnet-bot/master-UpdateDependencies

Update CoreClr, CoreFx to beta-24604-03, beta-24604-02, respectively (master)

Merge pull request #7481 from pgavlin/RyuJITCrossgen

Add an option to crossgen S.P.CoreLib using the alt jit.

Add an option to crossgen S.P.CoreLib using the alt jit.

This also changes the x86/RyuJIT CI job to pass this option to
build.cmd. This leg will now use RyuJIT when crossgen'ing S.P.CoreLib
and when running tests.

Merge pull request #7436 from giuliohome/issue-7346

Issue 7346 ConstructorArguments from CustomAttributes for null array of enum

Merge pull request #7484 from adiaaida/assertOnNYI

Set default x86 test run to assert on nyi

Issue 7346 ConstructorArguments with null array of enum

From http://stackoverflow.com/a/39521919
In structure of the blob where the custom attribute is specified,
an enum argument is represented using the byte 0x55
followed by a string specifying the name and assembly of the enum type.
A null array is represented using a length of -1.

Unfortunately, what happens if you pass an array of enum as null is that
enum name is lost.

Fix #7346

Set default x86 test run to assert on nyi

Now that we have eliminated all of the NYIs from the base test run, set
the default to be to assert on NYI, incase we expose new NYIs.

Update CoreClr, CoreFx to beta-24604-03, beta-24604-02, respectively

Merge pull request #7476 from jkotas/security-annotations

Correct security annotations

[Linux][GDB-JIT] Fix incorrect frame location when we have a lot of locals (#7451)

* Fix incorrect frame location when we have a lot of (more than ten) locals or arguments

Add PGO GENPROFILE support to coreclr and clrjit (#7423)

* Add PGO GENPROFILE support to coreclr and clrjit

Update the cmake build system to enable support for Profile Guided
Optimization (PGO) on Windows, and enable this feature for two target
binaries (coreclr and clrjit).

With this change, toggle between instrumented and profile-optimized
settings for target binaries by passing pgoinstrument argument to the build.cmd
Assume profile-optimized mode by default. Fall back to regular non-PGO
optimized builds if profile data is not available.

API: Move Synchronized from StreamReader to TextReader (#7469)

Correct security annotations

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

Merge changes from TFS

Remove coreclr checks from AppDomain apis (#7471)

Merge pull request #7468 from CarolEidt/Fix7460

Allow GT_FIELD_LIST as legal arg for RyuJIT/x86

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

Merge changes from TFS

Add support for Alpine Linux (#7440)

This change enables build of CoreCLR on Alpine Linux. Here is the list
of changes:
- Disable asserts checking RSP in arbitrary threads against cached stack limit
  for the respective thread. The stack on Alpine obviously grows over the limit
  reported by the pthread functions.
- Disable using XSTATE. This should be re-enabled after MUSL gets the _xstate,
  _fpx_sw_bytes and related data structures added to the signal.h header.
- Disable setting rlimit of RLIMIT_NOFILE to the max value, since it breaks
  debugging for some reason.
- Add skipping over the hardware signal trampoline in the PAL_VirtualUnwind.
  While we were not trying to walk over it in a simple case, in a case where
  an exception was thrown from a catch handler of a hardware exception, we
  still attempted to walk over it and it fails on Alpine.
- Fix detection of Alpine Linux in the PAL's CMakeLists.txt so that it works
  in Docker containers too.
- Modified PAL_VirtualUnwind to make the check for unwinding past the bottom
  of the stack unconditional. We had a long list of platforms where we were
  doing this check and it doesn't hurt to do it on platforms where it is not
  needed. I have done that rather than adding a check for Alpine Linux as
  another platform that needs it.

Allow GT_FIELD_LIST as legal arg for RyuJIT/x86

The condition in GenTree::IsValidCallArgument() was not correct for
GT_FIELD_LIST, which is used for passing a struct on the stack in
RyuJIT/x86.

Fix #7460

Merge pull request #7464 from pgavlin/RyuJITPInvokeFrame

Fix P/Invoke call and method {pro,epi}logs in RyuJIT/x86.

Mark new UnmanagedMemoryAccessor methods as SafeCritical.

[tfs-changeset: 1630680]

Remove FirstChanceExceptionEventArgs from BCL folder. The file has been moved into mscorlib folder

[tfs-changeset: 1630635]

Add comment anchors.

Fix P/Invoke call and method {pro,epi}logs in RyuJIT/x86.

The contract for methods that contain P/Invokes differs between 64- and
32-bit targets.

In the former case, the JIT must:
- In the method prolog, initialize the P/Invoke frame with a call to
  CORINFO_HELP_INIT_PINVOKE_FRAME and push the frame on to the current
  thread's frame list if the method is an IL stub.
- Before/after each call, if the method is *not* an IL stub, push/pop
  the frame (respectively).
- In the method epilog, if the method is an IL stub, pop the P/Invoke
  frame.

In the latter case, CORINFO_HELP_INIT_PINVOKE_FRAME pushes the P/Invoke
frame on to the current thread's frame list, and the frame need only
be popped in the method epilog.

This change adjusts P/Invoke lowering s.t. the 64-bit discipline is
only followed for 64-bit targets.

Add Math.Clamp overloads to mscorlib.cs (#7462)

Merge pull request #7445 from dotnet-bot/master-UpdateDependencies

Update CoreClr to beta-24603-03 (master)

[Linux] [SOS.NETCore] Quick fix for Path.GetFileName (#7441)

* Quick fix for Path.GetFileName

* Updated after review

Fix DWARF linetable info provided by GDBJIT (#7444)

Extend PC to the end of function in DWARF linetable commands.
This allows the debugger to show source lines for all addresses
inside a function.

Update CoreClr to beta-24603-03

Fix a bug where the DAC read four more bytes than necessary (#7430)

to retrieve gcHeapType, which failed on crash dumps.

Remove WaitHandleExtensions, as it is implemented in CoreFX (#7431)

Merge pull request #7361 from vancem/MessageInLttng.9-26-16

Add the serialization of the Message field when writting LTTng events on Linux

Merge pull request #7359 from vancem/EventSOurceNullRefInLevelProperty.9-26-16

Fix Null Reference in accessing Level property in EventSource failure msgs

Initial support of local variables and method arguments in GDB JIT interface (#7400)

Merge pull request #7437 from dotnet-bot/master-UpdateDependencies

Update CoreClr, CoreFx to beta-24601-02, beta-24601-02, respectively (master)

Update CoreClr, CoreFx to beta-24601-02, beta-24601-02, respectively

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

Merge changes from TFS

Merge pull request #7438 from pgavlin/gh7090

Properly initialize lvaTrackedVarSet.

Merge pull request #7432 from pgavlin/gh6920

Call `gtEffectiveVal` in `gtWalkOp`.

Merge pull request #7388 from rahku/_appdomain

Expose AppDomain apis

Properly initialize lvaTrackedVarSet.

The lack of initialization when `lvaCount == 0` was causing failures
under JITStressRegs=0x80. When this initialization is not performed,
it is initialized s.t. every bit is set, including bits that represent
non-existent lclVars. This caused LSRA to AV when attempting to access
the lclVar table using a lclNum derived from an iteration over
`lvaTrackedVarSet`.

Fixes #7090.

Port changes to UnmanagedMemoryStream from corefx (#7418)

* Port changes to UnmanagedMemoryStream from corefx

dotnet/corefx#12170

* Add PrepareConstrainedRegions

* Add Back Read<T> and Write<T> methods

* Replace MemoryCopy with Memcpy

Expose AppDomain apis

Call `gtEffectiveVal` in `gtWalkOp`.

This function was using an ad-hoc, open-coded version of
`gtEffectiveVal` that was missing the effective value of `GT_NOP` nodes.
This change replaces these implementations with calls to
`gtEffectiveVal` and makes `gtEffectiveVal` non-recursive.

Fixes #6920.

Merge pull request #7428 from adiaaida/audit_flags

Copy GTF_ALL_EFFECTS to hiResult in decomp

Merge pull request #7427 from CarolEidt/Fix7197

Arm64 StoreBlk Lowering Fix

Merge pull request #7365 from dotnet-bot/master-UpdateDependencies

Update CoreClr, CoreFx, External to beta-24529-03, beta-24530-02, beta-24523-00, respectively (master)

Merge pull request #7429 from jashook/jit32_oss_devdiv255294

Exclude DevDiv_255294.cmd for jit32 due to timeout

Copy GTF_ALL_EFFECTS to hiResult in decomp

We need to make sure that the hiResult in decompose gets the same effect
flags as the original tree. This change updates decompose methods to pass
those flags from the tree to the hiResult in the cases that they weren't
being passed before.

Exclude DevDiv_255294.cmd for jit32 due to timeout

Update CoreClr, CoreFx, External to beta-24529-03, beta-24530-02, beta-24523-00, respectively

Explicitly specify feature test macro for glibc earlier than 2.19 (#7397)

Arm64 StoreBlk Lowering Fix

With the block assignment changes, the Arm64 version of
Lowering::TreeNodeInfoInitBlockStore was not using the correct node
for the source address.

Fix #7197

Fix change to GenericEqualityComparer.Equals from #5804 (#7419)

Merge pull request #7420 from tarekgh/EnableCalendarsAPisOnLinux

Enable added Calendar APIS on Linux

Add missing System.IO APIs (#7385)

This is the last chunk of APIs missing from System.IO that will be included in netstandard20 and that live in mscorlib.

Merge pull request #7407 from sivarv/simdOpt

Optimize codegen when SIMD (in)Equality that produces bool result is compared against true/false.

Enable added Calendar APIS on Linux

Merge pull request #7399 from CarolEidt/LinearCodegenRefactor

Refactor common codegen code

Optimize codegen when SIMD (in)Equality that produces bool result is compared against true/false.

Correct preprocessor conditional termination in case BACKGROUND_GC is not defined. (#7411)

This patch ensures that the code remains valid even when BACKGROUND_GC is not defined.
Before this patch, the endif that terminates the conditional compilation block
misses the terminating curly brace. That means there will be an extra, erroneous
closing brace the moment BACKGROUND_GC isn't defined.

Remove some unreachable code that was causing the ProjectK build to fail.

[tfs-changeset: 1630090]

Set THUMB bit for RUNTIME_FIXUP_HELPER functions (#7373)

* Appends THUMB bit for RUNTIME_FIXUP_HELPER address
* Revise GetEEFuncEntryPoint (for ARM) and use it to set thumb bit
* Uses GetEEFuncEntryPoint instead of GFN_TADDR

Fix ifdefs used to select the symbol reader dll name (#7406)

Refactor common codegen code

Extract the main code generator loop, the register management methods, and some debug info code.

Fix a typo in jit.settings.targets.

[tfs-changeset: 1630047]

Merge pull request #7404 from tarekgh/AddNormalizationToLinux

Add Normalization functionality to Linux

Add option to measure time spent inside calls to the CLR. (#7357)

* Add option to measure time spent inside calls to the CLR (off by default).

[tfs-changeset: 1629999]

Add Normalization functionality to Linux

This functionality will be used in different places (e.g. string class)

Expose required S.Resources members on corelib (#7402)

Fixes dotnet/corefx#12012

Merge pull request #7368 from pgavlin/SideEffects

Fix lowering's containment analysis.

Fix lowering's containment analysis.

This fixes a silent bad code generation issue that arose during internal
testing. The original repro is a test failure under COMPlus_JitStress=2.
Due to explicit null check insertion, we (eventually) end up with the
following LIR:

    t6096 =    lclVar    ref    V86 cse10         <l:$4ad, c:$1b5>

            /--*  t6096  ref
            *  st.lclVar ref    V41 tmp29        d:26

    t2733 =    lclVar    ref    V41 tmp29        u:26 <l:$4ad, c:$1b5>

            /--*  t2733  ref
            *  nullcheck byte   <l:$4b8, c:$58a>

    t2736 =    lclVar    ref    V41 tmp29        u:26 (last use) <l:$4ad, c:$1b5>

    t2737 =    const     long   20 field offset Fseq[y] $107

            /--*  t2736  ref
            +--*  t2737  long
    t2735 = *  +         byref  <l:$2ad, c:$2ac>

    t6081 =    lclVar    ref    V83 cse7          <l:$4bd, c:$1b7>

            /--*  t6081  ref
            *  st.lclVar ref    V41 tmp29        d:27

    t2762 =    lclVar    ref    V41 tmp29        u:27 <l:$4bd, c:$1b7>

            /--*  t2762  ref
            *  nullcheck byte   <l:$583, c:$58f>

    t2765 =    lclVar    ref    V41 tmp29        u:27 (last use) <l:$4bd, c:$1b7>

    t2766 =    const     long   20 field offset Fseq[y] $107

            /--*  t2765  ref
            +--*  t2766  long
    t2764 = *  +         byref  <l:$2af, c:$2ae>

            /--*  t2764  byref
    t2763 = *  indir     int    <l:$54e, c:$1ed>

    t2767 =    lclVar    int   (AX) V07 loc4          $1ee

            /--*  t2763  int
            +--*  t2767  int
    t2738 = *  +         int    <l:$554, c:$553>

            /--*  t2735  byref
            +--*  t2738  int
            *  storeIndir int

During lowering, we attempt to form an RMW add rooted at the final
storeIndir. The pattern matching that attempts to form RMW operations,
however, does not consider whether or not it is safe to perform the
code motion involved in making the destination and source addresses
for the operator contained. In this case, lowering moves the evaluation
of the address (i.e. the dataflow tree rooted at the add that produces
t2735) into the storeIndir. This moves a use of tmp29 across a def of
the same and causes the program to store a value to an incorrect
address.

There are many variations on this pattern. For example, given the
following C#:

static int T(C[] a, C c)
{
    return a.Length != c.M() ? 100 : 0;
}

The evaluation of a.Length (including the necessary null check) should
occur before the call to c.M(). The lack of correct checks for safe
code motion that caused the original repro, however, cause the JIT to
generate bad code in this case as well: the null check for a is folded
into the load of a.Length, which is then made contained by the compare.
This results in the call to c.M() executing before the null check, which
causes the program to behave incorrectly in the case that a is null.

In order to fix the code motion analysis, this change introduces a new
type, `SideEffectSet`, that can be used to summarize the side effects
of a set of nodes and check whether or not they interfere with another
set of side effects. This change then uses the new type to ensure that
it is safe to perform the code motion necessary to make an operand
contained before doing so.

Merge pull request #7403 from ramarag/addisvolatile

Adding back isVolatile to mscorlib facade as C# compiler uses it