| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
To fix tests, change dnxcore50 -> netcoreapp1.0 and add test_runtime.
|
|
While working on #5956, I uncovered a silent bad codegen bug in signed
comparison. The way the code was written, we'd do an unsigned set after a
signed compare/jump from the high comparison. However, in this case, we
need to make sure that we are honoring the sign of the comparison done on
the high part of the operation, and the lo comparison would still want to
be an unsigned compare followed by an unsigned set. This change splits
comparisons into two cases: 1) A signed comparison where we have two jumps
for the high part (GT_GT, GT_LT, GT_GE, and GT_LE), which require a signed
set if the high comparisons are true, and an unsigned set if not, and 2)
An unsigned comparison, or a comparison where the sign does not matter for
the compare (GT_NE, GT_EQ), which just require an unsigned set for both
the high and lo operations (the code we already had in genCompareLong).
When we compare longs, we don't need to have both a jg/ja and a jne
instruction for the hi compare for the case where we enregister the result
of the compare, since the set will do the right thing. We only need to
check the lo halves if the hi halves were equal.
For long compares where the result isn't stored in a register, we need to use
signed jumps for the high comparison, and unsigned jumps for the low compare.
Currently, we generate a signed jump in the code for GT_JTRUE that is used by
both compares. This change modifies the logic for these compares/JTRUEs.
We separate the logic into genJTrueLong. In genJTrueLong, we use similar
logic as the legacy backend for the jumps, using a signed jump after the
high compare when we have signed operands, and unsigned jump when we have
a unsigned operands, and an unsigned jump for the low compare.
This change also modifies genJumpKindsForTreeLongHi, since it is now only
used for the uncontained case, where we need to jump to the bbJumpDest if
the compare is true, so we need to use the actual jump type, rather than
just checking for inequality (as inequality only tells us if we need to
check the low halves, not if the condition is true or not).
This change also adds test cases for the two silent bad codegen cases this
commit fixes.
|
|
For non-blittable embedded array in structs we ignored the SizeConst and wrote past the
buffer when number of elementsin the arrayis greater than SizeConst.Fix is to truncate
the array at SizeConst
MarshalAs(UnManaged.ByValTStr)
Very subtle case when the SizeConst == Number of bytes required to marshal , we
write the null one past the buffer.This happens only on machine with non-english
(multi-byte) locale as default. Fix is to check the number of bytes required and
truncate the correctly leaving space for the terminating null.
|
|
RunBenchmark's help text claims that there's a -coreclr option when in fact the option is -runner.
|
|
Remove misplaced call to genUnspillRegIfNeeded
|
|
|
|
Disable tests that timeout under gcstress
|
|
After increasing the timeout time for gcstress, these tests continue to fail
due to timeouts. To get the gcstress legs green and keep them within a manageable
amount of time they will be disabled.
|
|
Following tests contain undefined behaviour.
(Casting double to an integer type for a value that cannot be represent as the integer type.)
- JIT.Methodical.casts.ilseq._il_reltypeEqualOp._il_reltypeEqualOp
- JIT.Regression.CLR-x86-JIT.V1-M10.b08107
|
|
|
|
Fix SBCG in value-numbering constant assertprop
|
|
Value-numbering can assign the same value number to nodes
of different type as long as they have the same bit-representation.
However when substituting a constant into a tree node of different
type, we want the bit-exact representation and not the same value.
Assertion prop should reinterpret int/float value changes rather
than coercing them.
Add an il test that exposes a bug in assertionprop when doing
value-numbering based constant propagation. A cpblk can be used
to copy a scalar value between differing types but for which there
is no change in bit representation.
|
|
Fix statement insertion point in GT_STORE_LCL_VAR decomposition
|
|
|
|
|
|
Improve div/mod by const power of 2
|
|
|
|
|
|
Set b14364 as gcstress incompat
|
|
Up the default timeout for GCStress
|
|
stress run infrastructure
|
|
This test is set to be excluded to in interal testing under gc stress.
Add that information here as well.
|
|
|
|
|
|
|
|
Inliner: simple performance tests
|
|
Tests that demonstrate that constant arguments passed to callees can
lead to inlining performance wins. All numeric types are tested, as
well as strings.
Tests are generally written as positive/negative pairs with calls to
the same inlinee. This exposes the call site sensitivity. Performance
of the positive test should be better than the negative test.
The overall benchmarking approach used here is something that we might
consider adopting for other small-scale codegen performance tests.
|
|
|
|
|
|
Fix seed so benchmark behavior doesn't vary randomly from run to run.
|
|
Remove need for longgc and gcsimulator tests to have their own build
|
|
|
|
Fix WeakReference tests depending on JIT not extending lifetimes
|
|
Mark KeepAliveRecur as GCStressIncompatible
|
|
Target and IsAlive_neg are failing in some cases when JIT optimization is
disabled because the JIT (legally) generates code that holds a reference
to an object longer than expected. Instead of forcing optimization on for
these tests, I'm using the pattern of moving the problematic object
reference to a non-inlined helper method.
Fixes #5555
|
|
This extends impInitializeArrayIntrinsic to support MD arrays in addition to SD arrays. This includes support for SD arrays which are created via CORINFO_HELP_NEW_MDARR when the lower bound is not specified or known to be 0.
The generated code is similar to the code generated for the SD arrays, for example:
call CORINFO_HELP_NEW_MDARR
mov rdx, 0x202AB822050
lea rcx, bword ptr [rax+32]
vmovdqu ymm0, qword ptr [rdx]
vmovdqu qword ptr [rcx], ymm0
mov r8d, dword ptr [rdx+16]
mov dword ptr [rcx+16], r8d
|
|
* Fixing issue with perf targets restoring test runtime
* Fixing perf runs on helix
|
|
The test makes assumptions of what the lifetime of the object is
that may not be necessarily true in GCStress.
|
|
Detects issue #5275
|
|
Remove unnecessary dependencies from JIT tests causing R2R failures
|
|
|
|
'readytorun/mainv1' and 'readytorun/mainv2' tests on Linux wait for human
response asking permission to remove write-protected file:
rm: remove write-protected regular file 'test.dll'?
'rm' command shall be used with '-f' flag to make it non-interactive.
|
|
Inliner: enable inlining of methods with cpblk
|
|
b05623 did basically nothing so I deleted it.
I removed a presumably useless VisualBasic attribute and other unnecessary
assembly references from the other two tests.
Fixes #5428
|
|
Fix for methods that tail call via helpers
|
|
* Adding some basic System.Math performance tests.
* Renaming 'floatnative' to 'floatdouble'.
* Removing outdated workarounds in the floatdouble interop code.
* Renaming 'finite.cpp' to 'math.cpp'
* Updating the double-precision math tests.
* Updating PAL_EPSILON to be more precise.
|
|
on the caller's frame. If an argument lives on the caller caller's frame, it may get
overwritten if that frame is reused for the tail call. Therefore, we should always copy
struct parameters if they are passed as arguments to a tail call.
The simple il regression test has a scenario similar to that of the F# repro in #5164.
Closes #5164.
|
|
|
|
Mark two tests as always optimized and exclude two others from x86/JI…
|
|
Allow jit to inline methods with the cpblk IL opcode. Add a test case
where such an inline happens.
|
