Merge commit '7cde97423347' from llvm.org/main into next

# Conflicts:
#	clang/include/clang/Basic/Features.def

Author: egorzhdan

clang/docs/CXXTypeAwareAllocators.rst

@@ -0,0 +1,155 @@
+=========================
+C++ Type Aware Allocators
+=========================
+
+.. contents::
+   :local:
+
+Introduction
+============
+
+Clang includes an implementation of P2719 "Type-aware allocation and deallocation
+functions".
+
+This is a feature that extends the semantics of `new`, `new[]`, `delete` and
+`delete[]` operators to expose the type being allocated to the operator. This
+can be used to customize allocation of types without needing to modify the
+type declaration, or via template definitions fully generic type aware
+allocators.
+
+P2719 introduces a type-identity tag as valid parameter type for all allocation
+operators. This tag is a default initialized value of type `std::type_identity<T>`
+where T is the type being allocated or deallocated.  Unlike the other placement
+arguments this tag is passed as the first parameter to the operator.
+
+The most basic use case is as follows
+
+.. code-block:: c++
+
+  #include <new>
+  #include <type_traits>
+
+  struct S {
+   // ...
+  };
+
+  void *operator new(std::type_identity<S>, size_t, std::align_val_t);
+  void operator delete(std::type_identity<S>, void *, size_t, std::align_val_t);
+
+  void f() {
+    S *s = new S; // calls ::operator new(std::type_identity<S>(), sizeof(S), alignof(S))
+    delete s; // calls ::operator delete(std::type_identity<S>(), s, sizeof(S), alignof(S))
+  }
+
+While this functionality alone is powerful and useful, the true power comes
+by using templates. In addition to adding the type-identity tag, P2719 allows
+the tag parameter to be a dependent specialization of `std::type_identity`,
+updates the overload resolution rules to support full template deduction and
+constraint semantics, and updates the definition of usual deallocation functions
+to include `operator delete` definitions that are templatized on the
+type-identity tag.
+
+This allows arbitrarily constrained definitions of the operators that resolve
+as would be expected for any other template function resolution, e.g (only
+showing `operator new` for brevity)
+
+.. code-block:: c++
+
+   template <typename T, unsigned Size> struct Array {
+     T buffer[Size];
+   };
+
+   // Starting with a concrete type
+   void *operator new(std::type_identity<Array<int, 5>>, size_t, std::align_val_t);
+
+   // Only care about five element arrays
+   template <typename T>
+   void *operator new(std::type_identity<Array<T, 5>>, size_t, std::align_val_t);
+
+   // An array of N floats
+   template <unsigned N>
+   void *operator new(std::type_identity<Array<float, N>>, size_t, std::align_val_t);
+
+   // Any array
+   template <typename T, unsigned N>
+   void *operator new(std::type_identity<Array<T, N>>, size_t, std::align_val_t);
+
+   // A handy concept
+   template <typename T> concept Polymorphic = std::is_polymorphic_v<T>;
+
+   // Only applies is T is Polymorphic
+   template <Polymorphic T, unsigned N>
+   void *operator new(std::type_identity<Array<T, N>>, size_t, std::align_val_t);
+
+   // Any even length array
+   template <typename T, unsigned N>
+   void *operator new(std::type_identity<Array<T, N>>, size_t, std::align_val_t)
+       requires(N%2 == 0);
+
+Operator selection then proceeds according to the usual rules for choosing
+the best/most constrained match.
+
+Any declaration of a type aware operator new or operator delete must include a
+matching complimentary operator defined in the same scope.
+
+Notes
+=====
+
+Unconstrained Global Operators
+------------------------------
+
+Declaring an unconstrained type aware global operator `new` or `delete` (or
+`[]` variants) creates numerous hazards, similar to, but different from, those
+created by attempting to replace the non-type aware global operators. For that
+reason unconstrained operators are strongly discouraged.
+
+Mismatching Constraints
+-----------------------
+
+When declaring global type aware operators you should ensure the constraints
+applied to new and delete match exactly, and declare them together. This
+limits the risk of having mismatching operators selected due to differing
+constraints resulting in changes to prioritization when determining the most
+viable candidate.
+
+Declarations Across Libraries
+-----------------------------
+
+Declaring a typed allocator for a type in a separate TU or library creates
+similar hazards as different libraries and TUs may see (or select) different
+definitions.
+
+Under this model something like this would be risky
+
+.. code-block:: c++
+
+  template<typename T>
+  void *operator new(std::type_identity<std::vector<T>>, size_t, std::align_val_t);
+
+However this hazard is not present simply due to the use of the a type from
+another library:
+
+.. code-block:: c++
+
+  template<typename T>
+  struct MyType {
+    T thing;
+  };
+  template<typename T>
+  void *operator new(std::type_identity<MyType<std::vector<T>>>, size_t, std::align_val_t);
+
+Here we see `std::vector` being used, but that is not the actual type being
+allocated.
+
+Implicit and Placement Parameters
+---------------------------------
+
+Type aware allocators are always passed both the implicit alignment and size
+parameters in all cases. Explicit placement parameters are supported after the
+mandatory implicit parameters.
+
+Publication
+===========
+
+`Type-aware allocation and deallocation functions <https://wg21.link/P2719>`_.
+Louis Dionne, Oliver Hunt.

