[MLIR][mlir-link] Refactor out SymbolAttrLinkerInterface

Author: xlauko

mlir/include/mlir/Linker/LinkerInterface.h

@@ -131,6 +131,24 @@ class SymbolLinkerInterface : public LinkerInterface<SymbolLinkerInterface> {
   unsigned flags = LinkerFlags::None;
 };
 
+//===----------------------------------------------------------------------===//
+// SymbolAttrLinkerInterface
+//===----------------------------------------------------------------------===//
+
+class SymbolAttrLinkerInterface : public SymbolLinkerInterface {
+public:
+  using SymbolLinkerInterface::SymbolLinkerInterface;
+
+  /// Returns the symbol for the given operation.
+  StringRef getSymbol(Operation *op) const override;
+
+  /// Checks if an operation conflicts with existing linked operations.
+  Conflict findConflict(Operation *src) const override;
+
+protected:
+  llvm::StringMap<Operation *> summary;
+};
+
 //===----------------------------------------------------------------------===//
 // SymbolLinkerInterfaceCollection
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/LLVMIR/IR/LLVMLinkerInterface.cpp

@@ -212,26 +212,14 @@ unsigned getBitWidth(LLVM::GlobalOp op) {
 // LLVMSymbolLinkerInterface
 //===----------------------------------------------------------------------===//
 
-class LLVMSymbolLinkerInterface : public SymbolLinkerInterface {
+class LLVMSymbolLinkerInterface : public SymbolAttrLinkerInterface {
 public:
-  using SymbolLinkerInterface::SymbolLinkerInterface;
+  using SymbolAttrLinkerInterface::SymbolAttrLinkerInterface;
 
   bool canBeLinked(Operation *op) const override {
     return isa<LLVM::GlobalOp>(op) || isa<LLVM::LLVMFuncOp>(op);
   }
 
-  StringRef getSymbol(Operation *op) const override { return symbol(op); }
-
-  Conflict findConflict(Operation *src) const override {
-    assert(canBeLinked(src) && "expected linkable operation");
-
-    if (auto it = summary.find(getSymbol(src)); it != summary.end()) {
-      return {it->second, src};
-    }
-
-    return Conflict::noConflict(src);
-  }
-
   bool isLinkNeeded(Conflict pair, bool forDependency) const override {
     assert(canBeLinked(pair.src) && "expected linkable operation");
     if (pair.src == pair.dst)
@@ -466,7 +454,6 @@ class LLVMSymbolLinkerInterface : public SymbolLinkerInterface {
   }
 
   SetVector<Operation *> uniqued;
-  llvm::StringMap<Operation *> summary;
 };
 
 //===----------------------------------------------------------------------===//

mlir/lib/Linker/LinkerInterface.cpp

@@ -13,6 +13,10 @@
 using namespace mlir;
 using namespace mlir::link;
 
+//===----------------------------------------------------------------------===//
+// LinkState
+//===----------------------------------------------------------------------===//
+
 template <typename CloneFunc>
 Operation *cloneImpl(Operation *src, IRMapping &mapping, CloneFunc cloneFunc) {
   assert(!mapping.contains(src));
@@ -40,3 +44,21 @@ Operation *LinkState::getDestinationOp() const {
 Operation *LinkState::remapped(Operation *src) const {
   return mapping.lookupOrNull(src);
 }
+
+//===----------------------------------------------------------------------===//
+// SymbolAttrLinkerInterface
+//===----------------------------------------------------------------------===//
+
+StringRef SymbolAttrLinkerInterface::getSymbol(Operation *op) const {
+  return op->getAttrOfType<StringAttr>(SymbolTable::getSymbolAttrName())
+      .getValue();
+}
+
+Conflict SymbolAttrLinkerInterface::findConflict(Operation *src) const {
+  assert(canBeLinked(src) && "expected linkable operation");
+  StringRef symbol = getSymbol(src);
+  auto it = summary.find(symbol);
+  if (it == summary.end())
+    return Conflict::noConflict(src);
+  return {it->second, src};
+}