JIT: Remove JTRUE(relop) invariant in the backend #82766

jakobbotsch · 2023-02-28T13:34:54Z

Today the backend (and much of the JIT) allows only JTRUE with a relop
operand, and it is always assumed that this relop appears right before
JTRUE in linear order. This change adds support for JTRUE nodes with
arbitrary integral operands from lowering and onwards. The operand is
also allowed to appear at arbitrary locations in LIR.

With this, we can now enable an optimization that turns
EQ/NE(relop/SETCC, 0) into just a (potentially) reversed condition. This
improves codegen for some cases with SELECTCC and gives us a simple way
to allow for compare chains that feed conditional branches in the
future.

Not so many diffs are expected, but they should come with #79283.

Currently based on top of #82610.

Example diffs:

[MethodImpl(MethodImplOptions.NoInlining)]
public static int Foo(int a, int b, int c)
{
    if (a < b & b < c & c < 10)
        return a * 42 + b;

    return 13;
}

         6B01001F          cmp     w0, w1
         7A42B024          ccmp    w1, w2, z, lt
         7A4AB844          ccmp    w2, #10, z, lt
-        9A9FA7E2          cset    x2, lt
-        340000A2          cbz     w2, G_M35561_IG05
-						;; size=20 bbWeight=1 PerfScore 3.00
-G_M35561_IG03:              ;; offset=001CH
+        540000AA          bge     G_M35561_IG05
+						;; size=16 bbWeight=1 PerfScore 2.50
+G_M35561_IG03:              ;; offset=0018H
         52800542          mov     w2, #42
         1B020400          madd    w0, w0, w2, w1
 						;; size=8 bbWeight=0.50 PerfScore 1.25

[MethodImpl(MethodImplOptions.NoInlining)]
public static int Foo(int a, int b, int c)
{
    if (a < b & b < c & c < 10)
        return 42;

    return 13;
}

G_M35561_IG01:              ;; offset=0000H
         910003FD          mov     fp, sp
 						;; size=8 bbWeight=1 PerfScore 1.50
 G_M35561_IG02:              ;; offset=0008H
+        528001A3          mov     w3, #13
+        52800544          mov     w4, #42
         6B01001F          cmp     w0, w1
         7A42B024          ccmp    w1, w2, z, lt
         7A4AB844          ccmp    w2, #10, z, lt
-        9A9FA7E0          cset    x0, lt
-        528001A1          mov     w1, #13
-        52800542          mov     w2, #42
-        7100001F          cmp     w0, #0
-        1A820020          csel    w0, w1, w2, eq
-						;; size=32 bbWeight=1 PerfScore 4.00
-G_M35561_IG03:              ;; offset=0028H
+        1A84A060          csel    w0, w3, w4, ge
+						;; size=24 bbWeight=1 PerfScore 3.00
+G_M35561_IG03:              ;; offset=0020H
         A8C17BFD          ldp     fp, lr, [sp], #0x10
         D65F03C0          ret     lr
 						;; size=8 bbWeight=1 PerfScore 2.00

ghost · 2023-02-28T13:35:05Z

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch, @kunalspathak
See info in area-owners.md if you want to be subscribed.

Issue Details

Today the backend (and much of the JIT) allows only JTRUE with a relop
operand, and it is always assumed that this relop appears right before
JTRUE in linear order. This change adds support for JTRUE nodes with
arbitrary integral operands from lowering and onwards. The operand is
also allowed to appear at arbitrary locations in LIR.

With this, we can now enable an optimization that turns
EQ/NE(relop/SETCC, 0) into just a (potentially) reversed condition. This
improves codegen for some cases with SELECTCC and gives us a simple way
to allow for compare chains that feed conditional branches in the
future.

Not so many diffs are expected, but they should come with #79283.

Currently based on top of #82610.

Example diffs:

[MethodImpl(MethodImplOptions.NoInlining)]
public static int Foo(int a, int b, int c)
{
    if (a < b & b < c & c < 10)
        return a * 42 + b;

    return 13;
}

         6B01001F          cmp     w0, w1
         7A42B024          ccmp    w1, w2, z, lt
         7A4AB844          ccmp    w2, #10, z, lt
