[GISel]: Add helpers for easy building G_FCONSTANT along with matchers

[aditya_nandakumar]

Summary

Added helpers to build G_FCONSTANT, along with matching ConstantFP and unit tests for the same.

Sample usage.

auto MIB = Builder.buildFConstant(DstReg, 0.5, s32); // Build IEEESingle

For Matching the above

const ConstantFP* Tmp;
mi_match(DstReg, MRI, m_GFCst(Tmp));

[aditya_nandakumar]

Perhaps we could add some checks to make sure that the user is not building a larger floating point constant into a register of smaller type under Asserts. Not sure if that's ever a valid use case - but if it's not I'll definitely add that bit.

[aditya_nandakumar]

Added check to assert that the sizes are compatible. Also moved comments for the two functions from Utils.cpp to Utils.h.

[volkan]

lib/CodeGen/GlobalISel/MachineIRBuilder.cpp

291

Could you check this in MachineVerifier as well?

295

We already know DstTy here, can't we just use DstTy instead of Ty?

lib/CodeGen/GlobalISel/Utils.cpp

217

We don't need fltSemantics for float and double so I think we can move this to getAPFloatFromSize and always use getAPFloatFromSize to create an APFloat. What do you think?

240

This can be simplified as APFloat APF(Val); if you prefer.

unittests/CodeGen/GlobalISel/PatternMatchTest.cpp

292

This can be replaced with getAPFloatFromSize(0.5, 16).

[aditya_nandakumar]

lib/CodeGen/GlobalISel/MachineIRBuilder.cpp

291

I can do this in a separate commit as this is only adding builder helpers vs adding verifier + fixing tests.

295

I was hoping to avoid needless getGenericVirtualReg() -> getType() lookups.
I've gone ahead and removed it for now.

unittests/CodeGen/GlobalISel/PatternMatchTest.cpp

292

I was hoping to test that part as well here (getting the correct APFloat).

[aditya_nandakumar]

Updated based on Volkan's feedback.

[volkan]

LGTM. Thank you Aditya.

include/llvm/CodeGen/GlobalISel/Utils.h

38

I think fltSemantics and LLT are no longer required. Could you remove them before committing?

lib/CodeGen/GlobalISel/MachineIRBuilder.cpp

291

That works for me.

[aditya_nandakumar]

Committed in r327152

include/llvm/CodeGen/GlobalISel/MIPatternMatch.h

template <> struct bind_helper<LLT> {
   static bool bind(const MachineRegisterInfo &MRI, LLT &Ty, unsigned Reg) {
     Ty = MRI.getType(Reg);
     if (Ty.isValid())
       return true;
     return false;
   }
 };
 
+template <> struct bind_helper<const ConstantFP *> {
+  static bool bind(const MachineRegisterInfo &MRI, const ConstantFP *&F,
+                   unsigned Reg) {
+    F = getConstantFPVRegVal(Reg, MRI);
+    if (F)
+      return true;
+    return false;
+  }
+};
+
 template <typename Class> struct bind_ty {
   Class &VR;
 
   bind_ty(Class &V) : VR(V) {}
 
   template <typename ITy> bool match(const MachineRegisterInfo &MRI, ITy &&V) {
     return bind_helper<Class>::bind(MRI, VR, V);
   }
 };
 
 inline bind_ty<unsigned> m_Reg(unsigned &R) { return R; }
 inline bind_ty<MachineInstr *> m_MInstr(MachineInstr *&MI) { return MI; }
 inline bind_ty<LLT> m_Type(LLT &Ty) { return Ty; }
 
