Merge from 'main' to 'sycl-web' (41 commits)

  CONFLICT (content): Merge conflict in clang/lib/CodeGen/CGLoopInfo.cpp
  CONFLICT (content): Merge conflict in clang/lib/CodeGen/CGLoopInfo.h
  CONFLICT (content): Merge conflict in clang/lib/Sema/SemaStmtAttr.cpp
  CONFLICT (content): Merge conflict in clang/lib/Sema/SemaTemplateInstantiate.cpp
  CONFLICT (content): Merge conflict in clang/lib/Sema/TreeTransform.h

Author: XinWang10

.github/workflows/libcxx-build-and-test.yaml

@@ -44,7 +44,7 @@ env:
 jobs:
   stage1:
     runs-on:
-      group: libcxx-runners-16
+      group: libcxx-runners-8
     continue-on-error: false
     strategy:
       fail-fast: true
@@ -163,10 +163,10 @@ jobs:
           machine: libcxx-runners-8
           std_modules: 'ON'
         - config: 'generic-asan'
-          machine: libcxx-runners-16
+          machine: libcxx-runners-8
           std_modules: 'OFF'
         - config: 'generic-tsan'
-          machine: libcxx-runners-16
+          machine: libcxx-runners-8
           std_modules: 'OFF'
         - config: 'generic-ubsan'
           machine: libcxx-runners-8

bolt/test/lsda.cpp renamed to bolt/test/lsda-section-name.cpp

@@ -1,8 +1,8 @@
 // This test check that LSDA section named by .gcc_except_table.main is
 // disassembled by BOLT.
 
-// RUN: %clang++ %cxxflags -O3 -flto=thin -no-pie -c %s -o %t.o
-// RUN: %clang++ %cxxflags -flto=thin -no-pie -fuse-ld=lld %t.o -o %t.exe \
+// RUN: %clang++ %cxxflags -O3 -no-pie -c %s -o %t.o
+// RUN: %clang++ %cxxflags -no-pie -fuse-ld=lld %t.o -o %t.exe \
 // RUN:   -Wl,-q -Wl,--script=%S/Inputs/lsda.ldscript
 // RUN: llvm-readelf -SW %t.exe | FileCheck %s
 // RUN: llvm-bolt %t.exe -o %t.bolt

clang/docs/ReleaseNotes.rst

@@ -209,6 +209,12 @@ C23 Feature Support
 - Clang now supports ``<stdckdint.h>`` which defines several macros for performing
   checked integer arithmetic. It is also exposed in pre-C23 modes.
 
+- Completed the implementation of
+  `N2508 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2508.pdf>`_. We
+  previously implemented allowing a label at the end of a compound statement,
+  and now we've implemented allowing a label to be followed by a declaration
+  instead of a statement.
+
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 
@@ -311,6 +317,23 @@ Attribute Changes in Clang
   should be a coroutine. A non-coroutine function marked with ``[[clang::coro_wrapper]]``
   is still allowed to return the such a type. This is helpful for analyzers to recognize coroutines from the function signatures.
 
+- Clang now supports ``[[clang::code_align(N)]]`` as an attribute which can be
+  applied to a loop and specifies the byte alignment for a loop. This attribute
+  accepts a positive integer constant initialization expression indicating the
+  number of bytes for the minimum alignment boundary. Its value must be a power
+  of 2, between 1 and 4096(inclusive).
+
+  .. code-block:: c++
+
+      void Array(int *array, size_t n) {
+        [[clang::code_align(64)]] for (int i = 0; i < n; ++i) array[i] = 0;
+      }
+
+      template<int A>
+      void func() {
+        [[clang::code_align(A)]] for(;;) { }
+      }
+
 Improvements to Clang's diagnostics
 -----------------------------------
 - Clang constexpr evaluator now prints template arguments when displaying
@@ -566,6 +589,23 @@ Bug Fixes in This Version
   Fixes (`#67687 <https://github.com/llvm/llvm-project/issues/67687>`_)
 - Fix crash from constexpr evaluator evaluating uninitialized arrays as rvalue.
   Fixes (`#67317 <https://github.com/llvm/llvm-project/issues/67317>`_)
+- Clang now properly diagnoses use of stand-alone OpenMP directives after a
+  label (including ``case`` or ``default`` labels).
+
+  Before:
+
+  .. code-block:: c++
+
+    label:
+    #pragma omp barrier // ok
+
+  After:
+
+  .. code-block:: c++
+
+    label:
+    #pragma omp barrier // error: '#pragma omp barrier' cannot be an immediate substatement
+
 - Fixed an issue that a benign assertion might hit when instantiating a pack expansion
   inside a lambda. (`#61460 <https://github.com/llvm/llvm-project/issues/61460>`_)
 

