Refactored preinits handling and improved coverage

Author: eZWALT

clang/docs/OpenMPSupport.rst

@@ -376,7 +376,7 @@ implementation.
 +-------------------------------------------------------------+---------------------------+---------------------------+--------------------------------------------------------------------------+
 | loop stripe transformation                                  | :good:`done`              | https://github.com/llvm/llvm-project/pull/119891                                                     |
 +-------------------------------------------------------------+---------------------------+---------------------------+--------------------------------------------------------------------------+
-| loop fuse transformation                                    | :good:`done`              | :none:`unclaimed`        |                                                                          |
+| loop fuse transformation                                    | :good:`prototyped`        | :none:`unclaimed`         |                                                                          |
 +-------------------------------------------------------------+---------------------------+---------------------------+--------------------------------------------------------------------------+
 | work distribute construct                                   | :none:`unclaimed`         | :none:`unclaimed`         |                                                                          |
 +-------------------------------------------------------------+---------------------------+---------------------------+--------------------------------------------------------------------------+

clang/include/clang/AST/StmtOpenMP.h

@@ -1005,8 +1005,7 @@ class OMPLoopTransformationDirective : public OMPLoopBasedDirective {
     Stmt::StmtClass C = T->getStmtClass();
     return C == OMPTileDirectiveClass || C == OMPUnrollDirectiveClass ||
            C == OMPReverseDirectiveClass || C == OMPInterchangeDirectiveClass ||
-           C == OMPStripeDirectiveClass ||
-           C == OMPFuseDirectiveClass;
+           C == OMPStripeDirectiveClass || C == OMPFuseDirectiveClass;
   }
 };
 
