[NFC] Don't copy MachineFrameInfo on each invocation of HasAlias

[sanjoy.google]

Summary

Also fix a typo in a comment. This fixes a compile time issue in XLA
(https://www.tensorflow.org/xla).

[sanjoy.google]

Actually make sure this builds. :)

[rnk]

lgtm

llvm/lib/CodeGen/MachineInstr.cpp

1290

@hliao, this value capture is the source of the issue.

llvm/lib/CodeGen/MachineInstr.cpp

bool MachineInstr::isSafeToMove(AAResults *AA, bool &SawStore) const {
   if (mayLoad() && !isDereferenceableInvariantLoad(AA))
     // Otherwise, this is a real load.  If there is a store between the load and
     // end of block, we can't move it.
     return !SawStore;
 
   return true;
 }
 
-bool MachineInstr::mayAlias(AAResults *AA, const MachineInstr &Other,
-                            bool UseTBAA) const {
-  const MachineFunction *MF = getMF();
-  const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
-  const MachineFrameInfo &MFI = MF->getFrameInfo();
-
-  // Execulde call instruction which may alter the memory but can not be handled
-  // by this function.
-  if (isCall() || Other.isCall())
-    return true;
-
-  // If neither instruction stores to memory, they can't alias in any
-  // meaningful way, even if they read from the same address.
-  if (!mayStore() && !Other.mayStore())
-    return false;
-
-  // Both instructions must be memory operations to be able to alias.
-  if (!mayLoadOrStore() || !Other.mayLoadOrStore())
-    return false;
-
-  // Let the target decide if memory accesses cannot possibly overlap.
-  if (TII->areMemAccessesTriviallyDisjoint(*this, Other))
-    return false;
-
-  // Memory operations without memory operands may access anything. Be
-  // conservative and assume `MayAlias`.
-  if (memoperands_empty() || Other.memoperands_empty())
-    return true;
-
-  // Skip if there are too many memory operands.
-  auto NumChecks = getNumMemOperands() * Other.getNumMemOperands();
-  if (NumChecks > TII->getMemOperandAACheckLimit())
-    return true;
-
-  auto HasAlias = [MFI, AA, UseTBAA](const MachineMemOperand *MMOa,
-                                     const MachineMemOperand *MMOb) {
-    // The following interface to AA is fashioned after DAGCombiner::isAlias
-    // and operates with MachineMemOperand offset with some important
-    // assumptions:
-    //   - LLVM fundamentally assumes flat address spaces.
-    //   - MachineOperand offset can *only* result from legalization and
-    //     cannot affect queries other than the trivial case of overlap
-    //     checking.
-    //   - These offsets never wrap and never step outside
-    //     of allocated objects.
-    //   - There should never be any negative offsets here.
-    //
-    // FIXME: Modify API to hide this math from "user"
-    // Even before we go to AA we can reason locally about some
-    // memory objects. It can save compile time, and possibly catch some
-    // corner cases not currently covered.
+static bool MemOperandsHaveAlias(const MachineFrameInfo &MFI, AAResults *AA,
+                                 bool UseTBAA, const MachineMemOperand *MMOa,
+  // The following interface to AA is fashioned after DAGCombiner::isAlias and
+  // operates with MachineMemOperand offset with some important assumptions:
+  //   - MachineOperand offset can *only* result from legalization and cannot
+  //     affect queries other than the trivial case of overlap checking.
+  //   - These offsets never wrap and never step outside of allocated objects.
+  // Even before we go to AA we can reason locally about some memory objects. It
+  // can save compile time, and possibly catch some corner cases not currently
+  // covered.
 
-    int64_t OffsetA = MMOa->getOffset();
-    int64_t OffsetB = MMOb->getOffset();
-    int64_t MinOffset = std::min(OffsetA, OffsetB);
 
-    uint64_t WidthA = MMOa->getSize();
-    uint64_t WidthB = MMOb->getSize();
-    bool KnownWidthA = WidthA != MemoryLocation::UnknownSize;
-    bool KnownWidthB = WidthB != MemoryLocation::UnknownSize;
 
-    const Value *ValA = MMOa->getValue();
-    const Value *ValB = MMOb->getValue();
-    bool SameVal = (ValA && ValB && (ValA == ValB));
-    if (!SameVal) {
-      const PseudoSourceValue *PSVa = MMOa->getPseudoValue();
-      const PseudoSourceValue *PSVb = MMOb->getPseudoValue();
-      if (PSVa && ValB && !PSVa->mayAlias(&MFI))
-        return false;
-      if (PSVb && ValA && !PSVb->mayAlias(&MFI))
-        return false;
-      if (PSVa && PSVb && (PSVa == PSVb))
-        SameVal = true;
-    }
 
-    if (SameVal) {
-      if (!KnownWidthA || !KnownWidthB)
-        return true;
-      int64_t MaxOffset = std::max(OffsetA, OffsetB);
-      int64_t LowWidth = (MinOffset == OffsetA) ? WidthA : WidthB;
-      return (MinOffset + LowWidth > MaxOffset);
-    }
 
-    if (!AA)
-      return true;
 
-    if (!ValA || !ValB)
-      return true;
 
-    assert((OffsetA >= 0) && "Negative MachineMemOperand offset");
-    assert((OffsetB >= 0) && "Negative MachineMemOperand offset");
 
-    int64_t OverlapA = KnownWidthA ? WidthA + OffsetA - MinOffset
-                                   : MemoryLocation::UnknownSize;
-    int64_t OverlapB = KnownWidthB ? WidthB + OffsetB - MinOffset
-                                   : MemoryLocation::UnknownSize;
-
-    AliasResult AAResult =
-        AA->alias(MemoryLocation(ValA, OverlapA,
-                                 UseTBAA ? MMOa->getAAInfo() : AAMDNodes()),
-                  MemoryLocation(ValB, OverlapB,
-                                 UseTBAA ? MMOb->getAAInfo() : AAMDNodes()));
+  int64_t OverlapA =
+      KnownWidthA ? WidthA + OffsetA - MinOffset : MemoryLocation::UnknownSize;
+  int64_t OverlapB =
+      KnownWidthB ? WidthB + OffsetB - MinOffset : MemoryLocation::UnknownSize;
+
+  AliasResult AAResult = AA->alias(
+      MemoryLocation(ValA, OverlapA, UseTBAA ? MMOa->getAAInfo() : AAMDNodes()),
 
-    return (AAResult != NoAlias);
-  };
+}
+
+bool MachineInstr::mayAlias(AAResults *AA, const MachineInstr &Other,
+                            bool UseTBAA) const {
+  const MachineFunction *MF = getMF();
+  const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
+  const MachineFrameInfo &MFI = MF->getFrameInfo();
+
+  // Exclude call instruction which may alter the memory but can not be handled
+  // by this function.
+  if (isCall() || Other.isCall())
+    return true;
+
+  // If neither instruction stores to memory, they can't alias in any
+  // meaningful way, even if they read from the same address.
+  if (!mayStore() && !Other.mayStore())
+    return false;
+
+  // Both instructions must be memory operations to be able to alias.
+  if (!mayLoadOrStore() || !Other.mayLoadOrStore())
+    return false;
+
+  // Let the target decide if memory accesses cannot possibly overlap.
+  if (TII->areMemAccessesTriviallyDisjoint(*this, Other))
+    return false;
+
+  // Memory operations without memory operands may access anything. Be
+  // conservative and assume `MayAlias`.
+  if (memoperands_empty() || Other.memoperands_empty())
+    return true;
+
+  // Skip if there are too many memory operands.
+  auto NumChecks = getNumMemOperands() * Other.getNumMemOperands();
+  if (NumChecks > TII->getMemOperandAACheckLimit())
+    return true;
 
   // Check each pair of memory operands from both instructions, which can't
   // alias only if all pairs won't alias.
   for (auto *MMOa : memoperands())
     for (auto *MMOb : Other.memoperands())
-      if (HasAlias(MMOa, MMOb))
+      if (MemOperandsHaveAlias(MFI, UseTBAA, MMOa, MMOb))
         return true;
 
   return false;
 }
 
 /// hasOrderedMemoryRef - Return true if this instruction may have an ordered
 /// or volatile memory reference, or if the information describing the memory
 /// reference is not available. Return false if it is known to have no ordered