[IRBuilder] Add CreateUnOp(...) and CreateFNegFMF(...)

[craig.topper]

llvm/include/llvm/IR/IRBuilder.h

1369

Why can't this keep using Folder.CreateFNeg? CreateNot uses Folder.CreateNot.

[craig.topper]

llvm/include/llvm/IR/IRBuilder.h

1379

It feels weird that this creates unaryoperator::fneg but CreateFNeg uses the binaryoperator. Shouldn't these be consistent until we switch over?

[cameron.mcinally]

llvm/include/llvm/IR/IRBuilder.h

1369

I considered this also and went with something more like CreateBinOp (see CreateUnOp too). The UnOps are odd ducks since they’re not really unary operators, but rather they’re implemented with existing BinOps. IMO, we should be moving away from the weirdness of the UnOps...

I don’t feel very strongly about this though. If you think the current UnOp direction is better, that’s fine with me.

1379

So I did consider that. My thinking was that we wouldn’t be regressing calling the UnaryOperator here, since it’s brand new code, so it’s better to move towards the goal. The reason we haven’t updated the old BinaryOperator code yet is that we’re afraid of regressions.

I do see your point though...

Also, let me be clear that this function will have at least one use in a patch to come. I’ve just broken out this digestible chunk for now.

[cameron.mcinally]

llvm/include/llvm/IR/IRBuilder.h

1369

Oh oh, I just remembered why I went down the BinOps path. If I’m not mistaken, the Folder.CreateFNeg method throws away FMF when there’s no folder. I wanted to avoid that. I’ll confirm in the morning...

[cameron.mcinally]

llvm/include/llvm/IR/IRBuilder.h

1369

If I’m not mistaken, the Folder.CreateFNeg method throws away FMF when there’s no folder.

I confused myself. That is a problem, but it's not this problem. In general, when the NoFolder is used, the new CreateF*FMF(...) instruction picks up the default FMFs from the IRBuilder, not the instruction it's supposed to copy from.

So, yeah, I could change this code back to make it look more like CreateNot, if that's the preference.

llvm/unittests/IR/PatternMatch.cpp

641

Just realized I misplaced these tests, so I'll have to update them.

[cameron.mcinally]

Moving the test ended up being a can of worms. I'm going to abandon this Diff to split it into two...

llvm/include/llvm/Analysis/TargetFolder.h

public:
   }
   Constant *CreateFNeg(Constant *C) const {
     return Fold(ConstantExpr::getFNeg(C));
   }
   Constant *CreateNot(Constant *C) const {
     return Fold(ConstantExpr::getNot(C));
   }
 
+  Constant *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const {
+    return Fold(ConstantExpr::get(Opc, C));
+  }
+
   //===--------------------------------------------------------------------===//
   // Memory Instructions
   //===--------------------------------------------------------------------===//
 
   Constant *CreateGetElementPtr(Type *Ty, Constant *C,
                                 ArrayRef<Constant *> IdxList) const {
     return Fold(ConstantExpr::getGetElementPtr(Ty, C, IdxList));
   }

llvm/include/llvm/IR/ConstantFolder.h

public:
   Constant *CreateFNeg(Constant *C) const {
     return ConstantExpr::getFNeg(C);
   }
 
   Constant *CreateNot(Constant *C) const {
     return ConstantExpr::getNot(C);
   }
 
+  Constant *CreateUnOp(Instruction::UnaryOps Opc, Constant *V) const {
+    return ConstantExpr::get(Opc, V);
+  }
+
   //===--------------------------------------------------------------------===//
   // Memory Instructions
   //===--------------------------------------------------------------------===//
 
   Constant *CreateGetElementPtr(Type *Ty, Constant *C,
                                 ArrayRef<Constant *> IdxList) const {
     return ConstantExpr::getGetElementPtr(Ty, C, IdxList);
   }

llvm/include/llvm/IR/IRBuilder.h

Instruction *setFPAttrs(Instruction *I, MDNode *FPMD,
     if (!FPMD)
       FPMD = DefaultFPMathTag;
     if (FPMD)
       I->setMetadata(LLVMContext::MD_fpmath, FPMD);
     I->setFastMathFlags(FMF);
     return I;
   }
 
+  Value *foldConstant(Instruction::UnaryOps Opc, Value *V,
+                      const Twine &Name) const {
+    auto *C = dyn_cast<Constant>(V);
+    return C ? Insert(Folder.CreateUnOp(Opc, C), Name) : nullptr;
+  }
+
   Value *foldConstant(Instruction::BinaryOps Opc, Value *L,
                       Value *R, const Twine &Name) const {
     auto *LC = dyn_cast<Constant>(L);
     auto *RC = dyn_cast<Constant>(R);
     return (LC && RC) ? Insert(Folder.CreateBinOp(Opc, LC, RC), Name) : nullptr;
   }
 
 public:
