mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-05-01 20:26:05 +00:00
Code Issues Projects Releases Wiki Activity

[FPEnv] Divide macro INSTRUCTION into INSTRUCTION and DAG_INSTRUCTION,

Browse Source 
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) { switch (NodeType) {
default: default:
return false; return false;
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \
case ISD::STRICT_##DAGN: case ISD::STRICT_##DAGN:
#include "llvm/IR/ConstrainedOps.def" #include "llvm/IR/ConstrainedOps.def"
return true; return true;

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

@ -964,7 +964,7 @@ public:
unsigned EqOpc; unsigned EqOpc;
switch (Op) { switch (Op) {
default: llvm_unreachable("Unexpected FP pseudo-opcode"); 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; case ISD::STRICT_##DAGN: EqOpc = ISD::DAGN; break;
#define CMP_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define CMP_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \
case ISD::STRICT_##DAGN: EqOpc = ISD::SETCC; break; 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 #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 #endif
// In most cases intrinsic function is handled similar to instruction. // In most cases intrinsic function is handled similar to instruction.
#ifndef FUNCTION #ifndef FUNCTION
#define FUNCTION INSTRUCTION #define FUNCTION(N,A,R,I) INSTRUCTION(N,A,R,I)
#endif #endif
// Likewise for compare instructions. // Compare instruction have a DAG node so they are treated like DAG_INSTRUCTION.
#ifndef CMP_INSTRUCTION #ifndef CMP_INSTRUCTION
#define CMP_INSTRUCTION INSTRUCTION #define CMP_INSTRUCTION(N,A,R,I,D) DAG_INSTRUCTION(N,A,R,I,D)
#endif #endif
// Arguments of the entries are: // Arguments of the entries are:
@ -35,52 +49,54 @@
// These are definitions for instructions, that are converted into constrained // These are definitions for instructions, that are converted into constrained
// intrinsics. // intrinsics.
// //
INSTRUCTION(FAdd, 2, 1, experimental_constrained_fadd, FADD) DAG_INSTRUCTION(FAdd, 2, 1, experimental_constrained_fadd, FADD)
INSTRUCTION(FSub, 2, 1, experimental_constrained_fsub, FSUB) DAG_INSTRUCTION(FSub, 2, 1, experimental_constrained_fsub, FSUB)
INSTRUCTION(FMul, 2, 1, experimental_constrained_fmul, FMUL) DAG_INSTRUCTION(FMul, 2, 1, experimental_constrained_fmul, FMUL)
INSTRUCTION(FDiv, 2, 1, experimental_constrained_fdiv, FDIV) DAG_INSTRUCTION(FDiv, 2, 1, experimental_constrained_fdiv, FDIV)
INSTRUCTION(FRem, 2, 1, experimental_constrained_frem, FREM) DAG_INSTRUCTION(FRem, 2, 1, experimental_constrained_frem, FREM)
INSTRUCTION(FPExt, 1, 0, experimental_constrained_fpext, FP_EXTEND) DAG_INSTRUCTION(FPExt, 1, 0, experimental_constrained_fpext, FP_EXTEND)
INSTRUCTION(SIToFP, 1, 1, experimental_constrained_sitofp, SINT_TO_FP) DAG_INSTRUCTION(SIToFP, 1, 1, experimental_constrained_sitofp, SINT_TO_FP)
INSTRUCTION(UIToFP, 1, 1, experimental_constrained_uitofp, UINT_TO_FP) DAG_INSTRUCTION(UIToFP, 1, 1, experimental_constrained_uitofp, UINT_TO_FP)
INSTRUCTION(FPToSI, 1, 0, experimental_constrained_fptosi, FP_TO_SINT) DAG_INSTRUCTION(FPToSI, 1, 0, experimental_constrained_fptosi, FP_TO_SINT)
INSTRUCTION(FPToUI, 1, 0, experimental_constrained_fptoui, FP_TO_UINT) DAG_INSTRUCTION(FPToUI, 1, 0, experimental_constrained_fptoui, FP_TO_UINT)
INSTRUCTION(FPTrunc, 1, 1, experimental_constrained_fptrunc, FP_ROUND) DAG_INSTRUCTION(FPTrunc, 1, 1, experimental_constrained_fptrunc, FP_ROUND)
// These are definitions for compare instructions (signaling and quiet version). // These are definitions for compare instructions (signaling and quiet version).
// Both of these match to FCmp / SETCC. // Both of these match to FCmp / SETCC.
CMP_INSTRUCTION(FCmp, 2, 0, experimental_constrained_fcmp, FSETCC) 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_fcmps, FSETCCS)
// Theses are definitions for intrinsic functions, that are converted into // Theses are definitions for intrinsic functions, that are converted into
// constrained intrinsics. // constrained intrinsics.
// //
FUNCTION(ceil, 1, 0, experimental_constrained_ceil, FCEIL) DAG_FUNCTION(ceil, 1, 0, experimental_constrained_ceil, FCEIL)
FUNCTION(cos, 1, 1, experimental_constrained_cos, FCOS) DAG_FUNCTION(cos, 1, 1, experimental_constrained_cos, FCOS)
FUNCTION(exp, 1, 1, experimental_constrained_exp, FEXP) DAG_FUNCTION(exp, 1, 1, experimental_constrained_exp, FEXP)
FUNCTION(exp2, 1, 1, experimental_constrained_exp2, FEXP2) DAG_FUNCTION(exp2, 1, 1, experimental_constrained_exp2, FEXP2)
FUNCTION(floor, 1, 0, experimental_constrained_floor, FFLOOR) DAG_FUNCTION(floor, 1, 0, experimental_constrained_floor, FFLOOR)
FUNCTION(fma, 3, 1, experimental_constrained_fma, FMA) DAG_FUNCTION(fma, 3, 1, experimental_constrained_fma, FMA)
FUNCTION(log, 1, 1, experimental_constrained_log, FLOG) DAG_FUNCTION(log, 1, 1, experimental_constrained_log, FLOG)
FUNCTION(log10, 1, 1, experimental_constrained_log10, FLOG10) DAG_FUNCTION(log10, 1, 1, experimental_constrained_log10, FLOG10)
FUNCTION(log2, 1, 1, experimental_constrained_log2, FLOG2) DAG_FUNCTION(log2, 1, 1, experimental_constrained_log2, FLOG2)
FUNCTION(lrint, 1, 1, experimental_constrained_lrint, LRINT) DAG_FUNCTION(lrint, 1, 1, experimental_constrained_lrint, LRINT)
FUNCTION(llrint, 1, 1, experimental_constrained_llrint, LLRINT) DAG_FUNCTION(llrint, 1, 1, experimental_constrained_llrint, LLRINT)
FUNCTION(lround, 1, 0, experimental_constrained_lround, LROUND) DAG_FUNCTION(lround, 1, 0, experimental_constrained_lround, LROUND)
FUNCTION(llround, 1, 0, experimental_constrained_llround, LLROUND) DAG_FUNCTION(llround, 1, 0, experimental_constrained_llround, LLROUND)
FUNCTION(maxnum, 2, 0, experimental_constrained_maxnum, FMAXNUM) DAG_FUNCTION(maxnum, 2, 0, experimental_constrained_maxnum, FMAXNUM)
FUNCTION(minnum, 2, 0, experimental_constrained_minnum, FMINNUM) DAG_FUNCTION(minnum, 2, 0, experimental_constrained_minnum, FMINNUM)
FUNCTION(maximum, 2, 0, experimental_constrained_maximum, FMAXIMUM) DAG_FUNCTION(maximum, 2, 0, experimental_constrained_maximum, FMAXIMUM)
FUNCTION(minimum, 2, 0, experimental_constrained_minimum, FMINIMUM) DAG_FUNCTION(minimum, 2, 0, experimental_constrained_minimum, FMINIMUM)
FUNCTION(nearbyint, 1, 1, experimental_constrained_nearbyint, FNEARBYINT) DAG_FUNCTION(nearbyint, 1, 1, experimental_constrained_nearbyint, FNEARBYINT)
FUNCTION(pow, 2, 1, experimental_constrained_pow, FPOW) DAG_FUNCTION(pow, 2, 1, experimental_constrained_pow, FPOW)
FUNCTION(powi, 2, 1, experimental_constrained_powi, FPOWI) DAG_FUNCTION(powi, 2, 1, experimental_constrained_powi, FPOWI)
FUNCTION(rint, 1, 1, experimental_constrained_rint, FRINT) DAG_FUNCTION(rint, 1, 1, experimental_constrained_rint, FRINT)
FUNCTION(round, 1, 0, experimental_constrained_round, FROUND) DAG_FUNCTION(round, 1, 0, experimental_constrained_round, FROUND)
FUNCTION(sin, 1, 1, experimental_constrained_sin, FSIN) DAG_FUNCTION(sin, 1, 1, experimental_constrained_sin, FSIN)
FUNCTION(sqrt, 1, 1, experimental_constrained_sqrt, FSQRT) DAG_FUNCTION(sqrt, 1, 1, experimental_constrained_sqrt, FSQRT)
FUNCTION(trunc, 1, 0, experimental_constrained_trunc, FTRUNC) DAG_FUNCTION(trunc, 1, 0, experimental_constrained_trunc, FTRUNC)
#undef INSTRUCTION #undef INSTRUCTION
#undef FUNCTION #undef FUNCTION
#undef CMP_INSTRUCTION #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) { switch (ID) {
default: default:
break; break;
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
case Intrinsic::INTRINSIC: \ case Intrinsic::INTRINSIC: \
HasRoundingMD = ROUND_MODE; \ HasRoundingMD = ROUND_MODE; \
break; break;
@ -2550,7 +2550,7 @@ public:
switch (Callee->getIntrinsicID()) { switch (Callee->getIntrinsicID()) {
default: default:
break; break;
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
case Intrinsic::INTRINSIC: \ case Intrinsic::INTRINSIC: \
HasRoundingMD = ROUND_MODE; \ HasRoundingMD = ROUND_MODE; \
break; break;

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

@ -339,7 +339,7 @@ SDValue VectorLegalizer::LegalizeOp(SDValue Op) {
if (Action == TargetLowering::Legal) if (Action == TargetLowering::Legal)
Action = TargetLowering::Expand; Action = TargetLowering::Expand;
break; break;
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \
case ISD::STRICT_##DAGN: case ISD::STRICT_##DAGN:
#include "llvm/IR/ConstrainedOps.def" #include "llvm/IR/ConstrainedOps.def"
ValVT = Node->getValueType(0); ValVT = Node->getValueType(0);
@ -970,7 +970,7 @@ void VectorLegalizer::Expand(SDNode *Node, SmallVectorImpl<SDValue> &Results) {
case ISD::UDIVFIX: case ISD::UDIVFIX:
Results.push_back(ExpandFixedPointDiv(Node)); Results.push_back(ExpandFixedPointDiv(Node));
return; return;
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \
case ISD::STRICT_##DAGN: case ISD::STRICT_##DAGN:
#include "llvm/IR/ConstrainedOps.def" #include "llvm/IR/ConstrainedOps.def"
ExpandStrictFPOp(Node, Results); 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); R = ScalarizeVecRes_TernaryOp(N);
break; break;
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \
case ISD::STRICT_##DAGN: case ISD::STRICT_##DAGN:
#include "llvm/IR/ConstrainedOps.def" #include "llvm/IR/ConstrainedOps.def"
R = ScalarizeVecRes_StrictFPOp(N); R = ScalarizeVecRes_StrictFPOp(N);
@ -937,7 +937,7 @@ void DAGTypeLegalizer::SplitVectorResult(SDNode *N, unsigned ResNo) {
SplitVecRes_TernaryOp(N, Lo, Hi); SplitVecRes_TernaryOp(N, Lo, Hi);
break; break;
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \
case ISD::STRICT_##DAGN: case ISD::STRICT_##DAGN:
#include "llvm/IR/ConstrainedOps.def" #include "llvm/IR/ConstrainedOps.def"
SplitVecRes_StrictFPOp(N, Lo, Hi); SplitVecRes_StrictFPOp(N, Lo, Hi);
@ -2742,7 +2742,7 @@ void DAGTypeLegalizer::WidenVectorResult(SDNode *N, unsigned ResNo) {
Res = WidenVecRes_BinaryWithExtraScalarOp(N); Res = WidenVecRes_BinaryWithExtraScalarOp(N);
break; break;
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \
case ISD::STRICT_##DAGN: case ISD::STRICT_##DAGN:
#include "llvm/IR/ConstrainedOps.def" #include "llvm/IR/ConstrainedOps.def"
Res = WidenVecRes_StrictFP(N); Res = WidenVecRes_StrictFP(N);

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

@ -7932,7 +7932,7 @@ SDNode* SelectionDAG::mutateStrictFPToFP(SDNode *Node) {
switch (OrigOpc) { switch (OrigOpc) {
default: default:
llvm_unreachable("mutateStrictFPToFP called with unexpected opcode!"); 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; case ISD::STRICT_##DAGN: NewOpc = ISD::DAGN; break;
#define CMP_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define CMP_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \
case ISD::STRICT_##DAGN: NewOpc = ISD::SETCC; break; 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(1)),
getValue(I.getArgOperand(2)))); getValue(I.getArgOperand(2))));
return; return;
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
case Intrinsic::INTRINSIC: case Intrinsic::INTRINSIC:
#include "llvm/IR/ConstrainedOps.def" #include "llvm/IR/ConstrainedOps.def"
visitConstrainedFPIntrinsic(cast<ConstrainedFPIntrinsic>(I)); visitConstrainedFPIntrinsic(cast<ConstrainedFPIntrinsic>(I));
@ -7003,7 +7003,7 @@ void SelectionDAGBuilder::visitConstrainedFPIntrinsic(
unsigned Opcode; unsigned Opcode;
switch (FPI.getIntrinsicID()) { switch (FPI.getIntrinsicID()) {
default: llvm_unreachable("Impossible intrinsic"); // Can't reach here. 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: \ case Intrinsic::INTRINSIC: \
Opcode = ISD::STRICT_##DAGN; \ Opcode = ISD::STRICT_##DAGN; \
break; break;

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

@ -702,7 +702,7 @@ void TargetLoweringBase::initActions() {
} }
// Constrained floating-point operations default to 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); setOperationAction(ISD::STRICT_##DAGN, VT, Expand);
#include "llvm/IR/ConstrainedOps.def" #include "llvm/IR/ConstrainedOps.def"

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

@ -149,7 +149,7 @@ bool ConstrainedFPIntrinsic::isUnaryOp() const {
switch (getIntrinsicID()) { switch (getIntrinsicID()) {
default: default:
return false; return false;
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
case Intrinsic::INTRINSIC: \ case Intrinsic::INTRINSIC: \
return NARG == 1; return NARG == 1;
#include "llvm/IR/ConstrainedOps.def" #include "llvm/IR/ConstrainedOps.def"
@ -160,7 +160,7 @@ bool ConstrainedFPIntrinsic::isTernaryOp() const {
switch (getIntrinsicID()) { switch (getIntrinsicID()) {
default: default:
return false; return false;
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
case Intrinsic::INTRINSIC: \ case Intrinsic::INTRINSIC: \
return NARG == 3; return NARG == 3;
#include "llvm/IR/ConstrainedOps.def" #include "llvm/IR/ConstrainedOps.def"
@ -169,7 +169,7 @@ bool ConstrainedFPIntrinsic::isTernaryOp() const {
bool ConstrainedFPIntrinsic::classof(const IntrinsicInst *I) { bool ConstrainedFPIntrinsic::classof(const IntrinsicInst *I) {
switch (I->getIntrinsicID()) { switch (I->getIntrinsicID()) {
#define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC, DAGN) \ #define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC) \
case Intrinsic::INTRINSIC: case Intrinsic::INTRINSIC:
#include "llvm/IR/ConstrainedOps.def" #include "llvm/IR/ConstrainedOps.def"
return true; return true;

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

@ -4327,7 +4327,7 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) {
"an array"); "an array");
break; break;
} }
#define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC, DAGN) \ #define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC) \
case Intrinsic::INTRINSIC: case Intrinsic::INTRINSIC:
#include "llvm/IR/ConstrainedOps.def" #include "llvm/IR/ConstrainedOps.def"
visitConstrainedFPIntrinsic(cast<ConstrainedFPIntrinsic>(Call)); visitConstrainedFPIntrinsic(cast<ConstrainedFPIntrinsic>(Call));
@ -4778,7 +4778,7 @@ void Verifier::visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI) {
unsigned NumOperands; unsigned NumOperands;
bool HasRoundingMD; bool HasRoundingMD;
switch (FPI.getIntrinsicID()) { switch (FPI.getIntrinsicID()) {
#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \ #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
case Intrinsic::INTRINSIC: \ case Intrinsic::INTRINSIC: \
NumOperands = NARG; \ NumOperands = NARG; \
HasRoundingMD = ROUND_MODE; \ HasRoundingMD = ROUND_MODE; \