Commit 17b8f96d authored by Wang, Pengfei's avatar Wang, Pengfei
Browse files

[FPEnv] Divide macro INSTRUCTION into INSTRUCTION and DAG_INSTRUCTION, 

and macro FUNCTION likewise. NFCI.

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

Differential Revision: https://reviews.llvm.org/D72871
parent 9c24fca2

llvm/include/llvm/CodeGen/SelectionDAGNodes.h

+1 −1
Original line number Diff line number Diff line
@@ -701,7 +701,7 @@ public: 
    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;

llvm/include/llvm/CodeGen/TargetLowering.h

+1 −1
Original line number Diff line number Diff line
@@ -964,7 +964,7 @@ public: 
    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;

llvm/include/llvm/IR/ConstrainedOps.def

+58 −42
Original line number Diff line number Diff line
@@ -11,18 +11,32 @@ 
//

//===----------------------------------------------------------------------===//



// 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:
@@ -35,17 +49,17 @@ 
// 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.
@@ -55,32 +69,34 @@ 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

+2 −2
Original line number Diff line number Diff line
@@ -2279,7 +2279,7 @@ public: 
    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;
@@ -2550,7 +2550,7 @@ public: 
    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;

llvm/lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp

+2 −2
Original line number Diff line number Diff line
@@ -339,7 +339,7 @@ SDValue VectorLegalizer::LegalizeOp(SDValue Op) { 
    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);
@@ -970,7 +970,7 @@ void VectorLegalizer::Expand(SDNode *Node, SmallVectorImpl<SDValue> &Results) { 
  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);