[FPEnv] Divide macro INSTRUCTION into INSTRUCTION and DAG_INSTRUCTION, and macro FUNCTION likewise. NFCI.

[pengfei]

Summary

Some functions like fmuladd don't really have a node, we should divide the declaration form those have node to avoid introducing fake nodes.

[andrew.w.kaylor]

Could you make this a standalone patch that only modifies the table without adding the FP_CONTRACT support? Then the other patch can just be refactored to use this.

[pengfei]

Removed the FP_CONTRACT support code.

[craig.topper]

LGTM

llvm/include/llvm/CodeGen/SelectionDAGNodes.h

return (NodeType == ISD::INTRINSIC_W_CHAIN ||
            SDNodeBits.IsMemIntrinsic;
   }
 
   /// Test if this node is a strict floating point pseudo-op.
   bool isStrictFPOpcode() {
     switch (NodeType) {
       default:
         return false;
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
       case ISD::STRICT_##DAGN:
 #include "llvm/IR/ConstrainedOps.def"
         return true;
     }
   }
 
   /// Test if this node has a post-isel opcode, directly
   /// corresponding to a MachineInstr opcode.

llvm/include/llvm/CodeGen/TargetLowering.h

public:
   }
 
   // If Op is a strict floating-point operation, return the result
   // of getOperationAction for the equivalent non-strict operation.
   LegalizeAction getStrictFPOperationAction(unsigned Op, EVT VT) const {
     unsigned EqOpc;
     switch (Op) {
       default: llvm_unreachable("Unexpected FP pseudo-opcode");
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
       case ISD::STRICT_##DAGN: EqOpc = ISD::DAGN; break;
 #define CMP_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
       case ISD::STRICT_##DAGN: EqOpc = ISD::SETCC; break;
 #include "llvm/IR/ConstrainedOps.def"
     }
 
     return getOperationAction(EqOpc, VT);
   }

llvm/include/llvm/IR/ConstrainedOps.def

 //===- llvm/IR/ConstrainedOps.def - Constrained intrinsics ------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines properties of constrained intrinsics, in particular corresponding
 // floating point operations and DAG nodes.
 //
 //===----------------------------------------------------------------------===//
 
+// DAG_FUNCTION defers to DAG_INSTRUCTION if its defined, otherwise FUNCTION.
+#ifndef DAG_FUNCTION
+#ifdef DAG_INSTRUCTION
+#define DAG_FUNCTION(N,A,R,I,D) DAG_INSTRUCTION(N,A,R,I,D)
+#else
+#define DAG_FUNCTION(N,A,R,I,D) FUNCTION(N,A,R,I)
+#endif
+#endif
+
 #ifndef INSTRUCTION
-#define INSTRUCTION(N,A,R,I,D)
+#define INSTRUCTION(N,A,R,I)
+#endif
+
+// DAG_INSTRUCTION is treated like an INSTRUCTION if the DAG node isn't used.
+#ifndef DAG_INSTRUCTION
+#define DAG_INSTRUCTION(N,A,R,I,D) INSTRUCTION(N,A,R,I)
 #endif
 
 // In most cases intrinsic function is handled similar to instruction.
 #ifndef FUNCTION
-#define FUNCTION INSTRUCTION
+#define FUNCTION(N,A,R,I) INSTRUCTION(N,A,R,I)
 #endif
 
-// Likewise for compare instructions.
+// Compare instruction have a DAG node so they are treated like DAG_INSTRUCTION.
 #ifndef CMP_INSTRUCTION
-#define CMP_INSTRUCTION INSTRUCTION
+#define CMP_INSTRUCTION(N,A,R,I,D) DAG_INSTRUCTION(N,A,R,I,D)
 #endif
 
 // Arguments of the entries are:
 // - instruction or intrinsic function name.
 // - Number of original instruction/intrinsic arguments.
 // - 1 if the corresponding constrained intrinsic has rounding mode argument.
 // - name of the constrained intrinsic to represent this instruction/function.
 // - DAG node corresponding to the constrained intrinsic without prefix STRICT_.
 
 // These are definitions for instructions, that are converted into constrained
 // intrinsics.
 //
