//
//===----------------------------------------------------------------------===//
+// 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:
// 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