-        9A9FA7E2          cset    x2, lt
-        340000A2          cbz     w2, G_M35561_IG05
-						;; size=20 bbWeight=1 PerfScore 3.00
-G_M35561_IG03:              ;; offset=001CH
+        540000AA          bge     G_M35561_IG05
+						;; size=16 bbWeight=1 PerfScore 2.50
+G_M35561_IG03:              ;; offset=0018H
         52800542          mov     w2, #42
         1B020400          madd    w0, w0, w2, w1
 						;; size=8 bbWeight=0.50 PerfScore 1.25

[MethodImpl(MethodImplOptions.NoInlining)]
public static int Foo(int a, int b, int c)
{
    if (a < b & b < c & c < 10)
        return 42;

    return 13;
}

G_M35561_IG01:              ;; offset=0000H
         910003FD          mov     fp, sp
 						;; size=8 bbWeight=1 PerfScore 1.50
 G_M35561_IG02:              ;; offset=0008H
+        528001A3          mov     w3, #13
+        52800544          mov     w4, #42
         6B01001F          cmp     w0, w1
         7A42B024          ccmp    w1, w2, z, lt
         7A4AB844          ccmp    w2, #10, z, lt
-        9A9FA7E0          cset    x0, lt
-        528001A1          mov     w1, #13
-        52800542          mov     w2, #42
-        7100001F          cmp     w0, #0
-        1A820020          csel    w0, w1, w2, eq
-						;; size=32 bbWeight=1 PerfScore 4.00
-G_M35561_IG03:              ;; offset=0028H
+        1A84A060          csel    w0, w3, w4, ge
+						;; size=24 bbWeight=1 PerfScore 3.00
+G_M35561_IG03:              ;; offset=0020H
         A8C17BFD          ldp     fp, lr, [sp], #0x10
         D65F03C0          ret     lr
 						;; size=8 bbWeight=1 PerfScore 2.00

Author:	jakobbotsch
Assignees:	jakobbotsch
Labels:	`area-CodeGen-coreclr`
Milestone:	-

Today the backend (and much of the JIT) allows only JTRUE with a relop operand, and it is always assumed that this relop appears right before JTRUE in linear order. This change adds support for JTRUE nodes with arbitrary integral operands from lowering and onwards. The operand is also allowed to appear at arbitrary locations in LIR. With this, we can now enable an optimization that turns EQ/NE(relop/SETCC, 0) into just a (potentially) reversed condition. This improves codegen for some cases with SELECTCC and gives us a simple way to allow for compare chains that feed conditional branches in the future.

jakobbotsch · 2023-03-02T00:24:55Z

/azp run runtime-coreclr jitstress, runtime-coreclr libraries-jitstress, Fuzzlyn

azure-pipelines · 2023-03-02T00:25:25Z

Azure Pipelines successfully started running 3 pipeline(s).

jakobbotsch · 2023-03-02T18:04:07Z

cc @dotnet/jit-contrib PTAL @kunalspathak @BruceForstall @a74nh

Diffs.

With this PR #79283 should not need any (significant) backend work.

jakobbotsch · 2023-03-02T18:05:44Z

src/coreclr/jit/lowerloongarch64.cpp

+// Return Value:
+//    The next node to lower (usually nullptr).
+//
+GenTree* Lowering::LowerJTrue(GenTreeOp* jtrue)


I've split out LA64 LowerJTrue logic since it is very different from the rest of the backends. It lowers the new JTRUE(op) nodes by turning them into JCMP(op, 0, NE). @shushanhf this is untested, can you please double check that it looks ok?

Ok, I will check it for LA64.
Thanks.

src/coreclr/jit/codegenarm.cpp

src/coreclr/jit/codegenarm64.cpp

src/coreclr/jit/codegenxarch.cpp

src/coreclr/jit/lower.h

a74nh · 2023-03-03T13:00:12Z

src/coreclr/jit/lower.cpp

+            use.ReplaceWith(op1);
+            BlockRange().Remove(cmp->gtGetOp2());
+            BlockRange().Remove(cmp);
+            return next;


The difficulty I have with debugging the lowering phase, is that nodes can get renamed or moved, and there is no record in the JITDUMP except for the node dump before and after the phase. It's not always obvious what happened, especially when your work isn't focused on the lowering phase.
Not for this PR, but some extra debug throughout lowering would be useful.

