[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