[clang] [HLSL] Add a simplified version of precise (PR #234462)

Sarah Spall via cfe-commits cfe-commits at lists.llvm.org
Wed Nov 4 13:00:59 PST 2026


https://github.com/spall updated https://github.com/llvm/llvm-project/pull/234462

>From 7cbda93e2ab130a226b18d9c4f46ef866ad63db9 Mon Sep 17 00:00:00 2001
From: Sarah Spall <sarahspall at microsoft.com>
Date: Mon, 19 Oct 2026 15:20:14 -0700
Subject: [PATCH 01/10] add precise as an hlsl keyword + tests

---
 clang/include/clang/Basic/Attr.td          |  7 ++
 clang/include/clang/Basic/AttrDocs.td      | 17 +++++
 clang/include/clang/Basic/TokenKinds.def   |  1 +
 clang/lib/Parse/ParseDecl.cpp              |  4 ++
 clang/lib/Parse/ParseTentative.cpp         |  3 +-
 clang/lib/Sema/SemaDeclAttr.cpp            |  3 +
 clang/test/AST/HLSL/precise.hlsl           | 77 ++++++++++++++++++++++
 clang/test/ParserHLSL/precise-keyword.hlsl |  6 ++
 8 files changed, 117 insertions(+), 1 deletion(-)
 create mode 100644 clang/test/AST/HLSL/precise.hlsl
 create mode 100644 clang/test/ParserHLSL/precise-keyword.hlsl

diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td
index f8bd097733529a..a8c6efef0c5c9b 100644
--- a/clang/include/clang/Basic/Attr.td
+++ b/clang/include/clang/Basic/Attr.td
@@ -5477,6 +5477,13 @@ def HLSLColumnMajor : TypeAttr {
   let Documentation = [HLSLMatrixLayoutDocs];
 }
 
+def HLSLPrecise : HLSLAnnotationAttr {
+  let Spellings = [CustomKeyword<"precise">];
+  let Subjects = SubjectList<[Field, Function, Var, TypedefName], ErrorDiag>;
+  let LangOpts = [HLSL];
+  let Documentation = [HLSLPreciseDocs];
+}
+
 def RandomizeLayout : InheritableAttr {
   let Spellings = [GCC<"randomize_layout">];
   let Subjects = SubjectList<[Record]>;
diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td
index e8ce3c3dea7f3b..5088cd7373a10c 100644
--- a/clang/include/clang/Basic/AttrDocs.td
+++ b/clang/include/clang/Basic/AttrDocs.td
@@ -9759,6 +9759,23 @@ row_major float2x2 myMatrix;
   }];
 }
 
