Using getSource instead of getOriginalDef

Author: Renaud-K

flang/lib/Optimizer/Analysis/AliasAnalysis.cpp

@@ -439,20 +439,28 @@ static ModRefResult getCallModRef(fir::CallOp call, mlir::Value var) {
   // An example of something currently problematic is the allocmem generated for
   // ALLOCATE of allocatable target. It currently does not have the target
   // attribute, which would lead this analysis to believe it cannot escape.
-  if (!varSrc.isFortranUserVariable() || !isCallToFortranUserProcedure(call))
+  if (!varSrc.isFortranUserVariable() || !isCallToFortranUserProcedure(call)) {
+    LLVM_DEBUG(llvm::dbgs() << "ModAndRef because not a user variable or not a "
+                               "call to user procedure.\n");
     return ModRefResult::getModAndRef();
+  }
   // Pointer and target may have been captured.
-  if (varSrc.isTargetOrPointer())
+  if (varSrc.isTargetOrPointer()) {
+    LLVM_DEBUG(llvm::dbgs() << "ModAndRef because target or pointer.\n");
     return ModRefResult::getModAndRef();
+  }
   // Host associated variables may be addressed indirectly via an internal
   // function call, whether the call is in the parent or an internal procedure.
   // Note that the host associated/internal procedure may be referenced
   // indirectly inside calls to non internal procedure. This is because internal
   // procedures may be captured or passed. As this is tricky to analyze, always
   // consider such variables may be accessed in any calls.
   if (varSrc.kind == fir::AliasAnalysis::SourceKind::HostAssoc ||
-      varSrc.isCapturedInInternalProcedure)
+      varSrc.isCapturedInInternalProcedure) {
+    LLVM_DEBUG(llvm::dbgs() << "ModAndRef because var is host associated or "
+                               "captured in internal procedure.\n");
     return ModRefResult::getModAndRef();
+  }
   // At that stage, it has been ruled out that local (including the saved ones)
   // and dummy cannot be indirectly accessed in the call.
   if (varSrc.kind != fir::AliasAnalysis::SourceKind::Allocate &&
@@ -485,6 +493,8 @@ ModRefResult AliasAnalysis::getModRef(Operation *op, Value location) {
   if (!interface) {
     if (auto call = llvm::dyn_cast<fir::CallOp>(op))
       return getCallModRef(call, location);
+
+    LLVM_DEBUG(llvm::dbgs() << "ModAndRef because no interface or call.\n");
     return ModRefResult::getModAndRef();
   }
 
@@ -621,38 +631,33 @@ AliasAnalysis::Source AliasAnalysis::getSource(mlir::Value v,
             if (mlir::isa<fir::PointerType>(boxTy.getEleTy()))
               attributes.set(Attribute::Pointer);
 
-            auto def = getOriginalDef(op.getMemref(), attributes,
-                                      isCapturedInInternalProcedure,
-                                      approximateSource);
-            if (auto addrOfOp = def.template getDefiningOp<fir::AddrOfOp>()) {
-              global = addrOfOp.getSymbol();
-
-              if (hasGlobalOpTargetAttr(def, addrOfOp))
-                attributes.set(Attribute::Target);
+            auto boxSrc = getSource(op.getMemref());
+            attributes |= boxSrc.attributes;
+            approximateSource |= boxSrc.approximateSource;
+            isCapturedInInternalProcedure |= boxSrc.isCapturedInInternalProcedure;
 
+            global = llvm::dyn_cast<mlir::SymbolRefAttr>(boxSrc.origin.u);
+            if (global) {
               type = SourceKind::Global;
-            }
-            // TODO: Add support to fir.allocmem
-            else if (auto allocOp =
-                         def.template getDefiningOp<fir::AllocaOp>()) {
-              v = def;
-              defOp = v.getDefiningOp();
-              type = SourceKind::Allocate;
-            } else if (isDummyArgument(def)) {
-              defOp = nullptr;
-              v = def;
             } else {
-              type = SourceKind::Indirect;
+              auto def = llvm::cast<mlir::Value>(boxSrc.origin.u);
+              // TODO: Add support to fir.allocmem
+              if (auto allocOp = def.template getDefiningOp<fir::AllocaOp>()) {
+                v = def;
+                defOp = v.getDefiningOp();
+                type = SourceKind::Allocate;
+              } else if (isDummyArgument(def)) {
+                defOp = nullptr;
+                v = def;
+              } else {
+                type = SourceKind::Indirect;
+              }
             }
-            // TODO: This assignment is redundant but somehow works around an
-            // apparent MSVC bug reporting "undeclared identifier" at the next
-            // "breakFromLoop = true;".  See
-            // <https://github.com/llvm/llvm-project/pull/127845#issuecomment-2669829610>.
             breakFromLoop = true;
-          } else {
-            // No further tracking for addresses loaded from memory for now.
-            type = SourceKind::Indirect;
+            return;
           }
+          // No further tracking for addresses loaded from memory for now.
+          type = SourceKind::Indirect;
           breakFromLoop = true;
         })
         .Case<fir::AddrOfOp>([&](auto op) {