clang/include/clang/AST/OpenMPClause.h

@@ -2513,89 +2513,6 @@ class OMPRelaxedClause final : public OMPClause {
   }
 };
 
-/// This represents 'fail' clause in the '#pragma omp atomic'
-/// directive.
-///
-/// \code
-/// #pragma omp atomic compare fail
-/// \endcode
-/// In this example directive '#pragma omp atomic compare' has 'fail' clause.
-class OMPFailClause final : public OMPClause {
-
-  // FailParameter is a memory-order-clause. Storing the ClauseKind is
-  // sufficient for our purpose.
-  OpenMPClauseKind FailParameter = llvm::omp::Clause::OMPC_unknown;
-  SourceLocation FailParameterLoc;
-  SourceLocation LParenLoc;
-
-  friend class OMPClauseReader;
-
-  /// Sets the location of '(' in fail clause.
-  void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
-
-  /// Sets the location of memoryOrder clause argument in fail clause.
-  void setFailParameterLoc(SourceLocation Loc) { FailParameterLoc = Loc; }
-
-  /// Sets the mem_order clause for 'atomic compare fail' directive.
-  void setFailParameter(OpenMPClauseKind FailParameter) {
-    this->FailParameter = FailParameter;
-    assert(checkFailClauseParameter(FailParameter) &&
-           "Invalid fail clause parameter");
-  }
-
-public:
-  /// Build 'fail' clause.
-  ///
-  /// \param StartLoc Starting location of the clause.
-  /// \param EndLoc Ending location of the clause.
-  OMPFailClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(llvm::omp::OMPC_fail, StartLoc, EndLoc) {}
-
-  OMPFailClause(OpenMPClauseKind FailParameter, SourceLocation FailParameterLoc,
-                SourceLocation StartLoc, SourceLocation LParenLoc,
-                SourceLocation EndLoc)
-      : OMPClause(llvm::omp::OMPC_fail, StartLoc, EndLoc),
-        FailParameterLoc(FailParameterLoc), LParenLoc(LParenLoc) {
-
-    setFailParameter(FailParameter);
-  }
-
-  /// Build an empty clause.
-  OMPFailClause()
-      : OMPClause(llvm::omp::OMPC_fail, SourceLocation(), SourceLocation()) {}
-
-  child_range children() {
-    return child_range(child_iterator(), child_iterator());
-  }
-
-  const_child_range children() const {
-    return const_child_range(const_child_iterator(), const_child_iterator());
-  }
-
-  child_range used_children() {
-    return child_range(child_iterator(), child_iterator());
-  }
-  const_child_range used_children() const {
-    return const_child_range(const_child_iterator(), const_child_iterator());
-  }
-
-  static bool classof(const OMPClause *T) {
-    return T->getClauseKind() == llvm::omp::OMPC_fail;
-  }
-
-  /// Gets the location of '(' (for the parameter) in fail clause.
-  SourceLocation getLParenLoc() const {
-    return LParenLoc;
-  }
-
-  /// Gets the location of Fail Parameter (type memory-order-clause) in
-  /// fail clause.
-  SourceLocation getFailParameterLoc() const { return FailParameterLoc; }
-
-  /// Gets the parameter (type memory-order-clause) in Fail clause.
-  OpenMPClauseKind getFailParameter() const { return FailParameter; }
-};
-
 /// This represents clause 'private' in the '#pragma omp ...' directives.
 ///
 /// \code

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -3413,11 +3413,6 @@ bool RecursiveASTVisitor<Derived>::VisitOMPCompareClause(OMPCompareClause *) {
   return true;
 }
 
-template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPFailClause(OMPFailClause *) {
-  return true;
-}
-
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::VisitOMPSeqCstClause(OMPSeqCstClause *) {
   return true;

clang/include/clang/Basic/Attr.td

@@ -5378,3 +5378,15 @@ def PreferredType: InheritableAttr {
   let Args = [TypeArgument<"Type", 1>];
   let Documentation = [PreferredTypeDocumentation];
 }
+
+def CodeAlign: StmtAttr {
+  let Spellings = [Clang<"code_align">];
+  let Subjects = SubjectList<[ForStmt, CXXForRangeStmt, WhileStmt, DoStmt],
+                              ErrorDiag, "'for', 'while', and 'do' statements">;
+  let Args = [ExprArgument<"Alignment">];
+  let Documentation = [CodeAlignAttrDocs];
+  let AdditionalMembers = [{
+    static constexpr int MinimumAlignment = 1;
+    static constexpr int MaximumAlignment = 4096;
+  }];
+}

clang/include/clang/Basic/AttrDocs.td

@@ -9244,3 +9244,44 @@ Note: ``a_promise_type::get_return_object`` is exempted from this analysis as it
 implementation detail of any coroutine library.
 }];
 }