-INSTRUCTION(FAdd,         2, 1, experimental_constrained_fadd,       FADD)
-INSTRUCTION(FSub,         2, 1, experimental_constrained_fsub,       FSUB)
-INSTRUCTION(FMul,         2, 1, experimental_constrained_fmul,       FMUL)
-INSTRUCTION(FDiv,         2, 1, experimental_constrained_fdiv,       FDIV)
-INSTRUCTION(FRem,         2, 1, experimental_constrained_frem,       FREM)
-INSTRUCTION(FPExt,        1, 0, experimental_constrained_fpext,      FP_EXTEND)
-INSTRUCTION(SIToFP,       1, 1, experimental_constrained_sitofp,     SINT_TO_FP)
-INSTRUCTION(UIToFP,       1, 1, experimental_constrained_uitofp,     UINT_TO_FP)
-INSTRUCTION(FPToSI,       1, 0, experimental_constrained_fptosi,     FP_TO_SINT)
-INSTRUCTION(FPToUI,       1, 0, experimental_constrained_fptoui,     FP_TO_UINT)
-INSTRUCTION(FPTrunc,      1, 1, experimental_constrained_fptrunc,    FP_ROUND)
+DAG_INSTRUCTION(FAdd,         2, 1, experimental_constrained_fadd,       FADD)
+DAG_INSTRUCTION(FSub,         2, 1, experimental_constrained_fsub,       FSUB)
+DAG_INSTRUCTION(FMul,         2, 1, experimental_constrained_fmul,       FMUL)
+DAG_INSTRUCTION(FDiv,         2, 1, experimental_constrained_fdiv,       FDIV)
+DAG_INSTRUCTION(FRem,         2, 1, experimental_constrained_frem,       FREM)
+DAG_INSTRUCTION(FPExt,        1, 0, experimental_constrained_fpext,      FP_EXTEND)
+DAG_INSTRUCTION(SIToFP,       1, 1, experimental_constrained_sitofp,     SINT_TO_FP)
+DAG_INSTRUCTION(UIToFP,       1, 1, experimental_constrained_uitofp,     UINT_TO_FP)
+DAG_INSTRUCTION(FPToSI,       1, 0, experimental_constrained_fptosi,     FP_TO_SINT)
+DAG_INSTRUCTION(FPToUI,       1, 0, experimental_constrained_fptoui,     FP_TO_UINT)
+DAG_INSTRUCTION(FPTrunc,      1, 1, experimental_constrained_fptrunc,    FP_ROUND)
 
 // These are definitions for compare instructions (signaling and quiet version).
 // Both of these match to FCmp / SETCC.
-CMP_INSTRUCTION(FCmp,     2, 0, experimental_constrained_fcmp,       FSETCC)
-CMP_INSTRUCTION(FCmp,     2, 0, experimental_constrained_fcmps,      FSETCCS)
+CMP_INSTRUCTION(FCmp,         2, 0, experimental_constrained_fcmp,       FSETCC)
+CMP_INSTRUCTION(FCmp,         2, 0, experimental_constrained_fcmps,      FSETCCS)
 
 // Theses are definitions for intrinsic functions, that are converted into
 // constrained intrinsics.
 //