I agree, we should have more dump logging in lowering. I'll add some to this transform.

The additional dumping looks good. I think the "before" IR isn't required in these cases as that IR would have been printed the last time it was changed, but happy for it to stay like this.

BruceForstall · 2023-03-06T06:54:23Z

I'm wondering (and this is unrelated to your change): in your examples, the C# code uses & not &&, which is not short-circuiting, but the conditional compare chain is short-circuiting. Does that only happen if the compare chain has no possible side-effects? What happens if the C# code uses && (which would be normal)? Do we get extra blocks that interfere with the optimization?

jakobbotsch · 2023-03-06T09:48:53Z

I'm wondering (and this is unrelated to your change): in your examples, the C# code uses & not &&, which is not short-circuiting, but the conditional compare chain is short-circuiting. Does that only happen if the compare chain has no possible side-effects? What happens if the C# code uses && (which would be normal)? Do we get extra blocks that interfere with the optimization?

Yes, with && we get extra blocks and don't do the optimization. @a74nh is working on turning short-circuiting && into bitwise & in #79283 which should expose tons of opportunities to if-conversion and to emitting ccmps in the backend.

jakobbotsch · 2023-03-06T10:47:12Z

@BruceForstall @a74nh I added some JITDUMP logging. I had to add a couple of new helpers to deal with the fact that there are no explicit flags edges, so there are new LIR::EarliestNode and LIR::Range::GetTreeRangeWithFlags functions.
@BruceForstall Can you take another look at the latest commit?

For the example above the jitdump is now:

*************** Starting PHASE Lowering nodeinfo
[000006] is a candidate for CCMP:
N001 (  1,  1) [000000] -----------                    t0 =    LCL_VAR   int    V00 arg0         u:1 (last use) $80
N002 (  1,  1) [000001] -----------                    t1 =    LCL_VAR   int    V01 arg1         u:1 $81
                                                            ┌──▌  t0     int    
                                                            ├──▌  t1     int    
N003 (  6,  3) [000002] -----------                    t2 = ▌  LT        int    $100
N004 (  1,  1) [000003] -----------                    t3 =    LCL_VAR   int    V01 arg1         u:1 (last use) $81
N005 (  1,  1) [000004] -----------                    t4 =    LCL_VAR   int    V02 arg2         u:1 $82
                                                            ┌──▌  t3     int    
                                                            ├──▌  t4     int    
N006 (  6,  3) [000005] -----------                    t5 = ▌  LT        int    $101
                                                            ┌──▌  t2     int    
                                                            ├──▌  t5     int    
N007 ( 13,  7) [000006] -----------                    t6 = ▌  AND       int    $102

Conversion was legal. Result:
N001 (  1,  1) [000000] -----------                    t0 =    LCL_VAR   int    V00 arg0         u:1 (last use) $80
N002 (  1,  1) [000001] -----------                    t1 =    LCL_VAR   int    V01 arg1         u:1 $81
N004 (  1,  1) [000003] -----------                    t3 =    LCL_VAR   int    V01 arg1         u:1 (last use) $81
N005 (  1,  1) [000004] -----------                    t4 =    LCL_VAR   int    V02 arg2         u:1 $82
                                                            ┌──▌  t0     int    
                                                            ├──▌  t1     int    
N003 (  6,  3) [000002] -----------                         ▌  CMP       void  
                                                            ┌──▌  t3     int    
                                                            ├──▌  t4     int    
N006 (  6,  3) [000005] -----------                         ▌  CCMP      void   cond=SLT flags=z
N007 ( 13,  7) [000006] -----------                    t6 =    SETCC     int    cond=SLT

[000010] is a candidate for CCMP:
N001 (  1,  1) [000000] -----------                    t0 =    LCL_VAR   int    V00 arg0         u:1 (last use) $80
N002 (  1,  1) [000001] -----------                    t1 =    LCL_VAR   int    V01 arg1         u:1 $81
N004 (  1,  1) [000003] -----------                    t3 =    LCL_VAR   int    V01 arg1         u:1 (last use) $81
N005 (  1,  1) [000004] -----------                    t4 =    LCL_VAR   int    V02 arg2         u:1 $82
                                                            ┌──▌  t0     int    
                                                            ├──▌  t1     int    