@@ -5653,6 +5652,8 @@ class OMPStripeDirective final : public OMPLoopTransformationDirective {
                                        llvm::omp::OMPD_stripe, StartLoc, EndLoc,
                                        NumLoops) {
     setNumGeneratedLoops(2 * NumLoops);
+    // Similar to Tile, it only generates a single top level loop nest
+    setNumGeneratedLoopNests(1);
   }
 
   void setPreInits(Stmt *PreInits) {

clang/include/clang/Sema/SemaOpenMP.h

@@ -1494,16 +1494,96 @@ class SemaOpenMP : public SemaBase {
       SmallVectorImpl<OMPLoopBasedDirective::HelperExprs> &LoopHelpers,
       Stmt *&Body, SmallVectorImpl<SmallVector<Stmt *, 0>> &OriginalInits);
 
-  /// Analyzes and checks a loop sequence for use by a loop transformation
+  /// @brief Categories of loops encountered during semantic OpenMP loop
+  /// analysis
+  ///
+  /// This enumeration identifies the structural category of a loop or sequence
+  /// of loops analyzed in the context of OpenMP transformations and directives.
+  /// This categorization helps differentiate between original source loops
+  /// and the structures resulting from applying OpenMP loop transformations.
+  enum class OMPLoopCategory {
+
+    /// @var OMPLoopCategory::RegularLoop
+    /// Represents a standard canonical loop nest found in the
+    /// original source code or an intact loop after transformations
+    /// (i.e Post/Pre loops of a loopranged fusion)
+    RegularLoop,
+
+    /// @var OMPLoopCategory::TransformSingleLoop
+    /// Represents the resulting loop structure when an OpenMP loop
+    //  transformation, generates a single, top-level loop
+    TransformSingleLoop,
+
+    /// @var OMPLoopCategory::TransformLoopSequence
+    /// Represents the resulting loop structure when an OpenMP loop
+    /// transformation
+    /// generates a sequence of two or more canonical loop nests
+    TransformLoopSequence
+  };
+
+  /// The main recursive process of `checkTransformableLoopSequence` that
+  /// performs grammatical parsing of a canonical loop sequence. It extracts
+  /// key information, such as the number of top-level loops, loop statements,
+  /// helper expressions, and other relevant loop-related data, all in a single
+  /// execution to avoid redundant traversals. This analysis flattens inner
+  /// Loop Sequences
+  ///
+  /// \param LoopSeqStmt    The AST of the original statement.
+  /// \param LoopSeqSize    [out] Number of top level canonical loops.
+  /// \param NumLoops       [out] Number of total canonical loops (nested too).
+  /// \param LoopHelpers    [out] The multiple loop analyses results.
+  /// \param ForStmts       [out] The multiple Stmt of each For loop.
+  /// \param OriginalInits  [out] The raw original initialization statements
+  ///                       of each belonging to a loop of the loop sequence
+  /// \param TransformPreInits [out] The multiple collection of statements and
+  ///                       declarations that must have been executed/declared
+  ///                       before entering the loop (each belonging to a
+  ///                       particular loop transformation, nullptr otherwise)
+  /// \param LoopSequencePreInits [out] Additional general collection of loop
+  ///                       transformation related statements and declarations
+  ///                       not bounded to a particular loop that must be
+  ///                       executed before entering the loop transformation
+  /// \param LoopCategories [out] A sequence of OMPLoopCategory values,
+  ///                       one for each loop or loop transformation node
+  ///                       successfully analyzed.
+  /// \param Context
+  /// \param Kind           The loop transformation directive kind.
+  /// \return Whether the original statement is both syntactically and
+  /// semantically correct according to OpenMP 6.0 canonical loop
+  /// sequence definition.
+  bool analyzeLoopSequence(
+      Stmt *LoopSeqStmt, unsigned &LoopSeqSize, unsigned &NumLoops,
+      SmallVectorImpl<OMPLoopBasedDirective::HelperExprs> &LoopHelpers,
+      SmallVectorImpl<Stmt *> &ForStmts,
+      SmallVectorImpl<SmallVector<Stmt *, 0>> &OriginalInits,
+      SmallVectorImpl<SmallVector<Stmt *, 0>> &TransformsPreInits,
+      SmallVectorImpl<SmallVector<Stmt *, 0>> &LoopSequencePreInits,
+      SmallVectorImpl<OMPLoopCategory> &LoopCategories, ASTContext &Context,
+      OpenMPDirectiveKind Kind);
+
+  /// Validates and checks whether a loop sequence can be transformed according
+  /// to the given directive, providing necessary setup and initialization
+  /// (Driver function) before recursion using `analyzeLoopSequence`.
   ///
   /// \param Kind           The loop transformation directive kind.
-  /// \param NumLoops       [out] Number of total canonical loops
-  /// \param LoopSeqSize    [out] Number of top level canonical loops
+  /// \param AStmt          The AST of the original statement
+  /// \param LoopSeqSize    [out] Number of top level canonical loops.
+  /// \param NumLoops       [out] Number of total canonical loops (nested too)
   /// \param LoopHelpers    [out] The multiple loop analyses results.
-  /// \param LoopStmts      [out] The multiple Stmt of each For loop.
-  /// \param OriginalInits  [out] The multiple collection of statements and
+  /// \param ForStmts       [out] The multiple Stmt of each For loop.
+  /// \param OriginalInits  [out] The raw original initialization statements
+  ///                       of each belonging to a loop of the loop sequence
+  /// \param TransformsPreInits [out] The multiple collection of statements and
   ///                       declarations that must have been executed/declared
-  ///                       before entering the loop.
+  ///                       before entering the loop (each belonging to a
+  ///                       particular loop transformation, nullptr otherwise)
+  /// \param LoopSequencePreInits [out] Additional general collection of loop
+  ///                       transformation related statements and declarations
+  ///                       not bounded to a particular loop that must be
+  ///                       executed before entering the loop transformation
+  /// \param LoopCategories [out] A sequence of OMPLoopCategory values,
+  ///                       one for each loop or loop transformation node
+  ///                       successfully analyzed.
   /// \param Context
   /// \return Whether there was an absence of errors or not
   bool checkTransformableLoopSequence(
@@ -1512,7 +1592,9 @@ class SemaOpenMP : public SemaBase {
       SmallVectorImpl<OMPLoopBasedDirective::HelperExprs> &LoopHelpers,
       SmallVectorImpl<Stmt *> &ForStmts,
       SmallVectorImpl<SmallVector<Stmt *, 0>> &OriginalInits,
-      ASTContext &Context);
+      SmallVectorImpl<SmallVector<Stmt *, 0>> &TransformsPreInits,
+      SmallVectorImpl<SmallVector<Stmt *, 0>> &LoopSequencePreInits,
+      SmallVectorImpl<OMPLoopCategory> &LoopCategories, ASTContext &Context);
 
   /// Helper to keep information about the current `omp begin/end declare
   /// variant` nesting.

clang/lib/AST/StmtOpenMP.cpp

@@ -457,6 +457,8 @@ OMPUnrollDirective::Create(const ASTContext &C, SourceLocation StartLoc,
       C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc);
   Dir->setNumGeneratedLoops(NumGeneratedLoops);
   // The number of generated loops and loop nests during unroll matches
+  // given that unroll only generates top level canonical loop nests
+  // so each generated loop is a top level canonical loop nest
   Dir->setNumGeneratedLoopNests(NumGeneratedLoops);
   Dir->setTransformedStmt(TransformedStmt);
   Dir->setPreInits(PreInits);
@@ -520,6 +522,17 @@ OMPFuseDirective *OMPFuseDirective::Create(
       NumLoops);
   Dir->setTransformedStmt(TransformedStmt);
   Dir->setPreInits(PreInits);
+  // The number of top level canonical nests could 
+  // not match the total number of generated loops
+  // Example:
+  // Before fusion:
+  //   for (int i = 0; i < N; ++i)   
+  //     for (int j = 0; j < M; ++j) 
+  //       A[i][j] = i + j;
+  //   
+  //   for (int k = 0; k < P; ++k) 
+  //     B[k] = k * 2;
+  // Here, NumLoopNests = 2, but NumLoops = 3.
   Dir->setNumGeneratedLoopNests(NumLoopNests);
   Dir->setNumGeneratedLoops(NumLoops);
   return Dir;

clang/lib/Basic/OpenMPKinds.cpp

@@ -704,7 +704,8 @@ bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) {
 
 bool clang::isOpenMPLoopTransformationDirective(OpenMPDirectiveKind DKind) {
   return DKind == OMPD_tile || DKind == OMPD_unroll || DKind == OMPD_reverse ||
-         DKind == OMPD_interchange || DKind == OMPD_stripe || DKind == OMPD_fuse;
+         DKind == OMPD_interchange || DKind == OMPD_stripe ||
+         DKind == OMPD_fuse;
 }
 
 bool clang::isOpenMPCombinedParallelADirective(OpenMPDirectiveKind DKind) {

clang/lib/CodeGen/CGExpr.cpp

@@ -3257,6 +3257,8 @@ LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
 
     // No other cases for now.
     } else {
+      llvm::dbgs() << "THE DAMN DECLREFEXPR HASN'T BEEN ENTERED IN LOCALDECLMAP\n";
+      VD->dumpColor();
       llvm_unreachable("DeclRefExpr for Decl not entered in LocalDeclMap?");
     }
 

clang/lib/CodeGen/CodeGenFunction.h

@@ -5363,6 +5363,10 @@ class CodeGenFunction : public CodeGenTypeCache {
 
   /// Set the address of a local variable.
   void setAddrOfLocalVar(const VarDecl *VD, Address Addr) {
+    if (LocalDeclMap.count(VD)) {
+      llvm::errs() << "Warning: VarDecl already exists in map: ";
+      VD->dumpColor(); 
+    }
     assert(!LocalDeclMap.count(VD) && "Decl already exists in LocalDeclMap!");
     LocalDeclMap.insert({VD, Addr});
   }