Merge branch 'main' into fix-clang-linker-wrapper-remarks-yaml

Author: jdenny-ornl

.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/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-tools-extra/clangd/ModulesBuilder.cpp

@@ -219,8 +219,9 @@ bool IsModuleFileUpToDate(PathRef ModuleFilePath,
 
   IntrusiveRefCntPtr<ModuleCache> ModCache = createCrossProcessModuleCache();
   PCHContainerOperations PCHOperations;
+  CodeGenOptions CodeGenOpts;
   ASTReader Reader(PP, *ModCache, /*ASTContext=*/nullptr,
-                   PCHOperations.getRawReader(), {});
+                   PCHOperations.getRawReader(), CodeGenOpts, {});
 
   // We don't need any listener here. By default it will use a validator
   // listener.

clang-tools-extra/docs/ReleaseNotes.rst

@@ -88,6 +88,11 @@ Improvements to clang-doc
 Improvements to clang-query
 ---------------------------
 
+- Matcher queries interpreted by clang-query are now support trailing comma (,)
+  in matcher arguments. Note that C++ still doesn't allow this in function
+  arguments. So when porting a query to C++, remove all instances of trailing
+  comma (otherwise C++ compiler will just complain about "expected expression").
+
 Improvements to include-cleaner
 -------------------------------
 - Deprecated the ``-insert`` and ``-remove`` command line options, and added

clang-tools-extra/test/clang-query/trailing-comma.c

@@ -0,0 +1,21 @@
+void foo(void) {}
+// CHECK-OK: trailing-comma.c:1:1: note: "root" binds here
+// CHECK-ERR-COMMA: Invalid token <,> found when looking for a value.
+
+// RUN: clang-query -c "match \
+// RUN:   functionDecl( \
+// RUN:     hasName( \
+// RUN:       \"foo\", \
+// RUN:     ), \
+// RUN:   ) \
+// RUN: " %s | FileCheck --check-prefix=CHECK-OK %s
+
+// Same with \n tokens
+// RUN: echo "match functionDecl( hasName( \"foo\" , ) , )" | sed "s/ /\n/g" >%t
+// RUN: clang-query -f %t %s | FileCheck --check-prefix=CHECK-OK %s
+
+// RUN: not clang-query -c "match functionDecl(hasName(\"foo\"),,)" %s \
+// RUN:   | FileCheck --check-prefix=CHECK-ERR-COMMA %s
+
+// RUN: not clang-query -c "match functionDecl(,)" %s \
+// RUN:   | FileCheck --check-prefix=CHECK-ERR-COMMA %s

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

@@ -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
@@ -676,7 +674,7 @@ Improvements to Clang's diagnostics
   #GH142457, #GH139913, #GH138850, #GH137867, #GH137860, #GH107840, #GH93308,
   #GH69470, #GH59391, #GH58172, #GH46215, #GH45915, #GH45891, #GH44490,
   #GH36703, #GH32903, #GH23312, #GH69874.
-  
+
 - Clang no longer emits a spurious -Wdangling-gsl warning in C++23 when
   iterating over an element of a temporary container in a range-based
   for loop.(#GH109793, #GH145164)
@@ -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
 ----------------------------------
 
@@ -797,6 +800,8 @@ Bug Fixes in This Version
   declaration statements. Clang now emits a warning for these patterns. (#GH141659)
 - Fixed false positives for redeclaration errors of using enum in
   nested scopes. (#GH147495)
+- Fixed a failed assertion with an operator call expression which comes from a
+  macro expansion when performing analysis for nullability attributes. (#GH138371)
 
 Bug Fixes to Compiler Builtins
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -950,6 +955,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)
@@ -963,6 +969,8 @@ Bug Fixes to C++ Support
 - Fix a crash with NTTP when instantiating local class.
 - Fixed a crash involving list-initialization of an empty class with a
   non-empty initializer list. (#GH147949)
+- Fixed constant evaluation of equality comparisons of constexpr-unknown references. (#GH147663)
+- Diagnose binding a reference to ``*nullptr`` during constant evaluation. (#GH48665)
 
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -1024,15 +1032,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)
@@ -1125,6 +1147,8 @@ Fixed Point Support in Clang
 AST Matchers
 ------------
 
+- Ensure ``hasBitWidth`` doesn't crash on bit widths that are dependent on template
+  parameters.
 - Ensure ``isDerivedFrom`` matches the correct base in case more than one alias exists.
 - Extend ``templateArgumentCountIs`` to support function and variable template
   specialization.
@@ -1196,6 +1220,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/ThinLTO.rst

@@ -240,6 +240,38 @@ The ``BOOTSTRAP_LLVM_ENABLE_LTO=Thin`` will enable ThinLTO for stage 2 and
 stage 3 in case the compiler used for stage 1 does not support the ThinLTO
 option.
 
+Integrated Distributed ThinLTO (DTLTO)
+--------------------------------------
+
+Integrated Distributed ThinLTO (DTLTO) enables the distribution of backend
+ThinLTO compilations via external distribution systems, such as Incredibuild,
+during the traditional link step.
+
+The implementation is documented here: https://llvm.org/docs/DTLTO.html.
+
+DTLTO requires the LLD linker (``-fuse-ld=lld``).
+
+``-fthinlto-distributor=<path>``
+   - Specifies the ``<path>`` to the distributor process executable for DTLTO.
+   - If specified, ThinLTO backend compilations will be distributed by LLD.
+
+``-Xthinlto-distributor=<arg>``
+   - Passes ``<arg>`` to the distributor process (see ``-fthinlto-distributor=``).
+   - Can be specified multiple times to pass multiple options.
+   - Multiple options can also be specified by separating them with commas.
+
+Examples:
+   - ``clang -flto=thin -fthinlto-distributor=incredibuild.exe -Xthinlto-distributor=--verbose,--j10 -fuse-ld=lld``
+   - ``clang -flto=thin -fthinlto-distributor=$(which python) -Xthinlto-distributor=incredibuild.py -fuse-ld=lld``
+
+If ``-fthinlto-distributor=`` is specified, Clang supplies the path to a
+compiler to be executed remotely to perform the ThinLTO backend
+compilations. Currently, this is Clang itself.
+
+Note that currently, DTLTO is only supported in some LLD flavors. Support can
+be added to other LLD flavours in the future.
+See `DTLTO <https://lld.llvm.org/dtlto.html>`_ for more information.
+
 More Information
 ================