[GlobalISel] Add an isExtendedTrueVal helper.

[paquette]

Summary

Add a helper equivalent to TargetLowering::isExtendedTrueVal and test it.

This is necessary to implement one of the simplifications in TargetLowering::SimplifySetCC.

[aemerson]

llvm/lib/CodeGen/GlobalISel/Utils.cpp

983

Not saying this is wrong, but what's the rationale here for Val needing to be exactly 1 for s1? If The type is s1 then isn't either -1 or 1 equivalently true?

[paquette]

llvm/lib/CodeGen/GlobalISel/Utils.cpp

983

I think that's very philosophical, but I guess I'm fine either way?

I could believe that there's no meaningful distinction between 1 and -1 in 1-bit world.

[aemerson]

llvm/lib/CodeGen/GlobalISel/Utils.cpp

983

I guess it depends on what the contract is for this function when the type size is < 64 bits. I know that if you get the constant value from a G_CONSTANT i1 true then it ends up as a -1 int64_t, so passing to this function would return false. Maybe we should mask off the upper bits on entry?

[arsenm]

llvm/include/llvm/CodeGen/GlobalISel/Utils.h

379–380

Should pass LLT by value

llvm/lib/CodeGen/GlobalISel/Utils.cpp

983

i1 true constants are treated as -1 everywhere else

[paquette]

The original code was confusing. Rewrote this to use getICmpTrueVal + APInt. I think this simplifies the behaviour for s1 quite a bit.

[arsenm]

LGTM

llvm/include/llvm/CodeGen/GlobalISel/Utils.h

bool matchUnaryPredicate(const MachineRegisterInfo &MRI, Register Reg,
                          std::function<bool(const Constant *ConstVal)> Match,
                          bool AllowUndefs = false);
 
 /// Returns true if given the TargetLowering's boolean contents information,
 /// the value \p Val contains a true value.
 bool isConstTrueVal(const TargetLowering &TLI, int64_t Val, bool IsVector,
                     bool IsFP);
 
+/// \returns Whether or not \p Val would be a true value if it was extended to
+/// \p ExtTy.
+///
+/// \p IsFP is true if the true value is floating point.
+/// \p IsSignExtended is true if the extension should be signed.
+bool isExtendedTrueVal(const APInt &Val, const LLT ExtTy,
+                       const TargetLowering &TLI, bool IsFP,
+                       bool IsSignExtended);
+/// \returns Whether or not \p Val would be a true value if it was extended from
+/// \p OrigTy to \p ExtTy.
+///
+/// \p IsFP is true if the true value is floating point.
+/// \p IsSignExtended is true if the extension should be signed.
+bool isExtendedTrueVal(int64_t Val, const LLT OrigTy, const LLT ExtTy,
+                       const TargetLowering &TLI, bool IsFP,
+                       bool IsSignExtended);
+
 /// Returns an integer representing true, as defined by the
 /// TargetBooleanContents.
 int64_t getICmpTrueVal(const TargetLowering &TLI, bool IsVector, bool IsFP);
 
 /// Returns true if the given block should be optimized for size.
 bool shouldOptForSize(const MachineBasicBlock &MBB, ProfileSummaryInfo *PSI,
                       BlockFrequencyInfo *BFI);
 } // End namespace llvm.
 #endif

llvm/lib/CodeGen/GlobalISel/Utils.cpp

bool llvm::isConstTrueVal(const TargetLowering &TLI, int64_t Val, bool IsVector,
   case TargetLowering::ZeroOrOneBooleanContent:
     return Val == 1;
   case TargetLowering::ZeroOrNegativeOneBooleanContent:
     return Val == -1;
   }
   llvm_unreachable("Invalid boolean contents");
 }
 
