Add support for -mdecimal-float-abi option.

clang/include/clang/Basic/CodeGenOptions.h

@@ -217,6 +217,9 @@ class CodeGenOptions : public CodeGenOptionsBase {
   /// The ABI to use for passing floating point arguments.
   std::string FloatABI;
 
+  /// The encoding used for decimal floating point arguments.
+  std::string DecimalFloatABI;
+
   /// The file to use for dumping bug report by `Debugify` for original
   /// debug info.
   std::string DIBugsReportFilePath;

clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -62,6 +62,8 @@ def err_drv_no_cuda_libdevice : Error<
   "cannot find libdevice for %0; provide path to different CUDA installation "
   "via '--cuda-path', or pass '-nocudalib' to build without linking with "
   "libdevice">;
+def err_drv_unsupported_decimal_fp_encoding_for_target : Error<
+  "unsupported decimal floating-point encoding '%0' for target '%1'">;
 
 def err_drv_no_rocm_device_lib : Error<
   "cannot find ROCm device library%select{| for %1|for ABI version %1}0; provide its path via "
@@ -242,6 +244,8 @@ def err_drv_cannot_read_config_file : Error<
   "cannot read configuration file '%0': %1">;
 def err_drv_arg_requires_bitcode_input: Error<
   "option '%0' requires input to be LLVM bitcode">;
+def err_drv_invalid_mdecimal_float_abi_EQ: Error<
+  "invalid argument '%0' to -mdecimal-float-abi=; each element must be one of: %1">;
 
 def err_target_unsupported_arch
   : Error<"the target architecture '%0' is not supported by the target '%1'">;

clang/include/clang/Basic/TargetInfo.h

@@ -114,6 +114,8 @@ struct TransferrableTargetInfo {
   unsigned char DecimalFloat64Width, DecimalFloat64Align;
   unsigned char DecimalFloat128Width, DecimalFloat128Align;
 
+  enum DecimalFloat { Libgcc_BID, Libgcc_DPD, Hard } DecimalFloatABI;
+
   // Fixed point bit widths
   unsigned char ShortAccumWidth, ShortAccumAlign;
   unsigned char AccumWidth, AccumAlign;

clang/include/clang/Driver/Options.td

@@ -4284,6 +4284,11 @@ def malign_double : Flag<["-"], "malign-double">, Group<m_Group>,
   MarshallingInfoFlag<LangOpts<"AlignDouble">>;
 let Flags = [TargetSpecific] in {
 def mfloat_abi_EQ : Joined<["-"], "mfloat-abi=">, Group<m_Group>, Values<"soft,softfp,hard">;
+def mdecimal_float_abi_EQ : Joined<["-"], "mdecimal-float-abi=">, Group<m_Group>,
+Visibility<[ClangOption, CC1Option]>,
+  Values<"libgcc:bid,libgcc:dpd,hard">,
+  HelpText<"The decimal float encoding to use">,
+  MarshallingInfoString<CodeGenOpts<"DecimalFloatABI">>;
 def mfpmath_EQ : Joined<["-"], "mfpmath=">, Group<m_Group>;
 def mfpu_EQ : Joined<["-"], "mfpu=">, Group<m_Group>;
 def mhwdiv_EQ : Joined<["-"], "mhwdiv=">, Group<m_Group>;

clang/lib/Basic/Targets/X86.cpp

@@ -382,7 +382,8 @@ bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
       HasX87 = true;
     } else if (Feature == "+fullbf16") {
       HasFullBFloat16 = true;
-    }
+    } else if (Feature == "+bid-encoding")
+      HasBIDENCODING = true;
 
     X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
                            .Case("+avx512f", AVX512F)

clang/lib/Basic/Targets/X86.h

@@ -165,6 +165,7 @@ class LLVM_LIBRARY_VISIBILITY X86TargetInfo : public TargetInfo {
   bool HasUINTR = false;
   bool HasCRC32 = false;
   bool HasX87 = false;
+  bool HasBIDENCODING = false;
 
 protected:
   llvm::X86::CPUKind CPU = llvm::X86::CK_None;

clang/lib/CodeGen/BackendUtil.cpp

@@ -353,6 +353,12 @@ static bool initTargetOptions(DiagnosticsEngine &Diags,
           .Case("softfp", llvm::FloatABI::Soft)
           .Case("hard", llvm::FloatABI::Hard)
           .Default(llvm::FloatABI::Default);
+  Options.DecimalFloatABIType =
+      llvm::StringSwitch<llvm::DecimalFloatABI>(CodeGenOpts.DecimalFloatABI)
+          .Case("libgcc:bid", llvm::DecimalFloatABI::Libgcc_BID)
+          .Case("libgcc:dpd", llvm::DecimalFloatABI::Libgcc_DPD)
+          .Case("hard", llvm::DecimalFloatABI::Hard)
+          .Default(llvm::DecimalFloatABI::Default);
 
   // Set FP fusion mode.
   switch (LangOpts.getDefaultFPContractMode()) {

clang/lib/Driver/ToolChain.cpp

@@ -9,6 +9,7 @@
 #include "clang/Driver/ToolChain.h"
 #include "ToolChains/Arch/AArch64.h"
 #include "ToolChains/Arch/ARM.h"
+#include "ToolChains/Arch/X86.h"
 #include "ToolChains/Clang.h"
 #include "ToolChains/CommonArgs.h"
 #include "ToolChains/Flang.h"

clang/lib/Driver/ToolChains/Arch/X86.cpp

@@ -273,4 +273,44 @@ void x86::getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple,
     Features.push_back("+prefer-no-gather");
   if (Args.hasArg(options::OPT_mno_scatter))
     Features.push_back("+prefer-no-scatter");
+
+  // -mdecimal-float-abi
+  x86::DecimalFloatABI ABI = x86::getX86DecimalFloatABI(D, Triple, Args);
+  if (ABI == DecimalFloatABI::Invalid)
+    ABI = x86::getDefaultX86DecimalFloatABI(Triple, Args);
+  if (ABI != x86::DecimalFloatABI::None && ABI != x86::DecimalFloatABI::Default)
+      Features.push_back("+bid-encoding");
+}
+
+x86::DecimalFloatABI
+x86::getDefaultX86DecimalFloatABI(const llvm::Triple &Triple,
+                                  const ArgList &Args) {
+  if (const Arg *A = Args.getLastArg(options::OPT_fdecimal_floating_point))
+    return DecimalFloatABI::Libgcc_BID;
+  else
+    return DecimalFloatABI::None;
 }
+
+// Get the decimal float ABI type from the command line arguments
+// -mdecimal-float-abi=.
+x86::DecimalFloatABI x86::getX86DecimalFloatABI(const Driver &D,
+                                                const llvm::Triple &Triple,
+                                                const ArgList &Args) {
+  x86::DecimalFloatABI ABI = x86::DecimalFloatABI::Invalid;
+  if (const Arg *A = Args.getLastArg(options::OPT_mdecimal_float_abi_EQ)) {
+    StringRef Val = A->getValue();
+    ABI = llvm::StringSwitch<x86::DecimalFloatABI>(A->getValue())
+              .Case("libgcc:bid", DecimalFloatABI::Libgcc_BID)
+              .Case("libgcc:dpd", DecimalFloatABI::Libgcc_DPD)
+              .Case("hard", DecimalFloatABI::Hard)
+              .Default(DecimalFloatABI::None);
+    if (ABI != x86::DecimalFloatABI::None &&
+        ABI != x86::DecimalFloatABI::Default) {
+      // X86 targets only allow BID encoding.
+      if (ABI != x86::DecimalFloatABI::Libgcc_BID)
+        D.Diag(diag::err_drv_unsupported_decimal_fp_encoding_for_target)
+            << Val << "X86";
+    }
+  }
+  return ABI;
+}

clang/lib/Driver/ToolChains/Arch/X86.h

@@ -21,13 +21,29 @@ namespace driver {
 namespace tools {
 namespace x86 {
 
+enum class DecimalFloatABI {
+  Default,    // Target-specific default.
+  None,       // No decimal floating-point support.
+  Libgcc_BID, // libgcc with BID encoding.
+  Libgcc_DPD, // libgcc with DPD encoding.
+  Hard,       // Target-specific hard ABI.
+  Invalid
+};
+
 std::string getX86TargetCPU(const Driver &D, const llvm::opt::ArgList &Args,
                             const llvm::Triple &Triple);
 
 void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple,
                           const llvm::opt::ArgList &Args,
                           std::vector<llvm::StringRef> &Features);
 
+DecimalFloatABI getX86DecimalFloatABI(const Driver &D,
+                                      const llvm::Triple &Triple,
+                                      const llvm::opt::ArgList &Args);
+
+DecimalFloatABI getDefaultX86DecimalFloatABI(const llvm::Triple &Triple,
+                                             const llvm::opt::ArgList &Args);
+
 } // end namespace x86
 } // end namespace target
 } // end namespace driver

clang/lib/Driver/ToolChains/Clang.cpp

@@ -2818,6 +2818,16 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
     switch (optID) {
     default:
       break;
+    case options::OPT_mdecimal_float_abi_EQ: {
+      StringRef Val = A->getValue();
+      if (Val == "libgcc:bid" || Val == "libgcc:dpd" || Val == "hard") {
+        CmdArgs.push_back(Args.MakeArgString("-mdecimal-float-abi=" + Val));
+      } else {
+        D.Diag(diag::err_drv_unsupported_option_argument)
+            << A->getSpelling() << Val;
+      }
+      break;
+    }
     case options::OPT_ffp_model_EQ: {
       // If -ffp-model= is seen, reset to fno-fast-math
       HonorINFs = true;

clang/test/Driver/decimal-float-abi.c

@@ -0,0 +1,28 @@
+// DEFINE: %{common_opts_x86} = -###  \
+// DEFINE: -fexperimental-decimal-floating-point
+
+// X86
+// RUN: %clang %{common_opts_x86} --target=x86_64 \
+// RUN: -mdecimal-float-abi=libgcc:bid %s 2>&1 | FileCheck -check-prefix=BID %s
+
+// RUN: not %clang %{common_opts_x86} --target=x86_64 \
+// RUN: -mdecimal-float-abi=libgcc:dpd %s 2>&1 \
+// RUN: | FileCheck -check-prefix=ERROR_DPD %s
+
+// RUN: not %clang %{common_opts_x86} --target=x86_64 \
+// RUN: -mdecimal-float-abi=hard %s 2>&1 \
+// RUN: | FileCheck -check-prefix=ERROR_HARD %s
+
+// RUN: not %clang %{common_opts_x86} --target=mips64-unknown-linux \
+// RUN: -mdecimal-float-abi=hard %s 2>&1 \
+// RUN: | FileCheck -check-prefix=ERROR_MIPS_TRGT %s
+
+// BID: "-mdecimal-float-abi=libgcc:bid" {{.*}} "-target-feature" "+bid-encoding"
+
+// ERROR_DPD: unsupported decimal floating-point encoding 'libgcc:dpd' for target 'X86'
+// ERROR_HARD: unsupported decimal floating-point encoding 'hard' for target 'X86'
+// ERROR_MIPS_TRGT: unsupported option '-mdecimal-float-abi=' for target 'mips64-unknown-linux'
+
+// PPC
+// S390
+// ARM

llvm/include/llvm/CodeGen/CommandFlags.h

@@ -75,6 +75,8 @@ bool getEnableHonorSignDependentRoundingFPMath();
 
 llvm::FloatABI::ABIType getFloatABIForCalls();
 
+llvm::DecimalFloatABI getDecimalFloatABIForCalls();
+
 llvm::FPOpFusion::FPOpFusionMode getFuseFPOps();
 
 SwiftAsyncFramePointerMode getSwiftAsyncFramePointer();

llvm/include/llvm/Target/TargetOptions.h

@@ -32,6 +32,14 @@ namespace llvm {
     };
   }
 
+   enum class DecimalFloatABI {
+    Default,    // Target-specific.
+    None,       // No decimal floating-point support.
+    Libgcc_BID, // libgcc with BID encoding.
+    Libgcc_DPD, // libgcc with DPD encoding.
+    Hard        // Hardware with target-specific encoding.
+  };
+
   namespace FPOpFusion {
     enum FPOpFusionMode {
       Fast,     // Enable fusion of FP ops wherever it's profitable.
@@ -376,6 +384,8 @@ namespace llvm {
     /// arm-apple-darwin). Hard presumes that the normal FP ABI is used.
     FloatABI::ABIType FloatABIType = FloatABI::Default;
 
+    DecimalFloatABI DecimalFloatABIType = DecimalFloatABI::Default;
+
     /// AllowFPOpFusion - This flag is set by the -fp-contract=xxx option.
     /// This controls the creation of fused FP ops that store intermediate
     /// results in higher precision than IEEE allows (E.g. FMAs).

llvm/lib/Target/X86/X86.td

@@ -66,6 +66,9 @@ def FeatureXSAVES  : SubtargetFeature<"xsaves", "HasXSAVES", "true",
                                        "Support xsaves instructions",
                                        [FeatureXSAVE]>;
 
+def FeatureBIDENCODING : SubtargetFeature<"bid-encoding", "HasBIDENCODING", "true",
+                                          "Support BID encoding for decimal floatin-points">;
+
 def FeatureSSE1    : SubtargetFeature<"sse", "X86SSELevel", "SSE1",
                                       "Enable SSE instructions">;
 def FeatureSSE2    : SubtargetFeature<"sse2", "X86SSELevel", "SSE2",

llvm/lib/Target/X86/X86InstrInfo.td

@@ -929,6 +929,7 @@ def HasAVXVNNIINT16 : Predicate<"Subtarget->hasAVXVNNIINT16()">;
 def HasAVXVNNIINT8 : Predicate<"Subtarget->hasAVXVNNIINT8()">;
 def HasAVXVNNI : Predicate <"Subtarget->hasAVXVNNI()">;
 def NoVLX_Or_NoVNNI : Predicate<"!Subtarget->hasVLX() || !Subtarget->hasVNNI()">;
+def HasBIDENCODING : Predicate<"Subtarget->hasBIDENCODING()">;
 
 def HasBITALG    : Predicate<"Subtarget->hasBITALG()">;
 def HasPOPCNT    : Predicate<"Subtarget->hasPOPCNT()">;

llvm/lib/Target/X86/X86TargetMachine.cpp

@@ -238,6 +238,15 @@ X86TargetMachine::X86TargetMachine(const Target &T, const Triple &TT,
     this->Options.NoTrapAfterNoreturn = TT.isOSBinFormatMachO();
   }
 
+  // Default to triple-appropriate decimal float ABI.
+  if (Options.DecimalFloatABIType == DecimalFloatABI::None) {
+    this->Options.DecimalFloatABIType = DecimalFloatABI::None;
+  } else {
+    if (Options.DecimalFloatABIType == DecimalFloatABI::Default) {
+      this->Options.DecimalFloatABIType = DecimalFloatABI::Libgcc_BID;
+    }
+  }
+
   setMachineOutliner(true);
 
   // x86 supports the debug entry values.