-FUNCTION(ceil,            1, 0, experimental_constrained_ceil,       FCEIL)
-FUNCTION(cos,             1, 1, experimental_constrained_cos,        FCOS)
-FUNCTION(exp,             1, 1, experimental_constrained_exp,        FEXP)
-FUNCTION(exp2,            1, 1, experimental_constrained_exp2,       FEXP2)
-FUNCTION(floor,           1, 0, experimental_constrained_floor,      FFLOOR)
-FUNCTION(fma,             3, 1, experimental_constrained_fma,        FMA)
-FUNCTION(log,             1, 1, experimental_constrained_log,        FLOG)
-FUNCTION(log10,           1, 1, experimental_constrained_log10,      FLOG10)
-FUNCTION(log2,            1, 1, experimental_constrained_log2,       FLOG2)
-FUNCTION(lrint,           1, 1, experimental_constrained_lrint,      LRINT)
-FUNCTION(llrint,          1, 1, experimental_constrained_llrint,     LLRINT)
-FUNCTION(lround,          1, 0, experimental_constrained_lround,     LROUND)
-FUNCTION(llround,         1, 0, experimental_constrained_llround,    LLROUND)
-FUNCTION(maxnum,          2, 0, experimental_constrained_maxnum,     FMAXNUM)
-FUNCTION(minnum,          2, 0, experimental_constrained_minnum,     FMINNUM)
-FUNCTION(maximum,         2, 0, experimental_constrained_maximum,    FMAXIMUM)
-FUNCTION(minimum,         2, 0, experimental_constrained_minimum,    FMINIMUM)
-FUNCTION(nearbyint,       1, 1, experimental_constrained_nearbyint,  FNEARBYINT)
-FUNCTION(pow,             2, 1, experimental_constrained_pow,        FPOW)
-FUNCTION(powi,            2, 1, experimental_constrained_powi,       FPOWI)
-FUNCTION(rint,            1, 1, experimental_constrained_rint,       FRINT)
-FUNCTION(round,           1, 0, experimental_constrained_round,      FROUND)
-FUNCTION(sin,             1, 1, experimental_constrained_sin,        FSIN)
-FUNCTION(sqrt,            1, 1, experimental_constrained_sqrt,       FSQRT)
-FUNCTION(trunc,           1, 0, experimental_constrained_trunc,      FTRUNC)
+DAG_FUNCTION(ceil,            1, 0, experimental_constrained_ceil,       FCEIL)
+DAG_FUNCTION(cos,             1, 1, experimental_constrained_cos,        FCOS)
+DAG_FUNCTION(exp,             1, 1, experimental_constrained_exp,        FEXP)
+DAG_FUNCTION(exp2,            1, 1, experimental_constrained_exp2,       FEXP2)
+DAG_FUNCTION(floor,           1, 0, experimental_constrained_floor,      FFLOOR)
+DAG_FUNCTION(fma,             3, 1, experimental_constrained_fma,        FMA)
+DAG_FUNCTION(log,             1, 1, experimental_constrained_log,        FLOG)
+DAG_FUNCTION(log10,           1, 1, experimental_constrained_log10,      FLOG10)
+DAG_FUNCTION(log2,            1, 1, experimental_constrained_log2,       FLOG2)
+DAG_FUNCTION(lrint,           1, 1, experimental_constrained_lrint,      LRINT)
+DAG_FUNCTION(llrint,          1, 1, experimental_constrained_llrint,     LLRINT)
+DAG_FUNCTION(lround,          1, 0, experimental_constrained_lround,     LROUND)
+DAG_FUNCTION(llround,         1, 0, experimental_constrained_llround,    LLROUND)
+DAG_FUNCTION(maxnum,          2, 0, experimental_constrained_maxnum,     FMAXNUM)
+DAG_FUNCTION(minnum,          2, 0, experimental_constrained_minnum,     FMINNUM)
+DAG_FUNCTION(maximum,         2, 0, experimental_constrained_maximum,    FMAXIMUM)
+DAG_FUNCTION(minimum,         2, 0, experimental_constrained_minimum,    FMINIMUM)
+DAG_FUNCTION(nearbyint,       1, 1, experimental_constrained_nearbyint,  FNEARBYINT)
+DAG_FUNCTION(pow,             2, 1, experimental_constrained_pow,        FPOW)
+DAG_FUNCTION(powi,            2, 1, experimental_constrained_powi,       FPOWI)
+DAG_FUNCTION(rint,            1, 1, experimental_constrained_rint,       FRINT)
+DAG_FUNCTION(round,           1, 0, experimental_constrained_round,      FROUND)
+DAG_FUNCTION(sin,             1, 1, experimental_constrained_sin,        FSIN)
+DAG_FUNCTION(sqrt,            1, 1, experimental_constrained_sqrt,       FSQRT)
+DAG_FUNCTION(trunc,           1, 0, experimental_constrained_trunc,      FTRUNC)
 
 #undef INSTRUCTION
 #undef FUNCTION
 #undef CMP_INSTRUCTION