N003 (  6,  3) [000002] -----------                         ▌  CMP       void  
                                                            ┌──▌  t3     int    
                                                            ├──▌  t4     int    
N006 (  6,  3) [000005] -----------                         ▌  CCMP      void   cond=SLT flags=z
N007 ( 13,  7) [000006] -----------                    t6 =    SETCC     int    cond=SLT
N008 (  1,  1) [000007] -----------                    t7 =    LCL_VAR   int    V02 arg2         u:1 (last use) $82
N009 (  1,  2) [000008] -c---------                    t8 =    CNS_INT   int    10 $44
                                                            ┌──▌  t7     int    
                                                            ├──▌  t8     int    
N010 (  6,  4) [000009] -----------                    t9 = ▌  LT        int    $103
                                                            ┌──▌  t6     int    
                                                            ├──▌  t9     int    
N011 ( 20, 12) [000010] -----------                   t10 = ▌  AND       int    $104

Conversion was legal. Result:
N001 (  1,  1) [000000] -----------                    t0 =    LCL_VAR   int    V00 arg0         u:1 (last use) $80
N002 (  1,  1) [000001] -----------                    t1 =    LCL_VAR   int    V01 arg1         u:1 $81
N004 (  1,  1) [000003] -----------                    t3 =    LCL_VAR   int    V01 arg1         u:1 (last use) $81
N005 (  1,  1) [000004] -----------                    t4 =    LCL_VAR   int    V02 arg2         u:1 $82
N008 (  1,  1) [000007] -----------                    t7 =    LCL_VAR   int    V02 arg2         u:1 (last use) $82
N009 (  1,  2) [000008] -c---------                    t8 =    CNS_INT   int    10 $44
                                                            ┌──▌  t0     int    
                                                            ├──▌  t1     int    
N003 (  6,  3) [000002] -----------                         ▌  CMP       void  
                                                            ┌──▌  t3     int    
                                                            ├──▌  t4     int    
N006 (  6,  3) [000005] -----------                         ▌  CCMP      void   cond=SLT flags=z
                                                            ┌──▌  t7     int    
                                                            ├──▌  t8     int    
N010 (  6,  4) [000009] -----------                         ▌  CCMP      void   cond=SLT flags=z
N011 ( 20, 12) [000010] -----------                   t10 =    SETCC     int    cond=SLT

jakobbotsch · 2023-03-06T11:34:04Z

I reworked the JITDUMP handling a bit more in the latest commit. LIR::Range::GetMarkedRange now has some best-effort handling for flags operands with a new markFlagsOperands template argument. Since it is best-effort there is a static assert that we do not pass it as true in release builds.
LIR::Range::GetTreeRangeWithFlags is debug-only and uses the new handling, and gtDispTreeRange then uses GetTreeRangeWithFlags. The benefit is that DISPTREERANGE now is flags-aware and prints a more useful range by default when flags are involved.
I then added some JITDUMP handling to LowerJTrue and LowerSelect too. Now the JITDUMP for the above example is (with some additional dumping at the end from LowerSelect):

[000006] is a candidate for CCMP:
N001 (  1,  1) [000000] -----------                    t0 =    LCL_VAR   int    V00 arg0         u:1 (last use) $80
N002 (  1,  1) [000001] -----------                    t1 =    LCL_VAR   int    V01 arg1         u:1 $81
                                                            ┌──▌  t0     int    
                                                            ├──▌  t1     int    
N003 (  6,  3) [000002] -----------                    t2 = ▌  LT        int    $100
N004 (  1,  1) [000003] -----------                    t3 =    LCL_VAR   int    V01 arg1         u:1 (last use) $81
N005 (  1,  1) [000004] -----------                    t4 =    LCL_VAR   int    V02 arg2         u:1 $82
                                                            ┌──▌  t3     int    
                                                            ├──▌  t4     int    
N006 (  6,  3) [000005] -----------                    t5 = ▌  LT        int    $101
                                                            ┌──▌  t2     int    
                                                            ├──▌  t5     int    
N007 ( 13,  7) [000006] -----------                    t6 = ▌  AND       int    $102

