maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[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
This commit is contained in:
Wang, Pengfei 2020-01-17 10:32:30 +08:00
parent 9c24fca2a3
commit 17b8f96d65
11 changed files with 76 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
llvm/include/llvm/CodeGen/SelectionDAGNodes.h
View File

@ -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;

2
llvm/include/llvm/CodeGen/TargetLowering.h
View File

@ -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;

100
llvm/include/llvm/IR/ConstrainedOps.def
View File

@ -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,52 +49,54 @@
// 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

4
llvm/include/llvm/IR/IRBuilder.h
View File

@ -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;

4
llvm/lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp
View File

@ -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);

6
llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
View File

@ -147,7 +147,7 @@ void DAGTypeLegalizer::ScalarizeVectorResult(SDNode *N, unsigned ResNo) {
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);
@ -937,7 +937,7 @@ void DAGTypeLegalizer::SplitVectorResult(SDNode *N, unsigned ResNo) {
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);
@ -2742,7 +2742,7 @@ void DAGTypeLegalizer::WidenVectorResult(SDNode *N, unsigned ResNo) {
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);

2
llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
View File

@ -7932,7 +7932,7 @@ SDNode* SelectionDAG::mutateStrictFPToFP(SDNode *Node) {
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;

4
llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
View File

@ -6237,7 +6237,7 @@ void SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I,
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));
@ -7003,7 +7003,7 @@ void SelectionDAGBuilder::visitConstrainedFPIntrinsic(
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;

2
llvm/lib/CodeGen/TargetLoweringBase.cpp
View File

@ -702,7 +702,7 @@ void TargetLoweringBase::initActions() {
}
// 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"

6
llvm/lib/IR/IntrinsicInst.cpp
View File

@ -149,7 +149,7 @@ 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"
@ -160,7 +160,7 @@ 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"
@ -169,7 +169,7 @@ bool ConstrainedFPIntrinsic::isTernaryOp() const {
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;

4
llvm/lib/IR/Verifier.cpp
View File

@ -4327,7 +4327,7 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) {
"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));
@ -4778,7 +4778,7 @@ 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; \