Added Docs for Using Visual Studio to Edit and Debug in CoreCLR Repo (#7582)

Merge pull request #7600 from jkotas/master-UpdateDependencies

Update CoreClr, CoreFx to beta-24612-03, beta-24612-04, respectively

Merge pull request #7593 from pgavlin/DisableGCStressTest

Disable a test that is not compatible with GC stress.

Update tests to netcoreapp1.1

Disable a test that is not compatible with GC stress.

This test fails under GCStress=0xC for all of RyuJIT/x86, legacy backend
x86, and JIT32.

Merge pull request #7510 from kouvel/ApiThread

Expose some members of the Thread class

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

Merge changes from TFS

Merge pull request #7584 from sivarv/regressionTest

Adding JIT regression test for the re-morph optimzation that transforms JIT_Stelem_Ref(a, null, i)  into a[i]=null.

Merge pull request #7590 from smile21prc/coreclr-perf

Permanently fix benchview package version, and add code to produce perf-*-summary.xml on Linux

Merge pull request #7563 from wateret/fix-7398

[ARM/Linux] Fix HFA unit test regression

Cleanup files excluded from CoreCLR build

[tfs-changeset: 1633047]

Address feedback

Merge pull request #7585 from CarolEidt/Fix5699

x86: adjust stack level at throw blocks

x86: adjust stack level at throw blocks

When we don't have a frame pointer, we need to adjust the frame pointer before calling the throw helper.
I initially had some concern that we had some exposure from instruction reordering in the backend, but we don't do any reordering of the `GT_PUTARG_STK` nodes. I have added a note to sideeffects.h to call attention to the fact that we need to consider stack depth changes to be side effects, for future consideration should we start doing more general code motion.
For the more general issue, I have extracted the code from codegenlegacy.cpp that does the stack adjustment, and am now unconditionally calling it from both codegenlegacy.cpp and codegenxarch.cpp.

Fix #5699

Return false from IsMarshalByRefImpl/IsContextfulImpl when remoting is not supported (#7583)

Remove references to types have been moved to corefx in the build
Consolidate FEATURE_CORECLR ifdefs

Fail fast on a couple flaky tests to get crash dumps (#7588)

Fix a tailcall test that fails with Ready-to-Run (#7586)

The test case JIT/opt/Tailcall/TailcallVerifyWithPrefix has some methods that
depend on the JIT compiler doing automatic tail call. Since tail is not
supported with Ready-to-Run, the test case is modified to exclude such methods
from Ready-to-Run images.

Port NullStream.CopyTo override from corert (#7589)

Update CoreClr, CoreFx to beta-24612-03, beta-24612-04, respectively

Merge pull request #7557 from sandreenko/long_decomp_6925

Use the existing operands for long decomposition #6925

Run VS formatting (no semantic change) (#7587)

Debugging

Move StreamHelpers from corefx and refactor Stream and MemoryStream to use it (#7579)

Expose members of Thread that hide base class members

Fix build issue

Fix build issue

Address feedback

Expose some members of the Thread class

- Added RuntimeThread class that Thread derives from. An instance of RuntimeThread will be used by the Thread class in CoreFX to forward thread functionality to the runtime.
- Some functionality in the RuntimeThread could potentially be moved to CoreFX. In particular, some of thread creation and apartment state handling could probably be moved with some minimal help from the runtime. Leaving that refactoring for later.
- A few things are left unimplemented (for instance, apartment state handling doesn't work currently). That functionality will be enabled in a future change.

Part of dotnet/corefx#11632, dotnet/corefx#11638, dotnet/corefx#11635

Unnecessary temp loc vars were deleted in DecomposeLong.

Delete temp local variables from DecomposeNeg, DecomposeShift.
Remain local variables have several uses(DecomposeShift) or are call
arguments. Such variables can't be deleted.

Adding JIT regression test for a re-morph optimization.

Provide KeyValuePair.Create static factory method (#5755)

Just like Tuple.Create cuts down the noise and annoyance
of having to specify all the Ts when you already have typed
values to provide, a similarly designed KeyValuePair.Create
factory method would make code that creates those pairs
(i.e. public APIs that expose IEnumerable{KeyValuePair}
significantly more concise and readable.

Fixes dotnet/corefx#2127

Merge pull request #7576 from sandreenko/check_ready_to_run_for_protojit

set ready to run flag for protojit

Exposing MarshalByRefObject (#7558)

Merge pull request #7575 from sivarv/lsraStat

Dump LSRA stats.

Enable TextInfo APIs for netstandard 1.7 on Linux (#7568)

* Enable TextInfo APIs for netstandard 1.7 on Linux

The change here is to enable the newly added netstandard 1.7 TextInfo APIs on Linux.

- moved the locale specific data to its own file Locale.Unic.cs
- added needed data to handle the TextInfo properties (e.g. codepages)
- created some helper methods in LocaleData classto handle accessing the locale data
- added the implementation for added APIs

* Fix some typos

Merge pull request #7561 from BruceForstall/Fix7483

Fix assertion regarding byteable reg when ngen'ing desktop mscorlib

Fix assertion regarding byteable xor reg,reg when ngen'ing desktop mscorlib

Fixes #7483

The issue is that TreeNodeInfoInitCmp() will, under certain circumstances,
perform a tree transformation of a child node into a TYP_UBYTE type. Since
the TreeNodeInfo walk is bottom-up, its children have already been processed,
and they don't get the "byteable" register processing that is as the end of
TreeNodeInfoInit().

I extracted that processing into a TreeNodeInfoInitCheckByteable() function that
can be called after the TreeNodeInfoInitCmp() transformation.

A better solution might be to extract this, and other, tree transformations into
the prior "lowering" pass, such that TreeNodeInfoInit() and friends will only
do register requirement annotation. But that would be considerably more complicated,
so I opted not to do that for now.

I also fixed up a bunch of comments.

Fix conflicting identity of System.IO.TextReader (#7578)

System.IO build was switched to use CoreFX copy of System.IO.TextReader and friends. These type have to be removed from CoreLib now to avoid type identity mismatches.

set ready to run flag for protojit

Dump LSRA stats.

Merge pull request #7571 from pgavlin/MkRefAnyFieldTypeX86

Fix the type of the data field of a typed ref on x86.

Merge pull request #7574 from DrewScoggins/runtestfix

Fix runtest.cmd return code

Fix runtest.cmd return code

When running the GenerateLayoutOnly command of runtest.cmd the script
should return zero instead of one.

Fix the type of the data field of a typed ref on x86.

This field should be of type byref; not treating it as such causes GC
holes when passing typed references.

Merge pull request #7310 from wateret/for-7002-2

[ARM] Generate direct call instructions for recursive calls

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

Merge changes from TFS

Merge pull request #7560 from pgavlin/StoreBlkGCHole

Disable emit{Enable,Disable}GC for x86.

SemaphoreSlim performance improvement (#137)

* Waiters notification by the value of releaseCount (reduce the number of false-wakeups).

Update Readme.md to lead you through basic repo workflow (#7552)

Update README.md to contain much more information about using the repo

Fix a build break in the ARM64 JIT.

[tfs-changeset: 1632696]

Merge pull request #7562 from pgavlin/x86PreemptiveAssert

Remove an overly fragile assertion.

[ARM/Linux] Fix HFA unit test regression

Fix #7398

Remove an overly fragile assertion.

The GC stress infrastructure contained an assertion that was meant to
help detect managed code running in preemptive mode. Unfortunately, this
assertion was derived from the set of instructions emitted by the JIT at
the time at which it was added. As such, it is now out of date.

Because a failure of this assertion does not necessarily indicate a
correctness bug and because it is onerous to keep up-to-date, remove it.

Remove AllowPartiallyTrustedCallers from a test (#7555)

Partial trust is not part of .NET Core.

Disable emit{Enable,Disable}GC for x86.

The GC info encoding for this platform does not permit marking
arbitrary regions of generated code as non-interruptible.

Merge pull request #7518 from adiaaida/cmpByteable

Force byteable register for CMP if op2 is CNS_INT

Update adding_new_public_apis.md (#7544)

Merge pull request #7537 from pgavlin/PushStructArgsX86

Fix the codegen for by-value struct args on x86.

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.

Address PR feedback.

Merge pull request #7530 from ramarag/StrongNameKeyPair

Strong name key pair

Exposing StrongNameKeyPair

Merge pull request #7543 from JosephTremoulet/NoRngChecks_Rel

Stop making JitNoRngChecks debug-only

Fix buffer length usage in UTF-8 to Unicode conversion (#7540)

These changes are ported from desktop CLR.

Fix various CustomAttributeBuilder bugs (#7206)

Fix various CustomAttributeBuilder bugs

Stop making JitNoRngChecks debug-only

JitNoRngChecks is a flag, only available in special builds, that removes
all array bounds checks from generated code, which exists solely to
facilitate experiments measuring the cost of bounds checks.  Commit
0aebfbef0 added support for it to RyuJit, but accidentally did so only for
debug builds; release `FEATURE_ENABLE_NO_RANGE_CHECKS` builds are
currently broken.

This change makes the jit flag's definition available in release builds
with `FEATURE_ENABLE_NO_RANGE_CHECKS` defined as well.  The corresponding
code in clrconfigvalues.h already works that way.

Fix the codegen for by-value struct args on x86.

Although the existing code generation for by-value struct args containing
GC references on x86 was correct with respect to the layout of the data
being passed, it was not correct with respect to the invariants necessary
for the GC info encoder.

The existing codegen for by-value struct args--whether represented by
`GT_OBJ` or `GT_FIELD_LIST` nodes--takes what is essentially the
following approach:

    sub esp, argument_size
    mov [esp + offset_0], field_0
    mov [esp + offset_1], field_1
    ...
    mov [esp + offset_n], field_n

Although this puts the correct data in the correct locations, the
emitter is unable to recognize that a GC info update is requires if any
of the `mov` instructions write a GC reference to the stack: instead,
on x86, `push` instructions must be used to write GC references on the
stack. Furthermore, the stack must be kept 4-byte aligned.

This change modifies the code generator to use `push` instructions to
write outgoing GC references to the stack while obeying the alignment
invariant required by the GC encoding. For outgoing by-value struct
args represented by `GT_OBJ`, this results in very straightforward code:

    push [val_addr]
    push [val_addr + 4]
    ...
    push [val_addr + n]

For args represented by `GT_FIELD_LIST`, the picture is a bit more
complicated as the stack must be kept 4-byte aligned. Handling of these
args is split into two cases: if a field list contains no GC references
and is larger than 16 bytes or contains any fields that cannot be
treated as a 4-byte-aligned, int32-sized value, the argument is passed
using the `sub esp, arg_size; mov [esp + offset], field` approach.
Otherwise--if the struct contains any GC references or is smaller than
16 bytes and only contains fields that can be treated as slots--the
argument is passed using the following approach:
- If a field is a GC reference or can be treated as a 4-byte slot, the
  field is stored to the stack using a `push` instruction.
- Otherwise, the stack pointer is first adjusted to the next 4-byte
  aligned address after the offset of the field and the field is
  stored to the appropriate address using a `mov`.

For example, given the following IR:

     t55 =    lclVar    bool   V06 tmp4         u:6 esi REG esi RV $40

    t138 =    dconst    float  0.00000000000000000 REG mm0 $80

           /--*  t138   float
           +--*  t55    bool
    t139 = *  <fldList> void   float at offset 4 REG NA $180

           /--*  t139   void
    t152 = *  putarg_stk [+0x00] void   REG NA

The backend will generate the following code:

    sub      esp, 8
    movss    dword ptr [esp+04H], xmm0
    mov      dword ptr [esp], esi

And given the following IR:

    t13 =    lclVar    ref    V04 tmp1         u:2 esi (last use) REG esi RV $1c0

    t45 =    lclVar    int    V05 tmp2         u:2 eax (last use) REG eax RV $200

          /--*  t45    int
          +--*  t13    ref
    t46 = *  <fldList> void   int at offset 4 REG NA $240

The backend will instead generate the following:

    push     eax
    push     esi

These changes also produce beneficial diffs: for example, the native image
for System.Private.CoreLib.dll has diffs in ~1000 methods for an overall
size improvement of 1%.

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

Update CoreClr to beta-24609-02 (master)

Update CoreClr to beta-24609-02

Add test to validate ByRef type unification (#7534)

Make sure that `ldtoken SomeType&` leads to the same type as `ldtoken
SomeType` followed by `MakeByRefType`.

Implement CultureNotFoundException id-based ctors (#7536)

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

Update CoreClr, CoreFx to beta-24609-01, beta-24608-01, respectively (master)

Update CoreClr, CoreFx to beta-24609-01, beta-24608-01, respectively

Standardize on _echo name (#7532)

Merge pull request #7521 from vkvenkat/master

Fixed #7519 - Dotnet crashes while saturating multiple CPU groups on Windows

Return null on allocation failure due to OOM instead of throwing a exception from within the GC (#7501)

Disable CER code that is causing access violation

Resolves issue dotnet/corefx#12412.

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

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

Merge pull request #7520 from pgavlin/PutStructArgStk

Refactor genPutStructArgStk for clarity.

Fix formatting.

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

Fixed #7519 - Dotnet crashes while saturating multiple CPU groups on Windows

Refactor genPutStructArgStk for clarity.

This also contains a minor CQ improvement: instead of always
incrementing the source and destination pointers when copying a struct
argument to the stack, we now only do so if there are more slots to
copy.

Merge pull request #7515 from BruceForstall/FixMerge

Fix bad merge

Merge pull request #7509 from sandreenko/master

Set missed default value for coreclr runtest.cmd #7488.

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)

Fix bad merge

A previous checkin backed-out a change that moved one test out of
the RyuJIT/x86 section. I'm reverting that, and putting the test
exclusion back where it should be.

At the same time, now that there are no RyuJIT/x86 test exclusions,
I'm deleting the RyuJIT/x86 section.

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.

Set missed default value for coreclr runtest.cmd.

__MSBuildBuildArch is set to x64 by default like __BuildArch. Fix 7488.

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