Merge branch 'main' into sg_distr_minor_fixes

Author: charithaintc

.github/CODEOWNERS

@@ -31,9 +31,9 @@
 /clang/www/cxx_dr_status.html @Endilll
 /clang/www/make_cxx_dr_status @Endilll
 
-/clang/include/clang/CIR @lanza @bcardosolopes
-/clang/lib/CIR @lanza @bcardosolopes
-/clang/tools/cir-* @lanza @bcardosolopes
+/clang/include/clang/CIR @lanza @bcardosolopes @xlauko @andykaylor
+/clang/lib/CIR @lanza @bcardosolopes @xlauko @andykaylor
+/clang/tools/cir-* @lanza @bcardosolopes @xlauko @andykaylor
 
 /lldb/ @JDevlieghere
 

.github/workflows/libclang-python-tests.yml

@@ -10,15 +10,15 @@ on:
       - 'main'
     paths:
       - 'clang/bindings/python/**'
+      - 'clang/test/bindings/python/**'
       - 'clang/tools/libclang/**'
-      - 'clang/CMakeList.txt'
       - '.github/workflows/libclang-python-tests.yml'
       - '.github/workflows/llvm-project-tests.yml'
   pull_request:
     paths:
       - 'clang/bindings/python/**'
+      - 'clang/test/bindings/python/**'
       - 'clang/tools/libclang/**'
-      - 'clang/CMakeList.txt'
       - '.github/workflows/libclang-python-tests.yml'
       - '.github/workflows/llvm-project-tests.yml'
 

.github/workflows/premerge.yaml

@@ -76,7 +76,7 @@ jobs:
     if: >-
         github.repository_owner == 'llvm' &&
         (github.event_name != 'pull_request' || github.event.action != 'closed')
-    runs-on: llvm-premerge-windows-runners
+    runs-on: llvm-premerge-windows-2022-runners
     defaults:
       run:
         shell: bash

clang/CMakeLists.txt

@@ -536,7 +536,6 @@ if( CLANG_INCLUDE_TESTS )
     clang_unit_site_config=${CMAKE_CURRENT_BINARY_DIR}/test/Unit/lit.site.cfg
   )
   add_subdirectory(test)
-  add_subdirectory(bindings/python/tests)
 
   if(CLANG_BUILT_STANDALONE)
     umbrella_lit_testsuite_end(check-all)

clang/bindings/python/tests/CMakeLists.txt

@@ -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/CXXTypeAwareAllocators.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/LanguageExtensions.rst

@@ -36,7 +36,7 @@ Potentially Breaking Changes
 
 - The Objective-C ARC migrator (ARCMigrate) has been removed.
 - Fix missing diagnostics for uses of declarations when performing typename access,
-  such as when performing member access on a '[[deprecated]]' type alias.
+  such as when performing member access on a ``[[deprecated]]`` type alias.
   (#GH58547)
 - For ARM targets when compiling assembly files, the features included in the selected CPU
   or Architecture's FPU are included. If you wish not to use a specific feature,
@@ -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
@@ -707,6 +705,11 @@ Improvements to Clang's diagnostics
 - Improve the diagnostics for placement new expression when const-qualified
   object was passed as the storage argument. (#GH143708)
 
+- Clang now does not issue a warning about returning from a function declared with
+  the ``[[noreturn]]`` attribute when the function body is ended with a call via
+  pointer, provided it can be proven that the pointer only points to
+  ``[[noreturn]]`` functions.
+
 Improvements to Clang's time-trace
 ----------------------------------
 
@@ -950,6 +953,7 @@ Bug Fixes to C++ Support
 - Fix a bug where private access specifier of overloaded function not respected. (#GH107629)
 - Correctly handles calling an explicit object member function template overload set
   through its address (``(&Foo::bar<baz>)()``).
+- Fix a crash when using an explicit object parameter in a non-member function. (#GH113185)
 - Fix a crash when forming an invalid call to an operator with an explicit object member. (#GH147121)
 - Correctly handle allocations in the condition of a ``if constexpr``.(#GH120197) (#GH134820)
 - Fixed a crash when handling invalid member using-declaration in C++20+ mode. (#GH63254)
@@ -1024,15 +1028,29 @@ Arm and AArch64 Support
   `as specified here <https://github.com/ARM-software/acle/blob/main/main/acle.md#modal-8-bit-floating-point-extensions>`_
   is now available.
 - Support has been added for the following processors (command-line identifiers in parentheses):
+
   - Arm Cortex-A320 (``cortex-a320``)
+
 - For ARM targets, cc1as now considers the FPU's features for the selected CPU or Architecture.
 - The ``+nosimd`` attribute is now fully supported for ARM. Previously, this had no effect when being used with
   ARM targets, however this will now disable NEON instructions being generated. The ``simd`` option is
   also now printed when the ``--print-supported-extensions`` option is used.
 - When a feature that depends on NEON (``simd``) is used, NEON is now automatically enabled.
 - When NEON is disabled (``+nosimd``), all features that depend on NEON will now be disabled.
 
--  Support for __ptrauth type qualifier has been added.
+- Pointer authentication
+
+  - Support for __ptrauth type qualifier has been added.
+  - Objective-C adoption of pointer authentication
+
+    - ``isa`` and ``super`` pointers are protected with address diversity and separate
+      usage specific discriminators.
+    - methodlist pointers and content are protected with address diversity and methodlist
+      pointers have a usage specific discriminator.
+    - ``class_ro_t`` pointers are protected with address diversity and usage specific
+      discriminators.
+    - ``SEL`` typed ivars are protected with address diversity and usage specific
+      discriminators.
 
 - For AArch64, added support for generating executable-only code sections by using the
   ``-mexecute-only`` or ``-mpure-code`` compiler flags. (#GH125688)
@@ -1196,6 +1214,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
 ^^^^^^^^^^^^^^^^^^^