+#undef DAG_INSTRUCTION
+#undef DAG_FUNCTION

llvm/include/llvm/IR/IRBuilder.h

CallInst *CreateConstrainedFPCast(
     if (FMFSource)
       UseFMF = FMFSource->getFastMathFlags();
 
     CallInst *C;
     bool HasRoundingMD = false;
     switch (ID) {
     default:
       break;
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)  \
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC)        \
     case Intrinsic::INTRINSIC:                                \
       HasRoundingMD = ROUND_MODE;                             \
       break;
 #include "llvm/IR/ConstrainedOps.def"
     }
     if (HasRoundingMD) {
       Value *RoundingV = getConstrainedFPRounding(Rounding);
       C = CreateIntrinsic(ID, {DestTy, V->getType()}, {V, RoundingV, ExceptV},
CallInst *CreateConstrainedFPCall(
     llvm::SmallVector<Value *, 6> UseArgs;
 
     for (auto *OneArg : Args)
       UseArgs.push_back(OneArg);
     bool HasRoundingMD = false;
     switch (Callee->getIntrinsicID()) {
     default:
       break;
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)  \
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC)        \
     case Intrinsic::INTRINSIC:                                \
       HasRoundingMD = ROUND_MODE;                             \
       break;
 #include "llvm/IR/ConstrainedOps.def"
     }
     if (HasRoundingMD)
       UseArgs.push_back(getConstrainedFPRounding(Rounding));
     UseArgs.push_back(getConstrainedFPExcept(Except));

llvm/lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp

default:
     return TranslateLegalizeResults(Op, Node);
   case ISD::MERGE_VALUES:
     Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0));
     // This operation lies about being legal: when it claims to be legal,
     // it should actually be expanded.
     if (Action == TargetLowering::Legal)
       Action = TargetLowering::Expand;
     break;
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
   case ISD::STRICT_##DAGN:
 #include "llvm/IR/ConstrainedOps.def"
     ValVT = Node->getValueType(0);
     if (Op.getOpcode() == ISD::STRICT_SINT_TO_FP ||
         Op.getOpcode() == ISD::STRICT_UINT_TO_FP)
       ValVT = Node->getOperand(1).getValueType();
     Action = TLI.getOperationAction(Node->getOpcode(), ValVT);
     // If we're asked to expand a strict vector floating-point operation,
case ISD::UMULFIXSAT:
     // why. Maybe it results in worse codegen compared to the unroll for some
     // targets? This should probably be investigated. And if we still prefer to
     // unroll an explanation could be helpful.
     break;
   case ISD::SDIVFIX:
   case ISD::UDIVFIX:
     Results.push_back(ExpandFixedPointDiv(Node));
     return;
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
   case ISD::STRICT_##DAGN:
 #include "llvm/IR/ConstrainedOps.def"
     ExpandStrictFPOp(Node, Results);
     return;
   case ISD::VECREDUCE_ADD:
   case ISD::VECREDUCE_MUL:
   case ISD::VECREDUCE_AND:
   case ISD::VECREDUCE_OR:

llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp

#endif
   case ISD::SRA:
   case ISD::SRL:
     R = ScalarizeVecRes_BinOp(N);
     break;
   case ISD::FMA:
     R = ScalarizeVecRes_TernaryOp(N);
     break;
 
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
   case ISD::STRICT_##DAGN:
 #include "llvm/IR/ConstrainedOps.def"
     R = ScalarizeVecRes_StrictFPOp(N);
     break;
 
   case ISD::UADDO:
   case ISD::SADDO:
   case ISD::USUBO:
#endif
   case ISD::SSUBSAT:
   case ISD::USUBSAT:
     SplitVecRes_BinOp(N, Lo, Hi);
     break;
   case ISD::FMA:
     SplitVecRes_TernaryOp(N, Lo, Hi);
     break;
 
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
   case ISD::STRICT_##DAGN:
 #include "llvm/IR/ConstrainedOps.def"
     SplitVecRes_StrictFPOp(N, Lo, Hi);
     break;
 
   case ISD::UADDO:
   case ISD::SADDO:
   case ISD::USUBO:
#endif
   case ISD::SMULFIXSAT:
   case ISD::UMULFIX:
   case ISD::UMULFIXSAT:
     // These are binary operations, but with an extra operand that shouldn't
     // be widened (the scale).
     Res = WidenVecRes_BinaryWithExtraScalarOp(N);
     break;
 
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
   case ISD::STRICT_##DAGN:
 #include "llvm/IR/ConstrainedOps.def"
     Res = WidenVecRes_StrictFP(N);
     break;
 
   case ISD::UADDO:
   case ISD::SADDO:
   case ISD::USUBO:

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 }
 
 SDNode* SelectionDAG::mutateStrictFPToFP(SDNode *Node) {
   unsigned OrigOpc = Node->getOpcode();
   unsigned NewOpc;
   switch (OrigOpc) {
   default:
     llvm_unreachable("mutateStrictFPToFP called with unexpected opcode!");
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
   case ISD::STRICT_##DAGN: NewOpc = ISD::DAGN; break;
 #define CMP_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
   case ISD::STRICT_##DAGN: NewOpc = ISD::SETCC; break;
 #include "llvm/IR/ConstrainedOps.def"
   }
 
   assert(Node->getNumValues() == 2 && "Unexpected number of results!");
 

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

case Intrinsic::copysign:
     return;
   case Intrinsic::fma:
     setValue(&I, DAG.getNode(ISD::FMA, sdl,
                              getValue(I.getArgOperand(0)).getValueType(),
                              getValue(I.getArgOperand(0)),
                              getValue(I.getArgOperand(1)),
                              getValue(I.getArgOperand(2))));
     return;
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC)                         \
   case Intrinsic::INTRINSIC:
 #include "llvm/IR/ConstrainedOps.def"
     visitConstrainedFPIntrinsic(cast<ConstrainedFPIntrinsic>(I));
     return;
   case Intrinsic::fmuladd: {
     EVT VT = TLI.getValueType(DAG.getDataLayout(), I.getType());
     if (TM.Options.AllowFPOpFusion != FPOpFusion::Strict &&
         TLI.isFMAFasterThanFMulAndFAdd(DAG.getMachineFunction(), VT)) {
void SelectionDAGBuilder::visitConstrainedFPIntrinsic(
   } else {
     Opers.push_back(getValue(FPI.getArgOperand(0)));
     Opers.push_back(getValue(FPI.getArgOperand(1)));
   }
 
   unsigned Opcode;
   switch (FPI.getIntrinsicID()) {
   default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
   case Intrinsic::INTRINSIC:                                                   \
     Opcode = ISD::STRICT_##DAGN;                                               \
     break;
 #include "llvm/IR/ConstrainedOps.def"
   }
 
   // A few strict DAG nodes carry additional operands that are not
   // set up by the default code above.

llvm/lib/CodeGen/TargetLoweringBase.cpp

if (VT.isVector()) {
       setOperationAction(ISD::SIGN_EXTEND_INREG, VT, Expand);
       setOperationAction(ISD::ANY_EXTEND_VECTOR_INREG, VT, Expand);
       setOperationAction(ISD::SIGN_EXTEND_VECTOR_INREG, VT, Expand);
       setOperationAction(ISD::ZERO_EXTEND_VECTOR_INREG, VT, Expand);
       setOperationAction(ISD::SPLAT_VECTOR, VT, Expand);
     }
 
     // Constrained floating-point operations default to expand.
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)               \
     setOperationAction(ISD::STRICT_##DAGN, VT, Expand);
 #include "llvm/IR/ConstrainedOps.def"
 
     // For most targets @llvm.get.dynamic.area.offset just returns 0.
     setOperationAction(ISD::GET_DYNAMIC_AREA_OFFSET, VT, Expand);
 
     // Vector reduction default to expand.
     setOperationAction(ISD::VECREDUCE_FADD, VT, Expand);

llvm/lib/IR/IntrinsicInst.cpp

return StringSwitch<FCmpInst::Predicate>(cast<MDString>(MD)->getString())
            .Case("une", FCmpInst::FCMP_UNE)
            .Default(FCmpInst::BAD_FCMP_PREDICATE);
 }
 
 bool ConstrainedFPIntrinsic::isUnaryOp() const {
   switch (getIntrinsicID()) {
     default:
       return false;
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC)                         \
     case Intrinsic::INTRINSIC:                                                 \
       return NARG == 1;
 #include "llvm/IR/ConstrainedOps.def"
   }
 }
 
 bool ConstrainedFPIntrinsic::isTernaryOp() const {
   switch (getIntrinsicID()) {
     default:
       return false;
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC)                         \
     case Intrinsic::INTRINSIC:                                                 \
       return NARG == 3;
 #include "llvm/IR/ConstrainedOps.def"
   }
 }
 
 bool ConstrainedFPIntrinsic::classof(const IntrinsicInst *I) {
   switch (I->getIntrinsicID()) {
-#define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC, DAGN)                  \
+#define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC)                        \
   case Intrinsic::INTRINSIC:
 #include "llvm/IR/ConstrainedOps.def"
     return true;
   default:
     return false;
   }
 }
 