clang/docs/LanguageExtensions.rst

@@ -15,6 +15,7 @@ Clang Language Extensions
    AutomaticReferenceCounting
    PointerAuthentication
    MatrixTypes
+   CXXTypeAwareAllocators
 
 Introduction
 ============
@@ -1540,6 +1541,13 @@ Use ``__has_feature(cxx_variable_templates)`` or
 ``__has_extension(cxx_variable_templates)`` to determine if support for
 templated variable declarations is enabled.
 
+C++ type aware allocators
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Use ``__has_extension(cxx_type_aware_allocators)`` to determine the existence of
+support for the future C++2d type aware allocator feature. For full details see
+:doc:`C++ Type Aware Allocators <CXXTypeAwareAllocators>` for additional details.
+
 C11
 ---
 

clang/docs/ReleaseNotes.rst

@@ -133,8 +133,6 @@ C++2c Feature Support
 
 - Implemented `P0963R3 Structured binding declaration as a condition <https://wg21.link/P0963R3>`_.
 
-- Implemented `P2719R4 Type-aware allocation and deallocation functions <https://wg21.link/P2719>`_.
-
 - Implemented `P3618R0 Allow attaching main to the global module <https://wg21.link/P3618>`_.
 
 C++23 Feature Support
@@ -1196,6 +1194,9 @@ New features
   so frequent 'not yet implemented' diagnostics should be expected.  Also, the
   ACC MLIR dialect does not currently implement any lowering to LLVM-IR, so no
   code generation is possible for OpenACC.
+- Implemented `P2719R5 Type-aware allocation and deallocation functions <https://wg21.link/P2719>`_
+  as an extension in all C++ language modes.
+
 
 Crash and bug fixes
 ^^^^^^^^^^^^^^^^^^^

clang/docs/index.rst

@@ -61,6 +61,7 @@ Using Clang as a Compiler
    APINotes
    DebuggingCoroutines
    AMDGPUSupport
+   CXXTypeAwareAllocators
    CommandGuide/index
    FAQ
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -10153,11 +10153,8 @@ def err_destroying_operator_delete_not_usual : Error<
 def err_type_aware_destroying_operator_delete : Error<
   "destroying delete is not permitted to be type aware">;
 
-def ext_cxx26_type_aware_allocators : ExtWarn<
-  "type aware allocators are a C++2c extension">, InGroup<CXX26>;
-def warn_cxx26_type_aware_allocators : Warning<
-  "type aware allocators are incompatible with C++ standards before C++2c">,
-  DefaultIgnore, InGroup<CXXPre26Compat>;
+def warn_ext_type_aware_allocators : ExtWarn<
+  "type aware allocators are a Clang extension">, InGroup<DiagGroup<"ext-cxx-type-aware-allocators">>;
 def err_type_aware_allocator_missing_matching_operator : Error<
   "declaration of type aware %0 in %1 must have matching type aware %2"
 >;

clang/include/clang/Basic/Features.def

@@ -374,6 +374,9 @@ FEATURE(clang_atomic_attributes, true)
 FEATURE(cuda_noinline_keyword, LangOpts.CUDA)
 EXTENSION(cuda_implicit_host_device_templates, LangOpts.CUDA && LangOpts.OffloadImplicitHostDeviceTemplates)
 