public:
   }
 
   Value *CreateNUWNeg(Value *V, const Twine &Name = "") {
     return CreateNeg(V, Name, true, false);
   }
 
   Value *CreateFNeg(Value *V, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
-    if (auto *VC = dyn_cast<Constant>(V))
-      return Insert(Folder.CreateFNeg(VC), Name);
+    if (Value *VC = foldConstant(Instruction::FNeg, V, Name)) return VC;
     return Insert(setFPAttrs(BinaryOperator::CreateFNeg(V), FPMathTag, FMF),
                   Name);
   }
 
+  /// Copy fast-math-flags from an instruction rather than using the builder's
+  /// default FMF.
+  Value *CreateFNegFMF(Value *V, Instruction *FMFSource,
+                       const Twine &Name = "") {
+   if (Value *VC = foldConstant(Instruction::FNeg, V, Name)) return VC;
+   return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), nullptr,
+                            FMFSource->getFastMathFlags()),
+                 Name);
+  }
+
   Value *CreateNot(Value *V, const Twine &Name = "") {
     if (auto *VC = dyn_cast<Constant>(V))
       return Insert(Folder.CreateNot(VC), Name);
     return Insert(BinaryOperator::CreateNot(V), Name);
   }
 
+  Value *CreateUnOp(Instruction::UnaryOps Opc,
+                    Value *V, const Twine &Name = "",
+                    MDNode *FPMathTag = nullptr) {
+    if (Value *VC = foldConstant(Opc, V, Name)) return VC;
+    Instruction *UnOp = UnaryOperator::Create(Opc, V);
+    if (isa<FPMathOperator>(UnOp))
+      UnOp = setFPAttrs(UnOp, FPMathTag, FMF);
+    return Insert(UnOp, Name);
+  }
+
   //===--------------------------------------------------------------------===//
   // Instruction creation methods: Memory Instructions
   //===--------------------------------------------------------------------===//
 
   AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
                            Value *ArraySize = nullptr, const Twine &Name = "") {
     return Insert(new AllocaInst(Ty, AddrSpace, ArraySize), Name);
   }

llvm/include/llvm/IR/NoFolder.h

public:
   Instruction *CreateFNeg(Constant *C) const {
     return BinaryOperator::CreateFNeg(C);
   }
 
   Instruction *CreateNot(Constant *C) const {
     return BinaryOperator::CreateNot(C);
   }
 
+  Instruction *CreateUnOp(Instruction::UnaryOps Opc, Constant *V) const {
+    return UnaryOperator::Create(Opc, V);
+  }
+
   //===--------------------------------------------------------------------===//
   // Memory Instructions
   //===--------------------------------------------------------------------===//
 
   Constant *CreateGetElementPtr(Type *Ty, Constant *C,
                                 ArrayRef<Constant *> IdxList) const {
     return ConstantExpr::getGetElementPtr(Ty, C, IdxList);
   }

llvm/unittests/IR/PatternMatch.cpp

TEST_F(PatternMatchTest, FloatingPointFNeg) {
   // Test FSub(0.0, 1.0)
   EXPECT_FALSE(match(V2, m_FNeg(m_Value(Match))));
   cast<Instruction>(V2)->setHasNoSignedZeros(true);
   EXPECT_TRUE(match(V2, m_FNeg(m_Value(Match))));
   EXPECT_EQ(One, Match);
 
   // Test FAdd(-0.0, 1.0)
   EXPECT_FALSE(match(V3, m_FNeg(m_Value(Match))));
+
+  // Test FNeg(X) with inherited FMF
+  Instruction *I = cast<Instruction>(V);
+  I->setHasNoSignedZeros(true);
+  I->setHasNoNaNs(true);
+  Value *Alloca = IRB.CreateAlloca(FltTy);
+  Value *LoadInst = IRB.CreateLoad(FltTy, Alloca);
+  Value *VFMF = IRB.CreateFNegFMF(LoadInst, I);
+  Instruction *IFMF = cast<Instruction>(VFMF);
+  EXPECT_TRUE(IFMF->hasNoSignedZeros());
+  EXPECT_TRUE(IFMF->hasNoNaNs());
+  EXPECT_FALSE(IFMF->hasAllowReassoc());
+
+  // Test CreateUnOp(Opcode, C)
+  Value *CUP = IRB.CreateUnOp(Instruction::FNeg, One);
+  EXPECT_TRUE(match(CUP, m_FNeg(m_Value(Match))));
+  EXPECT_EQ(One, Match);
+
+  // Test CreateUnOp(Opcode, X)
+  Value *CUP2 = IRB.CreateUnOp(Instruction::FNeg, LoadInst);
+  EXPECT_TRUE(match(CUP2, m_FNeg(m_Value(Match))));
+  EXPECT_EQ(LoadInst, Match);
 }
 
 template <typename T> struct MutableConstTest : PatternMatchTest { };
 
 typedef ::testing::Types<std::tuple<Value*, Instruction*>,
                          std::tuple<const Value*, const Instruction *>>
     MutableConstTestTypes;
 TYPED_TEST_CASE(MutableConstTest, MutableConstTestTypes);