+def HLSLPreciseDocs : Documentation {
+  let Category = DocCatVariable;
+  let Heading = "precise";
+  let Content = [{
+The HLSL ``precise`` keyword can be applied to variables, parameters, fields,
+typedefs, and function return values to request that floating-point computations
+contributing to their values are performed with IEEE-strict semantics.
+
+Clang currently implements a simplified version of ``precise``: if the keyword
+is used anywhere in a translation unit, the whole translation unit is compiled
+in IEEE-strict floating-point mode, as if ``-Gis`` (``-ffp-model=strict``) had
+been specified.
+
+The full documentation is available here: https://learn.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-variable-syntax
+  }];
+}
+
 def WebAssemblyFuncrefDocs : Documentation {
   let Category = DocCatType;
   let Content = [{
diff --git a/clang/include/clang/Basic/TokenKinds.def b/clang/include/clang/Basic/TokenKinds.def
index 528825ad68b8dc..f8ef70728be001 100644
--- a/clang/include/clang/Basic/TokenKinds.def
+++ b/clang/include/clang/Basic/TokenKinds.def
@@ -555,6 +555,7 @@ KEYWORD(inout                       , KEYHLSL)
 KEYWORD(out                         , KEYHLSL)
 KEYWORD(row_major                   , KEYHLSL)
 KEYWORD(column_major                , KEYHLSL)
+KEYWORD(precise                     , KEYHLSL)
 // HLSL Intangible Types
 #define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) KEYWORD(Name, KEYHLSL)
 #include "clang/Basic/HLSLIntangibleTypes.def"
diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp
index 40249287184446..7482865e4b53ab 100644
--- a/clang/lib/Parse/ParseDecl.cpp
+++ b/clang/lib/Parse/ParseDecl.cpp
@@ -4706,6 +4706,7 @@ void Parser::ParseDeclarationSpecifiers(
     case tok::kw_in:
     case tok::kw_inout:
     case tok::kw_out:
+    case tok::kw_precise:
       // NOTE: ParseHLSLQualifiers will consume the qualifier token.
       ParseHLSLQualifiers(DS.getAttributes());
       continue;
@@ -5879,6 +5880,7 @@ bool Parser::isTypeSpecifierQualifier(const Token &Tok) {
   case tok::kw_out:
   case tok::kw_row_major:
   case tok::kw_column_major:
+  case tok::kw_precise:
     return getLangOpts().HLSL;
   }
 }
@@ -6161,6 +6163,7 @@ bool Parser::isDeclarationSpecifier(
   case tok::kw_groupshared:
     return true;
 
+  case tok::kw_precise:
   case tok::kw_nointerpolation:
   case tok::kw_linear:
   case tok::kw_centroid:
@@ -6419,6 +6422,7 @@ void Parser::ParseTypeQualifierListOpt(
     case tok::kw_noperspective:
     case tok::kw_sample:
     case tok::kw_center:
+    case tok::kw_precise:
       // NOTE: ParseHLSLQualifiers will consume the qualifier token.
       ParseHLSLQualifiers(DS.getAttributes());
       continue;
diff --git a/clang/lib/Parse/ParseTentative.cpp b/clang/lib/Parse/ParseTentative.cpp
index a4581538fbcec1..27a0ec79753e74 100644
--- a/clang/lib/Parse/ParseTentative.cpp
+++ b/clang/lib/Parse/ParseTentative.cpp
@@ -1286,7 +1286,7 @@ Parser::isCXXDeclarationSpecifier(ImplicitTypenameContext AllowImplicitTypename,
     // OpenCL pipe
   case tok::kw_pipe:
 
-    // HLSL interpolation and address space qualifiers
+    // HLSL interpolation, address space qualifiers, and precise
   case tok::kw_nointerpolation:
   case tok::kw_linear:
   case tok::kw_centroid:
@@ -1297,6 +1297,7 @@ Parser::isCXXDeclarationSpecifier(ImplicitTypenameContext AllowImplicitTypename,
   case tok::kw_in:
   case tok::kw_inout:
   case tok::kw_out:
+  case tok::kw_precise:
     // HLSL matrix layout qualifiers
   case tok::kw_row_major:
   case tok::kw_column_major:
diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
index 6205c705101592..98e9221847459e 100644
--- a/clang/lib/Sema/SemaDeclAttr.cpp
+++ b/clang/lib/Sema/SemaDeclAttr.cpp
@@ -8337,6 +8337,9 @@ ProcessDeclAttribute(Sema &S, Decl *D, const ParsedAttr &AL,
   case ParsedAttr::AT_HLSLVkLocation:
     S.HLSL().handleVkLocationAttr(D, AL);
     break;
+  case ParsedAttr::AT_HLSLPrecise:
+    handleSimpleAttribute<HLSLPreciseAttr>(S, D, AL);
+    break;
 
   case ParsedAttr::AT_AbiTag:
     handleAbiTagAttr(S, D, AL);
diff --git a/clang/test/AST/HLSL/precise.hlsl b/clang/test/AST/HLSL/precise.hlsl
new file mode 100644
index 00000000000000..6b436d05f39e61
--- /dev/null
+++ b/clang/test/AST/HLSL/precise.hlsl
@@ -0,0 +1,77 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -std=hlsl202x -finclude-default-header -ast-dump -verify %s | FileCheck %s
+// expected-no-diagnostics
+
+// CHECK-LABEL: TypedefDecl {{.*}} pfloat 'float'
+// CHECK-NEXT: BuiltinType {{.*}} 'float'
+// CHECK-NEXT: HLSLPreciseAttr
+typedef precise float pfloat;
+
+// CHECK-LABEL: VarDecl {{.*}} typed_global 'hlsl_constant pfloat':'hlsl_constant float'
+pfloat typed_global;
+
+// CHECK-LABEL: VarDecl {{.*}} global 'hlsl_constant float'
+// CHECK-NEXT: HLSLPreciseAttr
+precise float global;
+
+// CHECK-LABEL: VarDecl {{.*}} after_type 'hlsl_constant float'
+// CHECK-NEXT: HLSLPreciseAttr
+float precise after_type;
+
+// CHECK-LABEL: VarDecl {{.*}} first 'hlsl_constant float'
+// CHECK-NEXT: HLSLPreciseAttr
+// CHECK-LABEL: VarDecl {{.*}} second 'hlsl_constant float'
+// CHECK-NEXT: HLSLPreciseAttr
+precise float first, second;
+
+struct S {
+  // CHECK-LABEL: FieldDecl {{.*}} scalar 'float'
+  // CHECK-NEXT: HLSLPreciseAttr
+  precise float scalar;
+
+  // CHECK-LABEL: FieldDecl {{.*}} vec 'float4'
+  // CHECK-NEXT: HLSLPreciseAttr
+  precise float4 vec;
+
+  // CHECK-LABEL: FieldDecl {{.*}} mat 'float2x2'
+  // CHECK-NEXT: HLSLPreciseAttr
+  precise float2x2 mat;
+
+  // CHECK-LABEL: FieldDecl {{.*}} array 'float[2]'
+  // CHECK-NEXT: HLSLPreciseAttr
+  precise float array[2];
+};
+
+// CHECK-LABEL: FunctionDecl {{.*}} function 'float (float)'
+// CHECK-NEXT: ParmVarDecl {{.*}} input 'float'
+// CHECK-NEXT: HLSLPreciseAttr
+// CHECK-NEXT: HLSLPreciseAttr
+precise float function(precise float input);
+
+// CHECK-LABEL: FunctionDecl {{.*}} parameters 'void (
+// CHECK: ParmVarDecl {{.*}} input 'float'
+// CHECK-NEXT: HLSLPreciseAttr
+// CHECK: ParmVarDecl {{.*}} output
+// CHECK-NEXT: HLSLPreciseAttr
+// CHECK: ParmVarDecl {{.*}} both
+// CHECK: HLSLPreciseAttr
+void parameters(precise in float input, precise out float output,
+                inout precise float both);
+
+void locals() {
+  // CHECK-LABEL: VarDecl {{.*}} local 'float'
+  // CHECK-NEXT: HLSLPreciseAttr
+  precise float local;
+
+  // CHECK-LABEL: VarDecl {{.*}} constant 'const float'
+  // CHECK: HLSLPreciseAttr
+  const precise float constant = 1.0;
+
+  // CHECK-LABEL: VarDecl {{.*}} initialized 'float'
+  // CHECK: HLSLPreciseAttr
+  precise float initialized(float(1.0));
+
+  // CHECK-LABEL: VarDecl {{.*}} index 'float'
+  // CHECK: HLSLPreciseAttr
+  for (precise float index = 0.0; index < 2.0; index += 1.0) {
+  }
+}
diff --git a/clang/test/ParserHLSL/precise-keyword.hlsl b/clang/test/ParserHLSL/precise-keyword.hlsl
new file mode 100644
index 00000000000000..a3a8cb5be9bfb1
--- /dev/null
+++ b/clang/test/ParserHLSL/precise-keyword.hlsl
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -x c -verify %s
+// RUN: %clang_cc1 -x c++ -verify %s
+// expected-no-diagnostics
+
+// precise is a keyword only in HLSL.
+int precise;

>From b5d5db9ed127a9843d5dd305df02a9e98bf8f5f8 Mon Sep 17 00:00:00 2001
From: Sarah Spall <sarahspall at microsoft.com>
Date: Tue, 20 Oct 2026 09:17:40 -0700
Subject: [PATCH 02/10] if precise is seen mark that in semahlsl

---
 clang/include/clang/Sema/SemaHLSL.h | 3 +++
 clang/lib/Sema/SemaDeclAttr.cpp     | 2 +-
 clang/lib/Sema/SemaHLSL.cpp         | 7 +++++++
 3 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/clang/include/clang/Sema/SemaHLSL.h b/clang/include/clang/Sema/SemaHLSL.h
index 3d62f47dfde691..18f53779e2f797 100644
--- a/clang/include/clang/Sema/SemaHLSL.h
+++ b/clang/include/clang/Sema/SemaHLSL.h
@@ -191,6 +191,7 @@ class SemaHLSL : public SemaBase {
   void handleShaderAttr(Decl *D, const ParsedAttr &AL);
   void handleResourceBindingAttr(Decl *D, const ParsedAttr &AL);
   void handleParamModifierAttr(Decl *D, const ParsedAttr &AL);
+  void handlePreciseAttr(Decl *D, const ParsedAttr &AL);
   void handleInterpolationModifierAttr(Decl *D, const ParsedAttr &AL);
   Attr *buildMatrixLayoutTypeAttr(QualType T, const ParsedAttr &AL);
   bool diagnoseMatrixLayoutInstantiation(attr::Kind K, QualType T,
@@ -273,6 +274,8 @@ class SemaHLSL : public SemaBase {
 
   bool HasDeclaredAPushConstant = false;
 
+  bool PreciseUsed = false;
+
   // Information about the current subtree being flattened.
   struct SemanticInfo {
     HLSLParsedSemanticAttr *Semantic;
diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
index 98e9221847459e..f0240a7e7eb2cd 100644
--- a/clang/lib/Sema/SemaDeclAttr.cpp
+++ b/clang/lib/Sema/SemaDeclAttr.cpp
@@ -8338,7 +8338,7 @@ ProcessDeclAttribute(Sema &S, Decl *D, const ParsedAttr &AL,
     S.HLSL().handleVkLocationAttr(D, AL);
     break;
   case ParsedAttr::AT_HLSLPrecise:
-    handleSimpleAttribute<HLSLPreciseAttr>(S, D, AL);
+    S.HLSL().handlePreciseAttr(D, AL);
     break;
 
   case ParsedAttr::AT_AbiTag:
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index 4fe7ed151e9180..395bfbefdaee95 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -2918,6 +2918,13 @@ void SemaHLSL::handleParamModifierAttr(Decl *D, const ParsedAttr &AL) {
     D->addAttr(NewAttr);
 }
 
+void SemaHLSL::handlePreciseAttr(Decl *D, const ParsedAttr &AL) {
+  PreciseUsed = true;
+  HLSLPreciseAttr *NewAttr = HLSLPreciseAttr::Create(getASTContext(), AL);
+  if (NewAttr)
+    D->addAttr(NewAttr);
+}
+
 static bool isMatrixType(QualType QT) {
   const Type *Ty = QT->getUnqualifiedDesugaredType();
   return Ty->isDependentType() || Ty->isConstantMatrixType();

>From e6d5fa0386603791bec66dbe544f1571b1b07639 Mon Sep 17 00:00:00 2001
From: Sarah Spall <sarahspall at microsoft.com>
Date: Wed, 21 Oct 2026 11:21:43 -0700
Subject: [PATCH 03/10] delay emission of translation unit until entire until
 is parsed

---
 clang/lib/CodeGen/ModuleBuilder.cpp | 64 +++++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)

diff --git a/clang/lib/CodeGen/ModuleBuilder.cpp b/clang/lib/CodeGen/ModuleBuilder.cpp
index 0b00362487d2af..993db9f3d2fafc 100644
--- a/clang/lib/CodeGen/ModuleBuilder.cpp
+++ b/clang/lib/CodeGen/ModuleBuilder.cpp
@@ -27,6 +27,7 @@
 #include "llvm/IR/Module.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/VirtualFileSystem.h"
+#include <functional>
 #include <memory>
 
 using namespace clang;
@@ -66,6 +67,10 @@ namespace {
     std::unique_ptr<CodeGen::CodeGenModule> Builder;
     SmallVector<FunctionDecl *, 8> DeferredInlineMemberFuncDefs;
 
+    // HLSL emission must observe the final translation-unit-wide Sema state.
+    bool DeferEmission = false;
+    SmallVector<std::function<void()>, 8> DeferredCallbacks;
+
     static llvm::StringRef ExpandModuleName(llvm::StringRef ModuleName,
                                             const CodeGenOptions &CGO) {
       if (ModuleName == "-" && !CGO.MainFileName.empty())
@@ -157,6 +162,7 @@ namespace {
 
     void Initialize(ASTContext &Context) override {
       Ctx = &Context;
+      DeferEmission = Context.getLangOpts().HLSL;
 
       M->setTargetTriple(Ctx->getTargetInfo().getTriple());
       M->setDataLayout(Ctx->getTargetInfo().getDataLayoutString());
@@ -182,6 +188,12 @@ namespace {
       if (Diags.hasErrorOccurred())
         return;
 
+      if (DeferEmission) {
+        DeferredCallbacks.push_back(
+            [this, VD] { HandleCXXStaticMemberVarInstantiation(VD); });
+        return;
+      }
+
       Builder->HandleCXXStaticMemberVarInstantiation(VD);
     }
 
@@ -194,6 +206,11 @@ namespace {
       if (Diags.hasUnrecoverableErrorOccurred())
         return true;
 
+      if (DeferEmission) {
+        DeferredCallbacks.push_back([this, DG] { HandleTopLevelDecl(DG); });
+        return true;
+      }
+
       HandlingTopLevelDeclRAII HandlingDecl(*this);
 
       // Make sure to emit all elements of a Decl.
@@ -220,6 +237,12 @@ namespace {
       if (Diags.hasUnrecoverableErrorOccurred())
         return;
 
+      if (DeferEmission) {
+        DeferredCallbacks.push_back(
+            [this, D] { HandleInlineFunctionDefinition(D); });
+        return;
+      }
+
       assert(D->doesThisDeclarationHaveABody());
 
       // We may want to emit this definition. However, that decision might be
@@ -248,6 +271,11 @@ namespace {
       if (Diags.hasUnrecoverableErrorOccurred())
         return;
 
+      if (DeferEmission) {
+        DeferredCallbacks.push_back([this, D] { HandleTagDeclDefinition(D); });
+        return;
+      }
+
       // Don't allow re-entrant calls to CodeGen triggered by PCH
       // deserialization to emit deferred decls.
       HandlingTopLevelDeclRAII HandlingDecl(*this, /*EmitDeferred=*/false);
@@ -300,6 +328,12 @@ namespace {
       if (Diags.hasUnrecoverableErrorOccurred())
         return;
 
+      if (DeferEmission) {
+        DeferredCallbacks.push_back(
+            [this, D] { HandleTagDeclRequiredDefinition(D); });
+        return;
+      }
+
       // Don't allow re-entrant calls to CodeGen triggered by PCH
       // deserialization to emit deferred decls.
       HandlingTopLevelDeclRAII HandlingDecl(*this, /*EmitDeferred=*/false);
@@ -310,6 +344,14 @@ namespace {
     }
 
     void HandleTranslationUnit(ASTContext &Ctx) override {
+      // Replay in order before finalization. Callbacks triggered by replay,
+      // including AST deserialization, can now emit immediately.
+      DeferEmission = false;
+      if (!Diags.hasUnrecoverableErrorOccurred())
+        for (auto &Callback : DeferredCallbacks)
+          Callback();
+      DeferredCallbacks.clear();
+
       // Release the Builder when there is no error.
       if (!Diags.hasUnrecoverableErrorOccurred() && Builder)
         Builder->Release();
@@ -329,6 +371,11 @@ namespace {
       if (Diags.hasUnrecoverableErrorOccurred())
         return;
 
+      if (DeferEmission) {
+        DeferredCallbacks.push_back([this, RD] { AssignInheritanceModel(RD); });
+        return;
+      }
+
       Builder->RefreshTypeCacheForClass(RD);
     }
 
@@ -336,10 +383,22 @@ namespace {
       if (Diags.hasUnrecoverableErrorOccurred())
         return;
 
+      if (DeferEmission) {
+        DeferredCallbacks.push_back(
+            [this, D] { CompleteTentativeDefinition(D); });
+        return;
+      }
+
       Builder->EmitTentativeDefinition(D);
     }
 
     void CompleteExternalDeclaration(DeclaratorDecl *D) override {
+      if (DeferEmission) {
+        DeferredCallbacks.push_back(
+            [this, D] { CompleteExternalDeclaration(D); });
+        return;
+      }
+
       Builder->EmitExternalDeclaration(D);
     }
 
@@ -347,6 +406,11 @@ namespace {
       if (Diags.hasUnrecoverableErrorOccurred())
         return;
 
+      if (DeferEmission) {
+        DeferredCallbacks.push_back([this, RD] { HandleVTable(RD); });
+        return;
+      }
+
       Builder->EmitVTable(RD);
     }
   };

>From 62e0452e606bcbefd513959b1fa9068356c3003a Mon Sep 17 00:00:00 2001
From: Sarah Spall <sarahspall at microsoft.com>
Date: Wed, 21 Oct 2026 14:26:11 -0700
Subject: [PATCH 04/10] if precise is seen in TU then use -ffp-model=strict

---
 clang/include/clang/Sema/SemaHLSL.h   |  2 --
 clang/lib/CodeGen/CodeGenAction.cpp   | 28 +++++++++++++++++++++++++++
 clang/lib/CodeGen/CodeGenFunction.cpp |  6 ++++--
 clang/lib/Sema/SemaHLSL.cpp           |  5 ++++-
 clang/test/AST/HLSL/precise.hlsl      |  3 +++
 clang/test/CodeGenHLSL/precise.hlsl   | 25 ++++++++++++++++++++++++
 6 files changed, 64 insertions(+), 5 deletions(-)
 create mode 100644 clang/test/CodeGenHLSL/precise.hlsl

diff --git a/clang/include/clang/Sema/SemaHLSL.h b/clang/include/clang/Sema/SemaHLSL.h
index 18f53779e2f797..fa55337c6c221d 100644
--- a/clang/include/clang/Sema/SemaHLSL.h
+++ b/clang/include/clang/Sema/SemaHLSL.h
@@ -274,8 +274,6 @@ class SemaHLSL : public SemaBase {
 
   bool HasDeclaredAPushConstant = false;
 
-  bool PreciseUsed = false;
-
   // Information about the current subtree being flattened.
   struct SemanticInfo {
     HLSLParsedSemanticAttr *Semantic;
diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp
index 61ca1904d52685..42edd023692c33 100644
--- a/clang/lib/CodeGen/CodeGenAction.cpp
+++ b/clang/lib/CodeGen/CodeGenAction.cpp
@@ -177,6 +177,34 @@ bool BackendConsumer::LinkInModules(llvm::Module *M) {
 }
 
 void BackendConsumer::HandleTranslationUnit(ASTContext &C) {
+  if (LangOpts.HLSL && C.getTranslationUnitDecl()->hasAttr<HLSLPreciseAttr>() &&
+      !Diags.hasErrorOccurred()) {
+    auto &Opts = CI.getLangOpts();
+    bool SupportsStrictFP = CI.getTarget().hasStrictFP() || Opts.ExpStrictFP;
+    auto ExceptionMode =
+        SupportsStrictFP ? LangOptions::FPE_Strict : LangOptions::FPE_Ignore;
+    bool AlreadyStrict =
+        Opts.getDefaultFPContractMode() == LangOptions::FPM_Off &&
+        Opts.getComplexRange() == LangOptions::CX_Full &&
+        Opts.RoundingMath == SupportsStrictFP &&
+        Opts.getFPExceptionMode() == ExceptionMode;
+
+    // Match -Gis, including the target's existing strict-FP fallback.
+    Opts.MathErrno = true;
+    Opts.setDefaultFPContractMode(LangOptions::FPM_Off);
+    Opts.setComplexRange(LangOptions::CX_Full);
+    if (!AlreadyStrict) {
+      Opts.RoundingMath = true;
+      Opts.setFPExceptionMode(LangOptions::FPE_Strict);
+      if (!SupportsStrictFP) {
+        Diags.Report(diag::warn_fe_backend_unsupported_fp_rounding);
+        Opts.RoundingMath = false;
+        Diags.Report(diag::warn_fe_backend_unsupported_fp_exceptions);
+        Opts.setFPExceptionMode(LangOptions::FPE_Ignore);
+      }
+    }
+  }
+
   {
     llvm::TimeTraceScope TimeScope("Frontend");
     PrettyStackTraceString CrashInfo("Per-file LLVM IR generation");
diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
index e5bca359e6a855..92ef97fb1f1786 100644
--- a/clang/lib/CodeGen/CodeGenFunction.cpp
+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -1105,9 +1105,11 @@ void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
       ToConstrainedExceptMD(getLangOpts().getDefaultExceptionMode());
   Builder.setDefaultConstrainedRounding(RM);
   Builder.setDefaultConstrainedExcept(FPExceptionBehavior);
+  bool HLSLPrecise =
+      CGM.getContext().getTranslationUnitDecl()->hasAttr<HLSLPreciseAttr>();
   if ((FD && (FD->UsesFPIntrin() || FD->hasAttr<StrictFPAttr>())) ||
-      (!FD && (FPExceptionBehavior != llvm::fp::ebIgnore ||
-               RM != llvm::RoundingMode::NearestTiesToEven))) {
+      ((!FD || HLSLPrecise) && (FPExceptionBehavior != llvm::fp::ebIgnore ||
+                                RM != llvm::RoundingMode::NearestTiesToEven))) {
     Builder.setIsFPConstrained(true);
     Fn->addFnAttr(llvm::Attribute::StrictFP);
   }
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index 395bfbefdaee95..667d62b8393735 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -2919,7 +2919,10 @@ void SemaHLSL::handleParamModifierAttr(Decl *D, const ParsedAttr &AL) {
 }
 
 void SemaHLSL::handlePreciseAttr(Decl *D, const ParsedAttr &AL) {
-  PreciseUsed = true;
+  auto *TU = getASTContext().getTranslationUnitDecl();
+  if (!TU->hasAttr<HLSLPreciseAttr>())
+    TU->addAttr(HLSLPreciseAttr::CreateImplicit(getASTContext()));
+
   HLSLPreciseAttr *NewAttr = HLSLPreciseAttr::Create(getASTContext(), AL);
   if (NewAttr)
     D->addAttr(NewAttr);
diff --git a/clang/test/AST/HLSL/precise.hlsl b/clang/test/AST/HLSL/precise.hlsl
index 6b436d05f39e61..ebca20e65c48d8 100644
--- a/clang/test/AST/HLSL/precise.hlsl
+++ b/clang/test/AST/HLSL/precise.hlsl
@@ -1,6 +1,9 @@
 // RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -std=hlsl202x -finclude-default-header -ast-dump -verify %s | FileCheck %s
 // expected-no-diagnostics
 
+// CHECK-LABEL: TranslationUnitDecl
+// CHECK-NEXT: HLSLPreciseAttr {{.*}} Implicit
+
 // CHECK-LABEL: TypedefDecl {{.*}} pfloat 'float'
 // CHECK-NEXT: BuiltinType {{.*}} 'float'
 // CHECK-NEXT: HLSLPreciseAttr
diff --git a/clang/test/CodeGenHLSL/precise.hlsl b/clang/test/CodeGenHLSL/precise.hlsl
new file mode 100644
index 00000000000000..d20c5913be0a10
--- /dev/null
+++ b/clang/test/CodeGenHLSL/precise.hlsl
@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -ffp-contract=on -disable-llvm-passes -emit-llvm -verify=precise -o %t.precise.ll %s
+// RUN: FileCheck %s --check-prefix=PRECISE --implicit-check-not=llvm.fmuladd --implicit-check-not=llvm.experimental.constrained < %t.precise.ll
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -ffp-contract=off -fmath-errno -frounding-math -ffp-exception-behavior=strict -complex-range=full -disable-llvm-passes -emit-llvm -verify=precise -o %t.strict.ll %s
+// RUN: diff %t.precise.ll %t.strict.ll
+
+// precise-warning@* {{overriding currently unsupported rounding mode on this target}}
+// precise-warning@* {{overriding currently unsupported use of floating point exceptions on this target}}
+
+// PRECISE-LABEL: define {{.*}} @_Z5firstfff(
+// PRECISE: fmul reassoc nnan ninf nsz arcp afn float
+// PRECISE: fadd reassoc nnan ninf nsz arcp afn float
+float first(float a, float b, float c) {
+  return a * b + c;
+}
+
+// PRECISE-LABEL: define {{.*}} @_Z4lastfff(
+// PRECISE: fmul reassoc nnan ninf nsz arcp afn float
+// PRECISE: fadd reassoc nnan ninf nsz arcp afn float
+float last(float a, float b, float c) {
+  return a * b + c;
+}
+
+void marker() {
+  precise float unused;
+}

>From 83da5f72b8fa16f41c3a6b0b36ef8fe53ca21478 Mon Sep 17 00:00:00 2001
From: Sarah Spall <sarahspall at microsoft.com>
Date: Wed, 21 Oct 2026 17:11:05 -0700
Subject: [PATCH 05/10] updates from copilot review

---
 clang/include/clang/Basic/AttrDocs.td      |  4 ++--
 clang/lib/CodeGen/CGCall.cpp               | 10 +++++++--
 clang/lib/CodeGen/CodeGenAction.cpp        | 20 ++++++++++++++++-
 clang/lib/CodeGen/ModuleBuilder.cpp        |  7 +++++-
 clang/lib/Sema/SemaHLSL.cpp                |  4 +---
 clang/test/CodeGenHLSL/precise-unused.hlsl | 26 ++++++++++++++++++++++
 6 files changed, 62 insertions(+), 9 deletions(-)
 create mode 100644 clang/test/CodeGenHLSL/precise-unused.hlsl

diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td
index 5088cd7373a10c..821ee53958453d 100644
--- a/clang/include/clang/Basic/AttrDocs.td
+++ b/clang/include/clang/Basic/AttrDocs.td
@@ -9769,8 +9769,8 @@ contributing to their values are performed with IEEE-strict semantics.
 
 Clang currently implements a simplified version of ``precise``: if the keyword
 is used anywhere in a translation unit, the whole translation unit is compiled
-in IEEE-strict floating-point mode, as if ``-Gis`` (``-ffp-model=strict``) had
-been specified.
+in IEEE-strict floating-point mode, as if ``-Gis`` (``-ffp-model=strict``) and
+``-fno-fast-math`` had been specified.
 
 The full documentation is available here: https://learn.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-variable-syntax
   }];
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index bc942d8a6246f7..23d36a46888225 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -6292,7 +6292,11 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
   }
 
   if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurFuncDecl)) {
-    if (FD->hasAttr<StrictFPAttr>())
+    // HLSL `precise` makes the function strictfp after Sema decided whether to
+    // add StrictFPAttr, so also check the emitted function.
+    if (FD->hasAttr<StrictFPAttr>() ||
+        (getContext().getTranslationUnitDecl()->hasAttr<HLSLPreciseAttr>() &&
+         CurFn->hasFnAttribute(llvm::Attribute::StrictFP)))
       // All calls within a strictfp function are marked strictfp
       Attrs = Attrs.addFnAttribute(getLLVMContext(), llvm::Attribute::StrictFP);
 
@@ -6381,7 +6385,9 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
   EmitPointerAuthOperandBundle(ConcreteCallee.getPointerAuthInfo(), BundleList);
 
   if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurFuncDecl))
-    if (FD->hasAttr<StrictFPAttr>())
+    if (FD->hasAttr<StrictFPAttr>() ||
+        (getContext().getTranslationUnitDecl()->hasAttr<HLSLPreciseAttr>() &&
+         CurFn->hasFnAttribute(llvm::Attribute::StrictFP)))
       // All calls within a strictfp function are marked strictfp
       Attrs = Attrs.addFnAttribute(getLLVMContext(), llvm::Attribute::StrictFP);
 
diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp
index 42edd023692c33..bc49559e53fccd 100644
--- a/clang/lib/CodeGen/CodeGenAction.cpp
+++ b/clang/lib/CodeGen/CodeGenAction.cpp
@@ -177,7 +177,11 @@ bool BackendConsumer::LinkInModules(llvm::Module *M) {
 }
 
 void BackendConsumer::HandleTranslationUnit(ASTContext &C) {
-  if (LangOpts.HLSL && C.getTranslationUnitDecl()->hasAttr<HLSLPreciseAttr>() &&
+  // If HLSL `precise` appears anywhere in the TU, compile the whole TU as if
+  // -ffp-model=strict (-Gis) had been specified. This is only sound because
+  // CodeGeneratorImpl defers all HLSL emission until HandleTranslationUnit;
+  // see DeferEmission in ModuleBuilder.cpp.
+  if (C.getTranslationUnitDecl()->hasAttr<HLSLPreciseAttr>() &&
       !Diags.hasErrorOccurred()) {
     auto &Opts = CI.getLangOpts();
     bool SupportsStrictFP = CI.getTarget().hasStrictFP() || Opts.ExpStrictFP;
@@ -190,12 +194,26 @@ void BackendConsumer::HandleTranslationUnit(ASTContext &C) {
         Opts.getFPExceptionMode() == ExceptionMode;
 
     // Match -Gis, including the target's existing strict-FP fallback.
+    // Sema has already consulted MathErrno (e.g. to mark libm builtins const).
+    // This is consistent because the HLSL driver already passes -fmath-errno by
+    // default; it has no effect on HLSL intrinsics.
     Opts.MathErrno = true;
     Opts.setDefaultFPContractMode(LangOptions::FPM_Off);
     Opts.setComplexRange(LangOptions::CX_Full);
+    // HLSL enables -ffast-math by default; precise must not allow lossy FP
+    // optimizations, so clear it and every option it implies.
+    Opts.FastMath = false;
+    Opts.UnsafeFPMath = false;
+    Opts.AllowFPReassoc = false;
+    Opts.NoHonorNaNs = false;
+    Opts.NoHonorInfs = false;
+    Opts.NoSignedZero = false;
+    Opts.AllowRecip = false;
+    Opts.ApproxFunc = false;
     if (!AlreadyStrict) {
       Opts.RoundingMath = true;
       Opts.setFPExceptionMode(LangOptions::FPE_Strict);
+      // Mirrors the fallback in CompilerInstance::createTarget.
       if (!SupportsStrictFP) {
         Diags.Report(diag::warn_fe_backend_unsupported_fp_rounding);
         Opts.RoundingMath = false;
diff --git a/clang/lib/CodeGen/ModuleBuilder.cpp b/clang/lib/CodeGen/ModuleBuilder.cpp
index 993db9f3d2fafc..e015ff152dc76b 100644
--- a/clang/lib/CodeGen/ModuleBuilder.cpp
+++ b/clang/lib/CodeGen/ModuleBuilder.cpp
@@ -67,7 +67,12 @@ namespace {
     std::unique_ptr<CodeGen::CodeGenModule> Builder;
     SmallVector<FunctionDecl *, 8> DeferredInlineMemberFuncDefs;
 
-    // HLSL emission must observe the final translation-unit-wide Sema state.
+    // HLSL emission is deferred until HandleTranslationUnit so that it observes
+    // the final translation-unit-wide Sema state. In particular, if the
+    // `precise` keyword appears anywhere in the TU, the whole TU is compiled in
+    // strict FP mode (see BackendConsumer::HandleTranslationUnit). Because the
+    // keyword may appear after functions that would otherwise already have
+    // been emitted, every HLSL compile has to defer.
     bool DeferEmission = false;
     SmallVector<std::function<void()>, 8> DeferredCallbacks;
 
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index 667d62b8393735..060125d7d28dda 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -2923,9 +2923,7 @@ void SemaHLSL::handlePreciseAttr(Decl *D, const ParsedAttr &AL) {
   if (!TU->hasAttr<HLSLPreciseAttr>())
     TU->addAttr(HLSLPreciseAttr::CreateImplicit(getASTContext()));
 
-  HLSLPreciseAttr *NewAttr = HLSLPreciseAttr::Create(getASTContext(), AL);
-  if (NewAttr)
-    D->addAttr(NewAttr);
+  D->addAttr(HLSLPreciseAttr::Create(getASTContext(), AL));
 }
 
 static bool isMatrixType(QualType QT) {
diff --git a/clang/test/CodeGenHLSL/precise-unused.hlsl b/clang/test/CodeGenHLSL/precise-unused.hlsl
new file mode 100644
index 00000000000000..6812540dd5e856
--- /dev/null
+++ b/clang/test/CodeGenHLSL/precise-unused.hlsl
@@ -0,0 +1,26 @@
+// `precise` marks the whole translation unit as precise even when the
+// declaration it appears on is never used or never instantiated. Each case is
+// compiled separately so one cannot mask the other.
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -DTEMPLATE -disable-llvm-passes -emit-llvm -verify -o - %s | FileCheck %s --implicit-check-not=llvm.fmuladd --implicit-check-not=no-signed-zeros-fp-math
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -DTYPEDEF -disable-llvm-passes -emit-llvm -verify -o - %s | FileCheck %s --implicit-check-not=llvm.fmuladd --implicit-check-not=no-signed-zeros-fp-math
+
+// expected-warning@* {{overriding currently unsupported rounding mode on this target}}
+// expected-warning@* {{overriding currently unsupported use of floating point exceptions on this target}}
+
+#ifdef TEMPLATE
+template <typename T> T neverInstantiated(T a) {
+  precise T x = a;
+  return x;
+}
+#endif
+
+#ifdef TYPEDEF
+typedef precise float unused_precise_float;
+#endif
+
+// CHECK-LABEL: define {{.*}} @_Z1ffff(
+// CHECK: fmul float
+// CHECK: fadd float
+export float f(float a, float b, float c) {
+  return a * b + c;
+}

>From 2e635bafff9410a57bde3b842bef386e63bf23a8 Mon Sep 17 00:00:00 2001
From: Sarah Spall <sarahspall at microsoft.com>
Date: Wed, 21 Oct 2026 17:25:39 -0700
Subject: [PATCH 06/10] missed file

---
 clang/test/CodeGenHLSL/precise.hlsl | 45 +++++++++++++++++++++++++----
 1 file changed, 39 insertions(+), 6 deletions(-)

diff --git a/clang/test/CodeGenHLSL/precise.hlsl b/clang/test/CodeGenHLSL/precise.hlsl
index d20c5913be0a10..a716422587ca00 100644
--- a/clang/test/CodeGenHLSL/precise.hlsl
+++ b/clang/test/CodeGenHLSL/precise.hlsl
@@ -1,25 +1,58 @@
+// `precise` must match explicit strict flags plus -fno-fast-math, because HLSL
+// enables fast math by default and precise disables it.
 // RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -ffp-contract=on -disable-llvm-passes -emit-llvm -verify=precise -o %t.precise.ll %s
-// RUN: FileCheck %s --check-prefix=PRECISE --implicit-check-not=llvm.fmuladd --implicit-check-not=llvm.experimental.constrained < %t.precise.ll
-// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -ffp-contract=off -fmath-errno -frounding-math -ffp-exception-behavior=strict -complex-range=full -disable-llvm-passes -emit-llvm -verify=precise -o %t.strict.ll %s
+// RUN: FileCheck %s --check-prefix=PRECISE --implicit-check-not=llvm.fmuladd --implicit-check-not=llvm.experimental.constrained --implicit-check-not=no-signed-zeros-fp-math < %t.precise.ll
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -ffp-contract=off -fmath-errno -frounding-math -ffp-exception-behavior=strict -complex-range=full -fno-fast-math -disable-llvm-passes -emit-llvm -verify=precise -o %t.strict.ll %s
 // RUN: diff %t.precise.ll %t.strict.ll
 
+// Targets with strict-FP support: `precise` must also make every function use
+// constrained intrinsics and strictfp, matching explicit strict flags.
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -fexperimental-strict-floating-point -ffp-contract=on -disable-llvm-passes -emit-llvm -verify=xstrict -o %t.xprecise.ll %s
+// RUN: FileCheck %s --check-prefix=XPRECISE < %t.xprecise.ll
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -fexperimental-strict-floating-point -ffp-contract=off -fmath-errno -frounding-math -ffp-exception-behavior=strict -complex-range=full -fno-fast-math -disable-llvm-passes -emit-llvm -verify=xstrict -o %t.xstrict.ll %s
+// RUN: diff %t.xprecise.ll %t.xstrict.ll
+
+// xstrict-no-diagnostics
+
 // precise-warning@* {{overriding currently unsupported rounding mode on this target}}
 // precise-warning@* {{overriding currently unsupported use of floating point exceptions on this target}}
 
 // PRECISE-LABEL: define {{.*}} @_Z5firstfff(
-// PRECISE: fmul reassoc nnan ninf nsz arcp afn float
-// PRECISE: fadd reassoc nnan ninf nsz arcp afn float
+// PRECISE: fmul float
+// PRECISE: fadd float
+// XPRECISE: define {{.*}} @_Z5firstfff({{.*}}) #[[ATTR:[0-9]+]]
+// XPRECISE: call float @llvm.experimental.constrained.fmul.f32
+// XPRECISE: call float @llvm.experimental.constrained.fadd.f32
 float first(float a, float b, float c) {
   return a * b + c;
 }
 
 // PRECISE-LABEL: define {{.*}} @_Z4lastfff(
-// PRECISE: fmul reassoc nnan ninf nsz arcp afn float
-// PRECISE: fadd reassoc nnan ninf nsz arcp afn float
+// PRECISE: fmul float
+// PRECISE: fadd float
 float last(float a, float b, float c) {
   return a * b + c;
 }
 
+// Inline member functions are handed to codegen separately, via
+// HandleInlineFunctionDefinition, as soon as the class is complete.
+struct S {
+  float m(float a, float b, float c) { return a * b + c; }
+};
+
+export float callMember(S s, float a, float b, float c) {
+  return s.m(a, b, c);
+}
+
+// PRECISE-LABEL: define {{.*}} @_ZN1S1mEfff(
+// PRECISE: fmul float
+// PRECISE: fadd float
+// XPRECISE: define {{.*}} @_ZN1S1mEfff({{.*}}) #[[ATTR]]
+// XPRECISE: call float @llvm.experimental.constrained.fmul.f32
+// XPRECISE: call float @llvm.experimental.constrained.fadd.f32
+
 void marker() {
   precise float unused;
 }
+
+// XPRECISE: attributes #[[ATTR]] = {{{.*}}strictfp

>From 4b3904bbf33abdb9a7205770fe02216ff6308729 Mon Sep 17 00:00:00 2001
From: Sarah Spall <sarahspall at microsoft.com>
Date: Wed, 21 Oct 2026 18:03:52 -0700
Subject: [PATCH 07/10] updates from an additional copilot review

---
 clang/include/clang/Sema/SemaHLSL.h           |  4 ++
 clang/lib/Sema/SemaChecking.cpp               | 44 +++++++++++++------
 clang/lib/Sema/SemaHLSL.cpp                   | 12 +++++
 .../test/SemaHLSL/precise-fp-diagnostics.hlsl | 35 +++++++++++++++
 4 files changed, 82 insertions(+), 13 deletions(-)
 create mode 100644 clang/test/SemaHLSL/precise-fp-diagnostics.hlsl

diff --git a/clang/include/clang/Sema/SemaHLSL.h b/clang/include/clang/Sema/SemaHLSL.h
index fa55337c6c221d..cc3dc6b9f123b5 100644
--- a/clang/include/clang/Sema/SemaHLSL.h
+++ b/clang/include/clang/Sema/SemaHLSL.h
@@ -18,6 +18,7 @@
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/DiagnosticSema.h"
+#include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Sema/SemaBase.h"
 #include "llvm/ADT/ArrayRef.h"
@@ -192,6 +193,7 @@ class SemaHLSL : public SemaBase {
   void handleResourceBindingAttr(Decl *D, const ParsedAttr &AL);
   void handleParamModifierAttr(Decl *D, const ParsedAttr &AL);
   void handlePreciseAttr(Decl *D, const ParsedAttr &AL);
+  void deferFPNaNInfDiagnostic(const CallExpr *Call, bool IsNaN);
   void handleInterpolationModifierAttr(Decl *D, const ParsedAttr &AL);
   Attr *buildMatrixLayoutTypeAttr(QualType T, const ParsedAttr &AL);
   bool diagnoseMatrixLayoutInstantiation(attr::Kind K, QualType T,
@@ -245,6 +247,8 @@ class SemaHLSL : public SemaBase {
   bool initGlobalResourceArrayDecl(VarDecl *VD);
 
 private:
+  llvm::SmallVector<PartialDiagnosticAt> DeferredFPNaNInfDiagnostics;
+
   // HLSL resource type attributes need to be processed all at once.
   // This is a list to collect them.
   llvm::SmallVector<const Attr *> HLSLResourcesTypeAttrs;
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index 51506c62d4e35f..f1e6fa361aaa72 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -6495,9 +6495,13 @@ bool Sema::BuiltinUnorderedCompare(CallExpr *TheCall, unsigned BuiltinID) {
     return true;
 
   if (BuiltinID == Builtin::BI__builtin_isunordered &&
-      TheCall->getFPFeaturesInEffect(getLangOpts()).getNoHonorNaNs())
-    Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
-        << 1 << 0 << TheCall->getSourceRange();
+      TheCall->getFPFeaturesInEffect(getLangOpts()).getNoHonorNaNs()) {
+    if (getLangOpts().HLSL)
+      HLSL().deferFPNaNInfDiagnostic(TheCall, /*IsNaN=*/true);
+    else
+      Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
+          << 1 << 0 << TheCall->getSourceRange();
+  }
 
   ExprResult OrigArg0 = TheCall->getArg(0);
   ExprResult OrigArg1 = TheCall->getArg(1);
@@ -6538,14 +6542,22 @@ bool Sema::BuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs,
   FPOptions FPO = TheCall->getFPFeaturesInEffect(getLangOpts());
   if (FPO.getNoHonorInfs() && (BuiltinID == Builtin::BI__builtin_isfinite ||
                                BuiltinID == Builtin::BI__builtin_isinf ||
-                               BuiltinID == Builtin::BI__builtin_isinf_sign))
-    Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
-        << 0 << 0 << TheCall->getSourceRange();
+                               BuiltinID == Builtin::BI__builtin_isinf_sign)) {
+    if (getLangOpts().HLSL)
+      HLSL().deferFPNaNInfDiagnostic(TheCall, /*IsNaN=*/false);
+    else
+      Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
+          << 0 << 0 << TheCall->getSourceRange();
+  }
 
   if (FPO.getNoHonorNaNs() && (BuiltinID == Builtin::BI__builtin_isnan ||
-                               BuiltinID == Builtin::BI__builtin_isunordered))
-    Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
-        << 1 << 0 << TheCall->getSourceRange();
+                               BuiltinID == Builtin::BI__builtin_isunordered)) {
+    if (getLangOpts().HLSL)
+      HLSL().deferFPNaNInfDiagnostic(TheCall, /*IsNaN=*/true);
+    else
+      Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
+          << 1 << 0 << TheCall->getSourceRange();
+  }
 
   bool IsFPClass = NumArgs == 2;
 
@@ -10779,8 +10791,11 @@ void Sema::CheckInfNaNFunction(const CallExpr *Call,
   if (FPO.getNoHonorNaNs() &&
       (IsStdFunction(FDecl, "isnan") || IsStdFunction(FDecl, "isunordered") ||
        IsInfOrNanFunction(FDecl->getName(), MathCheck::NaN))) {
-    Diag(Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
-        << 1 << 0 << Call->getSourceRange();
+    if (getLangOpts().HLSL)
+      HLSL().deferFPNaNInfDiagnostic(Call, /*IsNaN=*/true);
+    else
+      Diag(Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
+          << 1 << 0 << Call->getSourceRange();
     return;
   }
 
@@ -10788,8 +10803,11 @@ void Sema::CheckInfNaNFunction(const CallExpr *Call,
       (IsStdFunction(FDecl, "isinf") || IsStdFunction(FDecl, "isfinite") ||
        IsInfinityFunction(FDecl) ||
        IsInfOrNanFunction(FDecl->getName(), MathCheck::Inf))) {
-    Diag(Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
-        << 0 << 0 << Call->getSourceRange();
+    if (getLangOpts().HLSL)
+      HLSL().deferFPNaNInfDiagnostic(Call, /*IsNaN=*/false);
+    else
+      Diag(Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
+          << 0 << 0 << Call->getSourceRange();
   }
 }
 
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index 060125d7d28dda..677f4b13419b4c 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -2926,6 +2926,13 @@ void SemaHLSL::handlePreciseAttr(Decl *D, const ParsedAttr &AL) {
   D->addAttr(HLSLPreciseAttr::Create(getASTContext(), AL));
 }
 
+void SemaHLSL::deferFPNaNInfDiagnostic(const CallExpr *Call, bool IsNaN) {
+  // A later precise declaration can invalidate this fast-math diagnostic.
+  DeferredFPNaNInfDiagnostics.emplace_back(
+      Call->getBeginLoc(), PDiag(diag::warn_fp_nan_inf_when_disabled)
+                               << IsNaN << 0 << Call->getSourceRange());
+}
+
 static bool isMatrixType(QualType QT) {
   const Type *Ty = QT->getUnqualifiedDesugaredType();
   return Ty->isDependentType() || Ty->isConstantMatrixType();
@@ -3533,6 +3540,11 @@ void SemaHLSL::ActOnEndOfTranslationUnit(TranslationUnitDecl *TU) {
     SemaRef.Consumer.HandleTopLevelDecl(DG);
   }
   diagnoseAvailabilityViolations(TU);
+
+  if (!TU->hasAttr<HLSLPreciseAttr>())
+    for (const auto &D : DeferredFPNaNInfDiagnostics)
+      Diag(D.first, D.second);
+  DeferredFPNaNInfDiagnostics.clear();
 }
 
 // For resource member access through a global struct array, verify that the
diff --git a/clang/test/SemaHLSL/precise-fp-diagnostics.hlsl b/clang/test/SemaHLSL/precise-fp-diagnostics.hlsl
new file mode 100644
index 00000000000000..07dc5b1d330e80
--- /dev/null
+++ b/clang/test/SemaHLSL/precise-fp-diagnostics.hlsl
@@ -0,0 +1,35 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -fsyntax-only -Werror -DPRECISE_AFTER -verify=precise %s
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -fsyntax-only -Werror -verify=fast %s
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -fsyntax-only -Werror -fno-fast-math -verify=precise %s
+// precise-no-diagnostics
+
+bool check_nan(float x) {
+  return __builtin_isnan(x); // fast-error {{use of NaN is undefined behavior}}
+}
+
+bool check_inf(float x) {
+  return __builtin_isinf(x); // fast-error {{use of infinity is undefined behavior}}
+}
+
+bool check_unordered(float x, float y) {
+  return __builtin_isunordered(x, y); // fast-error {{use of NaN is undefined behavior}}
+}
+
+float make_nan() {
+  return __builtin_nanf(""); // fast-error {{use of NaN is undefined behavior}}
+}
+
+float make_inf() {
+  return __builtin_inff(); // fast-error {{use of infinity is undefined behavior}}
+}
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnan-infinity-disabled"
+bool ignored_nan(float x) {
+  return __builtin_isnan(x);
+}
+#pragma clang diagnostic pop
+
+#ifdef PRECISE_AFTER
+typedef precise float precise_after;
+#endif

>From 0673307746860113da64d6c5e67f4bb414b315ae Mon Sep 17 00:00:00 2001
From: Sarah Spall <sarahspall at microsoft.com>
Date: Tue, 27 Oct 2026 12:19:45 -0700
Subject: [PATCH 08/10] implement two small suggestions

---
 clang/lib/CodeGen/CodeGenAction.cpp | 4 +---
 clang/lib/Sema/SemaHLSL.cpp         | 4 ++--
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp
index bc49559e53fccd..48c7a842e590dd 100644
--- a/clang/lib/CodeGen/CodeGenAction.cpp
+++ b/clang/lib/CodeGen/CodeGenAction.cpp
@@ -178,9 +178,7 @@ bool BackendConsumer::LinkInModules(llvm::Module *M) {
 
 void BackendConsumer::HandleTranslationUnit(ASTContext &C) {
   // If HLSL `precise` appears anywhere in the TU, compile the whole TU as if
-  // -ffp-model=strict (-Gis) had been specified. This is only sound because
-  // CodeGeneratorImpl defers all HLSL emission until HandleTranslationUnit;
-  // see DeferEmission in ModuleBuilder.cpp.
+  // -ffp-model=strict (-Gis) had been specified.
   if (C.getTranslationUnitDecl()->hasAttr<HLSLPreciseAttr>() &&
       !Diags.hasErrorOccurred()) {
     auto &Opts = CI.getLangOpts();
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index 677f4b13419b4c..19b6a2d1f3c9ad 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -3542,8 +3542,8 @@ void SemaHLSL::ActOnEndOfTranslationUnit(TranslationUnitDecl *TU) {
   diagnoseAvailabilityViolations(TU);
 
   if (!TU->hasAttr<HLSLPreciseAttr>())
-    for (const auto &D : DeferredFPNaNInfDiagnostics)
-      Diag(D.first, D.second);
+    for (const auto &[Loc, PD] : DeferredFPNaNInfDiagnostics)
+      Diag(Loc, PD);
   DeferredFPNaNInfDiagnostics.clear();
 }
 

>From 0ead833a3f34de6d9b0f0d175d1ef2684cc04126 Mon Sep 17 00:00:00 2001
From: Sarah Spall <sarahspall at microsoft.com>
Date: Mon, 2 Nov 2026 09:04:48 -0800
Subject: [PATCH 09/10] move code to cghlslruntime

---
 clang/lib/CodeGen/CGHLSLRuntime.cpp | 46 +++++++++++++++++++++++++++++
 clang/lib/CodeGen/CGHLSLRuntime.h   |  2 ++
 clang/lib/CodeGen/CodeGenAction.cpp | 46 ++---------------------------
 3 files changed, 51 insertions(+), 43 deletions(-)

diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp b/clang/lib/CodeGen/CGHLSLRuntime.cpp
index 35a31942c3b591..df220347b8c3f7 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.cpp
+++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp
@@ -29,6 +29,7 @@
 #include "clang/Basic/DiagnosticDriver.h"
 #include "clang/Basic/DiagnosticFrontend.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Enum.h"
@@ -999,6 +1000,51 @@ void CGHLSLRuntime::addHLSLBufferLayoutType(const RecordType *StructType,
   LayoutTypes[StructType] = LayoutTy;
 }
 
+void CGHLSLRuntime::setPreciseFPOptions(LangOptions &Opts) {
+  // If HLSL `precise` appears anywhere in the TU, compile the whole TU as if
+  // -ffp-model=strict (-Gis) had been specified.
+  if (!CGM.getContext().getTranslationUnitDecl()->hasAttr<HLSLPreciseAttr>())
+    return;
+
+  bool SupportsStrictFP = CGM.getTarget().hasStrictFP() || Opts.ExpStrictFP;
+  auto ExceptionMode =
+      SupportsStrictFP ? LangOptions::FPE_Strict : LangOptions::FPE_Ignore;
+  bool AlreadyStrict =
+      Opts.getDefaultFPContractMode() == LangOptions::FPM_Off &&
+      Opts.getComplexRange() == LangOptions::CX_Full &&
+      Opts.RoundingMath == SupportsStrictFP &&
+      Opts.getFPExceptionMode() == ExceptionMode;
+
+  // Match -Gis, including the target's existing strict-FP fallback.
+  // Sema has already consulted MathErrno (e.g. to mark libm builtins const).
+  // This is consistent because the HLSL driver already passes -fmath-errno by
+  // default; it has no effect on HLSL intrinsics.
+  Opts.MathErrno = true;
+  Opts.setDefaultFPContractMode(LangOptions::FPM_Off);
+  Opts.setComplexRange(LangOptions::CX_Full);
+  // HLSL enables -ffast-math by default; precise must not allow lossy FP
+  // optimizations, so clear it and every option it implies.
+  Opts.FastMath = false;
+  Opts.UnsafeFPMath = false;
+  Opts.AllowFPReassoc = false;
+  Opts.NoHonorNaNs = false;
+  Opts.NoHonorInfs = false;
+  Opts.NoSignedZero = false;
+  Opts.AllowRecip = false;
+  Opts.ApproxFunc = false;
+  if (!AlreadyStrict) {
+    Opts.RoundingMath = true;
+    Opts.setFPExceptionMode(LangOptions::FPE_Strict);
+    // Mirrors the fallback in CompilerInstance::createTarget.
+    if (!SupportsStrictFP) {
+      CGM.getDiags().Report(diag::warn_fe_backend_unsupported_fp_rounding);
+      Opts.RoundingMath = false;
+      CGM.getDiags().Report(diag::warn_fe_backend_unsupported_fp_exceptions);
+      Opts.setFPExceptionMode(LangOptions::FPE_Ignore);
+    }
+  }
+}
+
 void CGHLSLRuntime::finishCodeGen() {
   auto &TargetOpts = CGM.getTarget().getTargetOpts();
   auto &CodeGenOpts = CGM.getCodeGenOpts();
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.h b/clang/lib/CodeGen/CGHLSLRuntime.h
index f845aff5f5b763..0f8b892e6a00a0 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.h
+++ b/clang/lib/CodeGen/CGHLSLRuntime.h
@@ -62,6 +62,7 @@ class Metadata;
 } // namespace llvm
 
 namespace clang {
+class LangOptions;
 class NamedDecl;
 class VarDecl;
 class ParmVarDecl;
@@ -317,6 +318,7 @@ class CGHLSLRuntime {
 
   void addBuffer(const HLSLBufferDecl *D);
   void addRootSignature(const HLSLRootSignatureDecl *D);
+  void setPreciseFPOptions(LangOptions &Opts);
   void finishCodeGen();
 
   void setHLSLEntryAttributes(const FunctionDecl *FD, llvm::Function *Fn);
diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp
index 48c7a842e590dd..9ce0f1598a4f36 100644
--- a/clang/lib/CodeGen/CodeGenAction.cpp
+++ b/clang/lib/CodeGen/CodeGenAction.cpp
@@ -9,6 +9,7 @@
 #include "clang/CodeGen/CodeGenAction.h"
 #include "BackendConsumer.h"
 #include "CGCall.h"
+#include "CGHLSLRuntime.h"
 #include "CodeGenModule.h"
 #include "CoverageMappingGen.h"
 #include "MacroPPCallbacks.h"
@@ -177,49 +178,8 @@ bool BackendConsumer::LinkInModules(llvm::Module *M) {
 }
 
 void BackendConsumer::HandleTranslationUnit(ASTContext &C) {
-  // If HLSL `precise` appears anywhere in the TU, compile the whole TU as if
-  // -ffp-model=strict (-Gis) had been specified.
-  if (C.getTranslationUnitDecl()->hasAttr<HLSLPreciseAttr>() &&
-      !Diags.hasErrorOccurred()) {
-    auto &Opts = CI.getLangOpts();
-    bool SupportsStrictFP = CI.getTarget().hasStrictFP() || Opts.ExpStrictFP;
-    auto ExceptionMode =
-        SupportsStrictFP ? LangOptions::FPE_Strict : LangOptions::FPE_Ignore;
-    bool AlreadyStrict =
-        Opts.getDefaultFPContractMode() == LangOptions::FPM_Off &&
-        Opts.getComplexRange() == LangOptions::CX_Full &&
-        Opts.RoundingMath == SupportsStrictFP &&
-        Opts.getFPExceptionMode() == ExceptionMode;
-
-    // Match -Gis, including the target's existing strict-FP fallback.
-    // Sema has already consulted MathErrno (e.g. to mark libm builtins const).
-    // This is consistent because the HLSL driver already passes -fmath-errno by
-    // default; it has no effect on HLSL intrinsics.
-    Opts.MathErrno = true;
-    Opts.setDefaultFPContractMode(LangOptions::FPM_Off);
-    Opts.setComplexRange(LangOptions::CX_Full);
-    // HLSL enables -ffast-math by default; precise must not allow lossy FP
-    // optimizations, so clear it and every option it implies.
-    Opts.FastMath = false;
-    Opts.UnsafeFPMath = false;
-    Opts.AllowFPReassoc = false;
-    Opts.NoHonorNaNs = false;
-    Opts.NoHonorInfs = false;
-    Opts.NoSignedZero = false;
-    Opts.AllowRecip = false;
-    Opts.ApproxFunc = false;
-    if (!AlreadyStrict) {
-      Opts.RoundingMath = true;
-      Opts.setFPExceptionMode(LangOptions::FPE_Strict);
-      // Mirrors the fallback in CompilerInstance::createTarget.
-      if (!SupportsStrictFP) {
-        Diags.Report(diag::warn_fe_backend_unsupported_fp_rounding);
-        Opts.RoundingMath = false;
-        Diags.Report(diag::warn_fe_backend_unsupported_fp_exceptions);
-        Opts.setFPExceptionMode(LangOptions::FPE_Ignore);
-      }
-    }
-  }
+  if (CI.getLangOpts().HLSL && !Diags.hasErrorOccurred())
+    Gen->CGM().getHLSLRuntime().setPreciseFPOptions(CI.getLangOpts());
 
   {
     llvm::TimeTraceScope TimeScope("Frontend");

>From c109b8ead5930f0e156f834139e62012e59c5c37 Mon Sep 17 00:00:00 2001
From: Sarah Spall <sarahspall at microsoft.com>
Date: Wed, 4 Nov 2026 12:57:56 -0800
Subject: [PATCH 10/10] use hlsl specific builtins

---
 clang/lib/Sema/SemaChecking.cpp                | 14 ++++----------
 clang/lib/Sema/SemaHLSL.cpp                    | 10 ++++++++++
 .../test/SemaHLSL/precise-fp-diagnostics.hlsl  | 18 +++---------------
 3 files changed, 17 insertions(+), 25 deletions(-)

diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index f1e6fa361aaa72..a1f06935c07ce1 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -6543,20 +6543,14 @@ bool Sema::BuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs,
   if (FPO.getNoHonorInfs() && (BuiltinID == Builtin::BI__builtin_isfinite ||
                                BuiltinID == Builtin::BI__builtin_isinf ||
                                BuiltinID == Builtin::BI__builtin_isinf_sign)) {
-    if (getLangOpts().HLSL)
-      HLSL().deferFPNaNInfDiagnostic(TheCall, /*IsNaN=*/false);
-    else
-      Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
-          << 0 << 0 << TheCall->getSourceRange();
+    Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
+        << 0 << 0 << TheCall->getSourceRange();
   }
 
   if (FPO.getNoHonorNaNs() && (BuiltinID == Builtin::BI__builtin_isnan ||
                                BuiltinID == Builtin::BI__builtin_isunordered)) {
-    if (getLangOpts().HLSL)
-      HLSL().deferFPNaNInfDiagnostic(TheCall, /*IsNaN=*/true);
-    else
-      Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
-          << 1 << 0 << TheCall->getSourceRange();
+    Diag(TheCall->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
+        << 1 << 0 << TheCall->getSourceRange();
   }
 
   bool IsFPClass = NumArgs == 2;
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index 19b6a2d1f3c9ad..ed9e0f2d4b21c1 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -5026,6 +5026,16 @@ bool SemaHLSL::CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
     if (SemaRef.PrepareBuiltinElementwiseMathOneArgCall(TheCall))
       return true;
     SetElementTypeAsReturnType(&SemaRef, TheCall, getASTContext().BoolTy);
+
+    FPOptions FPO = TheCall->getFPFeaturesInEffect(getLangOpts());
+    if (FPO.getNoHonorInfs() &&
+        (BuiltinID == Builtin::BI__builtin_hlsl_elementwise_isinf ||
+         BuiltinID == Builtin::BI__builtin_hlsl_elementwise_isfinite))
+      deferFPNaNInfDiagnostic(TheCall, /*IsNan=*/false);
+
+    if (FPO.getNoHonorNaNs() &&
+        BuiltinID == Builtin::BI__builtin_hlsl_elementwise_isnan)
+      deferFPNaNInfDiagnostic(TheCall, /*IsNan=*/true);
     break;
   }
   case Builtin::BI__builtin_hlsl_mad: {
diff --git a/clang/test/SemaHLSL/precise-fp-diagnostics.hlsl b/clang/test/SemaHLSL/precise-fp-diagnostics.hlsl
index 07dc5b1d330e80..45f9517395dee0 100644
--- a/clang/test/SemaHLSL/precise-fp-diagnostics.hlsl
+++ b/clang/test/SemaHLSL/precise-fp-diagnostics.hlsl
@@ -4,29 +4,17 @@
 // precise-no-diagnostics
 
 bool check_nan(float x) {
-  return __builtin_isnan(x); // fast-error {{use of NaN is undefined behavior}}
+  return __builtin_hlsl_elementwise_isnan(x); // fast-error {{use of NaN is undefined behavior}}
 }
 
 bool check_inf(float x) {
-  return __builtin_isinf(x); // fast-error {{use of infinity is undefined behavior}}
-}
-
-bool check_unordered(float x, float y) {
-  return __builtin_isunordered(x, y); // fast-error {{use of NaN is undefined behavior}}
-}
-
-float make_nan() {
-  return __builtin_nanf(""); // fast-error {{use of NaN is undefined behavior}}
-}
-
-float make_inf() {
-  return __builtin_inff(); // fast-error {{use of infinity is undefined behavior}}
+  return __builtin_hlsl_elementwise_isinf(x); // fast-error {{use of infinity is undefined behavior}}
 }
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wnan-infinity-disabled"
 bool ignored_nan(float x) {
-  return __builtin_isnan(x);
+  return __builtin_hlsl_elementwise_isnan(x);
 }
 #pragma clang diagnostic pop
 



More information about the cfe-commits mailing list