[clang] c0005df - [Clang] Fix crash instantiating functions defaulted outside class templates (#240376)

via cfe-commits cfe-commits at lists.llvm.org
Sat Nov 14 07:40:03 PST 2026


Author: Muhammad Bassiouni
Date: 2026-11-14T17:39:58+02:00
New Revision: c0005dfe81fedaf852727b81a07d728f94ecfa2d

URL: https://github.com/llvm/llvm-project/commit/c0005dfe81fedaf852727b81a07d728f94ecfa2d
DIFF: https://github.com/llvm/llvm-project/commit/c0005dfe81fedaf852727b81a07d728f94ecfa2d.diff

LOG: [Clang] Fix crash instantiating functions defaulted outside class templates (#240376)

A function that is defaulted outside its class template is not defaulted
when its declaration is instantiated, so the instantiation of its
definition reuses the info recorded at its definition (#229560).
However, `SetDeclDefaulted` returned for such a pattern before recording
the floating-point features in effect there, so the pattern usually had
no info, and the transfer set the info bit with a null pointer. If
non-default floating-point features were in effect at the point of
instantiation, `SetDeclDefaulted` then tried to store them and asserted
that the function already had the info. Even without the crash, the
instantiation took the floating-point features in effect at its point of
instantiation rather than at its definition, which also crashed codegen
when those were strict but the function was not.

Fixes #240351

Added: 
    clang/test/SemaCXX/GH240351.cpp

Modified: 
    clang/lib/AST/Decl.cpp
    clang/lib/Sema/SemaDeclCXX.cpp
    clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
    clang/test/CodeGenCXX/defaulted-function-fp-features.cpp

Removed: 
    


################################################################################
diff  --git a/clang/lib/AST/Decl.cpp b/clang/lib/AST/Decl.cpp
index 87901d0a08a9a1..3fc5eed34dc617 100644
--- a/clang/lib/AST/Decl.cpp
+++ b/clang/lib/AST/Decl.cpp
@@ -3164,6 +3164,7 @@ FunctionDecl::DefaultedOrDeletedFunctionInfo::Create(
 
 void FunctionDecl::setDefaultedOrDeletedInfo(
     DefaultedOrDeletedFunctionInfo *Info) {
+  assert(Info && "expected defaulted or deleted function info");
   assert(!FunctionDeclBits.HasDefaultedOrDeletedInfo && "already have this");
   assert(!Body && "can't replace function body with defaulted function info");
 

diff  --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index cd021c660bf7be..62cbcc03ea42fe 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -19542,15 +19542,24 @@ void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc, Scope *S) {
 
   // Defer checking functions that are defaulted in a dependent context.
   if (FD->isDependentContext()) {
-    // The unqualified lookup of the prefix operator for a postfix operator
-    // defaulted outside its class can only be performed now, while we have the
-    // scope of the function-body. Instantiation reuses its result. (When it is
-    // defaulted in its class, the lookup is performed once the class is
-    // complete.)
-    if (DefKind.isPostfixOperator() &&
-        !isa<CXXRecordDecl>(FD->getLexicalDeclContext()))
-      CheckExplicitlyDefaultedPostfixOperator(S, FD,
-                                              DefKind.asPostfixOperator());
+    // A function defaulted outside its class is not defaulted when its
+    // declaration is instantiated, so record what the instantiation of its
+    // definition needs from here: the floating-point features in effect and,
+    // for a postfix operator, the unqualified lookup of the prefix operator,
+    // which can only be performed now, while we have the scope of the
+    // function-body. The info is recorded even for default floating-point
+    // features, so that the instantiation does not take those in effect at its
+    // point of instantiation. (When the function is defaulted in its class,
+    // the lookup is performed once the class is complete.)
+    if (!isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
+      if (DefKind.isPostfixOperator())
+        CheckExplicitlyDefaultedPostfixOperator(S, FD,
+                                                DefKind.asPostfixOperator());
+      else if (!FD->getDefaultedOrDeletedInfo())
+        FD->setDefaultedOrDeletedInfo(
+            FunctionDecl::DefaultedOrDeletedFunctionInfo::Create(
+                Context, /*Lookups=*/{}, CurFPFeatureOverrides()));
+    }
     return;
   }
 
@@ -19582,8 +19591,10 @@ void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc, Scope *S) {
 
   // Only allocate DefaultedOrDeletedFunctionInfo if we actually have
   // non-default FP features to stash. This avoids memory overhead for
-  // the vast majority of defaulted functions.
-  if (!FD->getDefaultedOrDeletedInfo() &&
+  // the vast majority of defaulted functions. A postfix operator defaulted
+  // with a scope gets its info, which includes these features, when the
+  // lookup of its prefix operator is performed below.
+  if (!FD->getDefaultedOrDeletedInfo() && !(DefKind.isPostfixOperator() && S) &&
       CurFPFeatureOverrides().requiresTrailingStorage()) {
     FD->setDefaultedOrDeletedInfo(
         FunctionDecl::DefaultedOrDeletedFunctionInfo::Create(

diff  --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
index a4ce596c7bfb1e..ead896eaa303c4 100644
--- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -6270,12 +6270,13 @@ void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
   if (PatternDecl->isDefaulted()) {
     RebuildTypeSourceInfoForDefaultSpecialMembers();
     // A function defaulted outside its class was not defaulted when its
-    // declaration was instantiated, so transfer the unqualified lookups
-    // performed at its definition now. They were performed from namespace
-    // scope, so they don't need to be instantiated.
+    // declaration was instantiated, so transfer the info recorded at its
+    // definition now: the floating-point features in effect there, and any
+    // unqualified lookups, which were performed from namespace scope and so
+    // don't need to be instantiated.
     if (!Function->getDefaultedOrDeletedInfo())
-      Function->setDefaultedOrDeletedInfo(
-          PatternDecl->getDefaultedOrDeletedInfo());
+      if (auto *DFI = PatternDecl->getDefaultedOrDeletedInfo())
+        Function->setDefaultedOrDeletedInfo(DFI);
     SetDeclDefaulted(Function, PatternDecl->getLocation());
   } else {
     DeclContext *DC = Function->getLexicalDeclContext();

diff  --git a/clang/test/CodeGenCXX/defaulted-function-fp-features.cpp b/clang/test/CodeGenCXX/defaulted-function-fp-features.cpp
index 3da4aa6976677b..563448d1959a2a 100644
--- a/clang/test/CodeGenCXX/defaulted-function-fp-features.cpp
+++ b/clang/test/CodeGenCXX/defaulted-function-fp-features.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux -std=c++20 -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux -std=c++20 -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,OGCG
 // RUN: %if cir-enabled %{ %clang_cc1 -fclangir -triple x86_64-unknown-linux -std=c++20 -emit-llvm -o - %s | FileCheck %s %}
 
 // CHECK-DAG: define {{.*}} @_ZeqRK6TargetS1_({{.*}}) [[NORMAL_ATTRS:#[0-9]+]]
@@ -11,6 +11,12 @@
 // CHECK-DAG: define {{.*}} @_ZeqRK14TemplateTargetIfES2_({{.*}}) [[NORMAL_ATTRS]]
 // CHECK-DAG: define {{.*}} @_ZeqRK20StrictTemplateTargetIdES2_({{.*}}) [[STRICT_ATTRS]]
 
+// Templates defaulted outside the class
+// CHECK-DAG: define {{.*}} @_ZNK15OutOfLineTargetIeEeqERKS0_({{.*}}) [[NORMAL_ATTRS]]
+// CHECK-DAG: fcmp oeq x86_fp80
+// CHECK-DAG: define {{.*}} @_ZNK21StrictOutOfLineTargetIeEeqERKS0_({{.*}}) [[STRICT_ATTRS]]
+// OGCG-DAG: call i1 @llvm.experimental.constrained.fcmp.f80({{.*}}, metadata !"fpexcept.strict")
+
 // --- NON-STRICT DECLARATIONS (at top of file, default FP is non-strict) ---
 
 struct Target {
@@ -36,6 +42,15 @@ struct TemplateTarget {
   friend bool operator==(const TemplateTarget&, const TemplateTarget&) = default;
 };
 
+template <typename T>
+struct OutOfLineTarget {
+  T d;
+  bool operator==(const OutOfLineTarget&) const;
+};
+
+template <typename T>
+bool OutOfLineTarget<T>::operator==(const OutOfLineTarget&) const = default;
+
 // Trigger instantiation of TemplateTarget<double>::operator== in non-strict context.
 bool test_template_non_strict(TemplateTarget<double> a, TemplateTarget<double> b) {
   return a == b;
@@ -61,6 +76,10 @@ bool test_template_strict(TemplateTarget<float> a, TemplateTarget<float> b) {
   return a == b;
 }
 
+// Instantiate OutOfLineTarget<long double>::operator== in strict context.
+// It should still be non-strict because it was defaulted in non-strict context.
+template bool OutOfLineTarget<long double>::operator==(const OutOfLineTarget<long double>&) const;
+
 // Strict declarations (must get strictfp)
 
 struct StrictTarget {
@@ -87,6 +106,16 @@ struct StrictTemplateTarget {
 };
 
 
+template <typename T>
+struct StrictOutOfLineTarget {
+  T d;
+  bool operator==(const StrictOutOfLineTarget&) const;
+};
+
+template <typename T>
+bool StrictOutOfLineTarget<T>::operator==(const StrictOutOfLineTarget&) const = default;
+
+
 // --- NON-STRICT CONTEXT AGAIN ---
 #pragma STDC FENV_ACCESS OFF
 
@@ -96,6 +125,12 @@ bool test_strict_template_non_strict(StrictTemplateTarget<double> a, StrictTempl
   return a == b;
 }
 
+// Trigger instantiation of StrictOutOfLineTarget<long double>::operator== in non-strict context.
+// It should be strict because it was defaulted in strict context.
+bool test_strict_out_of_line_non_strict(StrictOutOfLineTarget<long double> a, StrictOutOfLineTarget<long double> b) {
+  return a == b;
+}
+
 
 // CHECK-DAG: attributes [[STRICT_ATTRS]] = { {{.*}}strictfp{{.*}} }
 // CHECK-DAG: attributes [[NORMAL_ATTRS]] = { {{.*}} }

diff  --git a/clang/test/SemaCXX/GH240351.cpp b/clang/test/SemaCXX/GH240351.cpp
new file mode 100644
index 00000000000000..9daee4136515f0
--- /dev/null
+++ b/clang/test/SemaCXX/GH240351.cpp
@@ -0,0 +1,88 @@
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -Wno-c++2d-extensions -verify %s
+// RUN: %clang_cc1 -std=c++2d -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -Wno-c++2d-extensions -verify -DFP_PRAGMA %s
+// RUN: %clang_cc1 -std=c++2d -fsyntax-only -verify -DFP_PRAGMA %s
+// expected-no-diagnostics
+
+// A function defaulted outside its class template is not defaulted when its
+// declaration is instantiated. Instantiating its definition while non-default
+// floating-point features are in effect used to crash.
+
+namespace optnone {
+// Instantiating an optnone function leaves its floating-point features in
+// effect for the next pending instantiation.
+template <typename = int> struct a {
+  a();
+};
+template <typename b> a<b>::a() = default;
+template <typename f, typename g> __attribute__((optnone)) void h(f, g) {}
+void i(int j) {
+  h(j, j);
+  a k;
+}
+} // namespace optnone
+
+namespace special_members {
+template <typename T> struct S {
+  constexpr S();
+  constexpr S(const S &);
+  S &operator=(const S &);
+};
+template <typename T> constexpr S<T>::S() = default;
+template <typename T> constexpr S<T>::S(const S &) = default;
+template <typename T> S<T> &S<T>::operator=(const S &) = default;
+
+template <typename T> struct D {
+  D();
+  ~D();
+};
+template <typename T> D<T>::D() = default;
+template <typename T> D<T>::~D() = default;
+
+void f() {
+#ifdef FP_PRAGMA
+#pragma clang fp contract(fast)
+#endif
+  // The constexpr constructors are instantiated here, under the pragma.
+  constexpr S<int> s;
+  constexpr S<int> t = s;
+  S<int> u;
+  u = t;
+  D<int> d;
+}
+} // namespace special_members
+
+#ifdef FP_PRAGMA
+// This stays in effect until the end of the file, where pending instantiations
+// are performed.
+#pragma clang fp contract(fast)
+#endif
+
+namespace postfix {
+// The pattern of a postfix operator defaulted outside its class holds the
+// result of the prefix operator lookup, which the instantiation reuses.
+template <typename T> struct P {
+  P &operator++();
+  P operator++(int);
+};
+template <typename T> P<T> P<T>::operator++(int) = default;
+
+// The floating-point features of a postfix operator defaulted outside its
+// class are recorded along with the result of the prefix operator lookup.
+struct M {
+  M &operator++();
+  M operator++(int);
+};
+M M::operator++(int) = default;
+
+struct N {
+  N &operator--();
+};
+N operator--(N &, int) = default;
+
+void g(P<int> p, M m, N n) {
+  p++;
+  m++;
+  n--;
+}
+} // namespace postfix


        


More information about the cfe-commits mailing list