GlobalISel: Refactor unary FP op constant folding

[Pierre-vh]

LGTM, just a small style nit

llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp

1294

small nit: not a fan of having V/Val in the same function, the names get confusing - maybe use something like Ret instead? Or rename the Val parameter to something more descriptive.

1307

If I understand correctly this is a NFC, G_FPTRUNC was handled anyway by the V.convert call below, but now it's explicit?

[arsenm]

llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp

1307

Yes, the LLT-to-semantics is only used for fptrunc now.

I'm thinking of moving FPTRUNC handling out of here entirely. It's an annoying special case complicating another patch I'm working on

[arsenm]

7f54b38e28b3b66195de672848f2b5366d0d51e3

llvm/include/llvm/CodeGen/GlobalISel/CombinerHelper.h

 #include "llvm/IR/InstrTypes.h"
 #include <functional>
 
 namespace llvm {
 
 class GISelChangeObserver;
 class APFloat;
 class APInt;
+class ConstantFP;
 class GPtrAdd;
 class GStore;
 class GZExtLoad;
 class MachineIRBuilder;
 class MachineInstrBuilder;
 class MachineRegisterInfo;
 class MachineInstr;
 class MachineOperand;
public:
   void applyCombineUnmergeWithDeadLanesToTrunc(MachineInstr &MI);
 
   /// Transform X, Y = G_UNMERGE(G_ZEXT(Z)) -> X = G_ZEXT(Z); Y = G_CONSTANT 0
   bool matchCombineUnmergeZExtToZExt(MachineInstr &MI);
   void applyCombineUnmergeZExtToZExt(MachineInstr &MI);
 
   /// Transform fp_instr(cst) to constant result of the fp operation.
   bool matchCombineConstantFoldFpUnary(MachineInstr &MI,
-                                       std::optional<APFloat> &Cst);
-  void applyCombineConstantFoldFpUnary(MachineInstr &MI,
-                                       std::optional<APFloat> &Cst);
+                                       const ConstantFP *&Cst);
+  void applyCombineConstantFoldFpUnary(MachineInstr &MI, const ConstantFP *Cst);
 
   /// Transform IntToPtr(PtrToInt(x)) to x if cast is in the same address space.
   bool matchCombineI2PToP2I(MachineInstr &MI, Register &Reg);
   void applyCombineI2PToP2I(MachineInstr &MI, Register &Reg);
 
   /// Transform PtrToInt(IntToPtr(x)) to x.
   void applyCombineP2IToI2P(MachineInstr &MI, Register &Reg);
 

llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h

const MachineFunction &getMF() const {
     assert(State.MF && "MachineFunction is not set");
     return *State.MF;
   }
 
   const DataLayout &getDataLayout() const {
     return getMF().getFunction().getParent()->getDataLayout();
   }
 
+  LLVMContext &getContext() const {
+    return getMF().getFunction().getContext();
+  }
+
   /// Getter for DebugLoc
   const DebugLoc &getDL() { return State.DL; }
 
   /// Getter for MRI
   MachineRegisterInfo *getMRI() { return State.MRI; }
   const MachineRegisterInfo *getMRI() const { return State.MRI; }
 
   /// Getter for the State

llvm/include/llvm/Target/GlobalISel/Combine.td

 def simplify_add_to_sub: GICombineRule <
   (defs root:$root, simplify_add_to_sub_matchinfo:$info),
   (match (wip_match_opcode G_ADD):$root,
     [{ return Helper.matchSimplifyAddToSub(*${root}, ${info}); }]),
   (apply [{ Helper.applySimplifyAddToSub(*${root}, ${info});}])
 >;
 
 // Fold fp_op(cst) to the constant result of the floating point operation.
-def constant_fp_op_matchinfo: GIDefMatchData<"std::optional<APFloat>">;
+def constant_fp_op_matchinfo: GIDefMatchData<"const ConstantFP *">;
 def constant_fp_op: GICombineRule <
   (defs root:$root, constant_fp_op_matchinfo:$info),
   (match (wip_match_opcode G_FNEG, G_FABS, G_FPTRUNC, G_FSQRT, G_FLOG2):$root,
     [{ return Helper.matchCombineConstantFoldFpUnary(*${root}, ${info}); }]),
   (apply [{ Helper.applyCombineConstantFoldFpUnary(*${root}, ${info}); }])
 >;
 
 // Fold int2ptr(ptr2int(x)) -> x

llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp

bool CombinerHelper::tryCombineMemCpyFamily(MachineInstr &MI, unsigned MaxLen) {
   MachineIRBuilder HelperBuilder(MI);
   GISelObserverWrapper DummyObserver;
   LegalizerHelper Helper(HelperBuilder.getMF(), DummyObserver, HelperBuilder);
   return Helper.lowerMemCpyFamily(MI, MaxLen) ==
          LegalizerHelper::LegalizeResult::Legalized;
 }
 
 static std::optional<APFloat>
-constantFoldFpUnary(unsigned Opcode, LLT DstTy, const Register Op,
-                    const MachineRegisterInfo &MRI) {
-  const ConstantFP *MaybeCst = getConstantFPVRegVal(Op, MRI);
-  if (!MaybeCst)
-    return std::nullopt;
-
-  APFloat V = MaybeCst->getValueAPF();
-  switch (Opcode) {
+constantFoldFpUnary(const MachineInstr &MI, const MachineRegisterInfo &MRI,
+                    const APFloat &Val) {
+  APFloat V(Val);
+  switch (MI.getOpcode()) {
   default:
     llvm_unreachable("Unexpected opcode!");
   case TargetOpcode::G_FNEG: {
     V.changeSign();
     return V;
   }
   case TargetOpcode::G_FABS: {
     V.clearSign();
     return V;
   }
-  case TargetOpcode::G_FPTRUNC:
-    break;
+  case TargetOpcode::G_FPTRUNC: {
+    bool Unused;
+    LLT DstTy = MRI.getType(MI.getOperand(0).getReg());
+    V.convert(getFltSemanticForLLT(DstTy), APFloat::rmNearestTiesToEven,
+              &Unused);
+    return V;
+  }
   case TargetOpcode::G_FSQRT: {
     bool Unused;
     V.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &Unused);
     V = APFloat(sqrt(V.convertToDouble()));
     break;
   }
   case TargetOpcode::G_FLOG2: {
     bool Unused;
     V.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &Unused);
     V = APFloat(log2(V.convertToDouble()));
     break;
   }
   }
   // Convert `APFloat` to appropriate IEEE type depending on `DstTy`. Otherwise,
-  // `buildFConstant` will assert on size mismatch. Only `G_FPTRUNC`, `G_FSQRT`,
-  // and `G_FLOG2` reach here.
+  // `buildFConstant` will assert on size mismatch. Only `G_FSQRT`, and
+  // `G_FLOG2` reach here.
   bool Unused;
-  V.convert(getFltSemanticForLLT(DstTy), APFloat::rmNearestTiesToEven, &Unused);
+  V.convert(Val.getSemantics(), APFloat::rmNearestTiesToEven, &Unused);
   return V;
 }
 
-bool CombinerHelper::matchCombineConstantFoldFpUnary(
-    MachineInstr &MI, std::optional<APFloat> &Cst) {
-  Register DstReg = MI.getOperand(0).getReg();
+bool CombinerHelper::matchCombineConstantFoldFpUnary(MachineInstr &MI,
+                                                     const ConstantFP *&Cst) {
   Register SrcReg = MI.getOperand(1).getReg();
-  LLT DstTy = MRI.getType(DstReg);
-  Cst = constantFoldFpUnary(MI.getOpcode(), DstTy, SrcReg, MRI);
-  return Cst.has_value();
+  const ConstantFP *MaybeCst = getConstantFPVRegVal(SrcReg, MRI);
+  if (!MaybeCst)
+    return false;
+
+  if (auto Folded = constantFoldFpUnary(MI, MRI, MaybeCst->getValue())) {
+    Cst = ConstantFP::get(Builder.getContext(), *Folded);
+    return true;
   }
 
-void CombinerHelper::applyCombineConstantFoldFpUnary(
-    MachineInstr &MI, std::optional<APFloat> &Cst) {
-  assert(Cst && "Optional is unexpectedly empty!");
+  return false;
+}
+
+void CombinerHelper::applyCombineConstantFoldFpUnary(MachineInstr &MI,
+                                                     const ConstantFP *Cst) {
   Builder.setInstrAndDebugLoc(MI);
-  MachineFunction &MF = Builder.getMF();
-  auto *FPVal = ConstantFP::get(MF.getFunction().getContext(), *Cst);
-  Register DstReg = MI.getOperand(0).getReg();
-  Builder.buildFConstant(DstReg, *FPVal);
+  Builder.buildFConstant(MI.getOperand(0), *Cst);
   MI.eraseFromParent();
 }
 
 bool CombinerHelper::matchPtrAddImmedChain(MachineInstr &MI,
                                            PtrAddChain &MatchInfo) {
   // We're trying to match the following pattern:
   //   %t1 = G_PTR_ADD %base, G_CONSTANT imm1
   //   %root = G_PTR_ADD %t1, G_CONSTANT imm2