Card mark steal (dotnet/coreclr#25986)

Implement card marking stealing for better work balance in Server GC.

One of the last stages in the mark_phase is to mark objects referenced from older generations. This stage is often slow compared to the other stages, and it is also often somewhat unbalanced, i.e. some GC threads finish their work significantly sooner than others. The change also applies to the relocate_phase, but that phase usually takes significantly less time.

This change implements thread-safe enumeration of older generations by dividing them into chunks (2 MB in 64-bits, 1 MB in 32-bits), and arranges it so threads finishing work early will help on other heaps. Each thread grabs a chunk and then looks through the card table section corresponding to this chunk. When it's done with a chunk, it grabs the next one and so on.
There are changes at multiple levels:

- at the top level, mark_phase and relocate_phase contain changes to check for work already done for both the heap associated with the thread and other heaps.
- these routines call mark_through_cards_for_segments and mark_through_cards_for_large_objects which contain code to walk through the older generations in chunks.
 - ultimately card_marking_enumerator::move_next implements the thread safe enumeration, supplying chunks, and gc_heap::find_next_chunk supplies a chunk where all card bits are set.

Commit migrated from https://github.com/dotnet/coreclr/commit/5ca444ce55137d60f2fb033d8a110ce8b3e70df3

Apply SuppressGCAttribute to some SPCL functions. (dotnet/coreclr#27369)

Apply SuppressGCAttribute to some SPCL functions.

Only insert GC_POLL in first morph call.

Commit migrated from https://github.com/dotnet/coreclr/commit/8bc7fab14d78030914e98b33c70b370d513021f6

Adding SkipInit to Internal.Runtime.CompilerServices.Unsafe (dotnet/coreclr#27377)

* Adding SkipInit to Internal.Runtime.CompilerServices.Unsafe

* Updating the runtime to handle Unsafe.SkipInit

* Updating Decimal.DecCalc to use Unsafe.SkipInit

* Removing 'workaround for CS0165' comments

Commit migrated from https://github.com/dotnet/coreclr/commit/9bc350f2e7a0b21f1c7d71ffda5ae1797fb5caff

Move Vector2/3/4 to the shared CoreLib partition (dotnet/corefxdotnet/coreclr#42005)

Signed-off-by: dotnet-bot <dotnet-bot@microsoft.com>
Commit migrated from https://github.com/dotnet/coreclr/commit/8f936bc087359c94fb187971e024d7c39176ebda

Disable STRESS_MIN_OPTS for ObjectStackAllocationTests. (dotnet/coreclr#27344)

ObjectStackAllocationTests rely on the object stack allocation
optimization to be running. STRESS_MIN_OPTS  prevents that.

Commit migrated from https://github.com/dotnet/coreclr/commit/43ea88222cc458b05292b8a219728fba83203249

JIT: fix assertion prop issues with subtypes (dotnet/coreclr#27337)

* don't use late args to destructure helper call
* create proper subtype constant kind when jitting

Commit migrated from https://github.com/dotnet/coreclr/commit/77be4f2d950aa5f630cadc19c31a8121d7e8770f

BGC tuning using the free list with PI loops (dotnet/coreclr#26695)

This is the 1st part of BGC tuning using FL (free list) with a PID loop. Historically the most significant factor for triggering a BGC is based on the allocation budget. This experimental feature triggers based on the FL in gen2/3 with a PID loop (by default we only use PI, no D) so we use the allocation calculated based on the FL to determine when to trigger the next BGC.

    The goal of the PI feedback loop

The end goal of the tuning is keep a const physical ML (memory load). The ML goal is specified as a percentage (meaning the percent of physical memory in use). And we aim to do as few BGCs as possible to achieve this memory load.

This is most useful for the case where you are seeing that a large percent of free space in gen2 isn't getting used when a BGC is triggered; or you have plenty of memory but the GC heap size only takes up a small percentage and you want to delay BGCs to reduce the CPU consumed by BGC.

    Enable the FL tuning PI loop

Since this is an experimental feature, by default it's disabled. To enable set this env var:

set COMPlus_BGCFLTuningEnabled=1

When the FL tuning is enabled, by default we set the ML load to 75%. You can change it with this env var:

set COMPlus_BGCMemGoal=X

Note as with any COMPlus var, the value is interpreted as a hex number, not dec.

    Perf consideration of the current PI loop

Of course there’s always perturbation. From BGC’s POV there are 2 categories of perturbation –

1) from GC’s own perf characteristics changes, for example, suddenly we see a lot of pins from gen1 that get promoted into gen2.
2) non GC factors – this could be due to sudden increase of native memory usage in the process; or other processes on the same machine simply increase/decrease their memory usage.

And generally we don’t want to do something very high like 90% ‘cause it’s hard to react when the memory is tight – GC would need to compact and currently BGC does not compact. So for now we have to assume that “retracting the heap is difficult” which means we want our PI loop to be fairly conservative.

So we actually have another PI loop (the inner loop) to make sure the “sweep flr” is at a reasonable value. “Sweep flr” is the FLR (Free List Ratio) before BGC rebuilds the free list – so you can think of this as the smallest flr during a BGC. So the inner loop has a “sweep flr” goal of 20% by default which is pretty conservative. And when we can incrementally compact I would expect to reduce this by a fair amount. Another possibility is we do not set this as a fixed number and rather calculate a reasonable one dynamically based on what we observe how the free list is used.

Of course just because BGC does not compact it doesn’t mean that the total gen2 size cannot get smaller. It could get smaller just by objects at the end of gen2 naturally dying.

+ Initialization of the PI loops

We have to have some way to get this whole thing started so I usually do a few BGCs to reach 2/3 mem load goal then start using PI loops to decide when to trigger the next BGC.

+ Panic mode

I use a very simple rule to see if I should panic, ie, do an NGC2. If we observe the memory load is (goal + N%) where N is just a number we determine, we do an NGC2. This actually turned out to give decent results because we give it ample opportunity to allow some oscillation around goal (instead of panicking prematurely).

+ Implementation notes

When FL tuning is not enabled there should be no effect.

Record things when BGC starts, BGC sweep ends and BGC end.

I have other mechanisms like the D term, FF (feed forward) and smoothing. I have experimented with them in the past. Currently they are not enabled by default but can be enabled with COMPlus env vars.

Currently this doesn't work great with LOH because we have a fundamental limitation which is if we give free space to gen2 it's difficult to give it to LOH. One thing the user could do is to adjust the LOH threshold so most of the large object allocations happen in gen2.

Commit migrated from https://github.com/dotnet/coreclr/commit/30bb5b54c83bde9ef6fee5373a713b1328849980

Priority of the '&&' operation is higher than that of the '||' operation (dotnet/coreclr#27367)

It is a noway assert that was added before 2010, so that is hard to say what was the idea here.
However, the code before and the examples after show that there is no difference between `GT_EQ` and `GT_NE` and in both cases `c(omparand)` must be the first child of the compare node `t`.

Exisiting comments that confirm that it should be ((a &&b ) || c).
/* t1:c1==0 t2:c2==0 ==> Branch to BX if either value is 0
/* t1:c1!=0 t2:c2!=0 ==> Branch to BX if either value is non-0

Commit migrated from https://github.com/dotnet/coreclr/commit/71fe5c4796cd01fa62e202aab2ebc180d0e4a799

[crossgen2] Make sure hardware intrinsic are generated for CoreLib only (dotnet/coreclr#27347)

Commit migrated from https://github.com/dotnet/coreclr/commit/22e287956f84a0b666d6432968f9caddf1bbfd22

Add documentation for SuppressGCTransition (dotnet/coreclr#27368)

Commit migrated from https://github.com/dotnet/coreclr/commit/f661841ba0adced529faaf0c0e3b0f7505c50f39

Cleanup ILStub signature delta management (dotnet/coreclr#23572)

* Teach ILStubLinker to use the managed signature for the target stack delta when the stub is a reverse stub.

Make ILStubLinker understand changing calling conventions from instance to non-instance calling conventions.

* PR Feedback.

Commit migrated from https://github.com/dotnet/coreclr/commit/373380052a54c6fb86ede3a65e9c6cefafa4e2c1

Ensure that all of the calculations for PerfScore are done using doubles (dotnet/coreclr#27342)

Ensure that all of the calculations for PerfScore are done using doubles

Commit migrated from https://github.com/dotnet/coreclr/commit/020a8c44cc9606bf06b107597cd853533981bbd3

Fix: Expression 'refType == RefTypeUpperVectorSave' is always false. (dotnet/coreclr#27352)

* Expression 'refType == RefTypeUpperVectorSave' is always false.

We have a fast return for this type several lines before that check.

* format fix after deleting a scope.

Commit migrated from https://github.com/dotnet/coreclr/commit/eb4815e2b7f2481a7cb277c8128e691fe426d3e5

Refactor genEventing script to remove SELECTANY from provider context struct definitions (dotnet/coreclr#27354)

* Refactor genEventing script to remove SELECTANY initializations

* Fix windows build, remove newlines

Commit migrated from https://github.com/dotnet/coreclr/commit/b1d70d6a5ebed5872fd0e1b75deadbd0f9e6fe02

Delete `fgArgInfo::ArgsComplete():hasStackArgs` local var. (dotnet/coreclr#27350)

`fgArgInfo` has a field with the same name and the same function. The duplication happened because the local var was added in 2011 and the struct field was added in 2014.

PVS warning:  The 'hasStackArgs' local variable possesses the same name as one of the class members, which can result in a confusion. morph.cpp 1247

Commit migrated from https://github.com/dotnet/coreclr/commit/c9b92bcf062c1b57d836fdcf2e0d45c275423c13

[crossgen2] Fixes the test failure when crossgen2smoke is ran with GCStress turned on (dotnet/coreclr#27263)

Commit migrated from https://github.com/dotnet/coreclr/commit/80212b4d8202a0bdebf9feada8b759f99adb0842

Adding back more arm intrinsics that existing before refactoring (dotnet/coreclr#27153)

* Adding AdvSimd.And

* Adding AdvSimd.AndNot

* Adding AdvSimd.Or

* Adding AdvSimd.OrNot

* Adding AdvSimd.Xor

* Adding AdvSimd.Not

* Removing a trailing whitespace from AdvSimd.PlatformNotSupported.cs

* Adding AdvSimd.Subtract

Commit migrated from https://github.com/dotnet/coreclr/commit/04d2a2292e51f85f8192998684fd0d44da73e28f

Fix nullability error in portable thread pool (dotnet/coreclr#27366)

Commit migrated from https://github.com/dotnet/coreclr/commit/ddb1cf6abdc2ca54b1b6b5b4fa34bb2cdcbc9c3e

Delete Uap quirks from CoreLib (dotnet/coreclr#27356)

This matches cleanup done in CoreFX.

Commit migrated from https://github.com/dotnet/coreclr/commit/111b71a65bce77e63d2463a972fe78aa042c5c0a

remove double bound check from StringBuilder.Append(char) (dotnet/coreclr#27340)

Commit migrated from https://github.com/dotnet/coreclr/commit/46bffce7ee839a0d0d18801a6795e8d6d40ad728

Fix -gcc flag in bash build scripts. (dotnet/coreclr#27339)

Commit migrated from https://github.com/dotnet/coreclr/commit/f6c745f69a32da3eb7d101d59dffeb675525e531

Annotate System.Resources.ResourceWriter for nullable ref types (dotnet/coreclr#41880)

* Annotate System.Resources.ResourceWriter for nullable ref types

* ref

* Mark common as nullable enable explicitly

* _resourceList

Signed-off-by: dotnet-bot <dotnet-bot@microsoft.com>
Commit migrated from https://github.com/dotnet/coreclr/commit/a0a1ec681fd6aab0c072769616e95ff25a151591

Replace tfm based constants with SDK ones (dotnet/corefxdotnet/coreclr#41601)

* replace DefineConstants with SDK ones

Signed-off-by: dotnet-bot <dotnet-bot@microsoft.com>
Commit migrated from https://github.com/dotnet/coreclr/commit/6909f63cce34a6112dbf34c2ae15c94c88173f33

Move portable thread pool to shared partition (dotnet/corertdotnet/coreclr#7828)

* Move portable thread pool to shared partition

* Rename ClrThreadPool to PortableThreadPool

Signed-off-by: dotnet-bot <dotnet-bot@microsoft.com>
Commit migrated from https://github.com/dotnet/coreclr/commit/34878b2305f0b42553b95cd22e257a1be961fefb

Remove declspec (dotnet/coreclr#27341)

* Remove declspec

* Forgotten conversions

Commit migrated from https://github.com/dotnet/coreclr/commit/7a6bb220536af0dbc866aee65a7433e286bbe0f3

Fix setting winrt assembly's fallback binder (dotnet/coreclr#27348)

Remove unused AssemblySpec::SetHostBinder

Commit migrated from https://github.com/dotnet/coreclr/commit/69721cc27a115363e7c0f8b92210572bb67f8b93

Delete dead liveness code (dotnet/coreclr#27343)

Commit migrated from https://github.com/dotnet/coreclr/commit/083af635ec76547e50114d9f50191d69d39b8636

JIT: fix def tree for CSE locals going into SSA (dotnet/coreclr#27301)

When putting a new single-def CSE local into SSA, we need to set the def tree
to the LHS of the GT_ASG, not the GT_ASG.

Commit migrated from https://github.com/dotnet/coreclr/commit/90e59bed1cf8c513d42fc7c660953e7d46057a4e

F8 unwind code was incorrectly parsed as "F0-F4 code" in DumpUnwindInfo in src/jit/unwindarm.cpp (dotnet/coreclr#27298)

Commit migrated from https://github.com/dotnet/coreclr/commit/d05348c0b68162999c42621c1cca46c8a7d3aeac

find src/jit -type f -exec sed -i -e 's/gtFptrVal\./AsFptrVal()\./g' {} \; (dotnet/coreclr#27317)

Commit migrated from https://github.com/dotnet/coreclr/commit/45b313967cc1d9e609938583cd9f68a35a6e2c4a

Cleanup memory copy helpers (dotnet/coreclr#27307)

- Merge RuntimeImports that has just a few FCalls into Buffer.
- Delete assembly implementation of memcpy for ARM. The implementation was outdated and it was used only on Windows ARM and only for fraction of memcpy callsites.
- Delete unnecessary PInvoke into SysStringLen. We have a managed equivalent on System.Runtime.InteropServices.Marshal.
- Delete large amount of redundant code between SecureString.Windows.cs and SecureString.Unix.cs, and switch SecureString to use Spans
- Fold null check into IsWin32Atom

Commit migrated from https://github.com/dotnet/coreclr/commit/17cbbeeac4c6e455d6fd34be22f38ef1f1f49834

Enabled FunctionEnter/FunctionLeave/ProfileTailcall hooks on Linux x86. (dotnet/coreclr#27201)

Based on ./src/vm/i386/asmhelpers.asm FunctionEnter/FunctionLeave/ProfileTailcall
code for Windows x86.

Commit migrated from https://github.com/dotnet/coreclr/commit/e062585dbe0989487e4b23fc6fe7eb8dc6f784bc

Forgotten gtIntCon (dotnet/coreclr#27330)

Commit migrated from https://github.com/dotnet/coreclr/commit/6de88d4f5d291269f82e3dd1aa39cee026725dfe

Replace gtILOffset, with AsILOffset()->

Commit migrated from https://github.com/dotnet/coreclr/commit/2f1d783cbaa806981c6640d85a28da8f5875b735

Fix multicharacter constant issues (dotnet/coreclr#27323)

Commit migrated from https://github.com/dotnet/coreclr/commit/3b02b2f37c95f8550fa40234be9301afd175528b

Replace gtAllocObj. with AsAllocObj()->

Commit migrated from https://github.com/dotnet/coreclr/commit/12e115790cfd4f5a800442191c3115644522ec0e

Replace gtPhysReg. with AsPhysReg()->

Commit migrated from https://github.com/dotnet/coreclr/commit/857a3a6c1d629e5b75640369dd22a776f4f05092

Replace gtArrIndex. with AsArrIndex()->

Commit migrated from https://github.com/dotnet/coreclr/commit/08b4d4e28fec6e0d4eda01060aefe5821da7bb87

Replace gtRuntimeLookup. with AsRuntimeLookup()-> (dotnet/coreclr#27320)

* find src/jit -type f -exec sed -i -e 's/gtRuntimeLookup\./AsRuntimeLookup()\./g' {} \;

* Format patch

Commit migrated from https://github.com/dotnet/coreclr/commit/cd8bfb126af1939f88f0a033e555f2e43599660c

Replace gtDynBlk. with AsDynBlk()->

Commit migrated from https://github.com/dotnet/coreclr/commit/29f74ef213510479378b51fb1b6aea477f65afb8

Replace gtBlk. with AsBlk()->

Commit migrated from https://github.com/dotnet/coreclr/commit/6102cd4072dab9d5a104a82d5608e33eacf79bb8

Replace gtObj. with AsObj()->

Commit migrated from https://github.com/dotnet/coreclr/commit/a77d11a0ce971c25fb9eb9823c2f57138860900e

Cleanup Lowering::TryCreateAddrMode (dotnet/coreclr#27284)

* Move TryCreateAddrMode to XARCH LowerBlockStore

This has no effect on ARM so it doesn't need to be shared between XARCH and ARM

* Cleanup TryCreateAddrMode

* Reuse the existing node when creating address modes

GenTreeAddrMode was unnecessarily marked as "large". Appart from the waste
of memory this casues, it also makes address mode creation more complicated
because one needs to provide the use of the node so it can be updated.

Commit migrated from https://github.com/dotnet/coreclr/commit/a3a1c4d89862ee6b7ceb455b1efa896af5f63583

find src/jit -type f -exec sed -i -e 's/gtVal\./AsVal()\./g' {} \; (dotnet/coreclr#27312)

Commit migrated from https://github.com/dotnet/coreclr/commit/03f2942c6bfc3aa651c3564e9b75584672cda3a5

Replace gtStrCon. with AsStrCon()->

Commit migrated from https://github.com/dotnet/coreclr/commit/c480413490dba81d2e7464b7d444f550420eb112

Replace gtBoundsChk. with AsBoundsChk()->

Commit migrated from https://github.com/dotnet/coreclr/commit/034c4c89d78c875bda8703c0c0b87c4c2973bacf

Replace gtLclVarCommon. with AsLclVarCommon()-> (dotnet/coreclr#27207)

* find src/jit -type f -exec sed -i -e 's/gtLclVarCommon\./AsLclVarCommon()\./g' {} \;

gtLclVarCommon

* Format patch

* Format patch

* Format patch dotnet/coreclr#3

* Remove redundant /

Commit migrated from https://github.com/dotnet/coreclr/commit/5e231b5b5bced3e3548159fd79c4036fde4f135f

Replace gtHWIntrinsic. with AsHWIntrinsic()-> (dotnet/coreclr#27319)

* find src/jit -type f -exec sed -i -e 's/gtHWIntrinsic\./AsHWIntrinsic()\./g' {} \;

* Format patch

Commit migrated from https://github.com/dotnet/coreclr/commit/0027c9736062a268f2ccc842295b504909c20d48

Fix potential race with PerfMap::Destroy (dotnet/coreclr#27271)

* Fix potential race with PerfMap::Destroy

* Make PerfMap::s_enabled Volatile<bool>

Commit migrated from https://github.com/dotnet/coreclr/commit/e5916d4ef0779ebf189fb1d4d7ba6afde2893bbd

Avoid unintended cached var in CMake's find_program (dotnet/coreclr#27322)

Commit migrated from https://github.com/dotnet/coreclr/commit/2c22d9946b0f04c603a13cf7cc6196317e97442f

src/pal/src/cruntime/wchar.cpp: remove redundant condition (dotnet/coreclr#27308)

found by cppcheck

"while (*string)" already checks "string" against NULL

[src/pal/src/cruntime/wchar.cpp:641] -> [src/pal/src/cruntime/wchar.cpp:639]: (warning) Either the condition 'string?string:W16_NULLSTRING' is redundant or there is possible null pointer dereference: string.
[src/pal/src/cruntime/wchar.cpp:712] -> [src/pal/src/cruntime/wchar.cpp:710]: (warning) Either the condition 'string?string:W16_NULLSTRING' is redundant or there is possible null pointer dereference: string.

Commit migrated from https://github.com/dotnet/coreclr/commit/89dedbec8df5c34732f5a248051b921a74da437a

Mark GetTypeFromHandle as intrinsic (dotnet/coreclr#27306)

This change marks GetTypeFromHandle as intrinsic and add related
missing case CorInfoHelpFunc.CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE_MAYBENULL
to GetHelperFtnUncached.

This enables crossgen2 to eliminate call to GetTypeFromHandle.

Commit migrated from https://github.com/dotnet/coreclr/commit/9db8990bca7e0f44f60494d2608342a930d484ca

Changes in virtual.cpp to reduce coredump size(~20 times less) (dotnet/coreclr#27089)

* dotnet/coreclrdotnet/coreclr#10524 do not include reserved memory in coredump. MADV_DONTDUMP/MADV_DODUMP
* madvise(...MADV_DONTDUMP|MADV_DODUMP) only if MADV_DONTDUMP|MADV_DODUMP declared(for OSX)

Commit migrated from https://github.com/dotnet/coreclr/commit/d2c6068c5986771f0650cb218d5a0afcb6fd4014

Extend test coverage for SafeHandle (dotnet/coreclr#27285)

* Extend test coverage for SafeHandle

Trigger unmarshaling failure using an array marshaller. This is something crossgen2 will be able to pregenerate. The existing test case with CustomMarshaller will always be jitted and never pregenerated.

* a

Commit migrated from https://github.com/dotnet/coreclr/commit/605124c975c78a0aeb875c70f359737747bf55a8

Use a new COR_PRF_SUSPEND_FOR_PROFILER in ICorProfilerCallback::RuntimeThreadSuspended() when requested by profiler (dotnet/coreclr#27041)

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

Commit migrated from https://github.com/dotnet/coreclr/commit/09f9c9c40e96496ac0762dc63b0626b1e3fe9a7c

Validate cmake version in build scripts. (dotnet/coreclr#27293)

* Validate cmake version in build scripts.

* Only check CMake version in build-test.cmd when building native test components.

Commit migrated from https://github.com/dotnet/coreclr/commit/7b1dea7b4e4bfad9b845873f60ba0261e425e9f2

Disable VectorMgdMgd_ro.csproj under stress modes. (dotnet/coreclr#27291)

* Disable VectorMgdMgd_ro.csproj under stress modes.

* disable only on arm64.

Commit migrated from https://github.com/dotnet/coreclr/commit/a80153c544bbf6297c0079c6fad687582419b16d

Fix `costEx/Sz/level` for `GT_STORE_DYN_BLK`. (dotnet/coreclr#27277)

* Fix `costEx/Sz/level` for `GT_STORE_DYN_BLK`.

* delete more extra lines.

Commit migrated from https://github.com/dotnet/coreclr/commit/bc13d23a4d9351e85e90cb21faf758879ce7baf4

Fix assert when CORECLR_PROFILER is set but CORECLR_PROFILER_PATH is not (dotnet/coreclr#27138)

The null DLL name is eventually passed to FakeCoCallDllGetClassObject which
knowns how to look up the DLL name based on the CLSID specified by
CORECLR_PROFILER.

Commit migrated from https://github.com/dotnet/coreclr/commit/55f39c6037ee66771599a7b912ea210e7e61eaf2

Re-enable crossgen2 DGML log (dotnet/coreclr#27281)

The dependency graph can be dumped to disk as an XML-based DGML file. This functionality was severed when we moved over from the CoreRT repo.

Commit migrated from https://github.com/dotnet/coreclr/commit/f3131a2490df1f97d1af4fa31763884a6bd895fe

Replace gtIndex. with AsIndex()-> (dotnet/coreclr#27257)

* find src/jit -type f -exec sed -i -e 's/gtIndex\./AsIndex()\./g' {} \;

* Format patch

Commit migrated from https://github.com/dotnet/coreclr/commit/f2cbf9100e5ace69557eea679a9685e09a491bd6

Replace gtArrOffs. with AsArrOffs()-> (dotnet/coreclr#27265)

* find src/jit -type f -exec sed -i -e 's/gtArrOffs\./AsArrOffs()\./g' {} \;

* Format patch

Commit migrated from https://github.com/dotnet/coreclr/commit/8531b61bbfba101789423d6b5d3fcac93fafe41b

Fix unique ETW events for GC Type logging, so they are also fired across EventPipe (dotnet/coreclr#27250)

Commit migrated from https://github.com/dotnet/coreclr/commit/309d1f46f3ab947725f097b62602726a17219f5e

Rewrite Buffer.BlockCopy in C# (dotnet/coreclr#27216)

* Rewrite Buffer.BlockCopy in C#

Fixes dotnet/coreclr#27106

* Workaround to enable type check optimizations for BlockCopy only

Commit migrated from https://github.com/dotnet/coreclr/commit/495a6b5be006cbe16d0db961af4c493ce1b8382e

Fix step with stackalloc (dotnet/coreclr#27246)

* Make ControllerStackInfo::m_returnFrame private

* Make ControllerStackInfo always capture a return frame

In case the active frame has no managed caller, capture
the unmanaged frame

* Fix step over stackalloc

Generalize handling of stack allocations and stepping

* Fix GetFunctionFromToken() argument checking

Check token type is a method before creating a CordbFunction.

Add extra assert to check for invalid tokens

Commit migrated from https://github.com/dotnet/coreclr/commit/551710b95a0aa795f42750966a199c26cc9cd0d9

Process/send etw rundown events only during graceful shutdown and not during process detach (a form of abrupt shutdown) (dotnet/coreclr#27238)

Longer-term fix for https://github.com/dotnet/coreclr/issues/27129:
- Etw rundown events sent during process shutdown are currently (and have for a long time) been sent during process detach. By that time, all other threads have been abruptly terminated by the OS, and as a result the state of the system is fundamentally unpredictable.
- In this particular case, locks have been orphaned by threads that have been abruptly terminated, so taking locks is not feasible during processing of rundown events, and if acquiring locks were to be avoided based on such knowledge (not recommended, this would get messy), we'd have to resort to providing information that would not accurately reflect the state, in the events
- I consider any situation where process detach occurs before an opportunity to handle graceful shutdown (that is, the runtime is unaware that a shutdown is about to happen and does not have an opportunity to handle shutdown prior to process detach (before the OS already shuts some things down)), then that is abrupt shutdown and in that scenario all bets are off - in the case of this change, etw rundown events would not be sent
- This change has the following effects:
  - Graceful shutdown such as returning from `Main` or `Environment.Exit()` will send rundown events very slighly earlier than before. Background threads will still be running and there may be other etw events interspersed among rundown events and sent after rundown events.
  - On Windows, Ctrl+C and Ctrl+Break are not handled by the runtime and by default result in abrupt termination. The only indication the runtime gets is the process detach event, by which time the OS has already terminated all other threads
    - When these events are not handled (by the runtime or by the app), this is an abrupt shutdown scenario and rundown events will not be sent
    - When these events are handled by the app and canceled along with `Environment.Exit()`, that converts these events into graceful shutdown (see above). If an app handles these events and chooses to not cancel the event, the event remains unhandled and leads to abrupt shutdown (see immediately above).
  - On Unixes, there is no significant change. SIGTERM is graceful shutdown as described above and there are no similar issues of abrupt shutdown.
- There is an option of sending rundown events upon process detach (when we don't have an opportunity to do so gracefully), but as I described above that will get messy and is not a path that we should be headed down

Commit migrated from https://github.com/dotnet/coreclr/commit/147da0d2f36fc9a01eec609f33687ae829077a4f

only set THREAD_IS_SUSPENDED if we are truly doing an async stack walk (dotnet/coreclr#26985)

Commit migrated from https://github.com/dotnet/coreclr/commit/ef3180c7c737cb888bd1fea77e9d4c1a40fc5855

Change MSBuild property name for Microsoft.Private.CoreFx.NETCoreApp version. (dotnet/coreclr#27276)

Commit migrated from https://github.com/dotnet/coreclr/commit/e285505646547ffbf12ed699c37665e05360f35b

Fix LTTng build for build environments with older liblttng-ust-dev  (dotnet/coreclr#27273)

* Fix macro redefinition to use XplatEventLogger instead of simply writing FALSE

* Fix linker error

* undo newline changes

* Some changes to comment

* Move wrapper export from eventpipe.cpp to eventtrace.cpp

Commit migrated from https://github.com/dotnet/coreclr/commit/1e7552afb359d1fba2dc57d6f82f03d20db32dd2

Improve codegen for IsNan (dotnet/coreclr#27272)

* Updating double.IsNaN and float.IsNaN to just `return x != x`

* Updating x86 codegen to optimize `x != x` for floating-point

* Changing the isnan optimization to only check the operand assigned registers

Commit migrated from https://github.com/dotnet/coreclr/commit/7e1125c0339dff5747162babe73ed09409f18ba0

Enable NGEN for methods marked with AggressiveOptimization (dotnet/coreclr#27259)

- Methods marked with AggressiveOptimization are not NGENed at all.
- The methods are compiled during the runtime with high JITC overhead.
- It makes launching time slower over 6% in our embedded systems.

Commit migrated from https://github.com/dotnet/coreclr/commit/fc41ef23147964d621c28b76c18cda245e16f694

JIT: describe requested and actual opt levels more accurately (dotnet/coreclr#27249)

Note in jit dump headers and in `COMPlus_DumpJittedMethods` traces when the jit
changed the optimization level that the VM requested.

Also remove the FCOMI handling in the jit, x87 is not longer a thing. Needs to
stay in the options for now though.

Finally, reorder the `Options` struct fields to avoid gratuitous padding.

Commit migrated from https://github.com/dotnet/coreclr/commit/79319d50d45a95375f26f60341575e0284c3fa00

Replace gtCmpXchg with AsCmpXchg()->

Commit migrated from https://github.com/dotnet/coreclr/commit/e4c2246075d5c8cb040f75fbe58cbc089f67a5b2

Replace gtField. with AsField()-> (dotnet/coreclr#27264)

* find src/jit -type f -exec sed -i -e 's/gtField\./AsField()\./g' {} \;

* Format patch

Commit migrated from https://github.com/dotnet/coreclr/commit/6a9115bbf775bf24592ef0af53ef38c599aef714

Simplify native component build (dotnet/coreclr#27077)

* Move discovery of compiler-specific tools out of gen-buildsys-* and into CMake via a configuretools.cmake file.

* Split finding the compiler from calling CMake to generate the build system. Fold as much of gen-buildsys into the CMake scripts as possible.

First pass at moving builds to cmake --build.

* Clean up build.cmd.

* Remove extra MSBuild-specific logging of native components builds.

* Fix discovering linux id.

* Move code-coverage enable out of gen-buildsys.sh

* Fix gen-buildsys.sh argument validation.

* Fix objcopy search condition.

* Add back logging parameters. Make sure we don't regress on throughput.

* Match version lookup behavior in find-clang and find-gcc.

* Determine compiler version for tool location from the file name.

* Fix typo

* PR Feedback.

Commit migrated from https://github.com/dotnet/coreclr/commit/4c1e029deac53212c496c14010b11fc5fa3601a6

Delete fgMorphUnsafeBlk (dotnet/coreclr#27234)

Making block copy ops non-interruptible can and should be done during lowering, at least because this is intended only for unrolled block ops and it's lowering that decides when to unroll.

This also avoids accidentally making block init ops non-interruptible - the block op starts as copy but then assertion propagation managed to transform it into init but nothing resets gtBlkOpGcUnsafe.

Commit migrated from https://github.com/dotnet/coreclr/commit/8825ac695c7c510e72c8ef1043bd122da1d28f62

Fix incorrect log statements (dotnet/coreclr#27267)

Commit migrated from https://github.com/dotnet/coreclr/commit/62bba3cc35b3ca761c542551f6140f054e88e682

Replace gtArrElem. with AsArrElem()-> (dotnet/coreclr#27220)

* find src/jit -type f -exec sed -i -e 's/gtArrElem\./AsArrElem()\./g' {} \;

AsArrElem

* Format patch

* create lclVar in gentree.cpp and remove extra cast

* delete extra casts in lower.

Commit migrated from https://github.com/dotnet/coreclr/commit/2ad8229e5ed52e882a19f73f2e9fda6f70f7b1cf

Replace gtIntCon. with AsIntCon()-> (dotnet/coreclr#27213)

* find src/jit -type f -exec sed -i -e 's/gtIntCon\./AsIntCon()\./g' {} \;

* format patch

Commit migrated from https://github.com/dotnet/coreclr/commit/7e518f820a5db8f61ffe0dd653852558f1f238d9

Replace gtArgPlace. with AsArgPlace()->

Commit migrated from https://github.com/dotnet/coreclr/commit/cecb0e25cdc99d893adc9c8c10fe68e94b27e550

Replace gtIntrinsic. with AsIntrinsic()

Commit migrated from https://github.com/dotnet/coreclr/commit/a0cd1b84bdf47d784dde57b212c896df37366c92

Fix debug check in `CheckAndMoveRMWLastUse`. (dotnet/coreclr#27248)

* `toTree` can't be `nullptr` because the previous condition has checked it.

* define and use the function only for x86.

* fix the issue

Commit migrated from https://github.com/dotnet/coreclr/commit/10bf5d2010ed7416afed2234ee9ffea2264ae55b

Revert "Use ubuntu 1804 arm64 queue outerloop (dotnet/coreclr#26984)" (dotnet/coreclr#27262)

This reverts commit dotnet/coreclr@54d536fd7597541b860784edebb2389723626143.

Commit migrated from https://github.com/dotnet/coreclr/commit/7c9ea85d7be7ebebf9f7c48076cbad097260639a

find src/jit -type f -exec sed -i -e 's/gtAddrMode\./AsAddrMode()\./g' {} \; (dotnet/coreclr#27256)

Commit migrated from https://github.com/dotnet/coreclr/commit/a9045d9dcbb3f2586231e62c9762e8480e40841b

Replace gtLclFld. with AsLclFld()-> (dotnet/coreclr#27218)

* find src/jit -type f -exec sed -i -e 's/gtLclFld\./AsLclFld()\./g' {} \;

AsLclFld

* Format patch

* Remove double cast

Commit migrated from https://github.com/dotnet/coreclr/commit/93ef3998f079be0859eda77362e55e9e7c7cd96e

Use armarch queue for internal builds (dotnet/coreclr#27244)

* Use Ubuntu.1804.Armarch for the internal arm32 jobs

* Stop testing arm32 on ubuntu16.04

Commit migrated from https://github.com/dotnet/coreclr/commit/fd0ca058d96513d0b9aba543ea5239b9de2c634f

Use aligned memory access in JIT_StackProbe (dotnet/coreclr#27235)

Commit migrated from https://github.com/dotnet/coreclr/commit/73b9f63aecbc8157464c20adbf15ac9a3eb85ea3

Delete ENABLE_WINRT define (dotnet/coreclr#27240)

.NET Native specific code not needed anymore

Commit migrated from https://github.com/dotnet/coreclr/commit/fec0438426784470425abdd16ba088355bc9014e

Fix field offset computation in crossgen2 (dotnet/coreclr#27245)

The logic for determining when to align base offset was not matching the
logic that is used in the coreclr runtime. This resulted in assert
failure: m_alignpad == 0 at runtime in 4 CoreMangLib tests.

Commit migrated from https://github.com/dotnet/coreclr/commit/f744448122b6fc3c1868105bcb9e767ed62889d3

Replace gtLclVar. with AsLclVar()-> (dotnet/coreclr#27222)

* find src/jit -type f -exec sed -i -e 's/gtLclVar\./AsLclVar()\./g' {} \;

AsClsVar and AsArrElem

* Format patch

Commit migrated from https://github.com/dotnet/coreclr/commit/9fff11771055eec97c4f9769d1a2f97ff796ac6a

find src/jit -type f -exec sed -i -e 's/gtLngCon\./AsLngCon()\./g' {} \; (dotnet/coreclr#27219)

Commit migrated from https://github.com/dotnet/coreclr/commit/1776e777741ec31fca550207426f6cfdc33512b9

Update scripts to include activity ID / related activity ID in generated (dotnet/coreclr#27209)

native functions for firing runtime events through event pipe

Commit migrated from https://github.com/dotnet/coreclr/commit/32a1bd8f854d4b65565ad90cd42fc9643c42d510

Update UWP Jupiter interaction interface methods defined in .NET Core (dotnet/coreclr#27239)

Update Jupiter host interface method names defined in .NET Core to match officially documented method names. The interface names are still different, but all function names now match.

Commit migrated from https://github.com/dotnet/coreclr/commit/9504d23951bc29b98e8f3d55138493d51abaff87

Replace gtClsVar. with AsClsVar()-> (dotnet/coreclr#27223)

* find src/jit -type f -exec sed -i -e 's/gtClsVar\./AsClsVar()\./g' {} \;

* Format patch

Commit migrated from https://github.com/dotnet/coreclr/commit/f3060ceeef92858052384f6d14cc8eafa6d02a50

Optimize u>=1 to u!=0 and u<1 to u==0  (dotnet/coreclr#25458)

* Optimize u >= 1 to u != 0 and u < 1 to u == 0 (u - unsigned)

* undo some changes

* make clang-format happy

* Address feedback

* Update morph.cpp

Commit migrated from https://github.com/dotnet/coreclr/commit/580024875e08a1569b847086ac54f3b549fff334

Use ubuntu 1804 arm64 queue outerloop (dotnet/coreclr#26984)

* For pr use armarch queue for arm64 linux testing

* Set for pr to test

* Reflect armarch queue name

* Fix typo

* Fix other typo

* Only use armarch queue for outerloop testing

* Correctly use the old queue name

* Use armarch queue for all arm64 jobs

* Use arm32 and arm64 in the friendly names

Commit migrated from https://github.com/dotnet/coreclr/commit/54d536fd7597541b860784edebb2389723626143

[armel/Tizen] Fix broken crossgen2 build (dotnet/coreclr#27227)

Commit migrated from https://github.com/dotnet/coreclr/commit/c5e3a0171f01af2f8a38d57aed7758d141a61943

Refactor init/copy block codegen (dotnet/coreclr#27035)

* Delete INITBLK/CPBLK_STOS_LIMIT

* Treat 0 sized block ops as unrolled

Normally 0 sized block ops should be simply removed during lowering. But these are rare enough that adding special code to deal with them is questionable.

Instead unroll such block ops, the unroll codegen simply won't generate any code for a 0 sized block op. Of course, some registers will still be allocated.

* Cleanup BuildBlockStore

* BlkOpKindHelper is not available on x86

* Use GT_STORE_BLK/unroll consistently

Non-GC GT_STORE_OBJ nodes were changed to GT_STORE_BLK in block copy ops
but not in block init ops. Since block init is effectvely non-GC it is
preferable to be consistent and change to GT_STORE_BLK in both cases.

Commit migrated from https://github.com/dotnet/coreclr/commit/8370e676f2d558fc20b5920d3a424c4e419d5e3a

Preparation to introduce parallelism into CrossGen2 (dotnet/coreclr#27068)

* Preparation to introduce parallelism into CrossGen2

- Change dictionaries in ReadyToRunCodegenNodeFactory and ReadyToRunSymbolNodeFactory to NodeCaches (i.e. ConcurrentDictionary, at the moment)
- Add structs to act as keys for the above NodeCaches (MethodFixupKey, DynamicHelperKey, ReadyToRunHelperKey)
- Synchronize logger
- Update some Dictionaries to ConcurrentDictionary
- Add .Equals and GetHashCode to SignatureContext.

Commit migrated from https://github.com/dotnet/coreclr/commit/2ac3fc45d5ea5100caaf578dd4baaa1f9fd28640

Fix JIT.superpmi\superpmicollect broken on ReadyToRun jobs (dotnet/coreclr#25218)

Commit migrated from https://github.com/dotnet/coreclr/commit/e153d5dfd52bf4f6083b1d741c95e3a70868a963