Conversion was legal. Result:
N001 (  1,  1) [000000] -----------                    t0 =    LCL_VAR   int    V00 arg0         u:1 (last use) $80
N002 (  1,  1) [000001] -----------                    t1 =    LCL_VAR   int    V01 arg1         u:1 $81
N004 (  1,  1) [000003] -----------                    t3 =    LCL_VAR   int    V01 arg1         u:1 (last use) $81
N005 (  1,  1) [000004] -----------                    t4 =    LCL_VAR   int    V02 arg2         u:1 $82
                                                            ┌──▌  t0     int    
                                                            ├──▌  t1     int    
N003 (  6,  3) [000002] -----------                         ▌  CMP       void  
                                                            ┌──▌  t3     int    
                                                            ├──▌  t4     int    
N006 (  6,  3) [000005] -----------                         ▌  CCMP      void   cond=SLT flags=z
N007 ( 13,  7) [000006] -----------                    t6 =    SETCC     int    cond=SLT

[000010] is a candidate for CCMP:
N001 (  1,  1) [000000] -----------                    t0 =    LCL_VAR   int    V00 arg0         u:1 (last use) $80
N002 (  1,  1) [000001] -----------                    t1 =    LCL_VAR   int    V01 arg1         u:1 $81
N004 (  1,  1) [000003] -----------                    t3 =    LCL_VAR   int    V01 arg1         u:1 (last use) $81
N005 (  1,  1) [000004] -----------                    t4 =    LCL_VAR   int    V02 arg2         u:1 $82
                                                            ┌──▌  t0     int    
                                                            ├──▌  t1     int    
N003 (  6,  3) [000002] -----------                         ▌  CMP       void  
                                                            ┌──▌  t3     int    
                                                            ├──▌  t4     int    
N006 (  6,  3) [000005] -----------                         ▌  CCMP      void   cond=SLT flags=z
N007 ( 13,  7) [000006] -----------                    t6 =    SETCC     int    cond=SLT
N008 (  1,  1) [000007] -----------                    t7 =    LCL_VAR   int    V02 arg2         u:1 (last use) $82
N009 (  1,  2) [000008] -c---------                    t8 =    CNS_INT   int    10 $44
                                                            ┌──▌  t7     int    
                                                            ├──▌  t8     int    
N010 (  6,  4) [000009] -----------                    t9 = ▌  LT        int    $103
                                                            ┌──▌  t6     int    
                                                            ├──▌  t9     int    
N011 ( 20, 12) [000010] -----------                   t10 = ▌  AND       int    $104

Conversion was legal. Result:
N001 (  1,  1) [000000] -----------                    t0 =    LCL_VAR   int    V00 arg0         u:1 (last use) $80
N002 (  1,  1) [000001] -----------                    t1 =    LCL_VAR   int    V01 arg1         u:1 $81
N004 (  1,  1) [000003] -----------                    t3 =    LCL_VAR   int    V01 arg1         u:1 (last use) $81
N005 (  1,  1) [000004] -----------                    t4 =    LCL_VAR   int    V02 arg2         u:1 $82
N008 (  1,  1) [000007] -----------                    t7 =    LCL_VAR   int    V02 arg2         u:1 (last use) $82
N009 (  1,  2) [000008] -c---------                    t8 =    CNS_INT   int    10 $44
                                                            ┌──▌  t0     int    
                                                            ├──▌  t1     int    
N003 (  6,  3) [000002] -----------                         ▌  CMP       void  
                                                            ┌──▌  t3     int    
                                                            ├──▌  t4     int    
N006 (  6,  3) [000005] -----------                         ▌  CCMP      void   cond=SLT flags=z
                                                            ┌──▌  t7     int    
                                                            ├──▌  t8     int    
N010 (  6,  4) [000009] -----------                         ▌  CCMP      void   cond=SLT flags=z
N011 ( 20, 12) [000010] -----------                   t10 =    SETCC     int    cond=SLT

Lowering select:
N001 (  1,  1) [000000] -----------                    t0 =    LCL_VAR   int    V00 arg0         u:1 (last use) $80
N002 (  1,  1) [000001] -----------                    t1 =    LCL_VAR   int    V01 arg1         u:1 $81
N004 (  1,  1) [000003] -----------                    t3 =    LCL_VAR   int    V01 arg1         u:1 (last use) $81
N005 (  1,  1) [000004] -----------                    t4 =    LCL_VAR   int    V02 arg2         u:1 $82
N008 (  1,  1) [000007] -----------                    t7 =    LCL_VAR   int    V02 arg2         u:1 (last use) $82
N009 (  1,  2) [000008] -c---------                    t8 =    CNS_INT   int    10 $44
                                                            ┌──▌  t0     int    
                                                            ├──▌  t1     int    
