Merge branch 'llvm:main' into cfi-show

Author: eugeneepshteyn

clang-tools-extra/clang-tidy/abseil/DurationRewriter.cpp

@@ -6,24 +6,17 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include <array>
 #include <cmath>
 #include <optional>
 
 #include "DurationRewriter.h"
 #include "clang/Tooling/FixIt.h"
-#include "llvm/ADT/IndexedMap.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang::tidy::abseil {
 
-struct DurationScale2IndexFunctor {
-  using argument_type = DurationScale;
-  unsigned operator()(DurationScale Scale) const {
-    return static_cast<unsigned>(Scale);
-  }
-};
-
 /// Returns an integer if the fractional part of a `FloatingLiteral` is `0`.
 static std::optional<llvm::APSInt>
 truncateIfIntegral(const FloatingLiteral &FloatLiteral) {
@@ -39,31 +32,17 @@ truncateIfIntegral(const FloatingLiteral &FloatLiteral) {
 
 const std::pair<llvm::StringRef, llvm::StringRef> &
 getDurationInverseForScale(DurationScale Scale) {
-  static const llvm::IndexedMap<std::pair<llvm::StringRef, llvm::StringRef>,
-                                DurationScale2IndexFunctor>
-      InverseMap = []() {
-        // TODO: Revisit the immediately invoked lambda technique when
-        // IndexedMap gets an initializer list constructor.
-        llvm::IndexedMap<std::pair<llvm::StringRef, llvm::StringRef>,
-                         DurationScale2IndexFunctor>
-            InverseMap;
-        InverseMap.resize(6);
-        InverseMap[DurationScale::Hours] =
-            std::make_pair("::absl::ToDoubleHours", "::absl::ToInt64Hours");
-        InverseMap[DurationScale::Minutes] =
-            std::make_pair("::absl::ToDoubleMinutes", "::absl::ToInt64Minutes");
-        InverseMap[DurationScale::Seconds] =
-            std::make_pair("::absl::ToDoubleSeconds", "::absl::ToInt64Seconds");
-        InverseMap[DurationScale::Milliseconds] = std::make_pair(
-            "::absl::ToDoubleMilliseconds", "::absl::ToInt64Milliseconds");
-        InverseMap[DurationScale::Microseconds] = std::make_pair(
-            "::absl::ToDoubleMicroseconds", "::absl::ToInt64Microseconds");
-        InverseMap[DurationScale::Nanoseconds] = std::make_pair(
-            "::absl::ToDoubleNanoseconds", "::absl::ToInt64Nanoseconds");
-        return InverseMap;
-      }();
-
-  return InverseMap[Scale];
+  static constexpr std::array<std::pair<llvm::StringRef, llvm::StringRef>, 6>
+      InverseMap = {{
+          {"::absl::ToDoubleHours", "::absl::ToInt64Hours"},
+          {"::absl::ToDoubleMinutes", "::absl::ToInt64Minutes"},
+          {"::absl::ToDoubleSeconds", "::absl::ToInt64Seconds"},
+          {"::absl::ToDoubleMilliseconds", "::absl::ToInt64Milliseconds"},
+          {"::absl::ToDoubleMicroseconds", "::absl::ToInt64Microseconds"},
+          {"::absl::ToDoubleNanoseconds", "::absl::ToInt64Nanoseconds"},
+      }};
+
+  return InverseMap[llvm::to_underlying(Scale)];
 }
 
 /// If `Node` is a call to the inverse of `Scale`, return that inverse's
@@ -103,58 +82,31 @@ rewriteInverseTimeCall(const MatchFinder::MatchResult &Result,
 
 /// Returns the factory function name for a given `Scale`.
 llvm::StringRef getDurationFactoryForScale(DurationScale Scale) {
-  switch (Scale) {
-  case DurationScale::Hours:
-    return "absl::Hours";
-  case DurationScale::Minutes:
-    return "absl::Minutes";
-  case DurationScale::Seconds:
-    return "absl::Seconds";
-  case DurationScale::Milliseconds:
-    return "absl::Milliseconds";
-  case DurationScale::Microseconds:
-    return "absl::Microseconds";
-  case DurationScale::Nanoseconds:
-    return "absl::Nanoseconds";
-  }
-  llvm_unreachable("unknown scaling factor");
+  static constexpr std::array<llvm::StringRef, 6> FactoryMap = {
+      "absl::Hours",        "absl::Minutes",      "absl::Seconds",
+      "absl::Milliseconds", "absl::Microseconds", "absl::Nanoseconds",
+  };
+
+  return FactoryMap[llvm::to_underlying(Scale)];
 }
 
 llvm::StringRef getTimeFactoryForScale(DurationScale Scale) {
-  switch (Scale) {
-  case DurationScale::Hours:
-    return "absl::FromUnixHours";
-  case DurationScale::Minutes:
-    return "absl::FromUnixMinutes";
-  case DurationScale::Seconds:
-    return "absl::FromUnixSeconds";
-  case DurationScale::Milliseconds:
-    return "absl::FromUnixMillis";
-  case DurationScale::Microseconds:
-    return "absl::FromUnixMicros";
-  case DurationScale::Nanoseconds:
-    return "absl::FromUnixNanos";
-  }
-  llvm_unreachable("unknown scaling factor");
+  static constexpr std::array<llvm::StringRef, 6> FactoryMap = {
+      "absl::FromUnixHours",  "absl::FromUnixMinutes", "absl::FromUnixSeconds",
+      "absl::FromUnixMillis", "absl::FromUnixMicros",  "absl::FromUnixNanos",
+  };
+
+  return FactoryMap[llvm::to_underlying(Scale)];
 }
 
 /// Returns the Time factory function name for a given `Scale`.
 llvm::StringRef getTimeInverseForScale(DurationScale Scale) {
-  switch (Scale) {
-  case DurationScale::Hours:
-    return "absl::ToUnixHours";
-  case DurationScale::Minutes:
-    return "absl::ToUnixMinutes";
-  case DurationScale::Seconds:
-    return "absl::ToUnixSeconds";
-  case DurationScale::Milliseconds:
-    return "absl::ToUnixMillis";
-  case DurationScale::Microseconds:
-    return "absl::ToUnixMicros";
-  case DurationScale::Nanoseconds:
-    return "absl::ToUnixNanos";
-  }
-  llvm_unreachable("unknown scaling factor");
+  static constexpr std::array<llvm::StringRef, 6> InverseMap = {
+      "absl::ToUnixHours",  "absl::ToUnixMinutes", "absl::ToUnixSeconds",
+      "absl::ToUnixMillis", "absl::ToUnixMicros",  "absl::ToUnixNanos",
+  };
+
+  return InverseMap[llvm::to_underlying(Scale)];
 }
 
 /// Returns `true` if `Node` is a value which evaluates to a literal `0`.

clang/docs/OpenMPSupport.rst

@@ -153,7 +153,7 @@ implementation.
 +------------------------------+--------------------------------------------------------------+--------------------------+-----------------------------------------------------------------------+
 | device                       | clause: extended device                                      | :good:`done`             |                                                                       |
 +------------------------------+--------------------------------------------------------------+--------------------------+-----------------------------------------------------------------------+
-| device                       | clause: uses_allocators clause                               | :good:`done`             |                                                                       |
+| device                       | clause: uses_allocators clause                               | :good:`done`             | https://github.com/llvm/llvm-project/pull/157025                      |
 +------------------------------+--------------------------------------------------------------+--------------------------+-----------------------------------------------------------------------+
 | device                       | clause: in_reduction                                         | :part:`worked on`        | r308768                                                               |
 +------------------------------+--------------------------------------------------------------+--------------------------+-----------------------------------------------------------------------+
@@ -578,6 +578,7 @@ implementation.
 |                                                             |                           |                           |                                                                          |
 |                                                             |                           |                           | Flang parser: https://github.com/llvm/llvm-project/pull/153807           |
 |                                                             |                           |                           | Flang sema: https://github.com/llvm/llvm-project/pull/154779             |
+|                                                             |                           |                           | Clang parse/sema: https://github.com/llvm/llvm-project/pull/158134       |
 +-------------------------------------------------------------+---------------------------+---------------------------+--------------------------------------------------------------------------+
 | variable-category on default clause                         | :good:`done`              | :none:`unclaimed`         |                                                                          |
 +-------------------------------------------------------------+---------------------------+---------------------------+--------------------------------------------------------------------------+

clang/docs/ReleaseNotes.rst

@@ -562,9 +562,11 @@ OpenMP Support
 - Allow array length to be omitted in array section subscript expression.
 - Fixed non-contiguous strided update in the ``omp target update`` directive with the ``from`` clause.
 - Properly handle array section/assumed-size array privatization in C/C++.
+- Added support to handle new syntax of the ``uses_allocators`` clause.
 - Added support for ``variable-category`` modifier in ``default clause``.
 - Added support for ``defaultmap`` directive implicit-behavior ``storage``.
 - Added support for ``defaultmap`` directive implicit-behavior ``private``.
+- Added parsing and semantic analysis support for ``groupprivate`` directive.
 
 Improvements
 ^^^^^^^^^^^^

clang/include/clang/AST/ASTMutationListener.h

@@ -125,6 +125,12 @@ class ASTMutationListener {
   /// \param D the declaration marked OpenMP threadprivate.
   virtual void DeclarationMarkedOpenMPThreadPrivate(const Decl *D) {}
 
+  /// A declaration is marked as OpenMP groupprivate which was not
+  /// previously marked as groupprivate.
+  ///
+  /// \param D the declaration marked OpenMP groupprivate.
+  virtual void DeclarationMarkedOpenMPGroupPrivate(const Decl *D) {}
+
   /// A declaration is marked as OpenMP declaretarget which was not
   /// previously marked as declaretarget.
   ///

clang/include/clang/AST/ASTNodeTraverser.h

@@ -620,6 +620,11 @@ class ASTNodeTraverser
       Visit(E);
   }
 
+  void VisitOMPGroupPrivateDecl(const OMPGroupPrivateDecl *D) {
+    for (const auto *E : D->varlist())
+      Visit(E);
+  }
+
   void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) {
     Visit(D->getCombiner());
     if (const auto *Initializer = D->getInitializer())

clang/include/clang/AST/DeclOpenMP.h

@@ -158,6 +158,68 @@ class OMPThreadPrivateDecl final : public OMPDeclarativeDirective<Decl> {
   static bool classofKind(Kind K) { return K == OMPThreadPrivate; }
 };
 
+/// This represents '#pragma omp groupprivate ...' directive.
+/// For example, in the following, both 'a' and 'A::b' are groupprivate:
+///
+/// \code
+/// int a;
+/// #pragma omp groupprivate(a)
+/// struct A {
+///   static int b;
+/// #pragma omp groupprivate(b)
+/// };
+/// \endcode
+///
+class OMPGroupPrivateDecl final : public OMPDeclarativeDirective<Decl> {
+  friend class OMPDeclarativeDirective<Decl>;
+
+  LLVM_DECLARE_VIRTUAL_ANCHOR_FUNCTION();
+
+  OMPGroupPrivateDecl(DeclContext *DC = nullptr,
+                      SourceLocation L = SourceLocation())
+      : OMPDeclarativeDirective<Decl>(OMPGroupPrivate, DC, L) {}
+
+  ArrayRef<const Expr *> getVars() const {
+    auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data());
+    return {Storage, Data->getNumChildren()};
+  }
+
+  MutableArrayRef<Expr *> getVars() {
+    auto **Storage = reinterpret_cast<Expr **>(Data->getChildren().data());
+    return {Storage, Data->getNumChildren()};
+  }
+
+  void setVars(ArrayRef<Expr *> VL);
+
+public:
+  static OMPGroupPrivateDecl *Create(ASTContext &C, DeclContext *DC,
+                                     SourceLocation L, ArrayRef<Expr *> VL);
+  static OMPGroupPrivateDecl *CreateDeserialized(ASTContext &C, GlobalDeclID ID,
+                                                 unsigned N);
+
+  typedef MutableArrayRef<Expr *>::iterator varlist_iterator;
+  typedef ArrayRef<const Expr *>::iterator varlist_const_iterator;
+  typedef llvm::iterator_range<varlist_iterator> varlist_range;
+  typedef llvm::iterator_range<varlist_const_iterator> varlist_const_range;
+
+  unsigned varlist_size() const { return Data->getNumChildren(); }
+  bool varlist_empty() const { return Data->getChildren().empty(); }
+
+  varlist_range varlist() {
+    return varlist_range(varlist_begin(), varlist_end());
+  }
+  varlist_const_range varlist() const {
+    return varlist_const_range(varlist_begin(), varlist_end());
+  }
+  varlist_iterator varlist_begin() { return getVars().begin(); }
+  varlist_iterator varlist_end() { return getVars().end(); }
+  varlist_const_iterator varlist_begin() const { return getVars().begin(); }
+  varlist_const_iterator varlist_end() const { return getVars().end(); }
+
+  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
+  static bool classofKind(Kind K) { return K == OMPGroupPrivate; }
+};
+
 enum class OMPDeclareReductionInitKind {
   Call,   // Initialized by function call.
   Direct, // omp_priv(<expr>)

clang/include/clang/AST/Expr.h

@@ -634,8 +634,8 @@ class Expr : public ValueStmt {
 
     EvalStatus() = default;
 
-    // hasSideEffects - Return true if the evaluated expression has
-    // side effects.
+    /// Return true if the evaluated expression has
+    /// side effects.
     bool hasSideEffects() const {
       return HasSideEffects;
     }
@@ -646,8 +646,8 @@ class Expr : public ValueStmt {
     /// Val - This is the value the expression can be folded to.
     APValue Val;
 
-    // isGlobalLValue - Return true if the evaluated lvalue expression
-    // is global.
+    /// Return true if the evaluated lvalue expression
+    /// is global.
     bool isGlobalLValue() const;
   };
 
@@ -715,9 +715,7 @@ class Expr : public ValueStmt {
   /// EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded
   /// integer. This must be called on an expression that constant folds to an
   /// integer.
-  llvm::APSInt EvaluateKnownConstInt(
-      const ASTContext &Ctx,
-      SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const;
+  llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx) const;
 
   llvm::APSInt EvaluateKnownConstIntCheckOverflow(
       const ASTContext &Ctx,

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -1887,6 +1887,12 @@ DEF_TRAVERSE_DECL(OMPThreadPrivateDecl, {
   }
 })
 
+DEF_TRAVERSE_DECL(OMPGroupPrivateDecl, {
+  for (auto *I : D->varlist()) {
+    TRY_TO(TraverseStmt(I));
+  }
+})
+
 DEF_TRAVERSE_DECL(OMPRequiresDecl, {
   for (auto *C : D->clauselists()) {
     TRY_TO(TraverseOMPClause(C));

clang/include/clang/Basic/Attr.td

@@ -4585,6 +4585,12 @@ def OMPThreadPrivateDecl : InheritableAttr {
   let Documentation = [InternalOnly];
 }
 
+def OMPGroupPrivateDecl : InheritableAttr {
+  let Spellings = [];
+  let SemaHandler = 0;
+  let Documentation = [InternalOnly];
+}
+
 def OMPCaptureNoInit : InheritableAttr {
   // This attribute has no spellings as it is only ever created implicitly.
   let Spellings = [];

clang/include/clang/Basic/DeclNodes.td

@@ -106,6 +106,7 @@ def OutlinedFunction : DeclNode<Decl>, DeclContext;
 def Captured : DeclNode<Decl>, DeclContext;
 def Import : DeclNode<Decl>;
 def OMPThreadPrivate : DeclNode<Decl>;
+def OMPGroupPrivate : DeclNode<Decl>;
 def OMPAllocate : DeclNode<Decl>;
 def OMPRequires : DeclNode<Decl>;
 def Empty : DeclNode<Decl>;