+bool llvm::isExtendedTrueVal(const APInt &Val, const LLT ExtTy,
+                             const TargetLowering &TLI, bool IsFP,
+                             bool IsSignExtended) {
+  unsigned OrigWidth = Val.getBitWidth();
+  unsigned ExtWidth = ExtTy.getScalarSizeInBits();
+  assert(ExtWidth >= OrigWidth && "Extension cannot be smaller than width!");
+  APInt ExtVal =
+      IsSignExtended ? Val.sextOrSelf(ExtWidth) : Val.zextOrSelf(ExtWidth);
+  return ExtVal == APInt(ExtWidth, getICmpTrueVal(TLI, ExtTy.isVector(), IsFP));
+}
+
+bool llvm::isExtendedTrueVal(int64_t Val, const LLT OrigTy, const LLT ExtTy,
+                             const TargetLowering &TLI, bool IsFP,
+                             bool IsSignExtended) {
+  assert(OrigTy.isVector() == ExtTy.isVector() &&
+         "OrigTy and ExtTy must both be vectors or scalars!");
+  return isExtendedTrueVal(APInt(OrigTy.getScalarSizeInBits(), Val), ExtTy, TLI,
+                           IsFP, IsSignExtended);
+}
+
 int64_t llvm::getICmpTrueVal(const TargetLowering &TLI, bool IsVector,
                              bool IsFP) {
   switch (TLI.getBooleanContents(IsVector, IsFP)) {
   case TargetLowering::UndefinedBooleanContent:
   case TargetLowering::ZeroOrOneBooleanContent:
     return 1;
   case TargetLowering::ZeroOrNegativeOneBooleanContent:
     return -1;

llvm/unittests/CodeGen/GlobalISel/GISelUtilsTest.cpp

 //===- GISelUtilsTest.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "GISelMITest.h"
 #include "llvm/CodeGen/GlobalISel/Utils.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 static const LLT S1 = LLT::scalar(1);
 static const LLT S8 = LLT::scalar(8);
 static const LLT S16 = LLT::scalar(16);
 static const LLT S32 = LLT::scalar(32);
 static const LLT S64 = LLT::scalar(64);
 static const LLT P0 = LLT::pointer(0, 64);
 static const LLT P1 = LLT::pointer(1, 32);
 
+static const LLT V2S1 = LLT::vector(2, 1);
+
 static const LLT V2S8 = LLT::vector(2, 8);
 static const LLT V4S8 = LLT::vector(4, 8);
 static const LLT V8S8 = LLT::vector(8, 8);
 
 static const LLT V2S16 = LLT::vector(2, 16);
 static const LLT V3S16 = LLT::vector(3, 16);
 static const LLT V4S16 = LLT::vector(4, 16);
 
TEST(GISelUtilsTest, getLCMType) {
 
   EXPECT_EQ(V2S64, getLCMType(V2S64, P0));
   EXPECT_EQ(V2P0, getLCMType(P0, V2S64));
 
   EXPECT_EQ(V2S64, getLCMType(V2S64, P1));
   EXPECT_EQ(V4P1, getLCMType(P1, V2S64));
 }
 
+TEST_F(AArch64GISelMITest, ExtendedTrueTest) {
+  setUp();
+  if (!TM)
+    return;
+  const auto &TLI = *B.getMF().getSubtarget().getTargetLowering();
+  // Test extended true/false for s1. This should only return true for 1,
+  // regardless of any other inputs, because we only have one bit.
+  for (auto IsFP : {true, false}) {
+    for (auto IsSignExtended : {true, false}) {
+      for (auto Ty : {S1, V2S1}) {
+        // 1 and -1 both work, because these are all-ones values.
+        EXPECT_TRUE(isExtendedTrueVal(1, Ty, Ty, TLI, IsFP, IsSignExtended));
+        EXPECT_TRUE(isExtendedTrueVal(-1, Ty, Ty, TLI, IsFP, IsSignExtended));
+        EXPECT_FALSE(isExtendedTrueVal(0, Ty, Ty, TLI, IsFP, IsSignExtended));
+      }
+
+      // ZeroOrOneBooleanContent
+      EXPECT_TRUE(isExtendedTrueVal(1, S32, S32, TLI, IsFP, IsSignExtended));
+      EXPECT_TRUE(isExtendedTrueVal(1, S32, S64, TLI, IsFP, IsSignExtended));
+      EXPECT_FALSE(isExtendedTrueVal(0, S32, S64, TLI, IsFP, IsSignExtended));
+      EXPECT_FALSE(isExtendedTrueVal(-1, S32, S64, TLI, IsFP, IsSignExtended));
+
+      // ZeroOrNegativeOneBooleanContent
+      EXPECT_TRUE(
+          isExtendedTrueVal(-1, V2S32, V2S32, TLI, IsFP, IsSignExtended));
+      EXPECT_FALSE(
+          isExtendedTrueVal(0, V2S32, V2S64, TLI, IsFP, IsSignExtended));
+      EXPECT_FALSE(
+          isExtendedTrueVal(1, V2S32, V2S64, TLI, IsFP, IsSignExtended));
+    }
+
+    // Test differing behaviour between SExt + ZExt.
+    const bool SExt = true;
+    const bool ZExt = false;
+    // ZeroOrOneBooleanContent
+    EXPECT_TRUE(isExtendedTrueVal(1, S1, S32, TLI, IsFP, ZExt));
+    EXPECT_FALSE(isExtendedTrueVal(1, S1, S32, TLI, IsFP, SExt));
+
+    // ZeroOrNegativeOneBooleanContent
+    EXPECT_FALSE(isExtendedTrueVal(1, V2S1, V2S32, TLI, IsFP, ZExt));
+    EXPECT_FALSE(isExtendedTrueVal(-1, V2S1, V2S32, TLI, IsFP, ZExt));
+    EXPECT_FALSE(isExtendedTrueVal(-1, V2S32, V2S64, TLI, IsFP, ZExt));
+
+    EXPECT_TRUE(isExtendedTrueVal(1, V2S1, V2S32, TLI, IsFP, SExt));
+    EXPECT_TRUE(isExtendedTrueVal(-1, V2S1, V2S32, TLI, IsFP, SExt));
+    EXPECT_TRUE(isExtendedTrueVal(-1, V2S32, V2S64, TLI, IsFP, SExt));
+    EXPECT_TRUE(isExtendedTrueVal(0xFFFFFFFF, V2S32, V2S64, TLI, IsFP, SExt));
+    EXPECT_FALSE(isExtendedTrueVal(0xFFFFFFFE, V2S32, V2S64, TLI, IsFP, SExt));
+  }
 }
+} // namespace