+
+def CodeAlignAttrDocs : Documentation {
+  let Category = DocCatVariable;
+  let Heading = "clang::code_align";
+  let Content = [{
+The ``clang::code_align(N)`` attribute applies to a loop and specifies the byte
+alignment for a loop. The attribute accepts a positive integer constant
+initialization expression indicating the number of bytes for the minimum
+alignment boundary. Its value must be a power of 2, between 1 and 4096
+(inclusive).
+
+.. code-block:: c++
+
+  void foo() {
+    int var = 0;
+    [[clang::code_align(16)]] for (int i = 0; i < 10; ++i) var++;
+  }
+
+  void Array(int *array, size_t n) {
+    [[clang::code_align(64)]] for (int i = 0; i < n; ++i) array[i] = 0;
+  }
+
+  void count () {
+    int a1[10], int i = 0;
+    [[clang::code_align(32)]] while (i < 10) { a1[i] += 3; }
+  }
+
+  void check() {
+    int a = 10;
+    [[clang::code_align(8)]] do {
+      a = a + 1;
+    } while (a < 20);
+  }
+
+  template<int A>
+  void func() {
+    [[clang::code_align(A)]] for(;;) { }
+  }
+
+  }];
+}

clang/include/clang/Basic/DiagnosticParseKinds.td

@@ -299,6 +299,12 @@ def note_missing_selector_name : Note<
 def note_force_empty_selector_name : Note<
   "or insert whitespace before ':' to use %0 as parameter name "
   "and have an empty entry in the selector">;
+def ext_c_label_followed_by_declaration : ExtWarn<
+  "label followed by a declaration is a C23 extension">,
+  InGroup<C23>;
+def warn_c23_compat_label_followed_by_declaration : Warning<
+  "label followed by a declaration is incompatible with C standards before "
+  "C23">, InGroup<CPre23Compat>, DefaultIgnore;
 def ext_c_label_end_of_compound_statement : ExtWarn<
   "label at end of compound statement is a C23 extension">,
    InGroup<C23>;

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -10100,6 +10100,11 @@ def err_duplicate_case_differing_expr : Error<
 def warn_case_empty_range : Warning<"empty case range specified">;
 def warn_missing_case_for_condition :
   Warning<"no case matching constant switch condition '%0'">;
+def err_loop_attr_conflict : Error<
+  "conflicting loop attribute %0">;
+def err_attribute_power_of_two_in_range : Error<
+  "%0 attribute requires an integer argument which is a constant power of two "
+  "between %1 and %2 inclusive; provided argument was %3">;
 
 def warn_def_missing_case : Warning<"%plural{"
   "1:enumeration value %1 not explicitly handled in switch|"
@@ -11044,8 +11049,6 @@ def note_omp_atomic_compare: Note<
   "expect binary operator in conditional expression|expect '<', '>' or '==' as order operator|expect comparison in a form of 'x == e', 'e == x', 'x ordop expr', or 'expr ordop x'|"
   "expect lvalue for result value|expect scalar value|expect integer value|unexpected 'else' statement|expect '==' operator|expect an assignment statement 'v = x'|"
   "expect a 'if' statement|expect no more than two statements|expect a compound statement|expect 'else' statement|expect a form 'r = x == e; if (r) ...'}0">;
-def err_omp_atomic_fail_wrong_or_no_clauses : Error<"expected a memory order clause">;
-def err_omp_atomic_fail_no_compare : Error<"expected 'compare' clause with the 'fail' modifier">;
 def err_omp_atomic_several_clauses : Error<
   "directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause">;
 def err_omp_several_mem_order_clauses : Error<

clang/include/clang/Basic/OpenACCKinds.h

@@ -33,7 +33,10 @@ enum class OpenACCDirectiveKind {
   Loop,
   // FIXME: 'cache'
 
-  // FIXME: Combined Constructs.
+  // Combined Constructs.
+  ParallelLoop,
+  SerialLoop,
+  KernelsLoop,
 
   // FIXME: atomic Construct variants.