llvm/lib/IR/Verifier.cpp

Assert(GV && GV->isConstant() && GV->hasDefinitiveInitializer(),
       "info argument of llvm.coro.begin must refer to an initialized "
       "constant");
     Constant *Init = GV->getInitializer();
     Assert(isa<ConstantStruct>(Init) || isa<ConstantArray>(Init),
       "info argument of llvm.coro.begin must refer to either a struct or "
       "an array");
     break;
   }
-#define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC, DAGN)                  \
+#define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC)                        \
   case Intrinsic::INTRINSIC:
 #include "llvm/IR/ConstrainedOps.def"
     visitConstrainedFPIntrinsic(cast<ConstrainedFPIntrinsic>(Call));
     break;
   case Intrinsic::dbg_declare: // llvm.dbg.declare
     Assert(isa<MetadataAsValue>(Call.getArgOperand(0)),
            "invalid llvm.dbg.declare intrinsic call 1", Call);
     visitDbgIntrinsic("declare", cast<DbgVariableIntrinsic>(Call));
static DISubprogram *getSubprogram(Metadata *LocalScope) {
   assert(!isa<DILocalScope>(LocalScope) && "Unknown type of local scope");
   return nullptr;
 }
 
 void Verifier::visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI) {
   unsigned NumOperands;
   bool HasRoundingMD;
   switch (FPI.getIntrinsicID()) {
-#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC)                         \
   case Intrinsic::INTRINSIC:                                                   \
     NumOperands = NARG;                                                        \
     HasRoundingMD = ROUND_MODE;                                                \
     break;
 #include "llvm/IR/ConstrainedOps.def"
   default:
     llvm_unreachable("Invalid constrained FP intrinsic!");
   }