Use order of computation, instead of exprLocs for comparing attach-ptr-exprs.

Author: abhinavgaba

clang/lib/CodeGen/CGOpenMPRuntime.cpp

@@ -6765,35 +6765,16 @@ llvm::Value *CGOpenMPRuntime::emitNumThreadsForTargetDirective(
 namespace {
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
-/// Utility to compare expression locations.
-/// Returns true if expr-loc of LHS is less-than that of RHS.
-/// This function asserts that both expressions have valid expr-locations.
-static bool compareExprLocs(const Expr *LHS, const Expr *RHS) {
-  // Assert that neither LHS nor RHS can be null
-  assert(LHS && "LHS expression cannot be null");
-  assert(RHS && "RHS expression cannot be null");
-
-  // Get source locations
-  SourceLocation LocLHS = LHS->getExprLoc();
-  SourceLocation LocRHS = RHS->getExprLoc();
-
-  // Assert that we have valid source locations
-  assert(LocLHS.isValid() && "LHS expression must have valid source location");
-  assert(LocRHS.isValid() && "RHS expression must have valid source location");
-
-  // Compare source locations for deterministic ordering
-  return LocLHS < LocRHS;
-}
-
 // Utility to handle information from clauses associated with a given
 // construct that use mappable expressions (e.g. 'map' clause, 'to' clause).
 // It provides a convenient interface to obtain the information and generate
 // code for that information.
 class MappableExprsHandler {
 public:
   /// Custom comparator for attach-pointer expressions that compares them by
-  /// complexity (i.e. their component-depth) first, then by their expr-locs if
-  /// they are semantically different.
+  /// complexity (i.e. their component-depth) first, then by the order in which
+  /// they were computed by findAttachPtrExpr(), if they are semantically
+  /// different.
   struct AttachPtrExprComparator {
     const MappableExprsHandler *Handler;
     // Cache of previous equality comparison results.
@@ -6823,8 +6804,8 @@ class MappableExprsHandler {
         // Both have same complexity, now check semantic equality
         if (areEqual(LHS, RHS))
           return false;
-        // Different semantically, compare by location
-        return compareExprLocs(LHS, RHS);
+        // Different semantically, compare by computation order
+        return wasComputedBefore(LHS, RHS);
       }
       if (!DepthLHS.has_value())
         return true; // LHS has lower complexity
@@ -6838,8 +6819,8 @@ class MappableExprsHandler {
       // Same complexity, now check semantic equality
       if (areEqual(LHS, RHS))
         return false;
-      // Different semantically, compare by location
-      return compareExprLocs(LHS, RHS);
+      // Different semantically, compare by computation order
+      return wasComputedBefore(LHS, RHS);
     }
 
   public:
@@ -6860,6 +6841,15 @@ class MappableExprsHandler {
       return ComparisonResult;
     }
 
+    /// Compare the two attach-ptr expressions by their computation order.
+    /// Returns true iff LHS was computed before RHS by findAttachPtrExpr.
+    bool wasComputedBefore(const Expr *LHS, const Expr *RHS) const {
+      const size_t &OrderLHS = Handler->AttachPtrComputationOrderMap.at(LHS);
+      const size_t &OrderRHS = Handler->AttachPtrComputationOrderMap.at(RHS);
+
+      return OrderLHS < OrderRHS;
+    }
+
   private:
     /// Helper function to compare attach-pointer expressions semantically.
     /// This function handles various expression types that can be part of an
@@ -7218,6 +7208,11 @@ class MappableExprsHandler {
   llvm::DenseMap<const Expr *, std::optional<size_t>>
       AttachPtrComponentDepthMap = {{nullptr, std::nullopt}};
 
+  /// Map from attach pointer expressions to the order they were computed in, in
+  /// findAttachPtrExpr().
+  llvm::DenseMap<const Expr *, size_t> AttachPtrComputationOrderMap = {
+      {nullptr, 0}};
+
   llvm::Value *getExprTypeSize(const Expr *E) const {
     QualType ExprTy = E->getType().getCanonicalType();
 
@@ -8508,9 +8503,13 @@ class MappableExprsHandler {
     return true;
   }
 
-  // A wrapper around OMPClauseMappableExprCommon::findAttachPtrExpr. that
-  // accepts \p CurDir instead of an OpenMPDirectiveKind.
-  static std::pair<const Expr *, std::optional<size_t>> findAttachPtrExpr(
+  /// Computes the attach-ptr expr for \p Components, and updates various maps
+  /// with the information.
+  /// It internally calls OMPClauseMappableExprCommon::findAttachPtrExpr()
+  /// with the OpenMPDirectiveKind extracted from \p CurDir.
+  /// It updates AttachPtrComputationOrderMap, AttachPtrComponentDepthMap, and
+  /// AttachPtrExprMap.
+  void collectAttachPtrExprInfo(
       OMPClauseMappableExprCommon::MappableExprComponentListRef Components,
       llvm::PointerUnion<const OMPExecutableDirective *,
                          const OMPDeclareMapperDecl *>
@@ -8521,8 +8520,14 @@ class MappableExprsHandler {
             ? OMPD_declare_mapper
             : cast<const OMPExecutableDirective *>(CurDir)->getDirectiveKind();
 
-    return OMPClauseMappableExprCommon::findAttachPtrExpr(Components,
-                                                          CurDirectiveID);
+    const auto &[AttachPtrExpr, Depth] =
+        OMPClauseMappableExprCommon::findAttachPtrExpr(Components,
+                                                       CurDirectiveID);
+
+    AttachPtrComputationOrderMap.try_emplace(
+        AttachPtrExpr, AttachPtrComputationOrderMap.size());
+    AttachPtrComponentDepthMap.try_emplace(AttachPtrExpr, Depth);
+    AttachPtrExprMap.try_emplace(Components, AttachPtrExpr);
   }
 
   /// Generate all the base pointers, section pointers, sizes, map types, and