+// C++2d type-aware allocators
+EXTENSION(cxx_type_aware_allocators, true)
+
 // TODO(BoundsSafety): Deprecate this feature name
 FEATURE(bounds_attributes, LangOpts.BoundsSafety)
 /* TO_UPSTREAM(BoundsSafety) ON*/

clang/lib/Frontend/InitPreprocessor.cpp

@@ -779,9 +779,6 @@ static void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts,
   if (LangOpts.Char8)
     Builder.defineMacro("__cpp_char8_t", "202207L");
   Builder.defineMacro("__cpp_impl_destroying_delete", "201806L");
-
-  // TODO: Final number?
-  Builder.defineMacro("__cpp_type_aware_allocators", "202500L");
 }
 
 /// InitializeOpenCLFeatureTestMacros - Define OpenCL macros based on target

clang/lib/Sema/SemaDeclCXX.cpp

@@ -16541,12 +16541,8 @@ static inline bool CheckOperatorNewDeleteTypes(
   if (IsPotentiallyTypeAware) {
     // We don't emit this diagnosis for template instantiations as we will
     // have already emitted it for the original template declaration.
-    if (!FnDecl->isTemplateInstantiation()) {
-      unsigned DiagID = SemaRef.getLangOpts().CPlusPlus26
-                            ? diag::warn_cxx26_type_aware_allocators
-                            : diag::ext_cxx26_type_aware_allocators;
-      SemaRef.Diag(FnDecl->getLocation(), DiagID);
-    }
+    if (!FnDecl->isTemplateInstantiation())
+      SemaRef.Diag(FnDecl->getLocation(), diag::warn_ext_type_aware_allocators);
 
     if (OperatorKind == AllocationOperatorKind::New) {
       SizeParameterIndex = 1;

clang/test/SemaCXX/type-aware-class-scoped-mismatched-constraints.cpp

@@ -1,13 +1,15 @@
-// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -std=c++26 -fexceptions -fcxx-exceptions    -fsized-deallocation    -faligned-allocation -Wno-non-c-typedef-for-linkage -DDEFAULT_DELETE=1
-// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -std=c++26 -fexceptions -fcxx-exceptions -fno-sized-deallocation    -faligned-allocation -Wno-non-c-typedef-for-linkage -DDEFAULT_DELETE=0
-// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -std=c++26 -fexceptions -fcxx-exceptions    -fsized-deallocation -fno-aligned-allocation -Wno-non-c-typedef-for-linkage -DDEFAULT_DELETE=1
-// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -std=c++26 -fexceptions -fcxx-exceptions -fno-sized-deallocation -fno-aligned-allocation -Wno-non-c-typedef-for-linkage -DDEFAULT_DELETE=0
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -std=c++26 -Wno-ext-cxx-type-aware-allocators -fexceptions -fcxx-exceptions    -fsized-deallocation    -faligned-allocation -Wno-non-c-typedef-for-linkage -DDEFAULT_DELETE=1
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -std=c++26 -Wno-ext-cxx-type-aware-allocators -fexceptions -fcxx-exceptions -fno-sized-deallocation    -faligned-allocation -Wno-non-c-typedef-for-linkage -DDEFAULT_DELETE=0
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -std=c++26 -Wno-ext-cxx-type-aware-allocators -fexceptions -fcxx-exceptions    -fsized-deallocation -fno-aligned-allocation -Wno-non-c-typedef-for-linkage -DDEFAULT_DELETE=1
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -std=c++26 -Wno-ext-cxx-type-aware-allocators -fexceptions -fcxx-exceptions -fno-sized-deallocation -fno-aligned-allocation -Wno-non-c-typedef-for-linkage -DDEFAULT_DELETE=0
 
 namespace std {
   template <class T> struct type_identity {};
   enum class align_val_t : __SIZE_TYPE__ {};
 }
 
+static_assert(__has_extension(cxx_type_aware_allocators), "Verifying the type aware extension flag is set");
+
 using size_t = __SIZE_TYPE__;
 
 void *operator new(size_t); // #default_operator_new

clang/test/SemaCXX/type-aware-coroutines.cpp

@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -std=c++26 -fcoroutines -fexceptions -Wall -Wpedantic
+// RUN: %clang_cc1 -triple arm64-apple-macosx -fsyntax-only -verify %s -std=c++26 -Wno-ext-cxx-type-aware-allocators -fcoroutines -fexceptions -Wall -Wpedantic
 
 
 #include "Inputs/std-coroutine.h"