diff --git a/clang/include/clang/Basic/CodeGenOptions.h b/clang/include/clang/Basic/CodeGenOptions.h
index 08d4c103ce245..c7de31071731b 100644
--- a/clang/include/clang/Basic/CodeGenOptions.h
+++ b/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;
diff --git a/clang/include/clang/Basic/DiagnosticDriverKinds.td b/clang/include/clang/Basic/DiagnosticDriverKinds.td
index 9349ff85ca8a1..c7d625fce48e2 100644
--- a/clang/include/clang/Basic/DiagnosticDriverKinds.td
+++ b/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_option_for_target : Error<
+  "unsupported decimal floating-point option '%0' for this target">;
 
 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=; must be one of: %1">;
 
 def err_target_unsupported_arch
   : Error<"the target architecture '%0' is not supported by the target '%1'">;
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index b79f4cc2c6e65..d5c798b658e72 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -10234,8 +10234,6 @@ def err_missing_type_specifier : Error<
   "a type specifier is required for all declarations">;
 def err_dfp_disabled : Error<
   "decimal floating-point extensions are not enabled">;
-def err_dfp_not_supported : Error<
-  "decimal floating-point extensions are not supported on the current target">;
 def err_objc_array_of_interfaces : Error<
   "array of interface %0 is invalid (probably should be an array of pointers)">;
 def ext_c99_array_usage : Extension<
diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
index f7c7ffe967129..2211305a6f060 100644
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -287,10 +287,6 @@ class TargetInfo : public TransferrableTargetInfo,
 
   std::optional<unsigned> MaxBitIntWidth;
 
-  // If disengaged, decimal floating-point extensions are not supported,
-  // otherwise, the decimal floating-point mode that is enabled.
-  std::optional<DecimalFloatMode> DecimalFloatEnablementAndMode;
-
   std::optional<llvm::Triple> DarwinTargetVariantTriple;
 
   // TargetInfo Constructor.  Default initializes all fields.
@@ -723,20 +719,6 @@ class TargetInfo : public TransferrableTargetInfo,
   /// Determine whether constrained floating point is supported on this target.
   virtual bool hasStrictFP() const { return HasStrictFP; }
 
-  /// Determine whether decimal floating-point extensions are enabled on this
-  /// target.
-  bool hasDecimalFloatingPoint() const {
-    return DecimalFloatEnablementAndMode.has_value();
-  }
-
-  /// Determine the encoding used for decimal floating-point values on this
-  /// target if decimal floating-point extensions are enabled.
-  DecimalFloatMode getDecimalFloatingPointMode() const {
-    assert(hasDecimalFloatingPoint() &&
-           "Decimal floating-point extensions are not enabled");
-    return DecimalFloatEnablementAndMode.value();
-  }
-
   /// Return the alignment that is the largest alignment ever used for any
   /// scalar/SIMD data type on the target machine you are compiling for
   /// (including types with an extended alignment requirement).
