NFC: consistent fp denormal mode names

[SjoerdMeijer]

Summary

This fixes the inconsistency of the fp denormal option names: in LLVM this was DenormalType, but in Clang this is DenormalMode which seems better.

In a follow up patch I will fix clang/lib/CodeGen/BackendUtil.cpp, where Options.FPDenormalMode is not set CreateTargetMachine.

[hfinkel]

LGTM

include/llvm/CodeGen/CommandFlags.h

EnableNoNaNsFPMath("enable-no-nans-fp-math",
                    cl::init(false));
 
 cl::opt<bool>
 EnableNoTrappingFPMath("enable-no-trapping-fp-math",
                        cl::desc("Enable setting the FP exceptions build "
                                 "attribute not to use exceptions"),
                        cl::init(false));
 
-cl::opt<llvm::FPDenormal::DenormalType>
-DenormalType("denormal-fp-math",
+cl::opt<llvm::FPDenormal::DenormalMode>
+DenormalMode("denormal-fp-math",
           cl::desc("Select which denormal numbers the code is permitted to require"),
           cl::init(FPDenormal::IEEE),
           cl::values(
               clEnumValN(FPDenormal::IEEE, "ieee",
                          "IEEE 754 denormal numbers"),
               clEnumValN(FPDenormal::PreserveSign, "preserve-sign",
                          "the sign of a  flushed-to-zero number is preserved "
                          "in the sign of 0"),
static inline TargetOptions InitTargetOptionsFromCodeGenFlags() {
   TargetOptions Options;
   Options.LessPreciseFPMADOption = EnableFPMAD;
   Options.AllowFPOpFusion = FuseFPOps;
   Options.Reciprocals = TargetRecip(ReciprocalOps);
   Options.UnsafeFPMath = EnableUnsafeFPMath;
   Options.NoInfsFPMath = EnableNoInfsFPMath;
   Options.NoNaNsFPMath = EnableNoNaNsFPMath;
   Options.NoTrappingFPMath = EnableNoTrappingFPMath;
-  Options.FPDenormalType = DenormalType;
+  Options.FPDenormalMode = DenormalMode;
   Options.HonorSignDependentRoundingFPMathOption =
       EnableHonorSignDependentRoundingFPMath;
   if (FloatABIForCalls != FloatABI::Default)
     Options.FloatABIType = FloatABIForCalls;
   Options.NoZerosInBSS = DontPlaceZerosInBSS;
   Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt;
   Options.StackAlignmentOverride = OverrideStackAlignment;
   Options.StackSymbolOrdering = StackSymbolOrdering;

include/llvm/Target/TargetOptions.h

namespace llvm {
   namespace ThreadModel {
     enum Model {
       POSIX,  // POSIX Threads
       Single  // Single Threaded Environment
     };
   }
 
   namespace FPDenormal {
-    enum DenormalType {
+    enum DenormalMode {
       IEEE,           // IEEE 754 denormal numbers
       PreserveSign,   // the sign of a flushed-to-zero number is preserved in
                       // the sign of 0
       PositiveZero    // denormals are flushed to positive zero
     };
   }
 
   enum class EABI {
TargetOptions()
           DisableIntegratedAS(false), CompressDebugSections(false),
           RelaxELFRelocations(false), FunctionSections(false),
           DataSections(false), UniqueSectionNames(true), TrapUnreachable(false),
           EmulatedTLS(false), EnableIPRA(false),
           FloatABIType(FloatABI::Default),
           AllowFPOpFusion(FPOpFusion::Standard), Reciprocals(TargetRecip()),
           JTType(JumpTable::Single), ThreadModel(ThreadModel::POSIX),
           EABIVersion(EABI::Default), DebuggerTuning(DebuggerKind::Default),
-          FPDenormalType(FPDenormal::IEEE),
+          FPDenormalMode(FPDenormal::IEEE),
           ExceptionModel(ExceptionHandling::None) {}
 
     /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
     /// option is specified on the command line, and should enable debugging
     /// output from the code generator.
     unsigned PrintMachineCode : 1;
 
     /// DisableFramePointerElim - This returns true if frame pointer elimination
public:
     ThreadModel::Model ThreadModel;
 
     /// EABIVersion - This flag specifies the EABI version
     EABI EABIVersion;
 
     /// Which debugger to tune for.
     DebuggerKind DebuggerTuning;
 
-    /// FPDenormalType - This flags specificies which denormal numbers the code
+    /// FPDenormalMode - This flags specificies which denormal numbers the code
     /// is permitted to require.
-    FPDenormal::DenormalType FPDenormalType;
+    FPDenormal::DenormalMode FPDenormalMode;
 
     /// What exception model to use
     ExceptionHandling ExceptionModel;
 
     /// Machine level options.
     MCTargetOptions MCOptions;
   };
 
return
     ARE_EQUAL(EmulatedTLS) &&
     ARE_EQUAL(FloatABIType) &&
     ARE_EQUAL(AllowFPOpFusion) &&
     ARE_EQUAL(Reciprocals) &&
     ARE_EQUAL(JTType) &&
     ARE_EQUAL(ThreadModel) &&
     ARE_EQUAL(EABIVersion) &&
     ARE_EQUAL(DebuggerTuning) &&
-    ARE_EQUAL(FPDenormalType) &&
+    ARE_EQUAL(FPDenormalMode) &&
     ARE_EQUAL(ExceptionModel) &&
     ARE_EQUAL(MCOptions) &&
     ARE_EQUAL(EnableIPRA);
 #undef ARE_EQUAL
 }
 
 inline bool operator!=(const TargetOptions &LHS,
                        const TargetOptions &RHS) {
   return !(LHS == RHS);
 }
 
 } // End llvm namespace
 
 #endif

lib/Target/ARM/ARMAsmPrinter.cpp

void ARMAsmPrinter::emitAttributes() {
   } else {
     ATS.emitAttribute(ARMBuildAttrs::ABI_PCS_GOT_use,
                       ARMBuildAttrs::AddressDirect);
   }
 
   // Set FP Denormals.
   if (haveAllFunctionsAttribute(*MMI->getModule(), "denormal-fp-math",
                                 "preserve-sign") ||
-      TM.Options.FPDenormalType == FPDenormal::PreserveSign)
+      TM.Options.FPDenormalMode == FPDenormal::PreserveSign)
     ATS.emitAttribute(ARMBuildAttrs::ABI_FP_denormal,
                       ARMBuildAttrs::PreserveFPSign);
   else if (haveAllFunctionsAttribute(*MMI->getModule(), "denormal-fp-math",
                                      "positive-zero") ||
-           TM.Options.FPDenormalType == FPDenormal::PositiveZero)
+           TM.Options.FPDenormalMode == FPDenormal::PositiveZero)
     ATS.emitAttribute(ARMBuildAttrs::ABI_FP_denormal,
                       ARMBuildAttrs::PositiveZero);
   else if (!TM.Options.UnsafeFPMath)
     ATS.emitAttribute(ARMBuildAttrs::ABI_FP_denormal,
                       ARMBuildAttrs::IEEEDenormals);
   else {
     if (!STI.hasVFP2()) {
       // When the target doesn't have an FPU (by design or

lib/Target/TargetMachine.cpp

#define RESET_OPTION(X, Y)                                                     \
   RESET_OPTION(UnsafeFPMath, "unsafe-fp-math");
   RESET_OPTION(NoInfsFPMath, "no-infs-fp-math");
   RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math");
   RESET_OPTION(NoTrappingFPMath, "no-trapping-math");
 
   StringRef Denormal =
     F.getFnAttribute("denormal-fp-math").getValueAsString();
   if (Denormal == "ieee")
-    Options.FPDenormalType = FPDenormal::IEEE;
+    Options.FPDenormalMode = FPDenormal::IEEE;
   else if (Denormal == "preserve-sign")
-    Options.FPDenormalType = FPDenormal::PreserveSign;
+    Options.FPDenormalMode = FPDenormal::PreserveSign;
   else if (Denormal == "positive-zero")
-    Options.FPDenormalType = FPDenormal::PositiveZero;
+    Options.FPDenormalMode = FPDenormal::PositiveZero;
 }
 
 /// Returns the code generation relocation model. The choices are static, PIC,
 /// and dynamic-no-pic.
 Reloc::Model TargetMachine::getRelocationModel() const { return RM; }
 
 /// Returns the code model. The choices are small, kernel, medium, large, and
 /// target default.