Consider any weight greater or equal to be a max weight. Rule of thumb
is that you can assign BB_MAX_WEIGHT but for comparsions one should always
use an inequality or call the helper method.

Fixes #50808.

The file methodSetFile is never used outside of the constructor, but the
file is never closed, leaking a resource handle. Lets close it manually.

* Improve the speed of using COMPlus_JitTimeLogCsv

I noticed that setting this and running a superpmi replay
was super slow. (Btw, note that you must use `--sequential`
in the scenario to avoid parallel writes to the log file).

This change fixes this in a number of ways:
1. The `CycleTimer::CyclesPerSecond()` function does not-trivial
computation to compute its answer. So cache the result.
2. It's expensive to constantly open and close the output file
(once per function). Partially, this is because anti-virus seems to
get involved. So open it once, and keep it open until the JIT
process is shut down.
3. Avoid calling `eeGetMethodFullName()` in DEBUG builds. (Note that
JitTimeLogCsv collects interesting information beyond just per-phase
timings that are also useful for extracting from a CSV file.)

* Fix CachedCyclesPerSecond logging

* Fix clang build break

December infra rollout - remove duplicated 'src' from coreclr subrepo (src/coreclr/src becomes src/coreclr) (#44973)

* Move src/coreclr/src/Directory.Build.targets to src/coreclr
Merge src/coreclr/src/CMakeLists.txt into src/coreclr/CMakeLists.txt

* Mechanical move of src/coreclr/src to src/coreclr

* Scripts adjustments to reflect the changed paths

Change the core data type for basic block weights from unsigned to float,
to simplify overall calculations and allow for a wider dynamic range.

Many changes are straightforward, but a few are worth noting:
* LSRA needs a true max weight, so had to introduce infinity
* I removed some of the overflow checking as floats naturally saturate.
* The simple geometric loop weight scaling (*8 per loop nest level) leads
  to some very large counts in some tests (15 level loop nests). We may
  want to rethink this and scale less aggressively in deep nests.
* Morph's use of the weighted ref counts for RCS_EARLY is nonstandard
  and the values are not actually weights, so I just added a cast back to unsigned.
* Several places in the jit seem to try and compare or combine unweighted
  and weighted counts; I don't think this makes sense. But have left as is.
* Lower, LIR, and Decompose were passing around weights but never using them.
* I had to introduce a special new weight for the inline projection we do
  for the prejit root.

These changes lead to small numbers of diffs, mostly places where small rounding
changes have altered heuristics; notably:
* cse weights
* LSRA's initial take on whether a parameter should be enregistered

Overall diff impact is a wash.

There are almost no diffs without PGO/IBC data. Diffs are slightly more
prominent in the Roslyn assemblies prejitted with some IBC.

I've tried to keep the format of weights the same in dumps (in most places)
and see minimal diffs in dumps too.

* Convert get_ManagedThreadId(get_CurrentThread) optimization to NamedIntrinsics

* drop CORINFO_HELP_INTERNALTHROW and CORINFO_HELP_SEC_UNMGDCODE_EXCPT

Extract out the budget check logic so it can vary by inlining policy.
Use this to exempt the FullPolicy from budget checking.

Fix inline xml to dump the proper (full name) hash for inlinees.

Update range dumper to dump ranges in hex.

* Dump GC info always in release builds

Add support for dumping non-x86 info in release builds

* Revert DUMP_GC_TABLES change

* Fix formatting

* Add 10 when digit is [a-fA-F] in ConfigMethodRange::InitRanges in utils.cpp

* Zero out compMethodHashPrivate earlier in Compiler::compInit() in compiler.cpp

Calculation of `absNc` involves adding the sign bit of the denominator. It incorrectly used bit 31 of the denominator instead of bit 63.

This helper is idempotent and exception free, so enable it for value numbering.
Also, no need to spill the entire eval stack for a virtual stub calls.

Addresses part of #7723.

* Delete methods on JIT/EE interface that are no longer used in CoreCLR

* Remove workaround for getLocationOfThisType method

* Hardcode verificationNeeded to false

* Added links to issues

* Delete .gitmirror files

* Fix JIT TARGET usage

Fixes _TARGET* & TARGET*_ comments

Fixes TARGET_XARCH4 reference to TARGET_XARCH

Fixes #31372

* Remove no way assert

* Fix JIT formatting

* Use defined() in optcse.cpp

* Rename identifiers to be more consistent

This patch was a machine generated search and replace of
identifiers.  The replacement was done in the order listed
for the path specified.

A regex was used to find the identifiers.

s/(^|[^A-CE-Za-z0-9_])${find}($|[^A-Za-z0-9_])

The 'D' character was specifically allowed a s a prefix
to catch add_definitions(-D${find}).

The patch also reverts all managed code changes after replacement.

    _ARM_                -> HOST_ARM       in src/coreclr
    _ARM64_              -> HOST_ARM64     in src/coreclr
    _AMD64_              -> HOST_AMD64     in src/coreclr
    _X86_                -> HOST_X86       in src/coreclr
    _HOST_UNIX_          -> HOST_UNIX      in src/coreclr
    _HOST_AMD64_         -> HOST_AMD64     in src/coreclr
    _HOST_ARM64_         -> HOST_ARM64     in src/coreclr
    _HOST_ARM_           -> HOST_ARM       in src/coreclr
    _HOST_X86_           -> HOST_X86       in src/coreclr
    DBG_TARGET_AMD64     -> TARGET_AMD64   in src/coreclr
    DBG_TARGET_ARM64     -> TARGET_ARM64   in src/coreclr
    DBG_TARGET_ARM       -> TARGET_ARM     in src/coreclr
    DBG_TARGET_X86       -> TARGET_X86     in src/coreclr
    _TARGET_AMD64_       -> TARGET_AMD64   in src/coreclr
    _TARGET_ARM_         -> TARGET_ARM     in src/coreclr
    _TARGET_ARM64_       -> TARGET_ARM64   in src/coreclr
    _TARGET_X86_         -> TARGET_X86     in src/coreclr
    _TARGET_ARMARCH_     -> TARGET_ARMARCH in src/coreclr
    _TARGET_XARCH_       -> TARGET_XARCH   in src/coreclr
    _HOST_64BIT_         -> HOST_64BIT     in src/coreclr
    BIT64                -> HOST_64BIT     in src/coreclr
    _TARGET_64BIT_       -> TARGET_64BIT   in src/coreclr
    DBG_TARGET_64BIT     -> TARGET_64BIT   in src/coreclr
    HOST_IS_WINDOWS_OS   -> HOST_WINDOWS   in src/coreclr
    PLATFORM_UNIX        -> HOST_UNIX      in src/coreclr/*.cmake
    PLATFORM_WINDOWS     -> HOST_WINDOWS   in src/coreclr/*.cmake
    _TARGET_MAC64        -> TARGET_OSX     in src/coreclr
    FEATURE_PAL          -> TARGET_UNIX    in src/coreclr
    _TARGET_UNIX_        -> TARGET_UNIX    in src/coreclr
    _TARGET_WINDOWS_     -> TARGET_WINDOWS in src/coreclr
    PLATFORM_UNIX        -> TARGET_UNIX    in src/coreclr
    PLATFORM_WINDOWS     -> TARGET_WINDOWS in src/coreclr

* Miscellaneous manual fixes to fix compilation

Remove unused defines

Remove BIT32
Remove DBG_TARGET_AMD64_UNIX
Remove DBG_TARGET_ARM64_UNIX
Remove DBG_TARGET_ARM_UNIX
Remove DBG_TARGET_32BIT

Fixes for HOST_<arch> rename

Move TARGET_<Arch> and TARGET_<bit>

Move from clrdefinitions.cmake
to configurecompiler.cmake so it is used globally.

More jit.h

* Whitespace by clang-format

Use `compMethodHash` for stress and inline range inclusions.

Base all stress decisions on the hash of the root method.

Indicate if stress is potentially active for a method in the one-line output
from `DumpJittedMethods`. Indicate if stress is active but this method is
excluded from stress by name or hash.

Update inline xml to use hex for tokens and hashes.

Update`JitPrintInlinedMethods` to take a method set, likewise for `JitPrintDevirtualizedMethods`.

make_signed/make_unsigned moved to clr_std/type_traits.
Removed pair.h and type_traits.h

Fix #27557

* Reduce use of ArrayTpeDesc, somewhat

* remove `AsArray`. Fewer uses of ArrayTypeDesc

* remove `IsArrayType`

* remove AssertArrayTypeDescLoaded

* normalized use of GetElementType vs GetTypeParam vs GetArrayElementTypeHandle

* removed GetMethodTableOfElementType

* HasTypeParam  and GetTypeParam should work for TypeHandle when array is not a TypeDesc

* Some cleanup of `IsTypeDesc` use.

* Removed `ArrayTypeDesc`

* a few fixes

* another fix

* dealt with TODOs

* couple fixes from reviewing code

* PR feedback:
Removed `CORINFO_HELP_NEWARR_1_R2R_DIRECT`
Folded a `cmp` in x86 array Address.
Removed` METHOD__BUFFER__BLOCKCOPY` from mscorlib.h
`GetMethodTableOfRootTypeParam`
`GetRootTypeParam`
Straightened `Object::GetTypeHandle`
`AsMethodTable` changes from PR feedback

* Removed `ELEMENT_TYPE_NATIVE_ARRAY_TEMPLATE_ZAPSIG`

* `TypeDesc` is ok in `canInlineTypeCheckWithObjectVTable`

* trivial  `AsMethodTable` changes

*  `GetVarTypeForTypeHandle` should throw `unsupported` on TypeDescs

* not digging for the root element type in `GetGCSafeTypeHandleIfPossible`

* Last PR feedback

* Fix `TypeInfoTests.Guid()`

* Added the implementation of CSE live across call algorithm

Fix CSE dataflow for Zero Diffs
Perform backward walk of statements in optValnumCSE_InitDataFlow()

Code Review feedback
- Rename cseTraits to cseLivenessTraits
- Move initialization of cseMaskTraits to optCSE_canSwap
- Rework GT_CALL backwards walk for bbCseGen
- Correct comments

Rename cseBit to cseAvailBit and cseBit2 to cseAvailCrossCallBit
Update CSE_DataFlow to handle calls that kill CSE for live across calls

* Code review feedback, added lots of comments
Fixes printing of EXP_SET BitVecs with more than 64 bits


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

* Replace "val / dcon" with "val * (1.0 / dcon)"

* fix formatting issue

* replace tree->gtOp.gtOp2 with op2

* Address feedback

* fix mantissa calculations

* fix double mantissa

* use frexp+isnormal

* use frexp

* rollback frexp impl

* Add isNormal(float/double)

* fix exponent in isPow2(double)

* cleanup

* Add tests

* cleanup

* drop _finitef

* improve tests

* rename to hasPreciseReciprocal

* Add comments

* fix formatting issues

* add more test cases

* undo some formatting changes

* undo some formatting changes

* Address mikedn's feedback

* forgot to replace c-cast with reinterpret_cast in IsNormal()

* add fixed seed to Random in DivToMul (to make potential failures reproducible)

* use TestLibrary.Generator.GetDouble() instead of Random

* Remove Random-based values

* Update utils.cpp

* Update utils.cpp

* Address feedback


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

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

Updating Math.Round and MathF.Round to be IEEE compliant so that the intrinsic and managed form are deterministic. (dotnet/coreclr#25901)

* Updating Math.Round and MathF.Round to be IEEE compliant so that the intrinsic and managed form are deterministic.

* Fixing the Math.Round and MathF.Round handling for values greater than 0.5 and less than 1.0

* Applying formatting patch.


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

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

Only recognize ";" as a separator, so that we can support exclusions or inclusions
of assemblies whose names include spaces.

Impacts the altjit exclude list, and the disasm include list.

Addresses dotnet/jitutilsdotnet/coreclr#200.

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

* fix implicit constructor call

* extern c

format patch

* muti-line

* Remove direct constructor call

* Conversion

* Need paranthesis

* Return value on resize

* declspec(Thread)

* Ignore warnings for GCC

* Formatting issues

* Move cast to constant


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

Currently, all frame types place saved FP/LR at low addresses on the
frame, below the GS cookie. If a function has localloc, the dynamically
allocate and unsafe buffer will be lower than the saved FP/LR and
not the GS cookie won't properly protect the saved FP/LR.

This change introduces new frame types, used only for functions needing
a GS cookie and using localloc, saving FP/LR along with the rest of
the callee-saved registers at the top (highest addresses) of the frame,
above the GS cookie.


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

This change improves detection of allocators with side effects.
Allocators can cause side effects if the allocated object may have a finalizer.
This change adds a pHasSideEffects parameter to getNewHelper JitEE interface
method. It's used by the jit to check for allocator side effects instead of
guessing from helper ids.

Fixes dotnet/coreclr#21530.


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

This is to support dotnet/corertdotnet/coreclr#6688. They don't exist in CoreCLR (yet).

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

This has two parts:

## Part 1
CoreRT represents native type handles differently from CoreCLR - on CoreCLR, `RuntimeTypeHandle` is a wrapper over `RuntimeType` and RyuJIT is aware of that. On CoreRT, `RuntimeTypeHandle` wraps the native type handle, not a `RuntimeType`.

The knowledge is hardcoded in importer when importing the sequence "ldtoken foo / call Type.GetTypeFromHandle" - importer just removes the call and bashes the result of ldtoken to be a reference type. CoreRT had to avoid reporting `Type.GetTypeFromHandle` as an intrinsic because of that.

I'm adding another helper that lets RyuJIT avoid hardcoding that knowledge. Instead of just bashing the return type, we swap the helper call.

## Part 2

Native type handle equality checks need to go through a helper, unless the EE side says it's okay to compare native type handles directly.

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

Updating the importer to throw a NotImplementedException if it finds a mustExpand intrinsic that it can't expand (dotnet/coreclr#20792)

* Updating the importer to throw a NotImplementedException if it finds a mustExpand hwintrinsic that it can't expand

* Updating the JITEEVersionIdentifier


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

Consolidate various compiler globals used when setting local var ref
counts by folding them into the visitor:
* lvaMarkRefsCurBlock
* lvaMarkRefsCurStmt
* lvaMarkRefsWeight

Remove the largely vestigial `lvPrefReg` and associated methods to set
or modify this field. Haven't verified but this is likely a remmant of
the legacy backend.

In the one remaning use (lcl var sorting predicates), swap in `lvIsRegArg`
instead, which gets most of the same cases.


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

Passing CompAllocator objects by value is advantageous because it no longer needs to be dynamically allocated and cached. CompAllocator instances can now be freely created, copied and stored, which makes adding new CompMemKind values easier.

Together with other cleanup this also improves memory allocation performance by removing some extra levels of indirection that were previously required - jitstd::allocator had a pointer to CompAllocator, CompAllocator had a pointer to Compiler and Compiler finally had a pointer to ArenaAllocator. Without MEASURE_MEM_ALLOC enabled, both jitstd::allocator and CompAllocator now just contain a pointer to ArenaAllocator. When MEASURE_MEM_ALLOC is enabled CompAllocator also contains a pointer but to a MemStatsAllocator object that holds the relevant memory kind. This way CompAllocator is always pointer sized so that enabling MEASURE_MEM_ALLOC does not result in increased memory usage due to objects that store a CompAllocator instance.

In order to implement this, 2 additional signficant changes have been made:
* MemStats has been moved to ArenaAllocator, it's after all the allocator's job to maintain statistics. This also fixes some issues related to memory statistics, such as not tracking the memory allocated by the inlinee compiler (since that one used its own MemStats instance).
* Extract the arena page pooling logic out of the allocator. It doesn't make sense to pool an allocator, it has very little state that can actually be reused and everyting else (including MemStats) needs to be reset on reuse. What really needs to be pooled is just a page of memory.

Since this was touching allocation code the opportunity has been used to perform additional cleanup:
* Remove unnecessary LSRA ListElementAllocator
* Remove compGetMem and compGetMemArray
* Make CompAllocator and HostAllocator more like the std allocator
* Update HashTable to use CompAllocator
* Update ArrayStack to use CompAllocator
* Move CompAllocator & friends to alloc.h

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

* Corrected a few typos in the documentation and comments

* Corrected a few typos in the documentation and comments

* Corrected a few typos in the documentation and comments

* Corrected a few typos in the documentation and comments

* Corrected a few typos in the documentation and comments

* Corrected a few typos in the documentation and comments


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

Remove JIT LEGACY_BACKEND code

All code related to the LEGACY_BACKEND JIT is removed. This includes all code related to x87 floating-point code generation. Almost 50,000 lines of code have been removed.

Remove legacyjit/legacynonjit directories

Remove reg pairs

Remove tiny instruction descriptors

Remove compCanUseSSE2 (it's always true)

Remove unused FEATURE_FP_REGALLOC


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

It allows to remove deallocation in destuctor that can lead to uaf
for static Historgam's objects during shutdown.


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

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

Use macro _countof instead of explicit sizeof(arr) / sizeof(arr[0]) or sizeof(arr) / sizeof(*arr) in clrjit. (dotnet/coreclr#15474)



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

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

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