diff --git a/clang/include/clang/Basic/TargetOptions.h b/clang/include/clang/Basic/TargetOptions.h
index b192c856384b9..fc35fb2cf477a 100644
--- a/clang/include/clang/Basic/TargetOptions.h
+++ b/clang/include/clang/Basic/TargetOptions.h
@@ -129,6 +129,29 @@ class TargetOptions {
 
   /// The entry point name for HLSL shader being compiled as specified by -E.
   std::string HLSLEntry;
+
+  // If disengaged, decimal floating-point extensions are not supported,
+  // otherwise, the decimal floating-point mode is enabled.
+  std::optional<llvm::DecimalFloatMode> DecimalFloatEnablementAndMode;
+
+  /// Determine whether decimal floating-point extensions are enabled on this
+  /// target.
+  bool hasDecimalFloatingPoint() const {
+    return DecimalFloatEnablementAndMode.has_value();
+  }
+
+  /// Determine the encoding used for decimal floating-point values on this
+  /// target if decimal floating-point extensions are enabled.
+  llvm::DecimalFloatMode getDecimalFloatingPointMode() const {
+    assert(hasDecimalFloatingPoint() &&
+           "Decimal floating-point extensions are not enabled");
+    return DecimalFloatEnablementAndMode.value();
+  }
+
+  /// Set the encoding used for decimal floating-point value on this target.
+  void setDecimalFloatingPointMode(llvm::DecimalFloatMode Mode) {
+    DecimalFloatEnablementAndMode = Mode;
+  }
 };
 
 } // end namespace clang
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 8a510295d3441..4e784b24bf6b7 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/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<"hard,default,libgcc:bid,libgcc:dpd">,
+  HelpText<"The decimal floating-point ABI 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>;
diff --git a/clang/include/clang/Driver/ToolChain.h b/clang/include/clang/Driver/ToolChain.h
index 0b38b939a188a..fe49723814bd2 100644
--- a/clang/include/clang/Driver/ToolChain.h
+++ b/clang/include/clang/Driver/ToolChain.h
@@ -618,6 +618,10 @@ class ToolChain {
   ComputeLLVMTriple(const llvm::opt::ArgList &Args,
                     types::ID InputType = types::TY_INVALID) const;
 
+  llvm::DecimalFloatABI
+  checkDecimalFloatABI(const llvm::opt::ArgList &Args,
+                       const llvm::Triple &Triple) const;
+
   /// ComputeEffectiveClangTriple - Return the Clang triple to use for this
   /// target, which may take into account the command line arguments. For
   /// example, on Darwin the -mmacosx-version-min= command line argument (which
diff --git a/clang/lib/Basic/TargetInfo.cpp b/clang/lib/Basic/TargetInfo.cpp
index e62b215240ad3..6b34c9e8d33eb 100644
--- a/clang/lib/Basic/TargetInfo.cpp
+++ b/clang/lib/Basic/TargetInfo.cpp
@@ -524,12 +524,6 @@ void TargetInfo::adjust(DiagnosticsEngine &Diags, LangOptions &Opts) {
 
   if (Opts.FakeAddressSpaceMap)
     AddrSpaceMap = &FakeAddrSpaceMap;
-
-  // If decimal floating-point extensions are not enabled at the language
-  // level, reset the target dependent DFP mode configuration in order to
-  // avoid surprises.
-  if (!Opts.DecimalFloatingPoint)
-    DecimalFloatEnablementAndMode.reset();
 }
 
 bool TargetInfo::initFeatureMap(
diff --git a/clang/lib/Basic/Targets/OSTargets.h b/clang/lib/Basic/Targets/OSTargets.h
index 41abb01c42707..f2bd846e670d1 100644
--- a/clang/lib/Basic/Targets/OSTargets.h
+++ b/clang/lib/Basic/Targets/OSTargets.h
@@ -352,12 +352,6 @@ class LLVM_LIBRARY_VISIBILITY LinuxTargetInfo : public OSTargetInfo<Target> {
     case llvm::Triple::x86:
     case llvm::Triple::x86_64:
       this->HasFloat128 = true;
-      if (!Triple.isAndroid()) {
-        // Android NDK r23 and later no longer provide libgcc. DFP support
-        // for Android is therefore not enabled by default pending the
-        // availability of a different DFP run-time library.
-        this->DecimalFloatEnablementAndMode = DecimalFloatMode::BID;
-      }
       break;
     }
   }
diff --git a/clang/lib/Basic/Targets/X86.h b/clang/lib/Basic/Targets/X86.h
index b759c76fc95ca..13ec62039356d 100644
--- a/clang/lib/Basic/Targets/X86.h
+++ b/clang/lib/Basic/Targets/X86.h
@@ -719,6 +719,11 @@ class LLVM_LIBRARY_VISIBILITY X86_64TargetInfo : public X86TargetInfo {
     Int64Type = IsX32 ? SignedLongLong : SignedLong;
     RegParmMax = 6;
 
+    // TODO
+    // Here we would test for the value of Opts.DecimalFloatEnablementMode.
+    // If it is set we would make sure that it has the correct value for this
+    // target and set the datalayout accordingly.
+
     // Pointers are 32-bit in x32.
     resetDataLayout(IsX32 ? "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-"
                             "i64:64-f80:128-n8:16:32:64-S128"
diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp
index e2afc5d566281..6e6e40a75d4df 100644
--- a/clang/lib/CodeGen/BackendUtil.cpp
+++ b/clang/lib/CodeGen/BackendUtil.cpp
@@ -353,6 +353,19 @@ static bool initTargetOptions(DiagnosticsEngine &Diags,
           .Case("softfp", llvm::FloatABI::Soft)
           .Case("hard", llvm::FloatABI::Hard)
           .Default(llvm::FloatABI::Default);
+  // Set decimal float ABI type;
+  assert((CodeGenOpts.DecimalFloatABI == "hard" ||
+          CodeGenOpts.DecimalFloatABI == "default " ||
+          CodeGenOpts.DecimalFloatABI == "libgcc:bid" ||
+          CodeGenOpts.DecimalFloatABI == "libgcc:dpd" ||
+          CodeGenOpts.DecimalFloatABI.empty()) &&
+         "Invalid Decimal Floating Point ABI!");
+  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()) {
diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp
index 410757d5f9e18..2d0d6e3853b2f 100644
--- a/clang/lib/Driver/ToolChain.cpp
+++ b/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"
@@ -922,6 +923,24 @@ bool ToolChain::isThreadModelSupported(const StringRef Model) const {
   return false;
 }
 
+llvm::DecimalFloatABI
+ToolChain::checkDecimalFloatABI(const llvm::opt::ArgList &Args,
+                                const llvm::Triple &Triple) const {
+  tools::DecimalFloatABI ABI =
+      tools::getDecimalFloatABI(getDriver(), Triple, Args);
+  tools::DecimalFloatABI DefaultDecimalABI =
+      tools::getDefaultDecimalFloatABI(Triple);
+  if (DefaultDecimalABI != tools::DecimalFloatABI::None &&
+      ABI != DefaultDecimalABI) {
+    Arg *ABIArg =
+        Args.getLastArg(options::OPT_mdecimal_float_abi_EQ);
+    assert(ABIArg && "Non-default decimal float abi expected to be from arg");
+    D.Diag(diag::err_drv_unsupported_opt_for_target)
+        << ABIArg->getAsString(Args) << Triple.getTriple();
+  }
+  return ABI;
+}
+
 std::string ToolChain::ComputeLLVMTriple(const ArgList &Args,
                                          types::ID InputType) const {
   switch (getTriple().getArch()) {
diff --git a/clang/lib/Driver/ToolChains/Arch/X86.h b/clang/lib/Driver/ToolChains/Arch/X86.h
index e07387f3ece3d..eb8ce1e884dbd 100644
--- a/clang/lib/Driver/ToolChains/Arch/X86.h
+++ b/clang/lib/Driver/ToolChains/Arch/X86.h
@@ -19,6 +19,12 @@
 namespace clang {
 namespace driver {
 namespace tools {
+
+using llvm::DecimalFloatABI;
+DecimalFloatABI getDecimalFloatABI(const Driver &D, const llvm::Triple &Triple,
+                                   const llvm::opt::ArgList &Args);
+DecimalFloatABI getDefaultDecimalFloatABI(const llvm::Triple &Triple);
+
 namespace x86 {
 
 std::string getX86TargetCPU(const Driver &D, const llvm::opt::ArgList &Args,
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index d98574def75de..714d61fee268e 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -2266,9 +2266,31 @@ void Clang::AddSystemZTargetArgs(const ArgList &Args,
   }
 }
 
+static StringRef getDecimalFloatABIStr(llvm::DecimalFloatABI ABI) {
+  switch (ABI) {
+  case llvm::DecimalFloatABI::Libgcc_BID:
+    return "libgcc:bid";
+  case llvm::DecimalFloatABI::Libgcc_DPD:
+    return "libgcc:dpd";
+  case llvm::DecimalFloatABI::Hard:
+      return "hard";
+  case llvm::DecimalFloatABI::None:
+    return "none";
+  default:
+    return "default";
+  }
+}
+
 void Clang::AddX86TargetArgs(const ArgList &Args,
                              ArgStringList &CmdArgs) const {
   const Driver &D = getToolChain().getDriver();
+
+  // Determine floating point ABI from the options & target defaults.
+  llvm::DecimalFloatABI DFPABI =
+      getToolChain().checkDecimalFloatABI(Args, getToolChain().getTriple());
+  CmdArgs.push_back(Args.MakeArgString("-mdecimal-float-abi=" +
+                                       getDecimalFloatABIStr(DFPABI)));
+
   addX86AlignBranchArgs(D, Args, CmdArgs, /*IsLTO=*/false);
 
   if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
@@ -2818,6 +2840,7 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
     switch (optID) {
     default:
       break;
+
     case options::OPT_ffp_model_EQ: {
       // If -ffp-model= is seen, reset to fno-fast-math
       HonorINFs = true;
diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp
index 1db05b47e11ba..192564ef84c83 100644
--- a/clang/lib/Driver/ToolChains/CommonArgs.cpp
+++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp
@@ -2466,3 +2466,38 @@ void tools::addHIPRuntimeLibArgs(const ToolChain &TC, Compilation &C,
     }
   }
 }
+
+tools::DecimalFloatABI
+tools::getDefaultDecimalFloatABI(const llvm::Triple &Triple) {
+  switch (Triple.getArch()) {
+  case llvm::Triple::x86:
+  case llvm::Triple::x86_64:
+    if (Triple.getEnvironment() == llvm::Triple::GNU)
+      return DecimalFloatABI::Libgcc_BID;
+    return DecimalFloatABI::None;
+  case llvm::Triple::ppc:
+  case llvm::Triple::ppc64:
+    return DecimalFloatABI::Libgcc_DPD;
+  default:
+      return DecimalFloatABI::None;
+  }
+}
+
+// Get the decimal float ABI type from the command line arguments
+// -mdecimal-float-abi=.
+tools::DecimalFloatABI tools::getDecimalFloatABI(const Driver &D,
+                                                 const llvm::Triple &Triple,
+                                                 const ArgList &Args) {
+  tools::DecimalFloatABI ABI = tools::DecimalFloatABI::Default;
+  if (const Arg *A = Args.getLastArg(options::OPT_mdecimal_float_abi_EQ)) {
+    StringRef Val = A->getValue();
+    ABI = llvm::StringSwitch<tools::DecimalFloatABI>(Val)
+              .Case("libgcc:bid", DecimalFloatABI::Libgcc_BID)
+              .Case("libgcc:dpd", DecimalFloatABI::Libgcc_DPD)
+              .Case("hard", DecimalFloatABI::Hard)
+              .Default(DecimalFloatABI::Default);
+  }
+  if (ABI == DecimalFloatABI::Default)
+	ABI = getDefaultDecimalFloatABI(Triple);
+  return ABI;
+}
diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp
index f0d0260625c17..ffa0eccce59b5 100644
--- a/clang/lib/Frontend/InitPreprocessor.cpp
+++ b/clang/lib/Frontend/InitPreprocessor.cpp
@@ -501,8 +501,7 @@ static void InitializeStandardPredefinedMacros(const TargetInfo &TI,
   // C23 decimal floating point extensions.
   // FIXME: Define to 202311L when support for C23 decimal floating point
   // FIXME: extensions is feature complete.
-  if (!LangOpts.CPlusPlus && LangOpts.DecimalFloatingPoint &&
-      TI.hasDecimalFloatingPoint())
+  if (!LangOpts.CPlusPlus && LangOpts.DecimalFloatingPoint)
     Builder.defineMacro("__STDC_IEC_60559_DFP__", "197001L");
 
   if (LangOpts.ObjC)
diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
index 091b247f4794c..cf9c51329577e 100644
--- a/clang/lib/Sema/SemaDeclAttr.cpp
+++ b/clang/lib/Sema/SemaDeclAttr.cpp
@@ -4865,10 +4865,6 @@ void Sema::AddModeAttr(Decl *D, const AttributeCommonInfo &CI,
       Diag(AttrLoc, diag::err_dfp_disabled);
       return;
     }
-    if (!Context.getTargetInfo().hasDecimalFloatingPoint()) {
-      Diag(AttrLoc, diag::err_dfp_not_supported);
-      return;
-    }
   }
 
   if (ComplexMode) {
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 13c50b56972b7..c3ab0d000f4d3 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -1592,10 +1592,6 @@ static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
       S.Diag(DS.getTypeSpecTypeLoc(), diag::err_dfp_disabled);
       Result = Context.IntTy;
       declarator.setInvalidType(true);
-    } else if (!S.Context.getTargetInfo().hasDecimalFloatingPoint()) {
-      S.Diag(DS.getTypeSpecTypeLoc(), diag::err_dfp_not_supported);
-      Result = Context.IntTy;
-      declarator.setInvalidType(true);
     } else {
       Result = TSTToDecimalFloatType(Context, DS.getTypeSpecType());
     }
diff --git a/clang/test/Driver/decimal-float-abi.c b/clang/test/Driver/decimal-float-abi.c
new file mode 100644
index 0000000000000..0b84d8d27180e
--- /dev/null
+++ b/clang/test/Driver/decimal-float-abi.c
@@ -0,0 +1,47 @@
+// DEFINE: %{common_opts_x86} = -###  \
+// DEFINE: -fexperimental-decimal-floating-point
+
+// RUN: %clang %{common_opts_x86} --target=x86_64-unknown-linux-gnu \
+// RUN: %s 2>&1 | FileCheck -check-prefix=BID %s
+
+// RUN: %clang %{common_opts_x86} --target=x86_64-unknown-linux-gnu \
+// RUN: -mdecimal-float-abi=libgcc:bid %s 2>&1 \
+// RUN: | FileCheck -check-prefix=BID %s
+
+// RUN: %clang %{common_opts_x86} --target=x86_64-windows \
+// RUN: %s 2>&1 | FileCheck -check-prefix=NONE %s
+
+// RUN: %clang %{common_opts_x86} --target=x86_64-windows \
+// RUN: -mdecimal-float-abi=libgcc:bid %s 2>&1 \
+// RUN: | FileCheck -check-prefix=BID %s
+
+// RUN: %clang %{common_opts_x86} --target=x86_64-windows-gnu \
+// RUN: -mdecimal-float-abi=libgcc:bid %s 2>&1 | FileCheck -check-prefix=BID %s
+
+// RUN: %clang %{common_opts_x86} --target=x86_64-unknown-linux  \
+// RUN: -mdecimal-float-abi=libgcc:bid %s 2>&1 \
+// RUN: | FileCheck -check-prefix=BID %s
+
+// RUN: not %clang %{common_opts_x86} --target=x86_64-unknown-linux-gnu \
+// 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-unknown-linux-gnu \
+// RUN: -mdecimal-float-abi=hard %s 2>&1 \
+// RUN: | FileCheck -check-prefix=ERROR_HARD %s
+
+// RUN not %clang %{common_opts_x86} --target=x86_64-windows \
+// RUN -mdecimal-float-abi=libgcc:bid %s 2>&1 \
+// RUN | FileCheck -check-prefix=ERROR_BID %s
+
+// RUN: %clang %{common_opts_x86} --target=x86_64-unknown-linux-gnu \
+// RUN: -mdecimal-float-abi=libgcc:dpd %s 2>&1 \
+// RUN: | FileCheck -check-prefix=ERROR_DPD %s
+
+// BID: "-mdecimal-float-abi=libgcc:bid" {{.*}}
+// NONE: "-mdecimal-float-abi=none" {{.*}}
+
+// ERROR_DPD: unsupported option '-mdecimal-float-abi=libgcc:dpd' for target 'x86_64-unknown-linux-gnu'
+// ERROR_HARD: unsupported option '-mdecimal-float-abi=hard' for target 'x86_64-unknown-linux-gnu'
+// ERROR_BID: unsupported option '-mdecimal-float-abi=libgcc:bid' for target 'x86_64-unknown-windows-msvc'
+
diff --git a/llvm/include/llvm/ADT/FloatingPointMode.h b/llvm/include/llvm/ADT/FloatingPointMode.h
index 468de085d1bed..518c983a6c41a 100644
--- a/llvm/include/llvm/ADT/FloatingPointMode.h
+++ b/llvm/include/llvm/ADT/FloatingPointMode.h
@@ -279,6 +279,16 @@ FPClassTest unknown_sign(FPClassTest Mask);
 /// Write a human readable form of \p Mask to \p OS
 raw_ostream &operator<<(raw_ostream &OS, FPClassTest Mask);
 
+// ISO/IEC TS 18661-2, ISO/IEC TR 24733, and C23 decimal floating-point.
+// Multiple encoding forms for the storage of decimal floating-point
+// values have been defined for use on various platforms. This
+// enumeration provides an enumerator for each known encoding.
+enum class DecimalFloatMode : uint8_t {
+  BID, // Binary Integer Decimal.
+  DPD, // Densely Packed Decimal.
+  None // No decimal floating-point in target.
+};
+
 } // namespace llvm
 
 #endif // LLVM_ADT_FLOATINGPOINTMODE_H
diff --git a/llvm/include/llvm/CodeGen/CommandFlags.h b/llvm/include/llvm/CodeGen/CommandFlags.h
index 732d6d0211c99..2f2bb670d11a2 100644
--- a/llvm/include/llvm/CodeGen/CommandFlags.h
+++ b/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();
diff --git a/llvm/include/llvm/Target/TargetOptions.h b/llvm/include/llvm/Target/TargetOptions.h
index d6d767f3d22c7..e3be2b61c68d7 100644
--- a/llvm/include/llvm/Target/TargetOptions.h
+++ b/llvm/include/llvm/Target/TargetOptions.h
@@ -32,6 +32,14 @@ namespace llvm {
     };
   }
 
+  enum class DecimalFloatABI {
+    Default,    // Target-specific.
+    None,       // No decimal floating-point support.
+    Hard,       // Hardware with target-specific encoding.
+    Libgcc_BID, // libgcc with BID encoding.
+    Libgcc_DPD  // libgcc with DPD 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).
diff --git a/llvm/lib/Target/X86/X86TargetMachine.cpp b/llvm/lib/Target/X86/X86TargetMachine.cpp
index c0d3b8aa93e6c..03e448122a6dd 100644
--- a/llvm/lib/Target/X86/X86TargetMachine.cpp
+++ b/llvm/lib/Target/X86/X86TargetMachine.cpp
@@ -238,6 +238,17 @@ 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) {
+      if (TT.getOS() == llvm::Triple::Linux &&
+          TT.getEnvironment() == llvm::Triple::GNU)
+        this->Options.DecimalFloatABIType = DecimalFloatABI::Libgcc_BID;
+    }
+  }
+
   setMachineOutliner(true);
 
   // x86 supports the debug entry values.