+// Helper for matching G_FCONSTANT
+inline bind_ty<const ConstantFP *> m_GFCst(const ConstantFP *&C) { return C; }
+
 // General helper for all the binary generic MI such as G_ADD/G_SUB etc
 template <typename LHS_P, typename RHS_P, unsigned Opcode,
           bool Commutable = false>
 struct BinaryOp_match {
   LHS_P L;
   RHS_P R;
 
   BinaryOp_match(const LHS_P &LHS, const RHS_P &RHS) : L(LHS), R(RHS) {}

include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h

public:
   ///
   /// \return The newly created instruction.
   template <typename DstType>
   MachineInstrBuilder buildFConstant(DstType &&Res, const ConstantFP &Val) {
     return buildFConstant(getDestFromArg(Res), Val);
   }
   MachineInstrBuilder buildFConstant(unsigned Res, const ConstantFP &Val);
 
+  template <typename DstType>
+  MachineInstrBuilder buildFConstant(DstType &&Res, double Val, const LLT &Ty) {
+    return buildFConstant(getDestFromArg(Res), Val, Ty);
+  }
+  MachineInstrBuilder buildFConstant(unsigned Res, double Val, const LLT &Ty);
+
   /// Build and insert \p Res = COPY Op
   ///
   /// Register-to-register COPY sets \p Res to \p Op.
   ///
   /// \pre setBasicBlock or setMI must have been called.
   ///
   /// \return a MachineInstrBuilder for the newly created instruction.
   MachineInstrBuilder buildCopy(unsigned Res, unsigned Op);

include/llvm/CodeGen/GlobalISel/Utils.h

 class MCInstrDesc;
 class RegisterBankInfo;
 class TargetInstrInfo;
 class TargetPassConfig;
 class TargetRegisterInfo;
 class TargetRegisterClass;
 class Twine;
 class ConstantFP;
+struct fltSemantics;
+class APFloat;
+class LLT;
 
 /// Try to constrain Reg to the specified register class. If this fails,
 /// create a new virtual register in the correct class and insert a COPY before
 /// \p InsertPt. The debug location of \p InsertPt is used for the new copy.
 ///
 /// \return The virtual register constrained to the right register class.
 unsigned constrainRegToClass(MachineRegisterInfo &MRI,
                              const TargetInstrInfo &TII,
const ConstantFP* getConstantFPVRegVal(unsigned VReg,
                                        const MachineRegisterInfo &MRI);
 
 /// See if Reg is defined by an single def instruction that is
 /// Opcode. Also try to do trivial folding if it's a COPY with
 /// same types. Returns null otherwise.
 MachineInstr *getOpcodeDef(unsigned Opcode, unsigned Reg,
                            const MachineRegisterInfo &MRI);
 
+const fltSemantics &LLTToAPFloatSemantics(const LLT &Ty);
+
+APFloat getAPFloatFromSize(double Val, unsigned Size);
 } // End namespace llvm.
 #endif

lib/CodeGen/GlobalISel/MachineIRBuilder.cpp

 
 MachineInstrBuilder MachineIRBuilder::buildFConstant(unsigned Res,
                                                      const ConstantFP &Val) {
   assert(MRI->getType(Res).isScalar() && "invalid operand type");
 
   return buildInstr(TargetOpcode::G_FCONSTANT).addDef(Res).addFPImm(&Val);
 }
 
+MachineInstrBuilder MachineIRBuilder::buildFConstant(unsigned Res, double Val,
+                                                     const LLT &Ty) {
+  auto &Ctx = MF->getFunction().getContext();
+  auto *CFP = ConstantFP::get(Ctx, getAPFloatFromSize(Val, Ty.getSizeInBits()));
+  return buildFConstant(Res, *CFP);
+}
+
 MachineInstrBuilder MachineIRBuilder::buildBrCond(unsigned Tst,
                                                   MachineBasicBlock &Dest) {
   assert(MRI->getType(Tst).isScalar() && "invalid operand type");
 
   return buildInstr(TargetOpcode::G_BRCOND).addUse(Tst).addMBB(&Dest);
 }
 
 MachineInstrBuilder MachineIRBuilder::buildLoad(unsigned Res, unsigned Addr,
                                                 MachineMemOperand &MMO) {
   assert(MRI->getType(Res).isValid() && "invalid operand type");

lib/CodeGen/GlobalISel/Utils.cpp

 //===- llvm/CodeGen/GlobalISel/Utils.cpp -------------------------*- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file This file implements the utility functions used by the GlobalISel
 /// pipeline.
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/GlobalISel/Utils.h"
+#include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/CodeGen/GlobalISel/RegisterBankInfo.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
while (DefMI->getOpcode() == TargetOpcode::COPY) {
     unsigned SrcReg = DefMI->getOperand(1).getReg();
     auto SrcTy = MRI.getType(SrcReg);
     if (!SrcTy.isValid() || SrcTy != DstTy)
       break;
     DefMI = MRI.getVRegDef(SrcReg);
   }
   return DefMI->getOpcode() == Opcode ? DefMI : nullptr;
 }
+
+/// Returns an APFloat semantics tag appropriate for the given type.
+const llvm::fltSemantics &llvm::LLTToAPFloatSemantics(const LLT &Ty) {
+  if (!Ty.isValid())
+    llvm_unreachable("Unknown Type");
+  switch (Ty.getSizeInBits()) {
+  case 16:
+    return APFloat::IEEEhalf();
+  case 32:
+    return APFloat::IEEEsingle();
+  case 64:
+    return APFloat::IEEEdouble();
+  default:
+    llvm_unreachable("Unknown FP format");
+  }
+}
+
+/// Returns a APFloat from Val converted to the appropriate size
+APFloat llvm::getAPFloatFromSize(double Val, unsigned Size) {
+  if (Size == 32)
+    return APFloat(float(Val));
+  if (Size == 64)
+    return APFloat(Val);
+  if (Size != 16)
+    llvm_unreachable("Unsupported FPConstant size");
+  bool Ignored;
+  APFloat APF = APFloat(Val);
+  APF.convert(LLTToAPFloatSemantics(LLT::scalar(Size)),
+              APFloat::rmNearestTiesToEven, &Ignored);
+  return APF;
+}

unittests/CodeGen/GlobalISel/PatternMatchTest.cpp

TEST(PatternMatchInstr, MatchFPUnaryOp) {
   // Match G_FABS.
   auto MIBFabs = B.buildInstr(TargetOpcode::G_FABS, s32, Copy0s32);
   bool match = mi_match(MIBFabs->getOperand(0).getReg(), MRI, m_GFabs(m_Reg()));
   ASSERT_TRUE(match);
   unsigned Src;
   match = mi_match(MIBFabs->getOperand(0).getReg(), MRI, m_GFabs(m_Reg(Src)));
   ASSERT_TRUE(match);
   ASSERT_EQ(Src, Copy0s32->getOperand(0).getReg());
+
+  // Build and match FConstant.
+  auto MIBFCst = B.buildFConstant(s32, .5, s32);
+  const ConstantFP *TmpFP{};
+  match = mi_match(MIBFCst->getOperand(0).getReg(), MRI, m_GFCst(TmpFP));
+  ASSERT_TRUE(match);
+  ASSERT_TRUE(TmpFP);
+  APFloat APF((float).5);
+  auto *CFP = ConstantFP::get(Context, APF);
+  ASSERT_EQ(CFP, TmpFP);
+
+  // Build double float.
+  LLT s64 = LLT::scalar(64);
+  auto MIBFCst64 = B.buildFConstant(s64, .5, s64);
+  const ConstantFP *TmpFP64{};
+  match = mi_match(MIBFCst64->getOperand(0).getReg(), MRI, m_GFCst(TmpFP64));
+  ASSERT_TRUE(match);
+  ASSERT_TRUE(TmpFP64);
+  APFloat APF64(.5);
+  auto CFP64 = ConstantFP::get(Context, APF64);
+  ASSERT_EQ(CFP64, TmpFP64);
+  ASSERT_NE(TmpFP64, TmpFP);
+
+  // Build half float.
+  LLT s16 = LLT::scalar(16);
+  auto MIBFCst16 = B.buildFConstant(s16, .5, s16);
+  const ConstantFP *TmpFP16{};
+  match = mi_match(MIBFCst16->getOperand(0).getReg(), MRI, m_GFCst(TmpFP16));
+  ASSERT_TRUE(match);
+  ASSERT_TRUE(TmpFP16);
+  bool Ignored;
+  APFloat APF16(.5);
+  APF16.convert(LLTToAPFloatSemantics(s16), APFloat::rmNearestTiesToEven,
+                &Ignored);
+  auto CFP16 = ConstantFP::get(Context, APF16);
+  ASSERT_EQ(TmpFP16, CFP16);
+  ASSERT_NE(TmpFP16, TmpFP);
 }
 
 TEST(PatternMatchInstr, MatchExtendsTrunc) {
   LLVMContext Context;
   std::unique_ptr<TargetMachine> TM = createTargetMachine();
   if (!TM)
     return;
   auto ModuleMMIPair = createDummyModule(Context, *TM, "");