[SelectionDAG] Handle big-endian target BITCAST in computeKnownBits()

[jonpa]

Summary

The BITCAST handling in computeKnownBits() previously only worked for little endian.

This patch reverses the iteration over elements for a big-endian target which allows this to work in this case also.

SystemZ test case.

[RKSimon]

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

2381

Will this be correct? Does it need to be reversed for BE?

SubDemandedElts.shl(ISLE ? i : (SubScale - 1 - i))

[jonpa]

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

2381

PING!

(Personally I think this is correct - it seems to me to otherwise simply again disregard endianness. First the input is analyzed, then the bitcast is performed in the same way as if writing to memory and then loading back. Only in this second step should any reversal take place, or?)

[jonpa]

ping. Eli, could you take a look at this, please?

[efriedma]

LGTM

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

2381

It doesn't matter what order you analyze the sub-elements, as long as you map them correctly to the original element.

[jonpa]

Thank you. r327764.

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

if (!(SubVT.isInteger() || SubVT.isFloatingPoint()))
       break;
 
     // Fast handling of 'identity' bitcasts.
     if (BitWidth == SubBitWidth) {
       computeKnownBits(N0, Known, DemandedElts, Depth + 1);
       break;
     }
 
-    // Support big-endian targets when it becomes useful.
     bool IsLE = getDataLayout().isLittleEndian();
-    if (!IsLE)
-      break;
 
     // Bitcast 'small element' vector to 'large element' scalar/vector.
     if ((BitWidth % SubBitWidth) == 0) {
       assert(N0.getValueType().isVector() && "Expected bitcast from vector");
 
       // Collect known bits for the (larger) output by collecting the known
       // bits from each set of sub elements and shift these into place.
       // We need to separately call computeKnownBits for each set of
       // sub elements as the knownbits for each is likely to be different.
       unsigned SubScale = BitWidth / SubBitWidth;
       APInt SubDemandedElts(NumElts * SubScale, 0);
       for (unsigned i = 0; i != NumElts; ++i)
         if (DemandedElts[i])
           SubDemandedElts.setBit(i * SubScale);
 
       for (unsigned i = 0; i != SubScale; ++i) {
         computeKnownBits(N0, Known2, SubDemandedElts.shl(i),
                          Depth + 1);
-        Known.One |= Known2.One.zext(BitWidth).shl(SubBitWidth * i);
-        Known.Zero |= Known2.Zero.zext(BitWidth).shl(SubBitWidth * i);
+        unsigned Shifts = IsLE ? i : SubScale - 1 - i;
+        Known.One |= Known2.One.zext(BitWidth).shl(SubBitWidth * Shifts);
+        Known.Zero |= Known2.Zero.zext(BitWidth).shl(SubBitWidth * Shifts);
       }
     }
 
     // Bitcast 'large element' scalar/vector to 'small element' vector.
     if ((SubBitWidth % BitWidth) == 0) {
       assert(Op.getValueType().isVector() && "Expected bitcast to vector");
 
       // Collect known bits for the (smaller) output by collecting the known
       // bits from the overlapping larger input elements and extracting the
       // sub sections we actually care about.
       unsigned SubScale = SubBitWidth / BitWidth;
       APInt SubDemandedElts(NumElts / SubScale, 0);
       for (unsigned i = 0; i != NumElts; ++i)
         if (DemandedElts[i])
           SubDemandedElts.setBit(i / SubScale);
 
       computeKnownBits(N0, Known2, SubDemandedElts, Depth + 1);
 
       Known.Zero.setAllBits(); Known.One.setAllBits();
       for (unsigned i = 0; i != NumElts; ++i)
         if (DemandedElts[i]) {
-          unsigned Offset = (i % SubScale) * BitWidth;
+          unsigned Shifts = IsLE ? i : NumElts - 1 - i;
+          unsigned Offset = (Shifts % SubScale) * BitWidth;
           Known.One &= Known2.One.lshr(Offset).trunc(BitWidth);
           Known.Zero &= Known2.Zero.lshr(Offset).trunc(BitWidth);
           // If we don't know any bits, early out.
           if (Known.isUnknown())
             break;
         }
     }
     break;

test/CodeGen/SystemZ/dag-combine-03.ll

+; Test that DAGCombiner gets helped by getKnownBitsForTargetNode() when
+; BITCAST nodes are involved on a big-endian target.
+;
+; RUN: llc -mtriple=s390x-linux-gnu -mcpu=z13 < %s  | FileCheck %s
+
+define void @fun() {
+entry:
+  br label %lab0
+
+lab0:
+  %phi = phi i64 [ %sel, %lab0 ], [ 0, %entry ]
+  %add = add nuw nsw i64 %phi, 1
+  %cmp = icmp eq i64 %add, undef
+  %ins = insertelement <2 x i1> undef, i1 %cmp, i32 0
+  %xor = xor <2 x i1> %ins, <i1 true, i1 true>
+  %extr = extractelement <2 x i1> %xor, i32 0
+; The EXTRACT_VECTOR_ELT is done first into an i32, and then AND:ed with
+; 1. The AND is not actually necessary since the element contains a CC (i1)
+; value. Test that the BITCAST nodes in the DAG when computing KnownBits is
+; handled so that the AND is removed. If this succeeds, this results in a CHI
+; instead of TMLL.
+
+; CHECK-LABEL: # %bb.0:
+; CHECK:       chi
+; CHECK-NOT:   tmll
+; CHECK:       j
+  %sel = select i1 %extr, i64 %add, i64 0
+  br label %lab0
+}