Merge remote-tracking branch 'origin/main' into midhun7/big-archive-recognition

Author: midhuncodes7

clang-tools-extra/docs/clang-tidy/checks/performance/noexcept-move-constructor.rst

@@ -9,5 +9,5 @@ marked with ``noexcept`` or marked with ``noexcept(expr)`` where ``expr``
 evaluates to ``false`` (but is not a ``false`` literal itself).
 
 Move constructors of all the types used with STL containers, for example,
-need to be declared ``noexcept``. Otherwise STL will choose copy constructors
+should be declared ``noexcept``. Otherwise STL may choose copy constructors
 instead. The same is valid for move assignment operations.

clang/include/clang/AST/StmtOpenMP.h

@@ -889,23 +889,24 @@ class OMPLoopBasedDirective : public OMPExecutableDirective {
 
   /// Calls the specified callback function for all the loops in \p CurStmt,
   /// from the outermost to the innermost.
-  static bool
-  doForAllLoops(Stmt *CurStmt, bool TryImperfectlyNestedLoops,
-                unsigned NumLoops,
-                llvm::function_ref<bool(unsigned, Stmt *)> Callback,
-                llvm::function_ref<void(OMPLoopTransformationDirective *)>
-                    OnTransformationCallback);
+  static bool doForAllLoops(
+      Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops,
+      llvm::function_ref<bool(unsigned, Stmt *)> Callback,
+      llvm::function_ref<void(OMPCanonicalLoopNestTransformationDirective *)>
+          OnTransformationCallback);
   static bool
   doForAllLoops(const Stmt *CurStmt, bool TryImperfectlyNestedLoops,
                 unsigned NumLoops,
                 llvm::function_ref<bool(unsigned, const Stmt *)> Callback,
-                llvm::function_ref<void(const OMPLoopTransformationDirective *)>
+                llvm::function_ref<
+                    void(const OMPCanonicalLoopNestTransformationDirective *)>
                     OnTransformationCallback) {
     auto &&NewCallback = [Callback](unsigned Cnt, Stmt *CurStmt) {
       return Callback(Cnt, CurStmt);
     };
     auto &&NewTransformCb =
-        [OnTransformationCallback](OMPLoopTransformationDirective *A) {
+        [OnTransformationCallback](
+            OMPCanonicalLoopNestTransformationDirective *A) {
           OnTransformationCallback(A);
         };
     return doForAllLoops(const_cast<Stmt *>(CurStmt), TryImperfectlyNestedLoops,
@@ -918,7 +919,7 @@ class OMPLoopBasedDirective : public OMPExecutableDirective {
   doForAllLoops(Stmt *CurStmt, bool TryImperfectlyNestedLoops,
                 unsigned NumLoops,
                 llvm::function_ref<bool(unsigned, Stmt *)> Callback) {
-    auto &&TransformCb = [](OMPLoopTransformationDirective *) {};
+    auto &&TransformCb = [](OMPCanonicalLoopNestTransformationDirective *) {};
     return doForAllLoops(CurStmt, TryImperfectlyNestedLoops, NumLoops, Callback,
                          TransformCb);
   }
@@ -955,19 +956,18 @@ class OMPLoopBasedDirective : public OMPExecutableDirective {
   }
 };
 
-/// The base class for all loop transformation directives.
-class OMPLoopTransformationDirective : public OMPLoopBasedDirective {
+/// The base class for all transformation directives of canonical loop nests.
+class OMPCanonicalLoopNestTransformationDirective
+    : public OMPLoopBasedDirective {
   friend class ASTStmtReader;
 
   /// Number of loops generated by this loop transformation.
   unsigned NumGeneratedLoops = 0;
 
 protected:
-  explicit OMPLoopTransformationDirective(StmtClass SC,
-                                          OpenMPDirectiveKind Kind,
-                                          SourceLocation StartLoc,
-                                          SourceLocation EndLoc,
-                                          unsigned NumAssociatedLoops)
+  explicit OMPCanonicalLoopNestTransformationDirective(
+      StmtClass SC, OpenMPDirectiveKind Kind, SourceLocation StartLoc,
+      SourceLocation EndLoc, unsigned NumAssociatedLoops)
       : OMPLoopBasedDirective(SC, Kind, StartLoc, EndLoc, NumAssociatedLoops) {}
 
   /// Set the number of loops generated by this loop transformation.
@@ -5545,7 +5545,8 @@ class OMPTargetTeamsDistributeSimdDirective final : public OMPLoopDirective {
 };
 
 /// This represents the '#pragma omp tile' loop transformation directive.
-class OMPTileDirective final : public OMPLoopTransformationDirective {
+class OMPTileDirective final
+    : public OMPCanonicalLoopNestTransformationDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -5557,9 +5558,9 @@ class OMPTileDirective final : public OMPLoopTransformationDirective {
 
   explicit OMPTileDirective(SourceLocation StartLoc, SourceLocation EndLoc,
                             unsigned NumLoops)
-      : OMPLoopTransformationDirective(OMPTileDirectiveClass,
-                                       llvm::omp::OMPD_tile, StartLoc, EndLoc,
-                                       NumLoops) {
+      : OMPCanonicalLoopNestTransformationDirective(
+            OMPTileDirectiveClass, llvm::omp::OMPD_tile, StartLoc, EndLoc,
+            NumLoops) {
     setNumGeneratedLoops(2 * NumLoops);
   }
 
@@ -5622,7 +5623,8 @@ class OMPTileDirective final : public OMPLoopTransformationDirective {
 };
 
 /// This represents the '#pragma omp stripe' loop transformation directive.
-class OMPStripeDirective final : public OMPLoopTransformationDirective {
+class OMPStripeDirective final
+    : public OMPCanonicalLoopNestTransformationDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -5634,9 +5636,9 @@ class OMPStripeDirective final : public OMPLoopTransformationDirective {
 
   explicit OMPStripeDirective(SourceLocation StartLoc, SourceLocation EndLoc,
                               unsigned NumLoops)
-      : OMPLoopTransformationDirective(OMPStripeDirectiveClass,
-                                       llvm::omp::OMPD_stripe, StartLoc, EndLoc,
-                                       NumLoops) {
+      : OMPCanonicalLoopNestTransformationDirective(
+            OMPStripeDirectiveClass, llvm::omp::OMPD_stripe, StartLoc, EndLoc,
+            NumLoops) {
     setNumGeneratedLoops(2 * NumLoops);
   }
 
@@ -5702,7 +5704,8 @@ class OMPStripeDirective final : public OMPLoopTransformationDirective {
 /// #pragma omp unroll
 /// for (int i = 0; i < 64; ++i)
 /// \endcode
-class OMPUnrollDirective final : public OMPLoopTransformationDirective {
+class OMPUnrollDirective final
+    : public OMPCanonicalLoopNestTransformationDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -5713,9 +5716,9 @@ class OMPUnrollDirective final : public OMPLoopTransformationDirective {
   };
 
   explicit OMPUnrollDirective(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPLoopTransformationDirective(OMPUnrollDirectiveClass,
-                                       llvm::omp::OMPD_unroll, StartLoc, EndLoc,
-                                       1) {}
+      : OMPCanonicalLoopNestTransformationDirective(OMPUnrollDirectiveClass,
+                                                    llvm::omp::OMPD_unroll,
+                                                    StartLoc, EndLoc, 1) {}
 
   /// Set the pre-init statements.
   void setPreInits(Stmt *PreInits) {
@@ -5776,7 +5779,8 @@ class OMPUnrollDirective final : public OMPLoopTransformationDirective {
 /// for (int i = 0; i < n; ++i)
 ///   ...
 /// \endcode
-class OMPReverseDirective final : public OMPLoopTransformationDirective {
+class OMPReverseDirective final
+    : public OMPCanonicalLoopNestTransformationDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -5788,9 +5792,9 @@ class OMPReverseDirective final : public OMPLoopTransformationDirective {
 
   explicit OMPReverseDirective(SourceLocation StartLoc, SourceLocation EndLoc,
                                unsigned NumLoops)
-      : OMPLoopTransformationDirective(OMPReverseDirectiveClass,
-                                       llvm::omp::OMPD_reverse, StartLoc,
-                                       EndLoc, NumLoops) {
+      : OMPCanonicalLoopNestTransformationDirective(
+            OMPReverseDirectiveClass, llvm::omp::OMPD_reverse, StartLoc, EndLoc,
+            NumLoops) {
     setNumGeneratedLoops(NumLoops);
   }
 
@@ -5848,7 +5852,8 @@ class OMPReverseDirective final : public OMPLoopTransformationDirective {
 ///     for (int j = 0; j < n; ++j)
 ///       ..
 /// \endcode
-class OMPInterchangeDirective final : public OMPLoopTransformationDirective {
+class OMPInterchangeDirective final
+    : public OMPCanonicalLoopNestTransformationDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
@@ -5860,9 +5865,9 @@ class OMPInterchangeDirective final : public OMPLoopTransformationDirective {
 
   explicit OMPInterchangeDirective(SourceLocation StartLoc,
                                    SourceLocation EndLoc, unsigned NumLoops)
-      : OMPLoopTransformationDirective(OMPInterchangeDirectiveClass,
-                                       llvm::omp::OMPD_interchange, StartLoc,
-                                       EndLoc, NumLoops) {
+      : OMPCanonicalLoopNestTransformationDirective(
+            OMPInterchangeDirectiveClass, llvm::omp::OMPD_interchange, StartLoc,
+            EndLoc, NumLoops) {
     setNumGeneratedLoops(NumLoops);
   }
 

clang/include/clang/Basic/OpenMPKinds.h

@@ -365,6 +365,13 @@ bool isOpenMPTaskingDirective(OpenMPDirectiveKind Kind);
 /// functions
 bool isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind);
 
+/// Checks if the specified directive is a loop transformation directive that
+/// applies to a canonical loop nest.
+/// \param DKind Specified directive.
+/// \return True iff the directive is a loop transformation.
+bool isOpenMPCanonicalLoopNestTransformationDirective(
+    OpenMPDirectiveKind DKind);
+
 /// Checks if the specified directive is a loop transformation directive.
 /// \param DKind Specified directive.
 /// \return True iff the directive is a loop transformation.

clang/include/clang/Basic/StmtNodes.td

@@ -230,12 +230,14 @@ def OMPLoopBasedDirective : StmtNode<OMPExecutableDirective, 1>;
 def OMPLoopDirective : StmtNode<OMPLoopBasedDirective, 1>;
 def OMPParallelDirective : StmtNode<OMPExecutableDirective>;
 def OMPSimdDirective : StmtNode<OMPLoopDirective>;
-def OMPLoopTransformationDirective : StmtNode<OMPLoopBasedDirective, 1>;
-def OMPTileDirective : StmtNode<OMPLoopTransformationDirective>;
-def OMPStripeDirective : StmtNode<OMPLoopTransformationDirective>;
-def OMPUnrollDirective : StmtNode<OMPLoopTransformationDirective>;
-def OMPReverseDirective : StmtNode<OMPLoopTransformationDirective>;
-def OMPInterchangeDirective : StmtNode<OMPLoopTransformationDirective>;
+def OMPCanonicalLoopNestTransformationDirective
+    : StmtNode<OMPLoopBasedDirective, 1>;
+def OMPTileDirective : StmtNode<OMPCanonicalLoopNestTransformationDirective>;
+def OMPStripeDirective : StmtNode<OMPCanonicalLoopNestTransformationDirective>;
+def OMPUnrollDirective : StmtNode<OMPCanonicalLoopNestTransformationDirective>;
+def OMPReverseDirective : StmtNode<OMPCanonicalLoopNestTransformationDirective>;
+def OMPInterchangeDirective
+    : StmtNode<OMPCanonicalLoopNestTransformationDirective>;
 def OMPForDirective : StmtNode<OMPLoopDirective>;
 def OMPForSimdDirective : StmtNode<OMPLoopDirective>;
 def OMPSectionsDirective : StmtNode<OMPExecutableDirective>;

clang/lib/AST/ByteCode/Compiler.cpp

@@ -2912,7 +2912,8 @@ bool Compiler<Emitter>::VisitMaterializeTemporaryExpr(
   OptPrimType SubExprT = classify(SubExpr);
   bool IsStatic = E->getStorageDuration() == SD_Static;
   if (IsStatic) {
-    std::optional<unsigned> GlobalIndex = P.createGlobal(E);
+
+    UnsignedOrNone GlobalIndex = P.createGlobal(E);
     if (!GlobalIndex)
       return false;
 
@@ -3001,7 +3002,7 @@ bool Compiler<Emitter>::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
     if (T && !E->isLValue())
       return this->delegate(Init);
 
-    std::optional<unsigned> GlobalIndex = P.createGlobal(E);
+    UnsignedOrNone GlobalIndex = P.createGlobal(E);
     if (!GlobalIndex)
       return false;
 
@@ -3345,7 +3346,7 @@ bool Compiler<Emitter>::VisitSourceLocExpr(const SourceLocExpr *E) {
 
   auto *UGCD = cast<UnnamedGlobalConstantDecl>(BaseDecl);
 
-  std::optional<unsigned> GlobalIndex = P.getOrCreateGlobal(UGCD);
+  UnsignedOrNone GlobalIndex = P.getOrCreateGlobal(UGCD);
   if (!GlobalIndex)
     return false;
 
@@ -3868,7 +3869,7 @@ bool Compiler<Emitter>::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
   if (!RD->isCompleteDefinition())
     return this->emitDummyPtr(GuidDecl, E);
 
-  std::optional<unsigned> GlobalIndex = P.getOrCreateGlobal(GuidDecl);
+  UnsignedOrNone GlobalIndex = P.getOrCreateGlobal(GuidDecl);
   if (!GlobalIndex)
     return false;
   if (!this->emitGetPtrGlobal(*GlobalIndex, E))
@@ -4860,7 +4861,7 @@ VarCreationState Compiler<Emitter>::visitVarDecl(const VarDecl *VD,
     DeclScope<Emitter> LocalScope(this, VD);
 
     // We've already seen and initialized this global.
-    if (std::optional<unsigned> GlobalIndex = P.getGlobal(VD)) {
+    if (UnsignedOrNone GlobalIndex = P.getGlobal(VD)) {
       if (P.getPtrGlobal(*GlobalIndex).isInitialized())
         return checkDecl();
 
@@ -4869,7 +4870,7 @@ VarCreationState Compiler<Emitter>::visitVarDecl(const VarDecl *VD,
       return Init && checkDecl() && initGlobal(*GlobalIndex);
     }
 
-    std::optional<unsigned> GlobalIndex = P.createGlobal(VD, Init);
+    UnsignedOrNone GlobalIndex = P.createGlobal(VD, Init);
 
     if (!GlobalIndex)
       return false;
@@ -6802,7 +6803,7 @@ bool Compiler<Emitter>::visitDeclRef(const ValueDecl *D, const Expr *E) {
     return F && this->emitGetFnPtr(F, E);
   }
   if (const auto *TPOD = dyn_cast<TemplateParamObjectDecl>(D)) {
-    if (std::optional<unsigned> Index = P.getOrCreateGlobal(D)) {
+    if (UnsignedOrNone Index = P.getOrCreateGlobal(D)) {
       if (!this->emitGetPtrGlobal(*Index, E))
         return false;
       if (OptPrimType T = classify(E->getType())) {

clang/lib/AST/ByteCode/EvalEmitter.cpp

@@ -331,7 +331,7 @@ bool EvalEmitter::emitDestroy(uint32_t I, const SourceInfo &Info) {
 /// This is what we do here.
 void EvalEmitter::updateGlobalTemporaries() {
   for (const auto &[E, Temp] : S.SeenGlobalTemporaries) {
-    if (std::optional<unsigned> GlobalIndex = P.getGlobal(E)) {
+    if (UnsignedOrNone GlobalIndex = P.getGlobal(E)) {
       const Pointer &Ptr = P.getPtrGlobal(*GlobalIndex);
       APValue *Cached = Temp->getOrCreateValue(true);
 

clang/lib/AST/ByteCode/Program.cpp

@@ -111,7 +111,7 @@ Pointer Program::getPtrGlobal(unsigned Idx) const {
   return Pointer(Globals[Idx]->block());
 }
 
-std::optional<unsigned> Program::getGlobal(const ValueDecl *VD) {
+UnsignedOrNone Program::getGlobal(const ValueDecl *VD) {
   if (auto It = GlobalIndices.find(VD); It != GlobalIndices.end())
     return It->second;
 
@@ -131,14 +131,14 @@ std::optional<unsigned> Program::getGlobal(const ValueDecl *VD) {
   return std::nullopt;
 }
 
-std::optional<unsigned> Program::getGlobal(const Expr *E) {
+UnsignedOrNone Program::getGlobal(const Expr *E) {
   if (auto It = GlobalIndices.find(E); It != GlobalIndices.end())
     return It->second;
   return std::nullopt;
 }
 
-std::optional<unsigned> Program::getOrCreateGlobal(const ValueDecl *VD,
-                                                   const Expr *Init) {
+UnsignedOrNone Program::getOrCreateGlobal(const ValueDecl *VD,
+                                          const Expr *Init) {
   if (auto Idx = getGlobal(VD))
     return Idx;
 
@@ -195,8 +195,7 @@ unsigned Program::getOrCreateDummy(const DeclTy &D) {
   return I;
 }
 
-std::optional<unsigned> Program::createGlobal(const ValueDecl *VD,
-                                              const Expr *Init) {
+UnsignedOrNone Program::createGlobal(const ValueDecl *VD, const Expr *Init) {
   bool IsStatic, IsExtern;
   bool IsWeak = VD->isWeak();
   if (const auto *Var = dyn_cast<VarDecl>(VD)) {
@@ -213,7 +212,7 @@ std::optional<unsigned> Program::createGlobal(const ValueDecl *VD,
 
   // Register all previous declarations as well. For extern blocks, just replace
   // the index with the new variable.
-  std::optional<unsigned> Idx =
+  UnsignedOrNone Idx =
       createGlobal(VD, VD->getType(), IsStatic, IsExtern, IsWeak, Init);
   if (!Idx)
     return std::nullopt;
@@ -240,7 +239,7 @@ std::optional<unsigned> Program::createGlobal(const ValueDecl *VD,
   return *Idx;
 }
 
-std::optional<unsigned> Program::createGlobal(const Expr *E) {
+UnsignedOrNone Program::createGlobal(const Expr *E) {
   if (auto Idx = getGlobal(E))
     return Idx;
   if (auto Idx = createGlobal(E, E->getType(), /*isStatic=*/true,
@@ -251,9 +250,9 @@ std::optional<unsigned> Program::createGlobal(const Expr *E) {
   return std::nullopt;
 }
 
-std::optional<unsigned> Program::createGlobal(const DeclTy &D, QualType Ty,
-                                              bool IsStatic, bool IsExtern,
-                                              bool IsWeak, const Expr *Init) {
+UnsignedOrNone Program::createGlobal(const DeclTy &D, QualType Ty,
+                                     bool IsStatic, bool IsExtern, bool IsWeak,
+                                     const Expr *Init) {
   // Create a descriptor for the global.
   Descriptor *Desc;
   const bool IsConst = Ty.isConstQualified();