[GISel] Allow getConstantVRegVal() to return G_FCONSTANT values.

In GISel we have both G_CONSTANT and G_FCONSTANT, but because
in GISel we don't really have a concept of Float vs Int value
the only difference between the two is where the data originates
from.

What both G_CONSTANT and G_FCONSTANT return is just a bag of bits
with the constant representation in it.

By making getConstantVRegVal() return G_FCONSTANTs bit representation
as well we allow ConstantFold and other things to operate with
G_FCONSTANT.

Adding tests that show ConstantFolding to work on mixed G_CONSTANT
and G_FCONSTANT sources.

Differential Revision: https://reviews.llvm.org/D68739

llvm-svn: 374458

1 files changed, 168 insertions, 0 deletions

diff --git a/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp b/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp
index 6f4366bd09a..e36b4bd2e8a 100644
--- a/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp
+++ b/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp
@@ -68,4 +68,172 @@ TEST_F(GISelMITest, FoldWithBuilder) {
   EXPECT_EQ(-0x80, Cst);
 }
 
+TEST_F(GISelMITest, FoldBinOp) {
+  setUp();
+  if (!TM)
+    return;
+
+  LLT s32{LLT::scalar(32)};
+  auto MIBCst1 = B.buildConstant(s32, 16);
+  auto MIBCst2 = B.buildConstant(s32, 9);
+  auto MIBFCst1 = B.buildFConstant(s32, 1.0000001);
+  auto MIBFCst2 = B.buildFConstant(s32, 2.0);
+
+  // Test G_ADD folding Integer + Mixed Int-Float cases
+  Optional<APInt> FoldGAddInt =
+      ConstantFoldBinOp(TargetOpcode::G_ADD, MIBCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGAddInt.hasValue());
+  EXPECT_EQ(25ULL, FoldGAddInt.getValue().getLimitedValue());
+  Optional<APInt> FoldGAddMix =
+      ConstantFoldBinOp(TargetOpcode::G_ADD, MIBCst1->getOperand(0).getReg(),
+                        MIBFCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGAddMix.hasValue());
+  EXPECT_EQ(1073741840ULL, FoldGAddMix.getValue().getLimitedValue());
+
+  // Test G_AND folding Integer + Mixed Int-Float cases
+  Optional<APInt> FoldGAndInt =
+      ConstantFoldBinOp(TargetOpcode::G_AND, MIBCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGAndInt.hasValue());
+  EXPECT_EQ(0ULL, FoldGAndInt.getValue().getLimitedValue());
+  Optional<APInt> FoldGAndMix =
+      ConstantFoldBinOp(TargetOpcode::G_AND, MIBCst2->getOperand(0).getReg(),
+                        MIBFCst1->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGAndMix.hasValue());
+  EXPECT_EQ(1ULL, FoldGAndMix.getValue().getLimitedValue());
+
+  // Test G_ASHR folding Integer + Mixed cases
+  Optional<APInt> FoldGAShrInt =
+      ConstantFoldBinOp(TargetOpcode::G_ASHR, MIBCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGAShrInt.hasValue());
+  EXPECT_EQ(0ULL, FoldGAShrInt.getValue().getLimitedValue());
+  Optional<APInt> FoldGAShrMix =
+      ConstantFoldBinOp(TargetOpcode::G_ASHR, MIBFCst2->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGAShrMix.hasValue());
+  EXPECT_EQ(2097152ULL, FoldGAShrMix.getValue().getLimitedValue());
+
+  // Test G_LSHR folding Integer + Mixed Int-Float cases
+  Optional<APInt> FoldGLShrInt =
+      ConstantFoldBinOp(TargetOpcode::G_LSHR, MIBCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGLShrInt.hasValue());
+  EXPECT_EQ(0ULL, FoldGLShrInt.getValue().getLimitedValue());
+  Optional<APInt> FoldGLShrMix =
+      ConstantFoldBinOp(TargetOpcode::G_LSHR, MIBFCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGLShrMix.hasValue());
+  EXPECT_EQ(2080768ULL, FoldGLShrMix.getValue().getLimitedValue());
+
+  // Test G_MUL folding Integer + Mixed Int-Float cases
+  Optional<APInt> FoldGMulInt =
+      ConstantFoldBinOp(TargetOpcode::G_MUL, MIBCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGMulInt.hasValue());
+  EXPECT_EQ(144ULL, FoldGMulInt.getValue().getLimitedValue());
+  Optional<APInt> FoldGMulMix =
+      ConstantFoldBinOp(TargetOpcode::G_MUL, MIBCst1->getOperand(0).getReg(),
+                        MIBFCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGMulMix.hasValue());
+  EXPECT_EQ(0ULL, FoldGMulMix.getValue().getLimitedValue());
+
+  // Test G_OR folding Integer + Mixed Int-Float cases
+  Optional<APInt> FoldGOrInt =
+      ConstantFoldBinOp(TargetOpcode::G_OR, MIBCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGOrInt.hasValue());
+  EXPECT_EQ(25ULL, FoldGOrInt.getValue().getLimitedValue());
+  Optional<APInt> FoldGOrMix =
+      ConstantFoldBinOp(TargetOpcode::G_OR, MIBCst1->getOperand(0).getReg(),
+                        MIBFCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGOrMix.hasValue());
+  EXPECT_EQ(1073741840ULL, FoldGOrMix.getValue().getLimitedValue());
+
+  // Test G_SHL folding Integer + Mixed Int-Float cases
+  Optional<APInt> FoldGShlInt =
+      ConstantFoldBinOp(TargetOpcode::G_SHL, MIBCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGShlInt.hasValue());
+  EXPECT_EQ(8192ULL, FoldGShlInt.getValue().getLimitedValue());
+  Optional<APInt> FoldGShlMix =
+      ConstantFoldBinOp(TargetOpcode::G_SHL, MIBCst1->getOperand(0).getReg(),
+                        MIBFCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGShlMix.hasValue());
+  EXPECT_EQ(0ULL, FoldGShlMix.getValue().getLimitedValue());
+
+  // Test G_SUB folding Integer + Mixed Int-Float cases
+  Optional<APInt> FoldGSubInt =
+      ConstantFoldBinOp(TargetOpcode::G_SUB, MIBCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGSubInt.hasValue());
+  EXPECT_EQ(7ULL, FoldGSubInt.getValue().getLimitedValue());
+  Optional<APInt> FoldGSubMix =
+      ConstantFoldBinOp(TargetOpcode::G_SUB, MIBCst1->getOperand(0).getReg(),
+                        MIBFCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGSubMix.hasValue());
+  EXPECT_EQ(3221225488ULL, FoldGSubMix.getValue().getLimitedValue());
+
+  // Test G_XOR folding Integer + Mixed Int-Float cases
+  Optional<APInt> FoldGXorInt =
+      ConstantFoldBinOp(TargetOpcode::G_XOR, MIBCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGXorInt.hasValue());
+  EXPECT_EQ(25ULL, FoldGXorInt.getValue().getLimitedValue());
+  Optional<APInt> FoldGXorMix =
+      ConstantFoldBinOp(TargetOpcode::G_XOR, MIBCst1->getOperand(0).getReg(),
+                        MIBFCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGXorMix.hasValue());
+  EXPECT_EQ(1073741840ULL, FoldGXorMix.getValue().getLimitedValue());
+
+  // Test G_UDIV folding Integer + Mixed Int-Float cases
+  Optional<APInt> FoldGUdivInt =
+      ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGUdivInt.hasValue());
+  EXPECT_EQ(1ULL, FoldGUdivInt.getValue().getLimitedValue());
+  Optional<APInt> FoldGUdivMix =
+      ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1->getOperand(0).getReg(),
+                        MIBFCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGUdivMix.hasValue());
+  EXPECT_EQ(0ULL, FoldGUdivMix.getValue().getLimitedValue());
+
+  // Test G_SDIV folding Integer + Mixed Int-Float cases
+  Optional<APInt> FoldGSdivInt =
+      ConstantFoldBinOp(TargetOpcode::G_SDIV, MIBCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGSdivInt.hasValue());
+  EXPECT_EQ(1ULL, FoldGSdivInt.getValue().getLimitedValue());
+  Optional<APInt> FoldGSdivMix =
+      ConstantFoldBinOp(TargetOpcode::G_SDIV, MIBCst1->getOperand(0).getReg(),
+                        MIBFCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGSdivMix.hasValue());
+  EXPECT_EQ(0ULL, FoldGSdivMix.getValue().getLimitedValue());
+
+  // Test G_UREM folding Integer + Mixed Int-Float cases
+  Optional<APInt> FoldGUremInt =
+      ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGUremInt.hasValue());
+  EXPECT_EQ(1ULL, FoldGUremInt.getValue().getLimitedValue());
+  Optional<APInt> FoldGUremMix =
+      ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1->getOperand(0).getReg(),
+                        MIBFCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGUremMix.hasValue());
+  EXPECT_EQ(0ULL, FoldGUremMix.getValue().getLimitedValue());
+
+  // Test G_SREM folding Integer + Mixed Int-Float cases
+  Optional<APInt> FoldGSremInt =
+      ConstantFoldBinOp(TargetOpcode::G_SREM, MIBCst1->getOperand(0).getReg(),
+                        MIBCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGSremInt.hasValue());
+  EXPECT_EQ(7ULL, FoldGSremInt.getValue().getLimitedValue());
+  Optional<APInt> FoldGSremMix =
+      ConstantFoldBinOp(TargetOpcode::G_SREM, MIBCst1->getOperand(0).getReg(),
+                        MIBFCst2->getOperand(0).getReg(), *MRI);
+  EXPECT_TRUE(FoldGSremMix.hasValue());
+  EXPECT_EQ(16ULL, FoldGSremMix.getValue().getLimitedValue());
+}
+
 } // namespace
\ No newline at end of file