MCExpr: Move isSymbolUsedInExpression workaround to AMDGPU

This function was a workaround used to detect cyclic dependency
(properly resolved by 343428c).
We do not want backends to use it. However, llvm#112251 exposed it to MCExpr
to be reused by AMDGPU. Keep the workaround within AMDGPU to prevent
other backends from accidentally relying on it.

Author: MaskRay

llvm/include/llvm/MC/MCExpr.h

@@ -86,10 +86,6 @@ class MCExpr {
                       int SurroundingPrec = 0) const;
   LLVM_ABI void dump() const;
 
-  /// Returns whether the given symbol is used anywhere in the expression or
-  /// subexpressions.
-  LLVM_ABI bool isSymbolUsedInExpression(const MCSymbol *Sym) const;
-
   /// @}
   /// \name Expression Evaluation
   /// @{
@@ -489,9 +485,6 @@ class LLVM_ABI MCTargetExpr : public MCExpr {
                                          const MCAssembler *Asm) const = 0;
   // allow Target Expressions to be checked for equality
   virtual bool isEqualTo(const MCExpr *x) const { return false; }
-  virtual bool isSymbolUsedInExpression(const MCSymbol *Sym) const {
-    return false;
-  }
   // This should be set when assigned expressions are not valid ".set"
   // expressions, e.g. registers, and must be inlined.
   virtual bool inlineAssignedExpr() const { return false; }

llvm/lib/MC/MCExpr.cpp

@@ -187,38 +187,6 @@ LLVM_DUMP_METHOD void MCExpr::dump() const {
 }
 #endif
 
