[GlobalISel][AArch64] Fix narrowScalar for G_ICMP

[Petar.Avramovic]

@brzycki
I don't have necessary toolchain for full build, but from error report it is most likely __int128 compare. I made small test that triggers same assert. Does it work now?

@dsanders
G_ICMP has s1 result(type0) by default. For AArch64 G_ICMP type0 has to be widened to s32.
Narrow Scalar for G_ICMP uses G_SELECT where condition(type1) is result of one of the new G_ICMP instructions. Only s1 for type1 is legal for G_SELECT.
During narrowScalar for G_ICMP we could make G_SELECT with same type1 as a result(type0) for given G_ICMP but then again G_SELECT is only legal for s1(not for s32).
Here I put widen scalar rule for type0 in G_ICMP after clampScalar for type1 since G_ICMP and G_SELECT have different legalization strategies for operand with default s1 type.
Added a test to check that type mismatch assert does not trigger anymore.

Here is the llvm-ir test

define i1 @test_icmp_s128(i128* %x, i128* %y) {
entry:
  %0 = load i128, i128* %x
  %1 = load i128, i128* %y
  %cmp = icmp slt i128 %0, %1
  ret i1 %cmp
}

[brzycki]

Hello @Petar.Avramovic , I have verified this patch on a recent sha 510e6fadaae95a41bee0eb99d84a146efc612365 does not crash clang when compiling the libcxx shared library. Thank you for identifying the source of the crash.

I don't feel comfortable enough reviewing this change for all Aarch64 targets and recommend @evandro , @SjoerdMeijer, @rengolin, and/or @t.p.northover examine the change to lib/Target/AArch64/AArch64LegalizerInfo.cpp and its potential implications.

[aemerson]

I don't believe this is the right fix as the legalizer shouldn't really be hard coding the type of G_SELECT operands there. I fixed it by using the existing type of the G_ICMP in r366943.

[brzycki]

Thank you @aemerson , the fix in rL366943 seems to have prevented crashes when compiling libcxx for aarch64. I successfully compiled a nightly with sha f181dd99cf1c4e .

[Petar.Avramovic]

r367060

lib/Target/AArch64/AArch64LegalizerInfo.cpp

getActionDefinitionsBuilder(G_ICMP)
                  {v4s32, v4s32},
                  {v2s32, v2s32},
                  {v2s64, v2s64},
                  {v2s64, v2p0},
                  {v4s16, v4s16},
                  {v8s16, v8s16},
                  {v8s8, v8s8},
                  {v16s8, v16s8}})
-      .clampScalar(0, s32, s32)
       .clampScalar(1, s32, s64)
+      .clampScalar(0, s32, s32)
       .minScalarEltSameAsIf(
           [=](const LegalityQuery &Query) {
             const LLT &Ty = Query.Types[0];
             const LLT &SrcTy = Query.Types[1];
             return Ty.isVector() && !SrcTy.getElementType().isPointer() &&
                    Ty.getElementType() != SrcTy.getElementType();
           },
           0, 1)

test/CodeGen/AArch64/GlobalISel/legalize-cmp.mir

bb.0.entry:
     %12:_(s32) = G_ANYEXT %8(s1)
     $w0 = COPY %12(s32)
     %9:_(p0) = G_INTTOPTR %0(s64)
     %10:_(s1) = G_ICMP intpred(eq), %9(p0), %9
     %14:_(s32) = G_ANYEXT %10(s1)
     $w0 = COPY %14(s32)
 
 ...
+---
+name:            test_icmp_s128
+alignment:       2
+tracksRegLiveness: true
+body:             |
+  bb.1.entry:
+    liveins: $x0, $x1
+
+    ; CHECK-LABEL: name: test_icmp_s128
+    ; CHECK: liveins: $x0, $x1
+    ; CHECK: [[COPY:%[0-9]+]]:_(p0) = COPY $x0
+    ; CHECK: [[COPY1:%[0-9]+]]:_(p0) = COPY $x1
+    ; CHECK: [[LOAD:%[0-9]+]]:_(s64) = G_LOAD [[COPY]](p0) :: (load 8, align 16)
+    ; CHECK: [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 8
+    ; CHECK: [[GEP:%[0-9]+]]:_(p0) = G_GEP [[COPY]], [[C]](s64)
+    ; CHECK: [[LOAD1:%[0-9]+]]:_(s64) = G_LOAD [[GEP]](p0) :: (load 8)
+    ; CHECK: [[LOAD2:%[0-9]+]]:_(s64) = G_LOAD [[COPY1]](p0) :: (load 8, align 16)
+    ; CHECK: [[GEP1:%[0-9]+]]:_(p0) = G_GEP [[COPY1]], [[C]](s64)
+    ; CHECK: [[LOAD3:%[0-9]+]]:_(s64) = G_LOAD [[GEP1]](p0) :: (load 8)
+    ; CHECK: [[ICMP:%[0-9]+]]:_(s32) = G_ICMP intpred(slt), [[LOAD1]](s64), [[LOAD3]]
+    ; CHECK: [[ICMP1:%[0-9]+]]:_(s32) = G_ICMP intpred(eq), [[LOAD1]](s64), [[LOAD3]]
+    ; CHECK: [[TRUNC:%[0-9]+]]:_(s1) = G_TRUNC [[ICMP1]](s32)
+    ; CHECK: [[ICMP2:%[0-9]+]]:_(s32) = G_ICMP intpred(ult), [[LOAD]](s64), [[LOAD2]]
+    ; CHECK: [[COPY2:%[0-9]+]]:_(s32) = COPY [[ICMP2]](s32)
+    ; CHECK: [[COPY3:%[0-9]+]]:_(s32) = COPY [[ICMP]](s32)
+    ; CHECK: [[SELECT:%[0-9]+]]:_(s32) = G_SELECT [[TRUNC]](s1), [[COPY2]], [[COPY3]]
+    ; CHECK: [[COPY4:%[0-9]+]]:_(s32) = COPY [[SELECT]](s32)
+    ; CHECK: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
+    ; CHECK: [[AND:%[0-9]+]]:_(s32) = G_AND [[COPY4]], [[C1]]
+    ; CHECK: [[COPY5:%[0-9]+]]:_(s32) = COPY [[AND]](s32)
+    ; CHECK: $w0 = COPY [[COPY5]](s32)
+    ; CHECK: RET_ReallyLR implicit $w0
+    %0:_(p0) = COPY $x0
+    %1:_(p0) = COPY $x1
+    %2:_(s128) = G_LOAD %0(p0) :: (load 16)
+    %3:_(s128) = G_LOAD %1(p0) :: (load 16)
+    %4:_(s1) = G_ICMP intpred(slt), %2(s128), %3
+    %5:_(s8) = G_ZEXT %4(s1)
+    %6:_(s32) = G_ANYEXT %5(s8)
+    $w0 = COPY %6(s32)
+    RET_ReallyLR implicit $w0
+
+...