Merge pull request #13597 from CarolEidt/InfoLinearScan

Move TreeNodeInfoInit to LinearScan

Merge pull request #13581 from noahfalk/fix_corefx_testing

Fix running corefx tests

Merge pull request #13411 from pgavlin/RepriTests

Reprioritize tests to improve inner-loop throughput.

Use CreateFile2 instead of CreateFile2FromApp (#13595) (#13607)

* Use CreateFile2 instead of CreateFile2FromApp

* Feedback fixes

Merge pull request #13579 from CarolEidt/RemoveDupLowerBlockStore

Arm Containment Cleanup

Delete superfluous check in funceval.cpp (#13598)

Func-eval'ing BCL methods with the DynamicSecurityMethod attribute causes an ArgumentException.

Minor performance infrastructure changes. (#13557)

- IlLink scenario will run on a VM (currently it is only measuring MSIL size)
- Updated the patterns of files to search for on scenario runs
- Updated the JitBench commit hash being used ()
- Disable min_opt from the PR correctness mode.
- String was not being interpolated.

Fix generic context passed to resolved constrained method calls (#13577)

If the EE was able to resolve a constrained call, the instantiating
parameter to use is the type by which the call was constrained with. We
embed pConstrainedResolvedToken as the extra argument because
pResolvedToken is an interface method and interface types make a poor
generic context.

The CLR doesn't hit this path because these types of constrained method
calls go through an instantiating stub. We don't do instantiating stubs
in CoreRT.

[Arm64/Unix] Add JIT_Stelem_Ref helper (#13588)

Create deep-dive-blog-posts.md (#13336)

PR Feedback and formatting

Move TreeNodeInfoInit to LinearScan

In preparation for computing the TreeNodeInfo on the fly, move all the TreeNodeInfoInit and related methods to the LinearScan class.

Don't multiply YieldProcessor count by proc count (#13556)

Related to issue mentioned in https://github.com/dotnet/coreclr/issues/13388
- Multipying the YieldProcessor count by proc count can cause excessive delays that are not fruitful on machines with a large number of procs. Even on a 12-proc machine (6-core), the heuristics as they are without the multiply seem to perform much better.
- The issue above also mentions that the delay of PAUSE on Intel Skylake+ processors have a significantly larger delay (140 cycles vs 10 cycles). Simulating that by multiplying the YieldProcessor count by 14 shows that in both tests tested, it begins crawling at low thread counts.
- I did most of the testing on ManualResetEventSlim, and since Task is using the same spin heuristics, applied the same change there as well.

PR Feedback

Remove Span(T[], int) ctor (#13575)

* Remove Span(T[], int) ctor - from issue #23471

Use Span-based TryParse in several globalization types (#13582)

Merge pull request #13586 from parjong/fix/ClrStack_full

[ARM/Linux] Enable clrstack -f

Do not devirtualize indirect calls (#13561)

I'm seeing the affected code take the `impDevirtualizeCall` code path
with `CT_INDIRECT` calls. `gtCallMethHnd` is a `GenTreePtr` in that case
(it's a union) and passing that as as `CORINFO_METHOD_HANDLE` leads
to bad things.

Merge pull request #13245 from pgavlin/NoExpandIndex

Use a smaller expansion of GT_INDEX in MinOpts.

Arm Containment Cleanup

- Fix a couple of issues with TreeNodeInfoInit for struct arguments
- Remove duplicate calls to LowerBlockStore from TreeNodeInfoInit for arm and arm64
- Eliminate duplicative isMultiReg method from GenTree and fix condition for OperIsMultiRegOp()

Merge pull request #13584 from wateret/fix-armel-treenodeinfoinit

[RyuJIT/armel] Fix ifdef block in TreeNodeInfoInit

Enable clrstack -f in ARM/Linux

[RyuJIT/armel] Fix ifdef block in TreeNodeInfoInit

Merge pull request #13506 from mikedn/switch-un

Fix switch unsigned cast

Remove uses of the {RO}Span ctor that takes an array and offset (#13578)

Fix running corefx tests

Running CoreFX tests was supposed to use a batch file (env_script) to run CoreFX tests under different environment configurations. However due to subtlties in how the command line is parsed none of the environment variables set by this script would actually persist for the execution of the tests. As best I can tell prior to this fix specifying a env_script had no effect whatsoever on windows, and our CI corefx test stress scenarios weren't actually testing the scenario they claimed to be testing.

cmd /c "Set.bat&&Check.bat" will propagate env vars set in Set.bat so that they are visible in Check.bat because both batch files execute within the context of the newly invoked cmd.exe process. However cmd /c Set.bat&&Check.bat (no quotes) will run Set.bat in its own cmd.exe process, then exit that process and run Check.bat in the parent shell process. The parent process does not have any environment variable changes that were made by Set.bat.

Remove unnecessary buffer copy from EventPipe::WriteEvent pipeline (#13347)

* [WIP] Eliminate extra buffer copy with new api path

* Copy blobs to a flat buffer is Rundown is on

* Refactor to use payload class and dedupe code

* Add contracts

* Fix many small errors

* Make names unambiguous

* Add EventPipe::WriteEventBlob to ecalllist.h

* Address code review

* Add test and fix a buffer copy bug

* Copy data instead of data pointer

* Add optional output file arg to tests

* Change failure return code

* Renamed variables for clarity

Merge pull request #13573 from noahfalk/add_ci_logging

Makes sure the CI archiving runs even on failure

Makes sure the archiving runs even on failure

Fix switch unsigned cast

Address PR feedback.

mscorlib cache padding for 128 byte lines (#13102)

* mscorlib ConcurrentQueue pad for 128B cache lines

* Add Padding.cs

Merge pull request #11589 from mikedn/gen-am

Fix improper handling of GenTreeAddrMode offset

Merge pull request #13470 from CarolEidt/Fix13451

Fix ARM issues with Containment

Fix improper handling of GenTreeAddrMode offset

For unknown reasons GenTreeAddrMode::gtOffset is unsigned rather than
int. On 32 bit hosts this doesn't really matter but on 64 bit hosts we
end up zero extending instead of sign extending it, GetTreeIndir::Offset()
does that by casting from unsigned to size_t.

It doesn't appear possible for this to cause correctness issues (because
the address mode displacement is 32 bit anyway) but it's confusing and
hurts CQ because the emitter can't recognize small negative displacements
that can be encoded in a single byte.

It's worth noting that CodeGen::genCreateAddrMode uses ssize_t internally
to represent the offset but then returns it as unsigned the emitter works
with either int or ssize_t displacements (e.g. emitIns_R_ARX & co. have
int disp arguments, emitNewInstrAmd has ssize_t dsp argument).

Change steps:

Access GenTreeAddrMode's gtOffset via Offset() - Offset() returns the correct
type - int instead of unsigned. All non-legacy uses of gtOffset were replaced
with Offset() and casts were added where necessary. gtOffset was made private
in non-legacy builds to ensure it is not used directly.

Rename GenTreeIndir's Offset() to Address() - This function is problematic,
it returns size_t which is suitable for representing addresses but not
offsets. Rename it and then figure out where offsets are needed and where
addresses are needed.

Add back Offset() with the correct return type - All usages of
GenTreeIndir::Address() (e.g. emitNewInstrAmd) expect ssize_t, not size_t.

Fix the bug - GenTreeIndir::Offset() return ssize_t and
GenTreeAddrMode::Offset() returns int. It doesn't make sense to have a
cast to unsigned.

Fix ARM's handling of GenTreeAddrMode offset - Various pieces of code
(e.g. emitIns_valid_imm_for_ldst_offset) already treat the offset as
signed, they use int, INT64, ssize_t. More importantly, emitarm64's
emitInsLoadStoreOp treats the offset as signed while TreeNodeInfoInitIndir
treates it as unsigned. The later is wrong.

Add unwind info to core dumps. (#13547)

The createdump utility now enumerates all the native stack frames (with
some help from the managed stack walker) for all the threads adding all
the ELF unwind info needed.

On a different machine and without any of the native modules loaded when
the crashdump was generated all the thread stacks can still be unwound
with lldb/gdb.

Change the PAL_VirtualUnwindOutOfProc read memory adapter in DAC
to add the memory to instances manager.

Some misc. cleanup.

Merge pull request #13553 from tijoytom/master

Revert incorrect change from commit 16fc300

Fix ARM issues with Containment

These are changes that should have been part of PR #13198:
- Correctly contain struct arguments
- Correctly get number of source registers
- Clear register assignments on `GT_FIELD_LIST` nodes (thanks @hseok-oh).
- Remove now-redundant `ContainCheck` methods for armarch targets.

Merge pull request #13550 from pgavlin/DevDiv482577

Type `lea [this + delegateObject]` as `TYP_BYREF`.

Merge pull request #13529 from wtgodbe/ParameterizeRids

Parameterize RIDs for package restore

Merge pull request #13559 from noahfalk/add_ci_logging

Add more logging to corefx test CI runs

Add more logging to corefx test CI runs

Merge pull request #13548 from rartemev/revert_12469_fix

Revert "Fixed misconception between FP register allocator and RyuJIT's CSE phase"

Merge pull request #13533 from wtgodbe/buildNumber

Disable default BuildNumberMajor

This reverts
https://github.com/dotnet/coreclr/commit/16fc3005c085212f6e700a0df8ff7f36c1ea535b
The PR was trying to fix an incorrect test , we should be passing
in !fForWinRT.See https://github.com/dotnet/coreclr/issues/13460#issuecomment-324456870
for more info.

Fixed Equals/GetHashCode bug for struct. (#13164)

Other than `ContainsPointers` and `IsNotTightlyPacked`, added two new conditions for checking whether a valuetype can go to fast path or not. Following are the details of these 2 conditions:

- Check whether a valuetype contains a Single/Double field. If it does, we cannot go to fast path. Floating point numbers have special `Equals` and `GetHashCode` implementation. We cannot simply compare floating point numbers via bits (e.g. +0.0 should equal to -0.0, but their underlying bits are different).

- Check whether an user-defined valuetype overrides `Equals` or `GetHashCode`. If it does, we cannot go to fast path. Because `Equals` or `GetHashCode` result may be different to bit comparison.

To find Single/Double fields and overridden `Equals`/`GetHashCode`, we start a DFS to go through the whole hierachy of the source valuetype, and cache the result to `MethodTable`.

Fix #11452

Add "long GC" jobs to the pri1 build set.

Type `lea [this + delegateObject]` as `TYP_BYREF`.

This node was incorrectly typed as `TYP_GCREF`, which was causing an
assertion during GC stress in internal testing.

Fixes VSO 482577.

Parameterize RIDs for package restore

Revert "Fixed misconception between FP register allocator and RyuJIT's CSE phase"

This reverts commit 3f4ee3bed52291e592d7ab67da1fc0e39ee8a3b7.

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

Merge changes from TFS

Improve ReaderWriterLockSlim scalability (#13495)

* Improve ReaderWriterLockSlim scalability

Subset of #13243, fixes #12780

- Prevented waking more than one waiter when only one of them may acquire the lock
- Limited spinning in some cases where it is very unlikely that spinning would help

The _myLock spin lock runs into some bad scalability issues. For example:
1. Readers can starve writers for an unreasonable amount of time. Typically there would be more readers than writers, and it doesn't take many readers to starve a writer. On my machine with 6 cores (12 logical processors with hyperthreading), 6 to 16 reader threads attempting to acquire the spin lock to acquire or release a read lock can starve one writer thread from acquiring the spin lock for several or many seconds. The issue magnifies with more reader threads.
2. Readers and especially writers that hold the RW lock can be starved from even releasing their lock. Releasing an RW lock requires acquiring the spin lock, so releasers are easliy starved by acquirers. How badly they are starved depends on how many acquirers there are, and it doesn't take many to show a very noticeable scalability issue. Often, these acquirers are those that would not be able to acquire the RW lock until one or more releasers release their lock, so the acquirers effectively starve themselves.

This PR does not solve (1), but solves (2) to a degree that could be considered sufficient. #13243 solves (1) and (2) and for (2) it is still better by order-of-magnitude compared with this PR in several cases that I believe are not extreme, but if the complexity of deprioritization is deemed excessive for the goals then of what I tried so far this is the perhaps simplest and most reasonable way to solve (2).

I believe this PR would also be a reasonably low-risk one to port back to .NET Framework.

Enable overriding default stack size on Unix (#13517)

Alpine Linux has a very small default stack size limit, about 80kB.
This is not enough for running coreclr apps.

This change enables overriding the default stack size using the
COMPlus_DefaultStackSize env variable. For Alpine, it also sets
the default stack size to the same value we use for Windows, which
is 1.5MB.

Merge pull request #13540 from wateret/fix-13423

[RyuJIT/arm32] Fix MultiReg flag setter

JIT: refine types when creating arg temps to improve devirtualization (#13530)

The jit will refine the types of temps used to pass arguments to inlinees
when it creates the assignments to these temps.

Unfortunately this is too late to drive devirtualization in the body of
the inlinee, as thes assignments are created after the inlinee body is
imported.

So, add similar refinement logic to the place where the temps are first
created.

Closes #13520.

Add a regression test for #13160 (#13531)

Merge pull request #13450 from sjsinju/genisvaliddoublereg

[RyuJIT/ARM32] Remove unnecessary genIsValidDoubleReg() assertion

Merge pull request #13528 from JosephTremoulet/Iterate

Add InnerIterationCount to layout benchmarks

[RyuJIT/arm32] Fix MultiReg flag setter

Bitwise operation fix in `SetRegSpillFlagByIdx()`.

Fix #13423

Remove empty span check from Stream.Read/Write (#13536)

When I added the base Stream.Read/Write(span) default implementations, I added a special-case check for if the span is empty, in which case it made the operation a nop.  But various streams want to impose behavior even in the 0-byte case, e.g. throwing an ObjectDisposedException if the stream has been closed.  This commit just removes the check and allows Read/Write to delegate for all sized spans.

Merge pull request #13535 from rartemev/issue_12467

Fixed assertion failure in legacy backend

Merge pull request #13522 from stephentoub/fsspan

Override Span-based Read/Write on FileStream

Fixed assertion failure in legacy backend

JIT: don't self assign to temps (#13484)

Modify gtNewTempAssign to more generally map self-assignment of temps
into nops.

We already were doing something similar over in `impAssignStruct`, and
now we catch non-struct cases too.

rollback Changeset 1671419: importCall

[tfs-changeset: 1671421]

importCall

[tfs-changeset: 1671419]

Disable default BuildNumberMajor

Remove macro definition checks that aren't useful and cause unnecessary build breaks (#13523)

Fix inconsistency between GetHasCode and Equals (#13513)

Add InnerIterationCount to layout benchmarks

These tests were too short-running to measure effectively.  Add an inner
iteration count that makes the running time around 1 second (measured
locally).

Introduce COMPlus_GDBJitEmitDebugFrame (#13515)

* Introduce COMPlus_GDBJitEmitDebugFrame

* Use a proper #ifdef macro

Override Span-based Read/Write on FileStream

Adds overrides for the new Span-based Read/Write methods on FileStream.

A few notes:
- As with {Unmanaged}MemoryStream, FileStream isn't sealed, which means a derived type could have overridden all of the existing abstract/virtual methods, including Read(byte[],int,int).  If a consumer then switched to using that stream with Read(Span), because we now override Read(Span), the consumer should get the same behavior intended by the stream developer. As such, since we have no good/efficient way to check whether Read(byte[],int,int) is overridden, we check whether the current stream is a concrete FileStream (rather than a derived type), and if it isn't we use the default base behavior, which will call the Read(byte[],int,int) method.
- FileStream is odd in that it has a dual nature around whether it was initialized for sync vs async, a setting that on Windows ends up configuring the native handle to operate in async mode.  Sync operations on an async-configured FileStream end up delegating to the async methods and blocking, and async operations on a sync-configured FileStream end up using the synchronous behavior asynchronously.  There were some inconsistencies around how this was handled between Windows and Unix, in particular around the ReadByte method, and as part of adding these overloads, I changed that as well, as doing so made the code simpler with the new Span-based support.  Technically this is a breaking change on Unix, but it would be very niche, including calling ReadByte on an async stream while other async operations were in progress... in that case, the desktop and Windows core behavior was to allow direct access to any cached data in the buffer, whereas on Unix we would serialize the ReadByte call with other async operations in flight.

[Arm64/Unix] Use portable MP optimized new/alloc (#12333)

[Arm64] Fix RecycledListsWrapper cache guard (#13397)

Merge pull request #12216 from ellismg/fix-warnings

Fix warnings when building SOS.NETCore.csproj

[Local GC] Enable building the GC as a shared library (#13137)

* [Local GC] Build the GC using system headers

* Disable features to get the GC to build

* Get rid of the separate 'GC PAL' build

* Remove unused stuff

* Don't build gcenv.os.cpp when linking in a standalone gc

* Stub out CPUGroupInfo and NumaNodeInfo

* Stub out IsGCThread and friends

* Build the GC as a shared library :tada:

* Build, link, and run! :tada:

* Fix standalone GC build break

* Fixes where the GC's MethodTable and VM's MethodTable classes disagree

* Integrate a standalone GC into the CoreCLR build system (so it gets copied to the output folder). Re-enable some ifdef-ed out includes that are required for a non-standalone build of the GC.

* Bring changes to Unix and fix the Unix build. Implement some compiler intrinsic wrappers and alignment functions expected by the GC.

* Fix the Windows build

* 1. Code review feedback: use standard types for BitScanForward and
   BitScanForward64
2. Delete FEATURE_COM stuff from the build system, not needed for this
PR
3. Fix the Unix build

* Fix the Windows x86 build - the _BitScanForward64 intrinsic is not available when targeting 32-bit platforms

* Remove a number of things from gcenv.base.h that are not used

* Remove a linker workaround now that we are not linking a standalone GC into the runtime

* Remove dead code, make the lack of GC_PROFILING for standalone gc not break profiling on the non-standalone build

* Code review feedback - use add_library_clr and other cmake-related fixes

* Fix include indentation

* Remove some extraneous parameters to cmake functions (cmake is remarkably lenient...)

Merge pull request #13461 from JosephTremoulet/TodoUpdate

Update JitOptimizerTodoAssessment.md

Follow-up: Add enforce PGO to official builds (#13437)

* Add variables to pipeline to enable enforcepgo for Release

* Address review

Merge pull request #13487 from mikedn/switch-temp-type

Fix incorrect switch temp lcl type

Delete some dead PAL code (#13469)

* Delete some dead PAL code

GetComputerName and GetUserName are not used.

* HAVE_GETPWUID_R can now be deleted

Remove empty try's (#13493)

* Remove empty try's

* Remove some dead comments

* more

Undo a few JIT layout workarounds (#13505)

Remove some `goto`s that were added to work around #9692 (poor code
layout for loop exit paths) -- the JIT's layout decisions were improved
in #13314, and these particular `goto`s are no longer needed; crossgen
of System.Private.CoreLib now produces the same machine code with or
without this change.

Part of #13466.

ThreadPool minimalistic thread request cap (#13431)

Cap ThreadPool thread requests minimalistically

- Only request an additional thread on dequeue if enqueue request was suppressed, and if there are any work items left in the queues
- ThreadPool pad hot cache line
- Add ideas from #13408

fix JitConfig initialize and destoy (#13477)

fix JitConfig initialize and destoy.

Merge pull request #13496 from justinvp/version_parse

Avoid unnecessary intermediate Version allocation

Fixing wcsstr function to account for cases where search string is longer than remaining target string. (#13504)

Use CreateFile2FromApp if available (#13410)

* Use CreateFile2FromApp if available

This is needed for F5 UAP brokering scenarios.

Remove check for handle type. Overzealous, doesn't apply to UAP scenarios.

* Address feedback

- Use CreateFile2 if Win8 or higher
- Always use CreateFile2FromApp if Appx
- Make DisableMediaInsertionPrompt a struct
- Push CreateFile2FromApp down to avoid JIT

* More feedback

Always use FromApp for WinRT.

* Conditionalize IsWindows8OrAbove check

* Always use FromApp if in AppX

* Address more feedback

- Fix Unix build by moving LoadString to shared
- Break out CREATEFILE2 struct
- Condition CreateFile2FromApp usage

* Move include

Clean up VS experience for s.p.corelib.csproj (#13481)

* Remove bogus assembly warnings in VS

* Fix warnings about sharing files within the project tree

* Remove bogus lines

* Remove lines showing up as bogus source files

* Remove overridden target

* feedback

Merge pull request #13482 from rartemev/issue_12469

Fixed misconception between FP register allocator and RyuJIT's CSE phase

Merge pull request #13424 from stephentoub/versionspan

Add span-based Version methods

Support docker cgroup limits (#13488)

* Fix cgroup mountinfo parsing

The parsing would find the wrong '-' in lines like this:
354 347 0:28 /system.slice/docker-654dd7b6b8bbfe1739ae3309b471e95ccc82b3a3f56b7879f0a811d68b5c4e1d.scope /sys/fs/cgroup/cpuacct,cpu ro,nosuid,nodev,noexec,relatime - cgroup cgroup rw,cpuacct,cpu

* cgroup: don't append cgroup relative path for reading docker limits

Merge pull request #13497 from noahfalk/tiered_jit_fix_tests

Enable by-request tiered compilation testing in CI

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

Update CoreClr, CoreFx to preview2-25621-02, preview2-25621-02, respectively (master)

Use a smaller expansion of `GT_INDEX` in MinOpts.

We currently expand `GT_INDEX` nodes during morph into an explicit
bounds check followed by a load. For example, this tree:

```
[000059] ------------       /--*  LCL_VAR   int    V09 loc6
[000060] R--XG-------    /--*  INDEX     ref
[000058] ------------    |  \--*  LCL_VAR   ref    V00 arg0
[000062] -A-XG-------    *  ASG       ref
[000061] D------N----    \--*  LCL_VAR   ref    V10 loc7
```

is expanded into this tree:

```
[000060] R--XG+------       /--*  IND       ref
[000491] -----+------       |  |  /--*  CNS_INT   long   16 Fseq[#FirstElem]
[000492] -----+------       |  \--*  ADD       byref
[000488] -----+-N----       |     |     /--*  CNS_INT   long   3
[000489] -----+------       |     |  /--*  LSH       long
[000487] -----+------       |     |  |  \--*  CAST      long <- int
[000484] i----+------       |     |  |     \--*  LCL_VAR   int    V09 loc6
[000490] -----+------       |     \--*  ADD       byref
[000483] -----+------       |        \--*  LCL_VAR   ref    V00 arg0
[000493] ---XG+------    /--*  COMMA     ref
[000486] ---X-+------    |  \--*  ARR_BOUNDS_CHECK_Rng void
[000059] -----+------    |     +--*  LCL_VAR   int    V09 loc6
[000485] ---X-+------    |     \--*  ARR_LENGTH int
[000058] -----+------    |        \--*  LCL_VAR   ref    V00 arg0
[000062] -A-XG+------    *  ASG       ref
[000061] D----+-N----    \--*  LCL_VAR   ref    V10 loc7

```

Even in this simple case where both the array object and the index are
lclVars, this represents a rather large increase in the size of the IR.
In the worst case, the JIT introduces and additional lclVar for both the
array object and the index, adding several additional nodes to the tree.
When optimizing, exposing the structure of the array access may be
helpful, as it may allow the compiler to better analyze the program.
When we are not optimizing, however, the expansion serves little purpose
besides constraining the IR shapes that must be handled by the backend.
Due to its need for lclVars in the worst case, this expansion may even
bloat the size of the generated code, as all lclVar references are
generated as loads/stores from/to the stack when we are not optimizing.
In the case above, the expanded tree generates the following x64
assembly:

```
IN0018: 000092 mov      rdi, gword ptr [V00 rbp-10H]
IN0019: 000096 mov      edi, dword ptr [rdi+8]
IN001a: 000099 cmp      dword ptr [V09 rbp-48H], edi
IN001b: 00009C jae      G_M5106_IG38
IN001c: 0000A2 mov      rdi, gword ptr [V00 rbp-10H]
IN001d: 0000A6 mov      esi, dword ptr [V09 rbp-48H]
IN001e: 0000A9 movsxd   rsi, esi
IN001f: 0000AC mov      rdi, gword ptr [rdi+8*rsi+16]
IN0020: 0000B1 mov      gword ptr [V10 rbp-50H], rdi
```

Inspired by other recent experiments (e.g. #13188), this change
introduces a new node that replaces the above expansion in MinOpts. This
node, `GT_INDEX_ADDR`, represents the bounds check and address
computation involved in an array access, and returns the address of the
element that is to be loaded or stored. Using this node, the example
tree given above expands to the following:

```
[000489] a--XG+------    /--*  IND       ref
[000059] -----+------    |  |  /--*  LCL_VAR   int    V09 loc6
[000060] R--XG+--R---    |  \--*  INDEX_ADDR byref
[000058] -----+------    |     \--*  LCL_VAR   ref    V00 arg0
[000062] -A-XG+------    *  ASG       ref
[000061] D----+-N----    \--*  LCL_VAR   ref    V10 loc7
```

This expansion requires only the addition of the `GT_IND` node that
represents the memory access itself. This savings in IR size translates
to about a 2% decrease in instructions retired during non-optimizing
compilation. Furthermore, this expansion tends to generate smaller
code; for example, the tree given above is generated in 29 rather than
35 bytes:

```
IN0018: 000092 mov      edi, dword ptr [V09 rbp-48H]
IN0019: 000095 mov      rsi, gword ptr [V00 rbp-10H]
IN001a: 000099 cmp      rdi, qword ptr [rsi+8]
IN001b: 00009D jae      G_M5106_IG38
IN001c: 0000A3 lea      rsi, bword ptr [rsi+8*rdi+16]
IN001d: 0000A8 mov      rdi, gword ptr [rsi]
IN001e: 0000AB mov      gword ptr [V10 rbp-50H], rdi
```

Merge pull request #12489 from jashook/unix_x64_and_arm64_fasttailcall_fix

[Unix x64|Arm64] Correct canfastTailCall decisions

Update CoreClr, CoreFx to preview2-25621-02, preview2-25621-02, respectively

Change the position of unassignPhysReg()

Fixing assert in groovy

Enable by-request tiered compilation testing in CI

Avoid unnecessary intermediate Version allocation

`Version..ctor(string)` is implemented by calling `Version.Parse`, which
allocates an intermediate `Version` instance. Avoid the unnecessary
intermediate allocation by using `Version.Parse` directly.