| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
* Fail to explicitly tail call on x86 unix.
* Correctly return 100
* Correct return value
* Add noway assert in morphTailCall to avoid morphing slow tail calls on unix.
* Address feedback
|
|
CoreRT has an [actual field](https://github.com/dotnet/corert/blob/ba3ba929c88bd80ec5d4dd9cf6917471ad8fa180/src/System.Private.CoreLib/src/System/Object.CoreRT.cs#L30) for the method table table pointer in `System.Object`. CoreCLR does shenanigans when laying out `System.Object` to leave a pointer-sized hole instead.
I think the zero-offset field is triggering these asserts.
|
|
Add additional check for the GT_UNSIGNED flag
+ Ran clang-format
+ Code review feedback, use IsUnsigned()
|
|
* Cleanup block stores and test for 24846
Fix zero-length assert/bad codegen for initblk.
Remove redundant assertions in codegen and those that don't directly relate to codegen requirements.
Eliminate redundant LEA that was being generated by `genCodeForCpBlk`.
Rename `genCodeFor[Cp|Init]Blk` to `genCodeFor[Cp|Init]BlkHelper` to parallel the other forms.
Fix the test case for #24846.
|
|
Fix #24846
|
|
When a struct field is imported, its type needs to be normalized.
Also, the LHS of a struct init, even if a SIMD type, should not be transformed to a non-block node,
except in the case of a SIMD local, in which case it must be transformed to a simple assignment.
Also, add an assert to catch this kind of bug in liveness.
Fix #24336
|
|
|
|
|
|
- A GT_LCL_VAR may have a zeroOffset field
- Add an assert to prevent building field sequences with duplicates
- Fix fgMorphField when we have a zero offset field
Improve fgAddFieldSeqForZeroOffset
- Add JItDump info
- Handle GT_LCL_FLD
Changing the sign of an int constant also remove any field sequence information.
Added method header comment for fgAddFieldSeqForZeroOffset
Changed when we call fgAddFieldSeqForZeroOffset to be before the call to fgMorphSmpOp.
Prefer calling fgAddFieldSeqForZeroOffset() to GetZeroOffsetFieldMap()->Set()
|
|
Fix for Desktop build break
|
|
Morph has transformations
((x + const) + y) => ((x + y) + const)
and
((x + const1) + (y + const2)) => ((x + y) + (const1 + const2))
If x or y is a GC pointer and one of the int operands may be negative,
this may result in a byref temp that points outside of the ref object.
If the code is in a non-interruptible region and a GC happens, the byref
won't be updated.
This change disallows the transformations if one of the non-const
operands is a GC pointer.
Fixes #23792.
|
|
|
|
Before implicit byrefs were tracked by setting lvIsParam and lvIsTemp.
This change explicitly adds a flag for implicitByRef instead of overloading.
In addition, it fixes the decision to copy an implicitByRef for arm64 varargs.
Temporarily bump weight on byref params to match old behavior and avoid codegen
diffs.
Re-enabled various tests and parts of tests.
Closes #20046
Closes #19860
|
|
* Support for Arm64 Vector ABI
Extend HFA support to support vectors as well as floating point types.
This requires that the JIT recognize vector types even during crossgen,
so that the ABI is supported consistently.
Also, fix and re-enable the disabled Arm64 Simd tests.
Fix #16022
|
|
The jit was not properly accumulating offsets when figuring out if a byref
should be null checked.
Use a non-null MorphAddressContext as indication that GT_FIELD and GT_IND
nodes are actually part of an ongoing address computation.
During field morphing propagate the current address context to the child node,
instead of starting a new one.
Fixes #23791.
|
|
* Extract `impAppendStmt` and `impExtractLastStmt`.
* Delete `BEG_STMTS` fake stmt.
Use new functions to keep the list updated.
* Retype `impTreeList` and `impTreeLast` as statements.
Rename `impTreeList` and `impTreeLast` to show that they are statements.
* Fix fields that have to be stmt.
* Start using GenTreeStmt.
Change `optVNAssertionPropCurStmt` to use GenTreeStmt.
Replace `GenTree* stmt = block->bbTreeList` with `GenTreeStmt* stmt = block->firstStmt()`.
Save results of `FirstNonPhiDef` as `GenTreeStmt`.
* Replace do-while with for loop.
* Change type inside VNAssertionPropVisitorInfo.
* Delete unused args fron `optVNConstantPropOnTree`.
* Update fields to be stmt.
Update optVNConstantPropCurStmt to use Stmt.
Change `lvDefStmt` to stmt.
Update LoopCloning structs.
Update `optDebugLogLoopCloning`.
Make `compCurStmt` a statement.
Update declaration name in `BuildNode`.
* Clean simple cpp files.
Clean valuenum.
Clean ssabuilder.
Clean simd.
Clean optcse.
Clean loopcloning.
Clean copyprop.
Clean optimizer part1.
* Start cleaning importer, morph, flowgraph, gentree.
* Continue clean functons.
Clean assertionprop.
Clean morph.
Clean gentree.
Clean flowgraph.
Clean compiler.
Clean rangecheck.
Clean indirectcalltransofrmer.
Clean others.
* Create some temp stmt.
* Delete unnecessary noway_assert and casts.
* Init `impStmtList` and `impLastStmt` in release.
* Response review 1.
|
|
* [WIP] Struct & SIMD improvements
- Enable CSE of struct values when handle is available (and add code to get the handle of HW SIMD types)
- Don't require block nodes for SIMD assignments
- Don't set `GTF_GLOB_REF` on `GT_OBJ` if it is local
- Set `lvRegStruct` on promoted SIMD fields
- Add tests for #19910 (fixed with this PR) and #3539 & #19438 (fixed with #21314)
- Additional cleanup
Fix #19910
|
|
* 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
|
|
When we have a VSD tail call via a helper, the stub arg is passed as a normal
arg to the helper and moved to the right special register by the copy routine
that the helper invokes. So the jit does not need to pass the stub value in the
special register when calling the helper.
The stub arg gets set to that register by default, so we now unset it for the
tail call via helper case.
Closes #18943.
|
|
When transferring a Zero offset from one GenTree node to another, we need to check if there already is a FieldSeq and append to it.
Added third parameter 'kind' to JitHashTable::Set, and Added enum SetKind
Only allow Set to overwrite an existing entry when kind is set to Overwrite.
Added validation for all calls to JitHashTable::Set
asserting that we don't expect the key to already exist or that we passed Overwrite indicating that we expect to handle it properly.
Added two test cases for Issue 21231
|
|
The ref count update traversal in the optimizer is not doing anything,
so remove it. This was overlooked when we changed away from incremental
updates in #19345.
Also: fix up comments and documentation to reflect the current approach
to local var ref counts.
|
|
Fix condition for calling EvalArgsToTemps
|
|
* Set flag in comp info to signal that a caller has >8 byte struct args
This will be used by fgCanFastTailCall to correctly determine whether an arm64
or x64 linux caller/callee can fastTailCall.
It is also a workaround to #12468 to catch early any slot shuffling that would happen in LowerFastTailCall. Which currently assumes all parameters are one slot size.
* Address feedback
* Apply format patch
* Add comment
* apply new format patch
|
|
When checking for local assertions to kill in morph, only call `DefinesLocal` on `GT_ASG` nodes.
Also, assert that we never see LIR style assignments.
Resolves #22747.
|
|
`fgArgInfo::ArgsComplete()` checks for additional conditions requiring temps that are not checked for in the body of `fgMorphArgs()`. However, if there are no register args, it won't be called.
Fix #19256
|
|
(#22364)
* Force results of rejected multi-reg-returning tail-call candidates to temp.
Issue #20269 ran into an assert when trying to merge returns, one of which
is a call to a multi-reg-returning method. The repro in the bug is a pmi
of `System.Reflection.Metadata`. I added a simple repro test case.
Results of calls to multi-reg-returning methods are expected to
be saved to temps. Normally it's ensured by `impFixupCallStructReturn`;
however, it doesn't do that for tail-call candidates.
This change forces results of calls to multi-reg-returning methods
to temps if the tail call is rejected late in morph.
Fixes #20269.
|
|
* Allow lcl_var structs to be widened to primitive types on unix amd64. The already happens on armarch
* Apply format patch
|
|
IsVarAddr was checking GTF_ADDR_ONSTACK to determine if
the GT_ADDR node is an address of a local. This change removes both
GTF_ADDR_ONSTACK and IsVarAddr and uses IsLocalAdrExpr instead.
IsLocalAddrExpr uses opcodes to determine if GT_ADDR node is
a local address.
GTF_ADDR_ONSTACK flag is ancient, added before 2002 so I couldn't find
the checkin that introduced it.
I changed the assert to a check and an assignment since simplifications
inside fgMorphArgs between
https://github.com/dotnet/coreclr/blob/1a1e4c4d5a8030cb8d82a2e5b06c2ab357b92534/src/jit/morph.cpp#L3709
(which causes https://github.com/dotnet/coreclr/blob/1a1e4c4d5a8030cb8d82a2e5b06c2ab357b92534/src/jit/morph.cpp#L3057)
and
https://github.com/dotnet/coreclr/blob/1a1e4c4d5a8030cb8d82a2e5b06c2ab357b92534/src/jit/morph.cpp#L3790
may result in more GT_ADDR nodes recognized by IsLocalAdrExpr.
x86 and x64 pmi frameworks had no code diffs and some gcinfo reductions
(15 methods with gcinfo diffs in x86).
Fixes #22190.
|
|
* Fix various fgMorphInitBlock issues
* Remove unnecessary destAddr variable
* Extend/fix comment headers
|
|
|
|
This change enables object stack allocation for more cases.
1. Objects with gc fields can now be stack-allocated.
2. Object stack allocation is enabled for x86.
ObjectAllocator updates the types of trees containing references
to possibly-stack-allocated objects to TYP_BYREF or TYP_I_IMPL as appropriate.
That allows us to remove the hacks in gcencode.cpp and refine reporting of pointers:
the pointer is not reported when we can prove that it always points to a stack-allocated object or is null (typed as TYP_I_IMPL);
the pointer is reported as an interior pointer when it may point to either a stack-allocated object or a heap-allocated object (typed as TYP_BYREF);
the pointer is reported as a normal pointer when it points to a heap-allocated object (typed as TYP_REF).
ObjectAllocator also adds flags to indirections:
GTF_IND_TGTANYWHERE when the indirection may be the heap or the stack
(that results in checked write barriers used for writes)
or the new GTF_IND_TGT_NOT_HEAP when the indirection is null or stack memory
(that results in no barrier used for writes).
|
|
[x86] Make copies of odd-size struct arguments
|
|
|
|
Some IR cleanup
|
|
* Copy address-taken SIMD intrinsic
This occurs, for example, when boxing the result of a SIMD intrinsic. This was being handled for the HW intrinsic case, but not the SIMD Vector intrinsics. Also, eliminate `OperIsSimdHWIntrisic` since it redundantly checks for the case of a SIMD result, even though it was always called in a context where the result is known to be a struct type.
Fix #21854
|
|
Add methods that answer the general question of whether or not
the jit is optimizing the code it produces.
Use this to replace composite checks for minopts and debug
codegen (the two modes where the jit is not optimizing).
|
|
PR #21304 inadvertently disabled this code for x86.
This led to AV failures on desktop, but the same code silently loads
the larger size on coreclr without AV'ing.
Add an assert that we don't see this kind of node in x86 codegen.
|
|
The jit will opportunistically optimize away copies for some struct call
arguments, if that argument is a "last use" for the struct (and some other
conditions apply).
In cases like #21544 this leads to confusing debug experiences as inputs
to a call appear to be modified by the call.
Also we really should not be optimizing the code this way in debug or in
minopts codegen modes. So, block this optimization for debug and minopts.
Closes #21544.
|
|
* Add ArrayStack::Empty
* Add ArrayStack::BottomRef
* Delete unused `ReverseTop`.
* do not use default constructor.
|
|
Besides the fact that volatile indirections aren't supposed to be removed doing so in this case results in incorrect code being generated.
The GT_IND node has GTF_DONT_CSE set and this gets copied to the GT_LCL_VAR node. Later this prevents the insertion of a normalization cast because GTF_DONT_CSE on a GT_LCL_VAR node is assumed to mean that the variable address is being taken.
|
|
Fix #21546
|
|
Don't require BLK nodes for SIMD
|
|
Issue #18201 / Hackathon
|
|
Eliminate most cases where an OBJ or BLK node is required for SIMD
values. The exception is the case where a value produced by an intrinsic
(SIMD or HWIntrinsic) is used as an argument but the argument is of a
different SIMD type (e.g. a different baseType),
|
|
Don't struct-promote opaque vectors
|
|
Lay the groundwork for guarded devirtualization of virtual and interface
calls in the jit.
Introduce the notion of a guarded devirtualization candidate and identify
these if regular devirtualization fails. Use simple heuristics to produce
a class to guess for. Require that the method that would be invoked if the class
guess is correct be a plausible inline candidate.
Generalize the calli transformer to become an indirect call transformer.
This runs after importation because it needs to introduce control flow and
runs before inlining so that the new direct calls it introduces can be inlined.
Implement the transformation to duplicate the call site, devirtualize on the side
where the class is now known exactly, and turn the resulting direct call into an
inline candidate.
Add a motivation and design document.
|
|
The hardware vector types: `Vector64<T>`, `Vector128<T>` and `Vector256<T>` are declared
as having one or more fields of `ulong`. However, the JIT shouldn't be promoting these
fields to local variables. It is almost never the right type, and the intrinsics in any
case are not designed to cooperate with promoted fields (i.e. an index of a `Vector<ulong>`
won't map to the promoted lclVar).
Most importantly, it causes all copies of the vector to be done as 64-bit integer loads
and stores.
Finally, it will be important, as we support vector ABIs, to distinguish the handling of
the fixed-size vectors (`Vector2`, `Vector3` and `Vector4`) which *are* considered to be
normal structs of N floats, from the opaque types which will be passed in vector registers.
|
|
Use LclFld for full-width cpblk of different types
|
|
This issue arose because the source tree was a struct with a single double field, and the destination was a struct with a single long field. Copy prop replaced the lclVar in the source, which was under a `IND(ADDR)` with a lclVar that was not address taken, although it was marked `GTF_DONT_CSE`. Replacing the src tree with a `GT_LCL_FLD` addresses this issue.
Also, ensure that the target is marked `DoNotEnregister` if it isn't referenced as the same size/type.
Fix #21080
Fix #21064
|
|
* Fixing the simdHandleCache to add entries for Vector64FloatHandle and Vector128FloatHandle
* Fixing two places that were calling just OperIsSIMD() rather than OperIsSIMDorSimdHWintrinsic()
|