N003 (  6,  3) [000002] -----------                         ▌  CMP       void  
                                                            ┌──▌  t3     int    
                                                            ├──▌  t4     int    
N006 (  6,  3) [000005] -----------                         ▌  CCMP      void   cond=SLT flags=z
                                                            ┌──▌  t7     int    
                                                            ├──▌  t8     int    
N010 (  6,  4) [000009] -----------                         ▌  CCMP      void   cond=SLT flags=z
N011 ( 20, 12) [000010] -----------                   t10 =    SETCC     int    cond=SGE
N014 (  1,  2) [000014] -----------                   t14 =    CNS_INT   int    13 $45
N015 (  1,  2) [000016] -----------                   t16 =    CNS_INT   int    42 $46
                                                            ┌──▌  t10    int    
                                                            ├──▌  t14    int    
                                                            ├──▌  t16    int    
N016 ( 25, 20) [000018] -----------                   t18 = ▌  SELECT    int   

Converted to SELECTCC:
N001 (  1,  1) [000000] -----------                    t0 =    LCL_VAR   int    V00 arg0         u:1 (last use) $80
N002 (  1,  1) [000001] -----------                    t1 =    LCL_VAR   int    V01 arg1         u:1 $81
N004 (  1,  1) [000003] -----------                    t3 =    LCL_VAR   int    V01 arg1         u:1 (last use) $81
N005 (  1,  1) [000004] -----------                    t4 =    LCL_VAR   int    V02 arg2         u:1 $82
N008 (  1,  1) [000007] -----------                    t7 =    LCL_VAR   int    V02 arg2         u:1 (last use) $82
N009 (  1,  2) [000008] -c---------                    t8 =    CNS_INT   int    10 $44
N014 (  1,  2) [000014] -----------                   t14 =    CNS_INT   int    13 $45
N015 (  1,  2) [000016] -----------                   t16 =    CNS_INT   int    42 $46
                                                            ┌──▌  t0     int    
                                                            ├──▌  t1     int    
N003 (  6,  3) [000002] -----------                         ▌  CMP       void  
                                                            ┌──▌  t3     int    
                                                            ├──▌  t4     int    
N006 (  6,  3) [000005] -----------                         ▌  CCMP      void   cond=SLT flags=z
                                                            ┌──▌  t7     int    
                                                            ├──▌  t8     int    
N010 (  6,  4) [000009] -----------                         ▌  CCMP      void   cond=SLT flags=z
                                                            ┌──▌  t14    int    
                                                            ├──▌  t16    int    
N016 ( 25, 20) [000018] -----------                   t18 = ▌  SELECTCC  int    cond=SGE

BruceForstall

Very nice!

BruceForstall · 2023-03-06T23:33:09Z

src/coreclr/jit/lir.cpp

+//    markFlagsOperands - Whether the dataflow algorithm should also try to
+//                        mark operands that are defining flags. For example,
+//                        GT_JCC implicitly consumes the flags defined by the
+//                        previous node in linear order. If this argument is
+//                        true, then the algorithm will also include the flags
+//                        definition (which is e.g. a CMP node) in the returned
+//                        range.
+//                        This works on a best-effort basis; the user should not
+//                        rely on all flags defs to be found.


Move this down to "Template arguments"?

BruceForstall · 2023-03-06T23:33:33Z

src/coreclr/jit/lir.cpp

+//                        range contains only nodes in the dataflow tree and false
+//                        otherwise.
+//
+// Type arguments:


Call this "Template arguments:" instead?

BruceForstall · 2023-03-06T23:34:15Z

src/coreclr/jit/lir.cpp

+//    root              - The root of the dataflow tree.
+//    isClosed          - An output parameter that is set to true if the returned
+//                        range contains only nodes in the dataflow tree and false
+//                        otherwise.


While you're here, can you fix this? root doesn't match the declaration. It's missing markCount and sideEffects.