-bool MCExpr::isSymbolUsedInExpression(const MCSymbol *Sym) const {
-  switch (getKind()) {
-  case MCExpr::Binary: {
-    const MCBinaryExpr *BE = static_cast<const MCBinaryExpr *>(this);
-    return BE->getLHS()->isSymbolUsedInExpression(Sym) ||
-           BE->getRHS()->isSymbolUsedInExpression(Sym);
-  }
-  case MCExpr::Target: {
-    const MCTargetExpr *TE = static_cast<const MCTargetExpr *>(this);
-    return TE->isSymbolUsedInExpression(Sym);
-  }
-  case MCExpr::Constant:
-    return false;
-  case MCExpr::SymbolRef: {
-    const MCSymbol &S = static_cast<const MCSymbolRefExpr *>(this)->getSymbol();
-    if (S.isVariable() && !S.isWeakExternal())
-      return S.getVariableValue()->isSymbolUsedInExpression(Sym);
-    return &S == Sym;
-  }
-  case MCExpr::Unary: {
-    const MCExpr *SubExpr =
-        static_cast<const MCUnaryExpr *>(this)->getSubExpr();
-    return SubExpr->isSymbolUsedInExpression(Sym);
-  }
-  case MCExpr::Specifier:
-    return static_cast<const MCSpecifierExpr *>(this)->isSymbolUsedInExpression(
-        Sym);
-  }
-
-  llvm_unreachable("Unknown expr kind!");
-}
-
 /* *** */
 
 const MCBinaryExpr *MCBinaryExpr::create(Opcode Opc, const MCExpr *LHS,

llvm/lib/Target/AMDGPU/AMDGPUMCResourceInfo.cpp

@@ -127,7 +127,8 @@ void MCResourceInfo::assignResourceInfoExpr(
       // Avoid constructing recursive definitions by detecting whether `Sym` is
       // found transitively within any of its `CalleeValSym`.
       if (!CalleeValSym->isVariable() ||
-          !CalleeValSym->getVariableValue()->isSymbolUsedInExpression(Sym)) {
+          !AMDGPUMCExpr::isSymbolUsedInExpression(
+              Sym, CalleeValSym->getVariableValue())) {
         LLVM_DEBUG(dbgs() << "MCResUse:   " << Sym->getName() << ": Adding "
                           << CalleeValSym->getName() << " as callee\n");
         ArgExprs.push_back(MCSymbolRefExpr::create(CalleeValSym, OutContext));
@@ -243,7 +244,8 @@ void MCResourceInfo::gatherResourceInfo(
         // Avoid constructing recursive definitions by detecting whether `Sym`
         // is found transitively within any of its `CalleeValSym`.
         if (!CalleeValSym->isVariable() ||
-            !CalleeValSym->getVariableValue()->isSymbolUsedInExpression(Sym)) {
+            !AMDGPUMCExpr::isSymbolUsedInExpression(
+                Sym, CalleeValSym->getVariableValue())) {
           LLVM_DEBUG(dbgs() << "MCResUse:   " << Sym->getName() << ": Adding "
                             << CalleeValSym->getName() << " as callee\n");
           ArgExprs.push_back(MCSymbolRefExpr::create(CalleeValSym, OutContext));

llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCExpr.cpp

@@ -214,6 +214,37 @@ bool AMDGPUMCExpr::evaluateOccupancy(MCValue &Res,
   return true;
 }
 
+bool AMDGPUMCExpr::isSymbolUsedInExpression(const MCSymbol *Sym,
+                                            const MCExpr *E) {
+  switch (E->getKind()) {
+  case MCExpr::Constant:
+    return false;
+  case MCExpr::Unary:
+    return isSymbolUsedInExpression(
+        Sym, static_cast<const MCUnaryExpr *>(E)->getSubExpr());
+  case MCExpr::Binary: {
+    const MCBinaryExpr *BE = static_cast<const MCBinaryExpr *>(E);
+    return isSymbolUsedInExpression(Sym, BE->getLHS()) ||
+           isSymbolUsedInExpression(Sym, BE->getRHS());
+  }
+  case MCExpr::SymbolRef: {
+    const MCSymbol &S = static_cast<const MCSymbolRefExpr *>(E)->getSymbol();
+    if (S.isVariable())
+      return isSymbolUsedInExpression(Sym, S.getVariableValue());
+    return &S == Sym;
+  }
+  case MCExpr::Specifier:
+  case MCExpr::Target: {
+    auto *TE = static_cast<const AMDGPUMCExpr *>(E);
+    for (const MCExpr *E : TE->getArgs())
+      if (isSymbolUsedInExpression(Sym, E))
+        return true;
+    return false;
+  }
+  }
+  llvm_unreachable("Unknown expr kind!");
+}
+
 bool AMDGPUMCExpr::evaluateAsRelocatableImpl(MCValue &Res,
                                              const MCAssembler *Asm) const {
   std::optional<int64_t> Total;
@@ -303,14 +334,6 @@ const AMDGPUMCExpr *AMDGPUMCExpr::createOccupancy(unsigned InitOcc,
                 Ctx);
 }
 
-bool AMDGPUMCExpr::isSymbolUsedInExpression(const MCSymbol *Sym) const {
-  for (const MCExpr *E : getArgs()) {
-    if (E->isSymbolUsedInExpression(Sym))
-      return true;
-  }
-  return false;
-}
-
 static KnownBits fromOptionalToKnownBits(std::optional<bool> CompareResult) {
   static constexpr unsigned BitWidth = 64;
   const APInt True(BitWidth, 1);

llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCExpr.h

@@ -106,13 +106,13 @@ class AMDGPUMCExpr : public MCTargetExpr {
   void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override;
   bool evaluateAsRelocatableImpl(MCValue &Res,
                                  const MCAssembler *Asm) const override;
-  bool isSymbolUsedInExpression(const MCSymbol *Sym) const override;
   void visitUsedExpr(MCStreamer &Streamer) const override;
   MCFragment *findAssociatedFragment() const override;
 
   static bool classof(const MCExpr *E) {
     return E->getKind() == MCExpr::Target;
   }
+  static bool isSymbolUsedInExpression(const MCSymbol *Sym, const MCExpr *E);
 };
 
 namespace AMDGPU {