Simplify code

Author: wzssyqa

clang/lib/CodeGen/CGBuiltin.cpp

@@ -576,7 +576,8 @@ Value *emitUnaryMaybeConstrainedFPBuiltin(CodeGenFunction &CGF,
 // Depending on mode, this may be a constrained floating-point intrinsic.
 static Value *emitBinaryMaybeConstrainedFPBuiltin(
     CodeGenFunction &CGF, const CallExpr *E, unsigned IntrinsicID,
-    unsigned ConstrainedIntrinsicID, llvm::FastMathFlags *FMF = nullptr) {
+    unsigned ConstrainedIntrinsicID,
+    llvm::FastMathFlags FMF = llvm::FastMathFlags()) {
   llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
   llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));
 
@@ -587,7 +588,10 @@ static Value *emitBinaryMaybeConstrainedFPBuiltin(
                                                std::nullopt, std::nullopt, FMF);
   } else {
     Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
-    return CGF.Builder.CreateCall(F, {Src0, Src1}, "", nullptr, FMF);
+    CallInst *CI = CGF.Builder.CreateCall(F, {Src0, Src1});
+    if (isa<FPMathOperator>(CI))
+      CI->setFastMathFlags(FMF);
+    return CI;
   }
 }
 
@@ -2618,7 +2622,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
       FMF.setNoSignedZeros();
       return RValue::get(emitBinaryMaybeConstrainedFPBuiltin(
           *this, E, Intrinsic::maxnum,
-          Intrinsic::experimental_constrained_maxnum, &FMF));
+          Intrinsic::experimental_constrained_maxnum, FMF));
     }
 
     case Builtin::BIfmin:
@@ -2633,7 +2637,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
       FMF.setNoSignedZeros();
       return RValue::get(emitBinaryMaybeConstrainedFPBuiltin(
           *this, E, Intrinsic::minnum,
-          Intrinsic::experimental_constrained_minnum, &FMF));
+          Intrinsic::experimental_constrained_minnum, FMF));
     }
 
     case Builtin::BIfmaximum_num:

llvm/include/llvm/IR/IRBuilder.h

@@ -2491,14 +2491,12 @@ class IRBuilderBase {
 public:
   CallInst *CreateCall(FunctionType *FTy, Value *Callee,
                        ArrayRef<Value *> Args = {}, const Twine &Name = "",
-                       MDNode *FPMathTag = nullptr,
-                       FastMathFlags *uFMF = nullptr) {
+                       MDNode *FPMathTag = nullptr) {
     CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles);
     if (IsFPConstrained)
       setConstrainedFPCallAttr(CI);
-    if (isa<FPMathOperator>(CI)) {
-      setFPAttrs(CI, FPMathTag, uFMF ? (FMF | *uFMF) : FMF);
-    }
+    if (isa<FPMathOperator>(CI))
+      setFPAttrs(CI, FPMathTag, FMF);
     return Insert(CI, Name);
   }
 
@@ -2514,10 +2512,9 @@ class IRBuilderBase {
   }
 
   CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args = {},
-                       const Twine &Name = "", MDNode *FPMathTag = nullptr,
-                       FastMathFlags *uFMF = nullptr) {
+                       const Twine &Name = "", MDNode *FPMathTag = nullptr) {
     return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args, Name,
-                      FPMathTag, uFMF);
+                      FPMathTag);
   }
 
   CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args,
@@ -2531,7 +2528,7 @@ class IRBuilderBase {
       Function *Callee, ArrayRef<Value *> Args, const Twine &Name = "",
       std::optional<RoundingMode> Rounding = std::nullopt,
       std::optional<fp::ExceptionBehavior> Except = std::nullopt,
-      FastMathFlags *FMF = nullptr);
+      FastMathFlags newFMF = FastMathFlags());
 
   Value *CreateSelect(Value *C, Value *True, Value *False,
                       const Twine &Name = "", Instruction *MDFrom = nullptr);

llvm/lib/IR/IRBuilder.cpp

@@ -1082,15 +1082,17 @@ CallInst *IRBuilderBase::CreateConstrainedFPCmp(
 CallInst *IRBuilderBase::CreateConstrainedFPCall(
     Function *Callee, ArrayRef<Value *> Args, const Twine &Name,
     std::optional<RoundingMode> Rounding,
-    std::optional<fp::ExceptionBehavior> Except, FastMathFlags *FMF) {
+    std::optional<fp::ExceptionBehavior> Except, FastMathFlags newFMF) {
   llvm::SmallVector<Value *, 6> UseArgs(Args);
 
   if (Intrinsic::hasConstrainedFPRoundingModeOperand(Callee->getIntrinsicID()))
     UseArgs.push_back(getConstrainedFPRounding(Rounding));
   UseArgs.push_back(getConstrainedFPExcept(Except));
 
-  CallInst *C = CreateCall(Callee, UseArgs, Name, nullptr, FMF);
+  CallInst *C = CreateCall(Callee, UseArgs, Name);
   setConstrainedFPCallAttr(C);
+  if (isa<FPMathOperator>(C))
+    C->setFastMathFlags(newFMF);
   return C;
 }