dotnet-issue-labeler bot added the area-CodeGen-coreclr CLR JIT compiler in src/coreclr/src/jit and related components such as SuperPMI label Feb 28, 2023

ghost assigned jakobbotsch Feb 28, 2023

build-analysis bot mentioned this pull request Feb 28, 2023

Tracking issue for CI build timeouts #76454

Closed

jakobbotsch force-pushed the lower-eqne-relop-0 branch from 4ea9856 to dd46020 Compare March 1, 2023 21:48

jakobbotsch mentioned this pull request Mar 2, 2023

Test failure System.Net.Quic.Tests.MsQuicPlatformDetectionTests.SupportedWindowsPlatforms_IsSupportedIsTrue #82885

Closed

jakobbotsch added 2 commits March 2, 2023 11:50

Small cleanups

8996239

Add GT_JTRUE case in arm arch codegen

e6e2be0

jakobbotsch marked this pull request as ready for review March 2, 2023 18:02

jakobbotsch requested review from kunalspathak and BruceForstall March 2, 2023 18:04

jakobbotsch commented Mar 2, 2023

View reviewed changes

src/coreclr/jit/codegenarm.cpp Outdated Show resolved Hide resolved

jakobbotsch commented Mar 2, 2023

View reviewed changes

src/coreclr/jit/codegenarm64.cpp Outdated Show resolved Hide resolved

jakobbotsch commented Mar 2, 2023

View reviewed changes

src/coreclr/jit/codegenxarch.cpp Outdated Show resolved Hide resolved

jakobbotsch commented Mar 2, 2023

View reviewed changes

src/coreclr/jit/lower.h Outdated Show resolved Hide resolved

a74nh reviewed Mar 3, 2023

View reviewed changes

Apply suggestions from code review

0e30f7e

BruceForstall approved these changes Mar 6, 2023

View reviewed changes

Add some JITDUMP for the new transform

c86cb43

Handle flags in GetMarkedRange instead; add GT_SELECT, GT_JTRUE jitdump

32cb893

Fix build

091bc1a

Fix a function header

cd38ea4

BruceForstall approved these changes Mar 6, 2023

View reviewed changes

Update function header

13a5c89

jakobbotsch merged commit 8a28b11 into dotnet:main Mar 7, 2023

jakobbotsch deleted the lower-eqne-relop-0 branch March 7, 2023 00:01

EgorBo mentioned this pull request Mar 9, 2023

[Perf] Windows/arm64: 1 Regression on 3/7/2023 1:52:33 AM #83217

Closed

dotnet locked as resolved and limited conversation to collaborators Apr 6, 2023

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

JIT: Remove JTRUE(relop) invariant in the backend #82766

JIT: Remove JTRUE(relop) invariant in the backend #82766

jakobbotsch commented Feb 28, 2023

ghost commented Feb 28, 2023

jakobbotsch commented Mar 2, 2023

azure-pipelines bot commented Mar 2, 2023

jakobbotsch commented Mar 2, 2023

jakobbotsch Mar 2, 2023

shushanhf Mar 3, 2023

a74nh Mar 3, 2023

jakobbotsch Mar 3, 2023

a74nh Mar 6, 2023

BruceForstall commented Mar 6, 2023

jakobbotsch commented Mar 6, 2023 •

edited

jakobbotsch commented Mar 6, 2023 •

edited

jakobbotsch commented Mar 6, 2023 •

edited

BruceForstall left a comment

BruceForstall Mar 6, 2023

BruceForstall Mar 6, 2023

BruceForstall Mar 6, 2023

JIT: Remove JTRUE(relop) invariant in the backend #82766

JIT: Remove JTRUE(relop) invariant in the backend #82766

Conversation

jakobbotsch commented Feb 28, 2023

ghost commented Feb 28, 2023

jakobbotsch commented Mar 2, 2023

azure-pipelines bot commented Mar 2, 2023

jakobbotsch commented Mar 2, 2023

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

BruceForstall commented Mar 6, 2023

jakobbotsch commented Mar 6, 2023 • edited

jakobbotsch commented Mar 6, 2023 • edited

jakobbotsch commented Mar 6, 2023 • edited

BruceForstall left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jakobbotsch commented Mar 6, 2023 •

edited

jakobbotsch commented Mar 6, 2023 •

edited

jakobbotsch commented Mar 6, 2023 •

edited