[SymbolRefAttr] Revise SymbolRefAttr to hold a StringAttr.

[lattner]

Summary

SymbolRefAttr is fundamentally a base string plus a sequence
of nested references. Instead of storing the string data as
a copies StringRef, store it as an already-uniqued StringAttr.

This makes a lot of things simpler and more efficient because:

1. references to the symbol are already stored as StringAttr's: there is no need to copy the string data into MLIRContext multiple times.
2. This allows pointer comparisons instead of string comparisons (or redundant uniquing) within SymbolTable.cpp.
3. This allows SymbolTable to hold a DenseMap instead of a StringMap (which again copies the string data and slows lookup).

This is a moderately invasive patch, so I kept a lot of
compatibility APIs around. It would be nice to explore changing
getName() to return a StringAttr for example (right now you have
to use getNameAttr()), and eliminate things like the StringRef
version of getSymbol.

[rriddle]

mlir/include/mlir/IR/BuiltinAttributes.td

883–894

mlir/include/mlir/IR/SymbolInterfaces.td

178

183

198–210

199

204

mlir/include/mlir/IR/SymbolTable.h

225–228

mlir/lib/Dialect/SPIRV/Linking/ModuleCombiner/ModuleCombiner.cpp

38

mlir/lib/IR/Builders.cpp

220–228

I would remove these completely. We generally don't add builder methods for things that don't need the internal context in some way.

mlir/lib/IR/BuiltinAttributes.cpp

279–284

mlir/lib/IR/SymbolTable.cpp

28

This isn't necessary. Symbol operations already have it cached in there AbstractOperation. Restructuring this code and it's interaction with SymbolOpInterface would fix this.

[rriddle]

I'm slightly hesitant about all of the new StringAttr uniquing, but assuming we don't need to unique something in the common case I suppose it should be fine.

[lattner]

Incorporate River's feedback, thanks River!

mlir/lib/IR/Builders.cpp

220–228

The problem is that the StringRef version does arguably belong as part of Builder... and I don't want to have "just" the stringref version and not have the other one next to it.

I'll look into removing both completely in a follow-on patch. Thanks for pointing this out.

mlir/lib/IR/SymbolTable.cpp

28

I don't understand what you're suggesting, but I removed the comment.

The issue here is that getAttrOfType(StringRef) has to turn the StringRef into an Identifier to do the lookup or it does inefficient string compares. Other stuff is similarly doing stuff with getSymbolAttrName() that does similar uniquing. Symbols seem important enough to put one slot into MLIRContext to improve this. If you have another way to improve this, that would be great!

[lattner]

I'm slightly hesitant about all of the new StringAttr uniquing, but assuming we don't need to unique something in the common case I suppose it should be fine.

Understood. Two things:

1. It is really just _moving_ the uniquing in the normal case, because the StringRef stuff typically ends up uniquing it when forming the symbol anyway.
2. In lots of cases (particularly internal to the mechanics of the SymbolTable) we already have the attr around, so there isn't new uniquing.

There is definitely the chance to remove more use of the StringRef API (in favor of things that pass around the attrs) of course. I'll see how many of the convenience APIs can be reasonably removed. I only did a superficial pass in this patch because it was getting large as is.

Thank you so much for the quick review of this!

[aartbik]

Am I reading the report right? Did this go in with build failures?

mlir/include/mlir/Dialect/GPU/GPUOps.td

OpBuilder<(ins "GPUFuncOp":$kernelFunc, "KernelDim3":$gridSize,
       "KernelDim3":$blockSize, "ValueRange":$kernelOperands)>
   ];
 
   let extraClassDeclaration = [{
     /// The number of operands passed to the kernel function.
     unsigned getNumKernelOperands();
 
     /// The name of the kernel's containing module.
-    StringRef getKernelModuleName();
+    StringAttr getKernelModuleName();
 
     /// The name of the kernel.
-    StringRef getKernelName();
+    StringAttr getKernelName();
 
     /// The i-th operand passed to the kernel function.
     Value getKernelOperand(unsigned i);
 
     /// Get the SSA values passed as operands to specify the grid size.
     KernelDim3 getGridSizeOperandValues();
 
     /// Get the SSA values passed as operands to specify the block size.

mlir/include/mlir/IR/Builders.h

public:
   DictionaryAttr getDictionaryAttr(ArrayRef<NamedAttribute> value);
   IntegerAttr getIntegerAttr(Type type, int64_t value);
   IntegerAttr getIntegerAttr(Type type, const APInt &value);
   FloatAttr getFloatAttr(Type type, double value);
   FloatAttr getFloatAttr(Type type, const APFloat &value);
   StringAttr getStringAttr(const Twine &bytes);
   ArrayAttr getArrayAttr(ArrayRef<Attribute> value);
   FlatSymbolRefAttr getSymbolRefAttr(Operation *value);
-  FlatSymbolRefAttr getSymbolRefAttr(StringRef value);
-  SymbolRefAttr getSymbolRefAttr(StringRef value,
+  FlatSymbolRefAttr getSymbolRefAttr(StringAttr value);
+  SymbolRefAttr getSymbolRefAttr(StringAttr value,
                                  ArrayRef<FlatSymbolRefAttr> nestedReferences);
+  SymbolRefAttr getSymbolRefAttr(StringRef value,
+                                 ArrayRef<FlatSymbolRefAttr> nestedReferences) {
+    return getSymbolRefAttr(getStringAttr(value), nestedReferences);
+  }
+  FlatSymbolRefAttr getSymbolRefAttr(StringRef value) {
+    return getSymbolRefAttr(getStringAttr(value));
+  }
 
   // Returns a 0-valued attribute of the given `type`. This function only
   // supports boolean, integer, and 16-/32-/64-bit float types, and vector or
   // ranked tensor of them. Returns null attribute otherwise.
   Attribute getZeroAttr(Type type);
 
   // Convenience methods for fixed types.
   FloatAttr getF16FloatAttr(float value);

mlir/include/mlir/IR/BuiltinAttributes.h

 class Location;
 class ShapedType;
 
 //===----------------------------------------------------------------------===//
 // Elements Attributes
 //===----------------------------------------------------------------------===//
 
 namespace detail {
-template <typename T> class ElementsAttrIterator;
-template <typename T> class ElementsAttrRange;
+template <typename T>
+class ElementsAttrIterator;
+template <typename T>
+class ElementsAttrRange;
 } // namespace detail
 
 /// A base attribute that represents a reference to a static shaped tensor or
 /// vector constant.
 class ElementsAttr : public Attribute {
 public:
   using Attribute::Attribute;
-  template <typename T> using iterator = detail::ElementsAttrIterator<T>;
-  template <typename T> using iterator_range = detail::ElementsAttrRange<T>;
+  template <typename T>
+  using iterator = detail::ElementsAttrIterator<T>;
+  template <typename T>
+  using iterator_range = detail::ElementsAttrRange<T>;
 
   /// Return the type of this ElementsAttr, guaranteed to be a vector or tensor
   /// with static shape.
   ShapedType getType() const;
 
   /// Return the value at the given index. The index is expected to refer to a
   /// valid element.
   Attribute getValue(ArrayRef<uint64_t> index) const;
 
   /// Return the value of type 'T' at the given index, where 'T' corresponds to
   /// an Attribute type.
-  template <typename T> T getValue(ArrayRef<uint64_t> index) const {
+  template <typename T>
+  T getValue(ArrayRef<uint64_t> index) const {
     return getValue(index).template cast<T>();
   }
 
   /// Return the elements of this attribute as a value of type 'T'. Note:
   /// Aborts if the subclass is OpaqueElementsAttrs, these attrs do not support
   /// iteration.
-  template <typename T> iterator_range<T> getValues() const;
+  template <typename T>
+  iterator_range<T> getValues() const;
 
   /// Return if the given 'index' refers to a valid element in this attribute.
   bool isValidIndex(ArrayRef<uint64_t> index) const;
 
   /// Returns the number of elements held by this attribute.
   int64_t getNumElements() const;
 
   /// Returns the number of elements held by this attribute.
ptrdiff_t getDataIndex() const {
     return isSplat ? 0 : this->index;
   }
 
   /// Return the data base pointer.
   const char *getData() const { return this->base.getPointer(); }
 };
 
 /// Type trait detector that checks if a given type T is a complex type.
-template <typename T> struct is_complex_t : public std::false_type {};
+template <typename T>
+struct is_complex_t : public std::false_type {};
 template <typename T>
 struct is_complex_t<std::complex<T>> : public std::true_type {};
 } // namespace detail
 
 /// An attribute that represents a reference to a dense vector or tensor object.
 ///
 class DenseElementsAttr : public ElementsAttr {
 public:
   using ElementsAttr::ElementsAttr;
 
   /// Type trait used to check if the given type T is a potentially valid C++
   /// floating point type that can be used to access the underlying element
   /// types of a DenseElementsAttr.
   // TODO: Use std::disjunction when C++17 is supported.
-  template <typename T> struct is_valid_cpp_fp_type {
+  template <typename T>
+  struct is_valid_cpp_fp_type {
     /// The type is a valid floating point type if it is a builtin floating
     /// point type, or is a potentially user defined floating point type. The
     /// latter allows for supporting users that have custom types defined for
     /// bfloat16/half/etc.
     static constexpr bool value = llvm::is_one_of<T, float, double>::value ||
                                   (std::numeric_limits<T>::is_specialized &&
                                    !std::numeric_limits<T>::is_integer);
   };
getSplatValue() const {
     return getSplatValue().template cast<T>();
   }
 
   /// Return the value at the given index. The 'index' is expected to refer to a
   /// valid element.
   Attribute getValue(ArrayRef<uint64_t> index) const {
     return getValue<Attribute>(index);
   }
-  template <typename T> T getValue(ArrayRef<uint64_t> index) const {
+  template <typename T>
+  T getValue(ArrayRef<uint64_t> index) const {
     // Skip to the element corresponding to the flattened index.
     return *std::next(getValues<T>().begin(), getFlattenedIndex(index));
   }
 
   /// Return the held element values as a range of integer or floating-point
   /// values.
   template <typename T, typename = typename std::enable_if<
                             (!std::is_same<T, bool>::value &&
public:
   using SymbolRefAttr::SymbolRefAttr;
   using ValueType = StringRef;
 
   /// Construct a symbol reference for the given value name.
   static FlatSymbolRefAttr get(MLIRContext *ctx, StringRef value) {
     return SymbolRefAttr::get(ctx, value);
   }
 
+  static FlatSymbolRefAttr get(StringAttr value) {
+    return SymbolRefAttr::get(value);
+  }
+
+  /// Returns the name of the held symbol reference as a StringAttr.
+  StringAttr getAttr() const { return getRootReference(); }
+
   /// Returns the name of the held symbol reference.
-  StringRef getValue() const { return getRootReference(); }
+  StringRef getValue() const { return getAttr().getValue(); }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(Attribute attr) {
     SymbolRefAttr refAttr = attr.dyn_cast<SymbolRefAttr>();
     return refAttr && refAttr.getNestedReferences().empty();
   }
 
 private:
RetT process(Args &...args) const {
     if (attr.isa<DenseElementsAttr>())
       return ProcessFn<DenseIteratorT>()(args...);
     if (attr.isa<SparseElementsAttr>())
       return ProcessFn<SparseIteratorT>()(args...);
     llvm_unreachable("unexpected attribute kind");
   }
 
   /// Utility functors used to generically implement the iterators methods.
-  template <typename ItT> struct PlusAssign {
+  template <typename ItT>
+  struct PlusAssign {
     void operator()(ItT &it, ptrdiff_t offset) { it += offset; }
   };
-  template <typename ItT> struct Minus {
+  template <typename ItT>
+  struct Minus {
     ptrdiff_t operator()(const ItT &lhs, const ItT &rhs) { return lhs - rhs; }
   };
-  template <typename ItT> struct MinusAssign {
+  template <typename ItT>
+  struct MinusAssign {
     void operator()(ItT &it, ptrdiff_t offset) { it -= offset; }
   };
-  template <typename ItT> struct Dereference {
+  template <typename ItT>
+  struct Dereference {
     T operator()(ItT &it) { return *it; }
   };
-  template <typename ItT> struct ConstructIter {
+  template <typename ItT>
+  struct ConstructIter {
     void operator()(ItT &dest, const ItT &it) { ::new (&dest) ItT(it); }
   };
-  template <typename ItT> struct DestructIter {
+  template <typename ItT>
+  struct DestructIter {
     void operator()(ItT &it) { it.~ItT(); }
   };
 
 public:
   ElementsAttrIterator(const ElementsAttrIterator<T> &rhs) : attr(rhs.attr) {
     process<void, ConstructIter>(it, rhs.it);
   }
   ~ElementsAttrIterator() { process<void, DestructIter>(it); }

mlir/include/mlir/IR/BuiltinAttributes.td

let description = [{
     information.
 
     Examples:
 
     ```mlir
     @flat_reference
     @parent_reference::@nested_reference
     ```
   }];
-  let parameters = (ins
-    StringRefParameter<"">:$rootReference,
-    ArrayRefParameter<"FlatSymbolRefAttr", "">:$nestedReferences
-  );
+  let parameters =
+     (ins "StringAttr":$rootReference,
+          ArrayRefParameter<"FlatSymbolRefAttr", "">:$nestedReferences);
+
+  let builders = [
+    AttrBuilderWithInferredContext<
+      (ins "StringAttr":$rootReference,
+           "ArrayRef<FlatSymbolRefAttr>":$nestedReferences), [{
+      return $_get(rootReference.getContext(), rootReference, nestedReferences);
+    }]>,
+  ];
   let extraClassDeclaration = [{
     static FlatSymbolRefAttr get(MLIRContext *ctx, StringRef value);
+    static FlatSymbolRefAttr get(StringAttr value);
 
     /// Returns the name of the fully resolved symbol, i.e. the leaf of the
     /// reference path.
-    StringRef getLeafReference() const;
+    StringAttr getLeafReference() const;
   }];
+  let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TypeAttr
 //===----------------------------------------------------------------------===//
 
 def Builtin_TypeAttr : Builtin_Attr<"Type", [
     DeclareAttrInterfaceMethods<SubElementAttrInterface>

mlir/include/mlir/IR/OpBase.td

 
 // An attribute constraint on FlatSymbolRefAttr that requires that the
 // reference point to an op of `opClass` within the closest parent with a symbol
 // table.
 // TODO: Add support for nested symbol references.
 class ReferToOp<string opClass> : AttrConstraint<
     CPred<"isa_and_nonnull<" # opClass # ">("
             "::mlir::SymbolTable::lookupNearestSymbolFrom("
-              "&$_op, $_self.cast<::mlir::FlatSymbolRefAttr>().getValue()))">,
+              "&$_op, $_self.cast<::mlir::FlatSymbolRefAttr>().getAttr()))">,
     "referencing to a '" # opClass # "' symbol">;
 
 //===----------------------------------------------------------------------===//
 // Region definitions
 //===----------------------------------------------------------------------===//
 
 class Region<Pred condition, string descr = ""> :
     RegionConstraint<condition, descr>;

mlir/include/mlir/IR/SymbolInterfaces.td

let description = [{
     operation resides immediately within a region that defines a `SymbolTable`.
     See [Symbols and SymbolTables](../SymbolsAndSymbolTables.md) for more details
     and constraints on `Symbol` operations.
   }];
   let cppNamespace = "::mlir";
 
   let methods = [
     InterfaceMethod<"Returns the name of this symbol.",
-      "StringRef", "getName", (ins), [{
+      "StringAttr", "getNameAttr", (ins), [{
         // Don't rely on the trait implementation as optional symbol operations
         // may override this.
         return mlir::SymbolTable::getSymbolName($_op);
       }], /*defaultImplementation=*/[{
         return mlir::SymbolTable::getSymbolName(this->getOperation());
       }]
     >,
     InterfaceMethod<"Sets the name of this symbol.",
-      "void", "setName", (ins "StringRef":$name), [{}],
+      "void", "setName", (ins "StringAttr":$name), [{}],
       /*defaultImplementation=*/[{
         this->getOperation()->setAttr(
-            mlir::SymbolTable::getSymbolAttrName(),
-            StringAttr::get(this->getOperation()->getContext(), name));
+            mlir::SymbolTable::getSymbolAttrName(), name);
       }]
     >,
     InterfaceMethod<"Gets the visibility of this symbol.",
       "mlir::SymbolTable::Visibility", "getVisibility", (ins), [{}],
       /*defaultImplementation=*/[{
         return mlir::SymbolTable::getSymbolVisibility(this->getOperation());
       }]
     >,
InterfaceMethod<[{
                                                         from);
       }]
     >,
     InterfaceMethod<[{
         Attempt to replace all uses of the current symbol with the provided
         symbol 'newSymbol' that are nested within the given operation 'from'.
         Note: See mlir::SymbolTable::replaceAllSymbolUses for more details.
       }],
-      "LogicalResult", "replaceAllSymbolUses", (ins "StringRef":$newSymbol,
+      "LogicalResult", "replaceAllSymbolUses", (ins "StringAttr":$newSymbol,
                                                     "Operation *":$from), [{}],
       /*defaultImplementation=*/[{
         return ::mlir::SymbolTable::replaceAllSymbolUses(this->getOperation(),
                                                          newSymbol, from);
       }]
     >,
     InterfaceMethod<[{
         Returns true if this operation optionally defines a symbol based on the
if (::mlir::failed(::mlir::detail::verifySymbol($_op)))
       return ::mlir::failure();
     if (concreteOp.isDeclaration() && concreteOp.isPublic())
       return concreteOp.emitOpError("symbol declaration cannot have public "
              "visibility");
     return success();
   }];
 
   let extraClassDeclaration = [{
+    /// Convenience version of `getNameAttr` that returns a StringRef.
+    StringRef getName() {
+      return getNameAttr().getValue();
+    }
+
+    /// Convenience version of `setName` that take a StringRef.
+    void setName(StringRef name) {
+      setName(StringAttr::get(this->getContext(), name));
+    }
+
     /// Custom classof that handles the case where the symbol is optional.
     static bool classof(Operation *op) {
       auto *opConcept = getInterfaceFor(op);
       if (!opConcept)
         return false;
       return !opConcept->isOptionalSymbol(opConcept, op) ||
              op->getAttr(::mlir::SymbolTable::getSymbolAttrName());
     }
   }];
 
   let extraTraitClassDeclaration = [{
     using Visibility = mlir::SymbolTable::Visibility;
+
+    /// Convenience version of `getNameAttr` that returns a StringRef.
+    StringRef getName() {
+      return getNameAttr().getValue();
+    }
+
+    /// Convenience version of `setName` that take a StringRef.
+    void setName(StringRef name) {
+      setName(StringAttr::get(this->getContext(), name));
+    }
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolUserOpInterface
 //===----------------------------------------------------------------------===//
 
 def SymbolUserOpInterface : OpInterface<"SymbolUserOpInterface"> {
   let description = [{

mlir/include/mlir/IR/SymbolTable.h

 class SymbolTable {
 public:
   /// Build a symbol table with the symbols within the given operation.
   SymbolTable(Operation *symbolTableOp);
 
   /// Look up a symbol with the specified name, returning null if no such
   /// name exists. Names never include the @ on them.
   Operation *lookup(StringRef name) const;
-  template <typename T> T lookup(StringRef name) const {
+  template <typename T>
+  T lookup(StringRef name) const {
+    return dyn_cast_or_null<T>(lookup(name));
+  }
+
+  /// Look up a symbol with the specified name, returning null if no such
+  /// name exists. Names never include the @ on them.
+  Operation *lookup(StringAttr name) const;
+  template <typename T>
+  T lookup(StringAttr name) const {
     return dyn_cast_or_null<T>(lookup(name));
   }
 
   /// Erase the given symbol from the table.
   void erase(Operation *symbol);
 
   /// Insert a new symbol into the table, and rename it as necessary to avoid
   /// collisions. Also insert at the specified location in the body of the
enum class Visibility {
 
     /// The symbol is visible to the current IR, which may include operations in
     /// symbol tables above the one that owns the current symbol. `Nested`
     /// visibility allows for referencing a symbol outside of its current symbol
     /// table, while retaining the ability to observe all uses.
     Nested,
   };
 
-  /// Returns the name of the given symbol operation.
-  static StringRef getSymbolName(Operation *symbol);
+  /// Returns the name of the given symbol operation, aborting if no symbol is
+  /// present.
+  static StringAttr getSymbolName(Operation *symbol);
+
   /// Sets the name of the given symbol operation.
-  static void setSymbolName(Operation *symbol, StringRef name);
+  static void setSymbolName(Operation *symbol, StringAttr name);
+  static void setSymbolName(Operation *symbol, StringRef name) {
+    setSymbolName(symbol, StringAttr::get(symbol->getContext(), name));
+  }
 
   /// Returns the visibility of the given symbol operation.
   static Visibility getSymbolVisibility(Operation *symbol);
   /// Sets the visibility of the given symbol operation.
   static void setSymbolVisibility(Operation *symbol, Visibility vis);
 
   /// Returns the nearest symbol table from a given operation `from`. Returns
   /// nullptr if no valid parent symbol table could be found.
   static Operation *getNearestSymbolTable(Operation *from);
 
   /// Walks all symbol table operations nested within, and including, `op`. For
   /// each symbol table operation, the provided callback is invoked with the op
   /// and a boolean signifying if the symbols within that symbol table can be
   /// treated as if all uses within the IR are visible to the caller.
   /// `allSymUsesVisible` identifies whether all of the symbol uses of symbols
   /// within `op` are visible.
   static void walkSymbolTables(Operation *op, bool allSymUsesVisible,
                                function_ref<void(Operation *, bool)> callback);
 
   /// Returns the operation registered with the given symbol name with the
   /// regions of 'symbolTableOp'. 'symbolTableOp' is required to be an operation
   /// with the 'OpTrait::SymbolTable' trait.
-  static Operation *lookupSymbolIn(Operation *op, StringRef symbol);
+  static Operation *lookupSymbolIn(Operation *op, StringAttr symbol);
+  static Operation *lookupSymbolIn(Operation *op, StringRef symbol) {
+    return lookupSymbolIn(op, StringAttr::get(op->getContext(), symbol));
+  }
   static Operation *lookupSymbolIn(Operation *op, SymbolRefAttr symbol);
   /// A variant of 'lookupSymbolIn' that returns all of the symbols referenced
   /// by a given SymbolRefAttr. Returns failure if any of the nested references
   /// could not be resolved.
   static LogicalResult lookupSymbolIn(Operation *op, SymbolRefAttr symbol,
                                       SmallVectorImpl<Operation *> &symbols);
 
   /// Returns the operation registered with the given symbol name within the
   /// closest parent operation of, or including, 'from' with the
   /// 'OpTrait::SymbolTable' trait. Returns nullptr if no valid symbol was
   /// found.
-  static Operation *lookupNearestSymbolFrom(Operation *from, StringRef symbol);
+  static Operation *lookupNearestSymbolFrom(Operation *from, StringAttr symbol);
   static Operation *lookupNearestSymbolFrom(Operation *from,
                                             SymbolRefAttr symbol);
   template <typename T>
-  static T lookupNearestSymbolFrom(Operation *from, StringRef symbol) {
+  static T lookupNearestSymbolFrom(Operation *from, StringAttr symbol) {
     return dyn_cast_or_null<T>(lookupNearestSymbolFrom(from, symbol));
   }
   template <typename T>
   static T lookupNearestSymbolFrom(Operation *from, SymbolRefAttr symbol) {
     return dyn_cast_or_null<T>(lookupNearestSymbolFrom(from, symbol));
   }
 
   /// This class represents a specific symbol use.
public:
   /// operations that may potentially be symbol tables.
   static Optional<UseRange> getSymbolUses(Operation *from);
   static Optional<UseRange> getSymbolUses(Region *from);
 
   /// Get all of the uses of the given symbol that are nested within the given
   /// operation 'from'. This does not traverse into any nested symbol tables.
   /// This function returns None if there are any unknown operations that may
   /// potentially be symbol tables.
-  static Optional<UseRange> getSymbolUses(StringRef symbol, Operation *from);
+  static Optional<UseRange> getSymbolUses(StringAttr symbol, Operation *from);
   static Optional<UseRange> getSymbolUses(Operation *symbol, Operation *from);
-  static Optional<UseRange> getSymbolUses(StringRef symbol, Region *from);
+  static Optional<UseRange> getSymbolUses(StringAttr symbol, Region *from);
   static Optional<UseRange> getSymbolUses(Operation *symbol, Region *from);
 
   /// Return if the given symbol is known to have no uses that are nested
   /// within the given operation 'from'. This does not traverse into any nested
   /// symbol tables. This function will also return false if there are any
   /// unknown operations that may potentially be symbol tables. This doesn't
   /// necessarily mean that there are no uses, we just can't conservatively
   /// prove it.
-  static bool symbolKnownUseEmpty(StringRef symbol, Operation *from);
+  static bool symbolKnownUseEmpty(StringAttr symbol, Operation *from);
   static bool symbolKnownUseEmpty(Operation *symbol, Operation *from);
-  static bool symbolKnownUseEmpty(StringRef symbol, Region *from);
+  static bool symbolKnownUseEmpty(StringAttr symbol, Region *from);
   static bool symbolKnownUseEmpty(Operation *symbol, Region *from);
 
   /// Attempt to replace all uses of the given symbol 'oldSymbol' with the
   /// provided symbol 'newSymbol' that are nested within the given operation
   /// 'from'. This does not traverse into any nested symbol tables. If there are
   /// any unknown operations that may potentially be symbol tables, no uses are
   /// replaced and failure is returned.
-  static LogicalResult replaceAllSymbolUses(StringRef oldSymbol,
-                                            StringRef newSymbol,
+  static LogicalResult replaceAllSymbolUses(StringAttr oldSymbol,
+                                            StringAttr newSymbol,
                                             Operation *from);
   static LogicalResult replaceAllSymbolUses(Operation *oldSymbol,
-                                            StringRef newSymbolName,
+                                            StringAttr newSymbolName,
                                             Operation *from);
-  static LogicalResult replaceAllSymbolUses(StringRef oldSymbol,
-                                            StringRef newSymbol, Region *from);
+  static LogicalResult replaceAllSymbolUses(StringAttr oldSymbol,
+                                            StringAttr newSymbol, Region *from);
   static LogicalResult replaceAllSymbolUses(Operation *oldSymbol,
-                                            StringRef newSymbolName,
+                                            StringAttr newSymbolName,
                                             Region *from);
 
 private:
   Operation *symbolTableOp;
 
-  /// This is a mapping from a name to the symbol with that name.
-  llvm::StringMap<Operation *> symbolTable;
+  /// This is a mapping from a name to the symbol with that name.  They key is
+  /// always known to be a StringAttr.
+  DenseMap<Attribute, Operation *> symbolTable;
 
   /// This is used when name conflicts are detected.
   unsigned uniquingCounter = 0;
 };
 
 raw_ostream &operator<<(raw_ostream &os, SymbolTable::Visibility visibility);
 
 //===----------------------------------------------------------------------===//
 // SymbolTableCollection
 //===----------------------------------------------------------------------===//
 
 /// This class represents a collection of `SymbolTable`s. This simplifies
 /// certain algorithms that run recursively on nested symbol tables. Symbol
 /// tables are constructed lazily to reduce the upfront cost of constructing
 /// unnecessary tables.
 class SymbolTableCollection {
 public:
   /// Look up a symbol with the specified name within the specified symbol table
   /// operation, returning null if no such name exists.
-  Operation *lookupSymbolIn(Operation *symbolTableOp, StringRef symbol);
+  Operation *lookupSymbolIn(Operation *symbolTableOp, StringAttr symbol);
   Operation *lookupSymbolIn(Operation *symbolTableOp, SymbolRefAttr name);
   template <typename T, typename NameT>
   T lookupSymbolIn(Operation *symbolTableOp, NameT &&name) const {
     return dyn_cast_or_null<T>(
         lookupSymbolIn(symbolTableOp, std::forward<NameT>(name)));
   }
   /// A variant of 'lookupSymbolIn' that returns all of the symbols referenced
   /// by a given SymbolRefAttr when resolved within the provided symbol table
   /// operation. Returns failure if any of the nested references could not be
   /// resolved.
   LogicalResult lookupSymbolIn(Operation *symbolTableOp, SymbolRefAttr name,
                                SmallVectorImpl<Operation *> &symbols);
 
   /// Returns the operation registered with the given symbol name within the
   /// closest parent operation of, or including, 'from' with the
   /// 'OpTrait::SymbolTable' trait. Returns nullptr if no valid symbol was
   /// found.
-  Operation *lookupNearestSymbolFrom(Operation *from, StringRef symbol);
+  Operation *lookupNearestSymbolFrom(Operation *from, StringAttr symbol);
   Operation *lookupNearestSymbolFrom(Operation *from, SymbolRefAttr symbol);
   template <typename T>
-  T lookupNearestSymbolFrom(Operation *from, StringRef symbol) {
+  T lookupNearestSymbolFrom(Operation *from, StringAttr symbol) {
     return dyn_cast_or_null<T>(lookupNearestSymbolFrom(from, symbol));
   }
   template <typename T>
   T lookupNearestSymbolFrom(Operation *from, SymbolRefAttr symbol) {
     return dyn_cast_or_null<T>(lookupNearestSymbolFrom(from, symbol));
   }
 
   /// Lookup, or create, a symbol table for an operation.
public:
   }
 
   /// Return true if the given symbol has no uses.
   bool use_empty(Operation *symbol) const {
     return !symbolToUsers.count(symbol);
   }
 
   /// Replace all of the uses of the given symbol with `newSymbolName`.
-  void replaceAllUsesWith(Operation *symbol, StringRef newSymbolName);
+  void replaceAllUsesWith(Operation *symbol, StringAttr newSymbolName);
 
 private:
   /// A reference to the symbol table used to construct this map.
   SymbolTableCollection &symbolTable;
 
   /// A map of symbol operations to symbol users.
   DenseMap<Operation *, SetVector<Operation *>> symbolToUsers;
 };

 public:
   static LogicalResult verifyTrait(Operation *op) {
     return ::mlir::detail::verifySymbolTable(op);
   }
 
   /// Look up a symbol with the specified name, returning null if no such
   /// name exists. Symbol names never include the @ on them. Note: This
   /// performs a linear scan of held symbols.
-  Operation *lookupSymbol(StringRef name) {
+  Operation *lookupSymbol(StringAttr name) {
     return mlir::SymbolTable::lookupSymbolIn(this->getOperation(), name);
   }
-  template <typename T> T lookupSymbol(StringRef name) {
+  template <typename T>
+  T lookupSymbol(StringAttr name) {
     return dyn_cast_or_null<T>(lookupSymbol(name));
   }
   Operation *lookupSymbol(SymbolRefAttr symbol) {
     return mlir::SymbolTable::lookupSymbolIn(this->getOperation(), symbol);
   }
-  template <typename T> T lookupSymbol(SymbolRefAttr symbol) {
+  template <typename T>
+  T lookupSymbol(SymbolRefAttr symbol) {
     return dyn_cast_or_null<T>(lookupSymbol(symbol));
   }
+
+  Operation *lookupSymbol(StringRef name) {
+    return mlir::SymbolTable::lookupSymbolIn(this->getOperation(), name);
+  }
+  template <typename T>
+  T lookupSymbol(StringRef name) {
+    return dyn_cast_or_null<T>(lookupSymbol(name));
+  }
 };
 
 } // end namespace OpTrait
 
 //===----------------------------------------------------------------------===//
 // Visibility parsing implementation.
 //===----------------------------------------------------------------------===//
 

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

 
 MlirAttribute mlirSymbolRefAttrGet(MlirContext ctx, MlirStringRef symbol,
                                    intptr_t numReferences,
                                    MlirAttribute const *references) {
   SmallVector<FlatSymbolRefAttr, 4> refs;
   refs.reserve(numReferences);
   for (intptr_t i = 0; i < numReferences; ++i)
     refs.push_back(unwrap(references[i]).cast<FlatSymbolRefAttr>());
-  return wrap(SymbolRefAttr::get(unwrap(ctx), unwrap(symbol), refs));
+  auto symbolAttr = StringAttr::get(unwrap(ctx), unwrap(symbol));
+  return wrap(SymbolRefAttr::get(symbolAttr, refs));
 }
 
 MlirStringRef mlirSymbolRefAttrGetRootReference(MlirAttribute attr) {
-  return wrap(unwrap(attr).cast<SymbolRefAttr>().getRootReference());
+  return wrap(unwrap(attr).cast<SymbolRefAttr>().getRootReference().getValue());
 }
 
 MlirStringRef mlirSymbolRefAttrGetLeafReference(MlirAttribute attr) {
-  return wrap(unwrap(attr).cast<SymbolRefAttr>().getLeafReference());
+  return wrap(unwrap(attr).cast<SymbolRefAttr>().getLeafReference().getValue());
 }
 
 intptr_t mlirSymbolRefAttrGetNumNestedReferences(MlirAttribute attr) {
   return static_cast<intptr_t>(
       unwrap(attr).cast<SymbolRefAttr>().getNestedReferences().size());
 }
 
 MlirAttribute mlirSymbolRefAttrGetNestedReference(MlirAttribute attr,

mlir/lib/Conversion/GPUCommon/GPUToLLVMConversion.cpp

LogicalResult ConvertLaunchFuncOpToGpuRuntimeCallPattern::matchAndRewrite(
   Value data =
       LLVM::createGlobalString(loc, rewriter, nameBuffer.str(),
                                binaryAttr.getValue(), LLVM::Linkage::Internal);
 
   auto module = moduleLoadCallBuilder.create(loc, rewriter, data);
   // Get the function from the module. The name corresponds to the name of
   // the kernel function.
   auto kernelName = generateKernelNameConstant(
-      launchOp.getKernelModuleName(), launchOp.getKernelName(), loc, rewriter);
+      launchOp.getKernelModuleName().getValue(),
+      launchOp.getKernelName().getValue(), loc, rewriter);
   auto function = moduleGetFunctionCallBuilder.create(
       loc, rewriter, {module.getResult(0), kernelName});
   auto zero = rewriter.create<LLVM::ConstantOp>(loc, llvmInt32Type,
                                                 rewriter.getI32IntegerAttr(0));
   auto adaptor =
       gpu::LaunchFuncOpAdaptor(operands, launchOp->getAttrDictionary());
   Value stream =
       adaptor.asyncDependencies().empty()

mlir/lib/Conversion/GPUCommon/OpToFuncCallLowering.h

if (type.isa<Float64Type>())
       return f64Func;
     return "";
   }
 
   LLVM::LLVMFuncOp appendOrGetFuncOp(StringRef funcName, Type funcType,
                                      Operation *op) const {
     using LLVM::LLVMFuncOp;
 
-    Operation *funcOp = SymbolTable::lookupNearestSymbolFrom(op, funcName);
+    auto funcAttr = StringAttr::get(op->getContext(), funcName);
+    Operation *funcOp = SymbolTable::lookupNearestSymbolFrom(op, funcAttr);
     if (funcOp)
       return cast<LLVMFuncOp>(*funcOp);
 
     mlir::OpBuilder b(op->getParentOfType<LLVMFuncOp>());
     return b.create<LLVMFuncOp>(op->getLoc(), funcName, funcType);
   }
 
   const std::string f32Func;
   const std::string f64Func;
 };
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_GPUCOMMON_OPTOFUNCCALLLOWERING_H_

mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp

void ConvertGpuLaunchFuncToVulkanLaunchFunc::convertGpuLaunchFunc(
 
   // Set SPIR-V binary shader data as an attribute.
   vulkanLaunchCallOp->setAttr(
       kSPIRVBlobAttrName,
       StringAttr::get(loc->getContext(),
                       StringRef(binary.data(), binary.size())));
 
   // Set entry point name as an attribute.
-  vulkanLaunchCallOp->setAttr(
-      kSPIRVEntryPointAttrName,
-      StringAttr::get(loc->getContext(), launchOp.getKernelName()));
+  vulkanLaunchCallOp->setAttr(kSPIRVEntryPointAttrName,
+                              launchOp.getKernelName());
 
   launchOp.erase();
 }
 
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
 mlir::createConvertGpuLaunchFuncToVulkanLaunchFuncPass() {
   return std::make_unique<ConvertGpuLaunchFuncToVulkanLaunchFunc>();
 }

mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp

static FlatSymbolRefAttr getLibraryCallSymbolRef(Operation *op,
   if (fnName.empty()) {
     op->emitWarning("No library call defined for: ") << *op;
     return {};
   }
 
   // fnName is a dynamic std::string, unique it via a SymbolRefAttr.
   FlatSymbolRefAttr fnNameAttr = rewriter.getSymbolRefAttr(fnName);
   auto module = op->getParentOfType<ModuleOp>();
-  if (module.lookupSymbol(fnName)) {
+  if (module.lookupSymbol(fnNameAttr.getAttr()))
     return fnNameAttr;
-  }
 
   SmallVector<Type, 4> inputTypes(extractOperandTypes(op));
   assert(op->getNumResults() == 0 &&
          "Library call for linalg operation can be generated only for ops that "
          "have void return types");
   auto libFnType = rewriter.getFunctionType(inputTypes, {});
 
   OpBuilder::InsertionGuard guard(rewriter);

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

 static LogicalResult encodeKernelName(spirv::ModuleOp module) {
   StringRef spvModuleName = module.sym_name().getValue();
   // We already know that the module contains exactly one entry point function
   // based on `getKernelGlobalVariables()` call. Update this function's name
   // to:
   //   {spv_module_name}_{function_name}
   auto entryPoint = *module.getOps<spirv::EntryPointOp>().begin();
   StringRef funcName = entryPoint.fn();
-  auto funcOp = module.lookupSymbol<spirv::FuncOp>(funcName);
-  std::string newFuncName = spvModuleName.str() + "_" + funcName.str();
+  auto funcOp = module.lookupSymbol<spirv::FuncOp>(entryPoint.fnAttr());
+  StringAttr newFuncName =
+      StringAttr::get(module->getContext(), spvModuleName + "_" + funcName);
   if (failed(SymbolTable::replaceAllSymbolUses(funcOp, newFuncName, module)))
     return failure();
   SymbolTable::setSymbolName(funcOp, newFuncName);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Conversion patterns
matchAndRewrite(gpu::LaunchFuncOp launchOp, ArrayRef<Value> operands,
     auto *op = launchOp.getOperation();
     MLIRContext *context = rewriter.getContext();
     auto module = launchOp->getParentOfType<ModuleOp>();
 
     // Get the SPIR-V module that represents the gpu kernel module. The module
     // is named:
     //   __spv__{kernel_module_name}
     // based on GPU to SPIR-V conversion.
-    StringRef kernelModuleName = launchOp.getKernelModuleName();
+    StringRef kernelModuleName = launchOp.getKernelModuleName().getValue();
     std::string spvModuleName = kSPIRVModule + kernelModuleName.str();
-    auto spvModule = module.lookupSymbol<spirv::ModuleOp>(spvModuleName);
+    auto spvModule = module.lookupSymbol<spirv::ModuleOp>(
+        StringAttr::get(context, spvModuleName));
     if (!spvModule) {
       return launchOp.emitOpError("SPIR-V kernel module '")
              << spvModuleName << "' is not found";
     }
 
     // Declare kernel function in the main module so that it later can be linked
     // with its definition from the kernel module. We know that the kernel
     // function would have no arguments and the data is passed via global
     // variables. The name of the kernel will be
     //   {spv_module_name}_{kernel_function_name}
     // to avoid symbolic name conflicts.
-    StringRef kernelFuncName = launchOp.getKernelName();
+    StringRef kernelFuncName = launchOp.getKernelName().getValue();
     std::string newKernelFuncName = spvModuleName + "_" + kernelFuncName.str();
-    auto kernelFunc = module.lookupSymbol<LLVM::LLVMFuncOp>(newKernelFuncName);
+    auto kernelFunc = module.lookupSymbol<LLVM::LLVMFuncOp>(
+        StringAttr::get(context, newKernelFuncName));
     if (!kernelFunc) {
       OpBuilder::InsertionGuard guard(rewriter);
       rewriter.setInsertionPointToStart(module.getBody());
       kernelFunc = rewriter.create<LLVM::LLVMFuncOp>(
           rewriter.getUnknownLoc(), newKernelFuncName,
           LLVM::LLVMFunctionType::get(LLVM::LLVMVoidType::get(context),
                                       ArrayRef<Type>()));
       rewriter.setInsertionPoint(launchOp);

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

spvModule.walk([&](spirv::GlobalVariableOp op) {
         auto moduleAndName = spvModule.getName().hasValue()
                                  ? spvModule.getName().getValue().str() + "_" +
                                        op.sym_name().str()
                                  : op.sym_name().str();
         std::string name =
             llvm::formatv("{0}_descriptor_set{1}_binding{2}", moduleAndName,
                           std::to_string(descriptorSet.getInt()),
                           std::to_string(binding.getInt()));
+        auto nameAttr = StringAttr::get(op->getContext(), name);
 
         // Replace all symbol uses and set the new symbol name. Finally, remove
         // descriptor set and binding attributes.
-        if (failed(SymbolTable::replaceAllSymbolUses(op, name, spvModule)))
+        if (failed(SymbolTable::replaceAllSymbolUses(op, nameAttr, spvModule)))
           op.emitError("unable to replace all symbol uses for ") << name;
-        SymbolTable::setSymbolName(op, name);
+        SymbolTable::setSymbolName(op, nameAttr);
         op->removeAttr(kDescriptorSet);
         op->removeAttr(kBinding);
       }
     });
   }
 }

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

auto walkResult = module.walk([&module](LaunchFuncOp launchOp) -> WalkResult {
 
     // Ignore launch ops with missing attributes here. The errors will be
     // reported by the verifiers of those ops.
     if (!launchOp->getAttrOfType<SymbolRefAttr>(
             LaunchFuncOp::getKernelAttrName()))
       return success();
 
     // Check that `launch_func` refers to a well-formed GPU kernel module.
-    StringRef kernelModuleName = launchOp.getKernelModuleName();
+    StringAttr kernelModuleName = launchOp.getKernelModuleName();
     auto kernelModule = module.lookupSymbol<GPUModuleOp>(kernelModuleName);
     if (!kernelModule)
       return launchOp.emitOpError()
-             << "kernel module '" << kernelModuleName << "' is undefined";
+             << "kernel module '" << kernelModuleName.getValue()
+             << "' is undefined";
 
     // Check that `launch_func` refers to a well-formed kernel function.
-    Operation *kernelFunc = module.lookupSymbol(launchOp.kernel());
+    Operation *kernelFunc = module.lookupSymbol(launchOp.kernelAttr());
     auto kernelGPUFunction = dyn_cast_or_null<gpu::GPUFuncOp>(kernelFunc);
     auto kernelLLVMFunction = dyn_cast_or_null<LLVM::LLVMFuncOp>(kernelFunc);
     if (!kernelGPUFunction && !kernelLLVMFunction)
       return launchOp.emitOpError("kernel function '")
              << launchOp.kernel() << "' is undefined";
     if (!kernelFunc->getAttrOfType<mlir::UnitAttr>(
             GPUDialect::getKernelFuncAttrName()))
       return launchOp.emitOpError("kernel function is missing the '")
void LaunchFuncOp::build(OpBuilder &builder, OperationState &result,
   result.addAttribute(getOperandSegmentSizeAttr(),
                       builder.getI32VectorAttr(segmentSizes));
 }
 
 unsigned LaunchFuncOp::getNumKernelOperands() {
   return getNumOperands() - asyncDependencies().size() - kNumConfigOperands;
 }
 
-StringRef LaunchFuncOp::getKernelModuleName() {
+StringAttr LaunchFuncOp::getKernelModuleName() {
   return kernel().getRootReference();
 }
 
-StringRef LaunchFuncOp::getKernelName() { return kernel().getLeafReference(); }
+StringAttr LaunchFuncOp::getKernelName() { return kernel().getLeafReference(); }
 
 Value LaunchFuncOp::getKernelOperand(unsigned i) {
   return getOperand(asyncDependencies().size() + kNumConfigOperands + i);
 }
 
 KernelDim3 LaunchFuncOp::getGridSizeOperandValues() {
   auto operands = getOperands().drop_front(asyncDependencies().size());
   return KernelDim3{operands[0], operands[1], operands[2]};

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

 LogicalResult verifySymbolAttribute(
     Operation *op, StringRef attributeName,
     std::function<LogicalResult(Operation *, SymbolRefAttr)> verifySymbolType) {
   if (Attribute attribute = op->getAttr(attributeName)) {
     // The attribute is already verified to be a symbol ref array attribute via
     // a constraint in the operation definition.
     for (SymbolRefAttr symbolRef :
          attribute.cast<ArrayAttr>().getAsRange<SymbolRefAttr>()) {
-      StringRef metadataName = symbolRef.getRootReference();
-      StringRef symbolName = symbolRef.getLeafReference();
+      StringAttr metadataName = symbolRef.getRootReference();
+      StringAttr symbolName = symbolRef.getLeafReference();
       // We want @metadata::@symbol, not just @symbol
       if (metadataName == symbolName) {
         return op->emitOpError() << "expected '" << symbolRef
                                  << "' to specify a fully qualified reference";
       }
       auto metadataOp = SymbolTable::lookupNearestSymbolFrom<LLVM::MetadataOp>(
           op->getParentOp(), metadataName);
       if (!metadataOp)
static LogicalResult verify(CallOp &op) {
 
   // Type for the callee, we'll get it differently depending if it is a direct
   // or indirect call.
   Type fnType;
 
   bool isIndirect = false;
 
   // If this is an indirect call, the callee attribute is missing.
-  Optional<StringRef> calleeName = op.callee();
+  FlatSymbolRefAttr calleeName = op.calleeAttr();
   if (!calleeName) {
     isIndirect = true;
     if (!op.getNumOperands())
       return op.emitOpError(
           "must have either a `callee` attribute or at least an operand");
     auto ptrType = op.getOperand(0).getType().dyn_cast<LLVMPointerType>();
     if (!ptrType)
       return op.emitOpError("indirect call expects a pointer as callee: ")
              << ptrType;
     fnType = ptrType.getElementType();
   } else {
-    Operation *callee = SymbolTable::lookupNearestSymbolFrom(op, *calleeName);
+    Operation *callee =
+        SymbolTable::lookupNearestSymbolFrom(op, calleeName.getAttr());
     if (!callee)
       return op.emitOpError()
-             << "'" << *calleeName
+             << "'" << calleeName.getValue()
              << "' does not reference a symbol in the current scope";
     auto fn = dyn_cast<LLVMFuncOp>(callee);
     if (!fn)
-      return op.emitOpError() << "'" << *calleeName
+      return op.emitOpError() << "'" << calleeName.getValue()
                               << "' does not reference a valid LLVM function";
 
     fnType = fn.getType();
   }
 
   LLVMFunctionType funcType = fnType.dyn_cast<LLVMFunctionType>();
   if (!funcType)
     return op.emitOpError("callee does not have a functional type: ") << fnType;
if (parallelAccessGroup.hasValue()) {
         return op->emitOpError()
                << "expected '" << LLVMDialect::getParallelAccessAttrName()
                << "' to be an array attribute";
       for (Attribute attr : accessGroups) {
         auto accessGroupRef = attr.dyn_cast<SymbolRefAttr>();
         if (!accessGroupRef)
           return op->emitOpError()
                  << "expected '" << attr << "' to be a symbol reference";
-        StringRef metadataName = accessGroupRef.getRootReference();
+        StringAttr metadataName = accessGroupRef.getRootReference();
         auto metadataOp =
             SymbolTable::lookupNearestSymbolFrom<LLVM::MetadataOp>(
                 op->getParentOp(), metadataName);
         if (!metadataOp)
           return op->emitOpError()
                  << "expected '" << attr << "' to reference a metadata op";
-        StringRef accessGroupName = accessGroupRef.getLeafReference();
+        StringAttr accessGroupName = accessGroupRef.getLeafReference();
         Operation *accessGroupOp =
             SymbolTable::lookupNearestSymbolFrom(metadataOp, accessGroupName);
         if (!accessGroupOp)
           return op->emitOpError()
                  << "expected '" << attr << "' to reference an access_group op";
       }
     }
 

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

 void spirv::AddressOfOp::build(OpBuilder &builder, OperationState &state,
                                spirv::GlobalVariableOp var) {
   build(builder, state, var.type(), builder.getSymbolRefAttr(var));
 }
 
 static LogicalResult verify(spirv::AddressOfOp addressOfOp) {
   auto varOp = dyn_cast_or_null<spirv::GlobalVariableOp>(
       SymbolTable::lookupNearestSymbolFrom(addressOfOp->getParentOp(),
-                                           addressOfOp.variable()));
+                                           addressOfOp.variableAttr()));
   if (!varOp) {
     return addressOfOp.emitOpError("expected spv.GlobalVariable symbol");
   }
   if (addressOfOp.pointer().getType() != varOp.type()) {
     return addressOfOp.emitOpError(
         "result type mismatch with the referenced global variable's type");
   }
   return success();
ArrayRef<Type> spirv::FuncOp::getCallableResults() {
   return getType().getResults();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.FunctionCall
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(spirv::FunctionCallOp functionCallOp) {
-  auto fnName = functionCallOp.callee();
+  auto fnName = functionCallOp.calleeAttr();
 
   auto funcOp =
       dyn_cast_or_null<spirv::FuncOp>(SymbolTable::lookupNearestSymbolFrom(
           functionCallOp->getParentOp(), fnName));
   if (!funcOp) {
     return functionCallOp.emitOpError("callee function '")
-           << fnName << "' not found in nearest symbol table";
+           << fnName.getValue() << "' not found in nearest symbol table";
   }
 
   auto functionType = funcOp.getType();
 
   if (functionCallOp.getNumResults() > 1) {
     return functionCallOp.emitOpError(
                "expected callee function to have 0 or 1 result, but provided ")
            << functionCallOp.getNumResults();
if (storageClass == spirv::StorageClass::Generic ||
       storageClass == spirv::StorageClass::Function) {
     return varOp.emitOpError("storage class cannot be '")
            << stringifyStorageClass(storageClass) << "'";
   }
 
   if (auto init =
           varOp->getAttrOfType<FlatSymbolRefAttr>(kInitializerAttrName)) {
     Operation *initOp = SymbolTable::lookupNearestSymbolFrom(
-        varOp->getParentOp(), init.getValue());
+        varOp->getParentOp(), init.getAttr());
     // TODO: Currently only variable initialization with specialization
     // constants and other variables is supported. They could be normal
     // constants in the module scope as well.
     if (!initOp ||
         !isa<spirv::GlobalVariableOp, spirv::SpecConstantOp>(initOp)) {
       return varOp.emitOpError("initializer must be result of a "
                                "spv.SpecConstant or spv.GlobalVariable op");
     }

 }
 
 //===----------------------------------------------------------------------===//
 // spv.mlir.referenceof
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(spirv::ReferenceOfOp referenceOfOp) {
   auto *specConstSym = SymbolTable::lookupNearestSymbolFrom(
-      referenceOfOp->getParentOp(), referenceOfOp.spec_const());
+      referenceOfOp->getParentOp(), referenceOfOp.spec_constAttr());
   Type constType;
 
   auto specConstOp = dyn_cast_or_null<spirv::SpecConstantOp>(specConstSym);
   if (specConstOp)
     constType = specConstOp.default_value().getType();
 
   auto specConstCompositeOp =
       dyn_cast_or_null<spirv::SpecConstantCompositeOp>(specConstSym);
static LogicalResult verify(spirv::SpecConstantCompositeOp constOp) {
 
   if (!cType)
     return constOp.emitError(
                "result type must be a composite type, but provided ")
            << constOp.type();
 
   if (cType.isa<spirv::CooperativeMatrixNVType>())
     return constOp.emitError("unsupported composite type  ") << cType;
-  else if (constituents.size() != cType.getNumElements())
+  if (constituents.size() != cType.getNumElements())
     return constOp.emitError("has incorrect number of operands: expected ")
            << cType.getNumElements() << ", but provided "
            << constituents.size();
 
   for (auto index : llvm::seq<uint32_t>(0, constituents.size())) {
-    auto constituent = constituents[index].dyn_cast<FlatSymbolRefAttr>();
+    auto constituent = constituents[index].cast<FlatSymbolRefAttr>();
 
     auto constituentSpecConstOp =
         dyn_cast<spirv::SpecConstantOp>(SymbolTable::lookupNearestSymbolFrom(
-            constOp->getParentOp(), constituent.getValue()));
+            constOp->getParentOp(), constituent.getAttr()));
 
     if (constituentSpecConstOp.default_value().getType() !=
         cType.getElementType(index))
       return constOp.emitError("has incorrect types of operands: expected ")
              << cType.getElementType(index) << ", but provided "
              << constituentSpecConstOp.default_value().getType();
   }
 

mlir/lib/Dialect/SPIRV/Linking/ModuleCombiner/ModuleCombiner.cpp

 #include "llvm/ADT/StringMap.h"
 
 using namespace mlir;
 
 static constexpr unsigned maxFreeID = 1 << 20;
 
 /// Returns an unsed symbol in `module` for `oldSymbolName` by trying numeric
 /// suffix in `lastUsedID`.
-static SmallString<64> renameSymbol(StringRef oldSymName, unsigned &lastUsedID,
-                                    spirv::ModuleOp module) {
+static StringAttr renameSymbol(StringRef oldSymName, unsigned &lastUsedID,
   SmallString<64> newSymName(oldSymName);
   newSymName.push_back('_');
 
-  while (lastUsedID < maxFreeID) {
-    std::string possible = (newSymName + llvm::utostr(++lastUsedID)).str();
+  MLIRContext *ctx = module->getContext();
 
-    if (!SymbolTable::lookupSymbolIn(module, possible)) {
-      newSymName += llvm::utostr(lastUsedID);
-      break;
-    }
+  while (lastUsedID < maxFreeID) {
+    auto possible = StringAttr::get(ctx, newSymName + Twine(++lastUsedID));
+    if (!SymbolTable::lookupSymbolIn(module, possible))
+      return possible;
   }
 
-  return newSymName;
+  return StringAttr::get(ctx, newSymName);
 }
 
 /// Checks if a symbol with the same name as `op` already exists in `source`.
 /// If so, renames `op` and updates all its references in `target`.
 static LogicalResult updateSymbolAndAllUses(SymbolOpInterface op,
                                             spirv::ModuleOp target,
                                             spirv::ModuleOp source,
                                             unsigned &lastUsedID) {
   if (!SymbolTable::lookupSymbolIn(source, op.getName()))
     return success();
 
   StringRef oldSymName = op.getName();
-  SmallString<64> newSymName = renameSymbol(oldSymName, lastUsedID, target);
+  StringAttr newSymName = renameSymbol(oldSymName, lastUsedID, target);
 
   if (failed(SymbolTable::replaceAllSymbolUses(op, newSymName, target)))
     return op.emitError("unable to update all symbol uses for ")
            << oldSymName << " to " << newSymName;
 
   SymbolTable::setSymbolName(op, newSymName);
   return success();
 }
for (auto &op : *combinedModule.getBody()) {
 
     auto result = hashToSymbolOp.try_emplace(computeHash(symbolOp), symbolOp);
     if (result.second)
       continue;
 
     SymbolOpInterface replacementSymOp = result.first->second;
 
     if (failed(SymbolTable::replaceAllSymbolUses(
-            symbolOp, replacementSymOp.getName(), combinedModule))) {
+            symbolOp, replacementSymOp.getNameAttr(), combinedModule))) {
       symbolOp.emitError("unable to update all symbol uses for ")
           << symbolOp.getName() << " to " << replacementSymOp.getName();
       return nullptr;
     }
 
     eraseList.push_back(symbolOp);
   }
 
   for (auto symbolOp : eraseList)
     symbolOp.erase();
 
   return combinedModule;
 }
 
 } // namespace spirv
 } // namespace mlir

mlir/lib/Dialect/SPIRV/Transforms/DecorateCompositeTypeLayoutPass.cpp

 class SPIRVAddressOfOpLayoutInfoDecoration
     : public OpRewritePattern<spirv::AddressOfOp> {
 public:
   using OpRewritePattern<spirv::AddressOfOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(spirv::AddressOfOp op,
                                 PatternRewriter &rewriter) const override {
     auto spirvModule = op->getParentOfType<spirv::ModuleOp>();
-    auto varName = op.variable();
+    auto varName = op.variableAttr();
     auto varOp = spirvModule.lookupSymbol<spirv::GlobalVariableOp>(varName);
 
     rewriter.replaceOpWithNewOp<spirv::AddressOfOp>(
-        op, varOp.type(), rewriter.getSymbolRefAttr(varName));
+        op, varOp.type(), rewriter.getSymbolRefAttr(varName.getAttr()));
     return success();
   }
 };
 } // namespace
 
 static void populateSPIRVLayoutInfoPatterns(RewritePatternSet &patterns) {
   patterns.add<SPIRVGlobalVariableOpLayoutInfoDecoration,
                SPIRVAddressOfOpLayoutInfoDecoration>(patterns.getContext());

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp

static Value getTensor(ConversionPatternRewriter &rewriter, unsigned width,
   RankedTensorType tt1 = RankedTensorType::get({sz}, etp);
   RankedTensorType tt2 = RankedTensorType::get({ShapedType::kDynamicSize}, etp);
   auto elts =
       rewriter.create<ConstantOp>(loc, DenseElementsAttr::get(tt1, values));
   return rewriter.create<tensor::CastOp>(loc, tt2, elts);
 }
 
 /// Returns function reference (first hit also inserts into module).
-static FlatSymbolRefAttr getFunc(Operation *op, StringRef name, Type result,
+static FlatSymbolRefAttr getFunc(Operation *op, StringRef name, Type resultType,
                                  ValueRange operands) {
   MLIRContext *context = op->getContext();
   auto module = op->getParentOfType<ModuleOp>();
-  auto func = module.lookupSymbol<FuncOp>(name);
+  auto result = SymbolRefAttr::get(context, name);
+  auto func = module.lookupSymbol<FuncOp>(result.getAttr());
   if (!func) {
     OpBuilder moduleBuilder(module.getBodyRegion());
     moduleBuilder
-        .create<FuncOp>(op->getLoc(), name,
-                        FunctionType::get(context, operands.getTypes(), result))
+        .create<FuncOp>(
+            op->getLoc(), name,
+            FunctionType::get(context, operands.getTypes(), resultType))
         .setPrivate();
   }
-  return SymbolRefAttr::get(context, name);
+  return result;
 }
 
 /// Generates a call into the "swiss army knife" method of the sparse runtime
 /// support library for materializing sparse tensors into the computation. The
 /// method returns the call value and assigns the permutation to 'perm'.
 static Value genNewCall(ConversionPatternRewriter &rewriter, Operation *op,
                         SparseTensorEncodingAttr &enc, uint32_t action,
                         Value &perm, Value ptr = Value()) {

mlir/lib/IR/AsmPrinter.cpp

if (auto opaqueAttr = attr.dyn_cast<OpaqueAttr>()) {
 
     // IntegerSet always elides the type.
     return;
 
   } else if (auto typeAttr = attr.dyn_cast<TypeAttr>()) {
     printType(typeAttr.getValue());
 
   } else if (auto refAttr = attr.dyn_cast<SymbolRefAttr>()) {
-    printSymbolReference(refAttr.getRootReference(), os);
+    printSymbolReference(refAttr.getRootReference().getValue(), os);
     for (FlatSymbolRefAttr nestedRef : refAttr.getNestedReferences()) {
       os << "::";
       printSymbolReference(nestedRef.getValue(), os);
     }
 
   } else if (auto opaqueAttr = attr.dyn_cast<OpaqueElementsAttr>()) {
     if (printerFlags.shouldElideElementsAttr(opaqueAttr)) {
       printElidedElementsAttr(os);

mlir/lib/IR/Builders.cpp

 }
 
 FlatSymbolRefAttr Builder::getSymbolRefAttr(Operation *value) {
   auto symName =
       value->getAttrOfType<StringAttr>(SymbolTable::getSymbolAttrName());
   assert(symName && "value does not have a valid symbol name");
   return getSymbolRefAttr(symName.getValue());
 }
-FlatSymbolRefAttr Builder::getSymbolRefAttr(StringRef value) {
-  return SymbolRefAttr::get(getContext(), value);
+
+FlatSymbolRefAttr Builder::getSymbolRefAttr(StringAttr value) {
+  return SymbolRefAttr::get(value);
 }
+
 SymbolRefAttr
-Builder::getSymbolRefAttr(StringRef value,
+Builder::getSymbolRefAttr(StringAttr value,
                           ArrayRef<FlatSymbolRefAttr> nestedReferences) {
-  return SymbolRefAttr::get(getContext(), value, nestedReferences);
+  return SymbolRefAttr::get(value, nestedReferences);
 }
 
 ArrayAttr Builder::getBoolArrayAttr(ArrayRef<bool> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [this](bool v) -> Attribute { return getBoolAttr(v); }));
   return getArrayAttr(attrs);
 }
 
 ArrayAttr Builder::getI32ArrayAttr(ArrayRef<int32_t> values) {

mlir/lib/IR/BuiltinAttributes.cpp

LogicalResult FloatAttr::verify(function_ref<InFlightDiagnostic()> emitError,
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolRefAttr
 //===----------------------------------------------------------------------===//
 
 FlatSymbolRefAttr SymbolRefAttr::get(MLIRContext *ctx, StringRef value) {
-  return get(ctx, value, llvm::None).cast<FlatSymbolRefAttr>();
+  return get(StringAttr::get(ctx, value));
 }
 
-StringRef SymbolRefAttr::getLeafReference() const {
+FlatSymbolRefAttr SymbolRefAttr::get(StringAttr value) {
+  return get(value, {}).cast<FlatSymbolRefAttr>();
+}
+
+StringAttr SymbolRefAttr::getLeafReference() const {
   ArrayRef<FlatSymbolRefAttr> nestedRefs = getNestedReferences();
-  return nestedRefs.empty() ? getRootReference() : nestedRefs.back().getValue();
+  return nestedRefs.empty() ? getRootReference() : nestedRefs.back().getAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // IntegerAttr
 //===----------------------------------------------------------------------===//
 
 int64_t IntegerAttr::getInt() const {
   assert((getType().isIndex() || getType().isSignlessInteger()) &&

mlir/lib/IR/SymbolTable.cpp

 using namespace mlir;
 
 /// Return true if the given operation is unknown and may potentially define a
 /// symbol table.
 static bool isPotentiallyUnknownSymbolTable(Operation *op) {
   return op->getNumRegions() == 1 && !op->getDialect();
 }
 
-/// Returns the string name of the given symbol, or None if this is not a
+/// Returns the string name of the given symbol, or null if this is not a
 /// symbol.
-static Optional<StringRef> getNameIfSymbol(Operation *symbol) {
-  auto nameAttr =
-      symbol->getAttrOfType<StringAttr>(SymbolTable::getSymbolAttrName());
-  return nameAttr ? nameAttr.getValue() : Optional<StringRef>();
+static StringAttr getNameIfSymbol(Operation *op) {
+  return op->getAttrOfType<StringAttr>(SymbolTable::getSymbolAttrName());
 }
-static Optional<StringRef> getNameIfSymbol(Operation *symbol,
-                                           Identifier symbolAttrNameId) {
-  auto nameAttr = symbol->getAttrOfType<StringAttr>(symbolAttrNameId);
-  return nameAttr ? nameAttr.getValue() : Optional<StringRef>();
+static StringAttr getNameIfSymbol(Operation *op, Identifier symbolAttrNameId) {
+  return op->getAttrOfType<StringAttr>(symbolAttrNameId);
 }
 
 /// Computes the nested symbol reference attribute for the symbol 'symbolName'
 /// that are usable within the symbol table operations from 'symbol' as far up
 /// to the given operation 'within', where 'within' is an ancestor of 'symbol'.
 /// Returns success if all references up to 'within' could be computed.
 static LogicalResult
-collectValidReferencesFor(Operation *symbol, StringRef symbolName,
+collectValidReferencesFor(Operation *symbol, StringAttr symbolName,
                           Operation *within,
                           SmallVectorImpl<SymbolRefAttr> &results) {
   assert(within->isAncestor(symbol) && "expected 'within' to be an ancestor");
   MLIRContext *ctx = symbol->getContext();
 
-  auto leafRef = FlatSymbolRefAttr::get(ctx, symbolName);
+  auto leafRef = FlatSymbolRefAttr::get(symbolName);
   results.push_back(leafRef);
 
   // Early exit for when 'within' is the parent of 'symbol'.
   Operation *symbolTableOp = symbol->getParentOp();
   if (within == symbolTableOp)
     return success();
 
   // Collect references until 'symbolTableOp' reaches 'within'.
   SmallVector<FlatSymbolRefAttr, 1> nestedRefs(1, leafRef);
   Identifier symbolNameId =
       Identifier::get(SymbolTable::getSymbolAttrName(), ctx);
   do {
     // Each parent of 'symbol' should define a symbol table.
     if (!symbolTableOp->hasTrait<OpTrait::SymbolTable>())
       return failure();
     // Each parent of 'symbol' should also be a symbol.
-    Optional<StringRef> symbolTableName =
-        getNameIfSymbol(symbolTableOp, symbolNameId);
+    StringAttr symbolTableName = getNameIfSymbol(symbolTableOp, symbolNameId);
     if (!symbolTableName)
       return failure();
-    results.push_back(SymbolRefAttr::get(ctx, *symbolTableName, nestedRefs));
+    results.push_back(SymbolRefAttr::get(symbolTableName, nestedRefs));
 
     symbolTableOp = symbolTableOp->getParentOp();
     if (symbolTableOp == within)
       break;
     nestedRefs.insert(nestedRefs.begin(),
-                      FlatSymbolRefAttr::get(ctx, *symbolTableName));
+                      FlatSymbolRefAttr::get(symbolTableName));
   } while (true);
   return success();
 }
 
 /// Walk all of the operations within the given set of regions, without
 /// traversing into any nested symbol tables. Stops walking if the result of the
 /// callback is anything other than `WalkResult::advance`.
 static Optional<WalkResult>
SymbolTable::SymbolTable(Operation *symbolTableOp)
   assert(symbolTableOp->getNumRegions() == 1 &&
          "expected operation to have a single region");
   assert(llvm::hasSingleElement(symbolTableOp->getRegion(0)) &&
          "expected operation to have a single block");
 
   Identifier symbolNameId = Identifier::get(SymbolTable::getSymbolAttrName(),
                                             symbolTableOp->getContext());
   for (auto &op : symbolTableOp->getRegion(0).front()) {
-    Optional<StringRef> name = getNameIfSymbol(&op, symbolNameId);
+    StringAttr name = getNameIfSymbol(&op, symbolNameId);
     if (!name)
       continue;
 
-    auto inserted = symbolTable.insert({*name, &op});
+    auto inserted = symbolTable.insert({name, &op});
     (void)inserted;
     assert(inserted.second &&
            "expected region to contain uniquely named symbol operations");
   }
 }
 
 /// Look up a symbol with the specified name, returning null if no such name
 /// exists. Names never include the @ on them.
 Operation *SymbolTable::lookup(StringRef name) const {
+  return lookup(StringAttr::get(symbolTableOp->getContext(), name));
+}
+Operation *SymbolTable::lookup(StringAttr name) const {
   return symbolTable.lookup(name);
 }
 
 /// Erase the given symbol from the table.
 void SymbolTable::erase(Operation *symbol) {
-  Optional<StringRef> name = getNameIfSymbol(symbol);
+  StringAttr name = getNameIfSymbol(symbol);
   assert(name && "expected valid 'name' attribute");
   assert(symbol->getParentOp() == symbolTableOp &&
          "expected this operation to be inside of the operation with this "
          "SymbolTable");
 
-  auto it = symbolTable.find(*name);
+  auto it = symbolTable.find(name);
   if (it != symbolTable.end() && it->second == symbol) {
     symbolTable.erase(it);
     symbol->erase();
   }
 }
 
 // TODO: Consider if this should be renamed to something like insertOrUpdate
 /// Insert a new symbol into the table and associated operation if not already
if (!symbol->getParentOp()) {
 
     body.getOperations().insert(insertPt, symbol);
   }
   assert(symbol->getParentOp() == symbolTableOp &&
          "symbol is already inserted in another op");
 
   // Add this symbol to the symbol table, uniquing the name if a conflict is
   // detected.
-  StringRef name = getSymbolName(symbol);
+  StringAttr name = getSymbolName(symbol);
   if (symbolTable.insert({name, symbol}).second)
     return;
   // If the symbol was already in the table, also return.
   if (symbolTable.lookup(name) == symbol)
     return;
   // If a conflict was detected, then the symbol will not have been added to
   // the symbol table. Try suffixes until we get to a unique name that works.
-  SmallString<128> nameBuffer(name);
+  SmallString<128> nameBuffer(name.getValue());
   unsigned originalLength = nameBuffer.size();
 
+  MLIRContext *context = symbol->getContext();
+
   // Iteratively try suffixes until we find one that isn't used.
   do {
     nameBuffer.resize(originalLength);
     nameBuffer += '_';
     nameBuffer += std::to_string(uniquingCounter++);
-  } while (!symbolTable.insert({nameBuffer, symbol}).second);
+  } while (!symbolTable.insert({StringAttr::get(context, nameBuffer), symbol})
+                .second);
   setSymbolName(symbol, nameBuffer);
 }
 
 /// Returns the name of the given symbol operation.
-StringRef SymbolTable::getSymbolName(Operation *symbol) {
-  Optional<StringRef> name = getNameIfSymbol(symbol);
+StringAttr SymbolTable::getSymbolName(Operation *symbol) {
+  StringAttr name = getNameIfSymbol(symbol);
   assert(name && "expected valid symbol name");
-  return *name;
+  return name;
 }
+
 /// Sets the name of the given symbol operation.
-void SymbolTable::setSymbolName(Operation *symbol, StringRef name) {
-  symbol->setAttr(getSymbolAttrName(),
-                  StringAttr::get(symbol->getContext(), name));
+void SymbolTable::setSymbolName(Operation *symbol, StringAttr name) {
+  symbol->setAttr(getSymbolAttrName(), name);
 }
 
 /// Returns the visibility of the given symbol operation.
 SymbolTable::Visibility SymbolTable::getSymbolVisibility(Operation *symbol) {
   // If the attribute doesn't exist, assume public.
   StringAttr vis = symbol->getAttrOfType<StringAttr>(getVisibilityAttrName());
   if (!vis)
     return Visibility::Public;
if (isSymbolTable)
     callback(op, allSymUsesVisible);
 }
 
 /// Returns the operation registered with the given symbol name with the
 /// regions of 'symbolTableOp'. 'symbolTableOp' is required to be an operation
 /// with the 'OpTrait::SymbolTable' trait. Returns nullptr if no valid symbol
 /// was found.
 Operation *SymbolTable::lookupSymbolIn(Operation *symbolTableOp,
-                                       StringRef symbol) {
+                                       StringAttr symbol) {
   assert(symbolTableOp->hasTrait<OpTrait::SymbolTable>());
   Region &region = symbolTableOp->getRegion(0);
   if (region.empty())
     return nullptr;
 
   // Look for a symbol with the given name.
   Identifier symbolNameId = Identifier::get(SymbolTable::getSymbolAttrName(),
                                             symbolTableOp->getContext());
Operation *SymbolTable::lookupSymbolIn(Operation *symbolTableOp,
   return resolvedSymbols.back();
 }
 
 /// Internal implementation of `lookupSymbolIn` that allows for specialized
 /// implementations of the lookup function.
 static LogicalResult lookupSymbolInImpl(
     Operation *symbolTableOp, SymbolRefAttr symbol,
     SmallVectorImpl<Operation *> &symbols,
-    function_ref<Operation *(Operation *, StringRef)> lookupSymbolFn) {
+    function_ref<Operation *(Operation *, StringAttr)> lookupSymbolFn) {
   assert(symbolTableOp->hasTrait<OpTrait::SymbolTable>());
 
   // Lookup the root reference for this symbol.
   symbolTableOp = lookupSymbolFn(symbolTableOp, symbol.getRootReference());
   if (!symbolTableOp)
     return failure();
   symbols.push_back(symbolTableOp);
 
   // If there are no nested references, just return the root symbol directly.
   ArrayRef<FlatSymbolRefAttr> nestedRefs = symbol.getNestedReferences();
   if (nestedRefs.empty())
     return success();
 
   // Verify that the root is also a symbol table.
   if (!symbolTableOp->hasTrait<OpTrait::SymbolTable>())
     return failure();
 
   // Otherwise, lookup each of the nested non-leaf references and ensure that
   // each corresponds to a valid symbol table.
   for (FlatSymbolRefAttr ref : nestedRefs.drop_back()) {
-    symbolTableOp = lookupSymbolFn(symbolTableOp, ref.getValue());
+    symbolTableOp = lookupSymbolFn(symbolTableOp, ref.getAttr());
     if (!symbolTableOp || !symbolTableOp->hasTrait<OpTrait::SymbolTable>())
       return failure();
     symbols.push_back(symbolTableOp);
   }
   symbols.push_back(lookupSymbolFn(symbolTableOp, symbol.getLeafReference()));
   return success(symbols.back());
 }
 
 LogicalResult
 SymbolTable::lookupSymbolIn(Operation *symbolTableOp, SymbolRefAttr symbol,
                             SmallVectorImpl<Operation *> &symbols) {
-  auto lookupFn = [](Operation *symbolTableOp, StringRef symbol) {
+  auto lookupFn = [](Operation *symbolTableOp, StringAttr symbol) {
     return lookupSymbolIn(symbolTableOp, symbol);
   };
   return lookupSymbolInImpl(symbolTableOp, symbol, symbols, lookupFn);
 }
 
 /// Returns the operation registered with the given symbol name within the
 /// closes parent operation with the 'OpTrait::SymbolTable' trait. Returns
 /// nullptr if no valid symbol was found.
 Operation *SymbolTable::lookupNearestSymbolFrom(Operation *from,
-                                                StringRef symbol) {
+                                                StringAttr symbol) {
   Operation *symbolTableOp = getNearestSymbolTable(from);
   return symbolTableOp ? lookupSymbolIn(symbolTableOp, symbol) : nullptr;
 }
 Operation *SymbolTable::lookupNearestSymbolFrom(Operation *from,
                                                 SymbolRefAttr symbol) {
   Operation *symbolTableOp = getNearestSymbolTable(from);
   return symbolTableOp ? lookupSymbolIn(symbolTableOp, symbol) : nullptr;
 }
struct SymbolScope {
   /// The IR unit representing this scope.
   llvm::PointerUnion<Operation *, Region *> limit;
 };
 } // end anonymous namespace
 
 /// Collect all of the symbol scopes from 'symbol' to (inclusive) 'limit'.
 static SmallVector<SymbolScope, 2> collectSymbolScopes(Operation *symbol,
                                                        Operation *limit) {
-  StringRef symName = SymbolTable::getSymbolName(symbol);
+  StringAttr symName = SymbolTable::getSymbolName(symbol);
   assert(!symbol->hasTrait<OpTrait::SymbolTable>() || symbol != limit);
 
   // Compute the ancestors of 'limit'.
   SetVector<Operation *, SmallVector<Operation *, 4>,
             SmallPtrSet<Operation *, 4>>
       limitAncestors;
   Operation *limitAncestor = limit;
   do {
     // Check to see if 'symbol' is an ancestor of 'limit'.
     if (limitAncestor == symbol) {
       // Check that the nearest symbol table is 'symbol's parent. SymbolRefAttr
       // doesn't support parent references.
       if (SymbolTable::getNearestSymbolTable(limit->getParentOp()) ==
           symbol->getParentOp())
-        return {{SymbolRefAttr::get(symbol->getContext(), symName), limit}};
+        return {{SymbolRefAttr::get(symName), limit}};
       return {};
     }
 
     limitAncestors.insert(limitAncestor);
   } while ((limitAncestor = limitAncestor->getParentOp()));
 
   // Try to find the first ancestor of 'symbol' that is an ancestor of 'limit'.
   Operation *commonAncestor = symbol->getParentOp();
static SmallVector<SymbolScope, 2> collectSymbolScopes(Operation *symbol,
 
   // If we collected some scopes to walk, make sure to constrain the one for
   // limit to the specific region requested.
   if (!scopes.empty())
     scopes.back().limit = limit;
   return scopes;
 }
 template <typename IRUnit>
-static SmallVector<SymbolScope, 1> collectSymbolScopes(StringRef symbol,
+static SmallVector<SymbolScope, 1> collectSymbolScopes(StringAttr symbol,
                                                        IRUnit *limit) {
-  return {{SymbolRefAttr::get(limit->getContext(), symbol), limit}};
+  return {{SymbolRefAttr::get(symbol), limit}};
 }
 
 /// Returns true if the given reference 'SubRef' is a sub reference of the
 /// reference 'ref', i.e. 'ref' is a further qualified reference.
 static bool isReferencePrefixOf(SymbolRefAttr subRef, SymbolRefAttr ref) {
   if (ref == subRef)
     return true;
 
static Optional<SymbolTable::UseRange> getSymbolUsesImpl(SymbolT symbol,
   }
   return SymbolTable::UseRange(std::move(uses));
 }
 
 /// Get all of the uses of the given symbol that are nested within the given
 /// operation 'from', invoking the provided callback for each. This does not
 /// traverse into any nested symbol tables. This function returns None if there
 /// are any unknown operations that may potentially be symbol tables.
-auto SymbolTable::getSymbolUses(StringRef symbol, Operation *from)
+auto SymbolTable::getSymbolUses(StringAttr symbol, Operation *from)
     -> Optional<UseRange> {
   return getSymbolUsesImpl(symbol, from);
 }
 auto SymbolTable::getSymbolUses(Operation *symbol, Operation *from)
     -> Optional<UseRange> {
   return getSymbolUsesImpl(symbol, from);
 }
-auto SymbolTable::getSymbolUses(StringRef symbol, Region *from)
+auto SymbolTable::getSymbolUses(StringAttr symbol, Region *from)
     -> Optional<UseRange> {
   return getSymbolUsesImpl(symbol, from);
 }
 auto SymbolTable::getSymbolUses(Operation *symbol, Region *from)
     -> Optional<UseRange> {
   return getSymbolUsesImpl(symbol, from);
 }
 
static bool symbolKnownUseEmptyImpl(SymbolT symbol, IRUnitT *limit) {
   }
   return true;
 }
 
 /// Return if the given symbol is known to have no uses that are nested within
 /// the given operation 'from'. This does not traverse into any nested symbol
 /// tables. This function will also return false if there are any unknown
 /// operations that may potentially be symbol tables.
-bool SymbolTable::symbolKnownUseEmpty(StringRef symbol, Operation *from) {
+bool SymbolTable::symbolKnownUseEmpty(StringAttr symbol, Operation *from) {
   return symbolKnownUseEmptyImpl(symbol, from);
 }
 bool SymbolTable::symbolKnownUseEmpty(Operation *symbol, Operation *from) {
   return symbolKnownUseEmptyImpl(symbol, from);
 }
-bool SymbolTable::symbolKnownUseEmpty(StringRef symbol, Region *from) {
+bool SymbolTable::symbolKnownUseEmpty(StringAttr symbol, Region *from) {
   return symbolKnownUseEmptyImpl(symbol, from);
 }
 bool SymbolTable::symbolKnownUseEmpty(Operation *symbol, Region *from) {
   return symbolKnownUseEmptyImpl(symbol, from);
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolTable::replaceAllSymbolUses

 
 /// Generates a new symbol reference attribute with a new leaf reference.
 static SymbolRefAttr generateNewRefAttr(SymbolRefAttr oldAttr,
                                         FlatSymbolRefAttr newLeafAttr) {
   if (oldAttr.isa<FlatSymbolRefAttr>())
     return newLeafAttr;
   auto nestedRefs = llvm::to_vector<2>(oldAttr.getNestedReferences());
   nestedRefs.back() = newLeafAttr;
-  return SymbolRefAttr::get(oldAttr.getContext(), oldAttr.getRootReference(),
-                            nestedRefs);
+  return SymbolRefAttr::get(oldAttr.getRootReference(), nestedRefs);
 }
 
 /// The implementation of SymbolTable::replaceAllSymbolUses below.
 template <typename SymbolT, typename IRUnitT>
 static LogicalResult
-replaceAllSymbolUsesImpl(SymbolT symbol, StringRef newSymbol, IRUnitT *limit) {
+replaceAllSymbolUsesImpl(SymbolT symbol, StringAttr newSymbol, IRUnitT *limit) {
   // A collection of operations along with their new attribute dictionary.
   std::vector<std::pair<Operation *, DictionaryAttr>> updatedAttrDicts;
 
   // The current operation being processed.
   Operation *curOp = nullptr;
 
   // The set of access chains into the attribute dictionary of the current
   // operation, as well as the replacement attribute to use.
   SmallVector<std::pair<SmallVector<int, 1>, SymbolRefAttr>, 1> accessChains;
 
   // Generate a new attribute dictionary for the current operation by replacing
   // references to the old symbol.
   auto generateNewAttrDict = [&] {
     auto oldDict = curOp->getAttrDictionary();
     auto newDict = rebuildAttrAfterRAUW(oldDict, accessChains, /*depth=*/0);
     return newDict.cast<DictionaryAttr>();
   };
 
   // Generate a new attribute to replace the given attribute.
-  MLIRContext *ctx = limit->getContext();
-  FlatSymbolRefAttr newLeafAttr = FlatSymbolRefAttr::get(ctx, newSymbol);
+  FlatSymbolRefAttr newLeafAttr = FlatSymbolRefAttr::get(newSymbol);
   for (SymbolScope &scope : collectSymbolScopes(symbol, limit)) {
     SymbolRefAttr newAttr = generateNewRefAttr(scope.symbol, newLeafAttr);
     auto walkFn = [&](SymbolTable::SymbolUse symbolUse,
                       ArrayRef<int> accessChain) {
       SymbolRefAttr useRef = symbolUse.getSymbolRef();
       if (!isReferencePrefixOf(scope.symbol, useRef))
         return WalkResult::advance();
 
       // If we have a valid match, check to see if this is a proper
       // subreference. If it is, then we will need to generate a different new
       // attribute specifically for this use.
       SymbolRefAttr replacementRef = newAttr;
       if (useRef != scope.symbol) {
         if (scope.symbol.isa<FlatSymbolRefAttr>()) {
           replacementRef =
-              SymbolRefAttr::get(ctx, newSymbol, useRef.getNestedReferences());
+              SymbolRefAttr::get(newSymbol, useRef.getNestedReferences());
         } else {
           auto nestedRefs = llvm::to_vector<4>(useRef.getNestedReferences());
           nestedRefs[scope.symbol.getNestedReferences().size() - 1] =
               newLeafAttr;
           replacementRef =
-              SymbolRefAttr::get(ctx, useRef.getRootReference(), nestedRefs);
+              SymbolRefAttr::get(useRef.getRootReference(), nestedRefs);
         }
       }
 
       // If there was a previous operation, generate a new attribute dict
       // for it. This means that we've finished processing the current
       // operation, so generate a new dictionary for it.
       if (curOp && symbolUse.getUser() != curOp) {
         updatedAttrDicts.push_back({curOp, generateNewAttrDict()});
replaceAllSymbolUsesImpl(SymbolT symbol, StringAttr newSymbol, IRUnitT *limit) {
   return success();
 }
 
 /// Attempt to replace all uses of the given symbol 'oldSymbol' with the
 /// provided symbol 'newSymbol' that are nested within the given operation
 /// 'from'. This does not traverse into any nested symbol tables. If there are
 /// any unknown operations that may potentially be symbol tables, no uses are
 /// replaced and failure is returned.
-LogicalResult SymbolTable::replaceAllSymbolUses(StringRef oldSymbol,
-                                                StringRef newSymbol,
+LogicalResult SymbolTable::replaceAllSymbolUses(StringAttr oldSymbol,
+                                                StringAttr newSymbol,
                                                 Operation *from) {
   return replaceAllSymbolUsesImpl(oldSymbol, newSymbol, from);
 }
 LogicalResult SymbolTable::replaceAllSymbolUses(Operation *oldSymbol,
-                                                StringRef newSymbol,
+                                                StringAttr newSymbol,
                                                 Operation *from) {
   return replaceAllSymbolUsesImpl(oldSymbol, newSymbol, from);
 }
-LogicalResult SymbolTable::replaceAllSymbolUses(StringRef oldSymbol,
-                                                StringRef newSymbol,
+LogicalResult SymbolTable::replaceAllSymbolUses(StringAttr oldSymbol,
+                                                StringAttr newSymbol,
                                                 Region *from) {
   return replaceAllSymbolUsesImpl(oldSymbol, newSymbol, from);
 }
 LogicalResult SymbolTable::replaceAllSymbolUses(Operation *oldSymbol,
-                                                StringRef newSymbol,
+                                                StringAttr newSymbol,
                                                 Region *from) {
   return replaceAllSymbolUsesImpl(oldSymbol, newSymbol, from);
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolTableCollection
 //===----------------------------------------------------------------------===//
 
 Operation *SymbolTableCollection::lookupSymbolIn(Operation *symbolTableOp,
-                                                 StringRef symbol) {
+                                                 StringAttr symbol) {
   return getSymbolTable(symbolTableOp).lookup(symbol);
 }
 Operation *SymbolTableCollection::lookupSymbolIn(Operation *symbolTableOp,
                                                  SymbolRefAttr name) {
   SmallVector<Operation *, 4> symbols;
   if (failed(lookupSymbolIn(symbolTableOp, name, symbols)))
     return nullptr;
   return symbols.back();
 }
 /// A variant of 'lookupSymbolIn' that returns all of the symbols referenced by
 /// a given SymbolRefAttr. Returns failure if any of the nested references could
 /// not be resolved.
 LogicalResult
 SymbolTableCollection::lookupSymbolIn(Operation *symbolTableOp,
                                       SymbolRefAttr name,
                                       SmallVectorImpl<Operation *> &symbols) {
-  auto lookupFn = [this](Operation *symbolTableOp, StringRef symbol) {
+  auto lookupFn = [this](Operation *symbolTableOp, StringAttr symbol) {
     return lookupSymbolIn(symbolTableOp, symbol);
   };
   return lookupSymbolInImpl(symbolTableOp, name, symbols, lookupFn);
 }
 
 /// Returns the operation registered with the given symbol name within the
 /// closest parent operation of, or including, 'from' with the
 /// 'OpTrait::SymbolTable' trait. Returns nullptr if no valid symbol was
 /// found.
 Operation *SymbolTableCollection::lookupNearestSymbolFrom(Operation *from,
-                                                          StringRef symbol) {
+                                                          StringAttr symbol) {
   Operation *symbolTableOp = SymbolTable::getNearestSymbolTable(from);
   return symbolTableOp ? lookupSymbolIn(symbolTableOp, symbol) : nullptr;
 }
 Operation *
 SymbolTableCollection::lookupNearestSymbolFrom(Operation *from,
                                                SymbolRefAttr symbol) {
   Operation *symbolTableOp = SymbolTable::getNearestSymbolTable(from);
   return symbolTableOp ? lookupSymbolIn(symbolTableOp, symbol) : nullptr;
SymbolUserMap::SymbolUserMap(SymbolTableCollection &symbolTable,
   };
   // We just set `allSymUsesVisible` to false here because it isn't necessary
   // for building the user map.
   SymbolTable::walkSymbolTables(symbolTableOp, /*allSymUsesVisible=*/false,
                                 walkFn);
 }
 
 void SymbolUserMap::replaceAllUsesWith(Operation *symbol,
-                                       StringRef newSymbolName) {
+                                       StringAttr newSymbolName) {
   auto it = symbolToUsers.find(symbol);
   if (it == symbolToUsers.end())
     return;
   SetVector<Operation *> &users = it->second;
 
   // Replace the uses within the users of `symbol`.
   for (Operation *user : users)
     (void)SymbolTable::replaceAllSymbolUses(symbol, newSymbolName, user);

mlir/lib/Rewrite/ByteCode.cpp

void Generator::generate(pdl_interp::InferredTypesOp op,
   getMemIndex(op.type()) = getMemIndex(Type());
 }
 void Generator::generate(pdl_interp::IsNotNullOp op, ByteCodeWriter &writer) {
   writer.append(OpCode::IsNotNull, op.value(), op.getSuccessors());
 }
 void Generator::generate(pdl_interp::RecordMatchOp op, ByteCodeWriter &writer) {
   ByteCodeField patternIndex = patterns.size();
   patterns.emplace_back(PDLByteCodePattern::create(
-      op, rewriterToAddr[op.rewriter().getLeafReference()]));
+      op, rewriterToAddr[op.rewriter().getLeafReference().getValue()]));
   writer.append(OpCode::RecordMatch, patternIndex,
                 SuccessorRange(op.getOperation()), op.matchedOps());
   writer.appendPDLValueList(op.inputs());
 }
 void Generator::generate(pdl_interp::ReplaceOp op, ByteCodeWriter &writer) {
   writer.append(OpCode::ReplaceOp, op.operation());
   writer.appendPDLValueList(op.replValues());
 }

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

mlirModule->walk([&](LLVM::MetadataOp metadatas) {
     });
   });
   return success();
 }
 
 llvm::MDNode *
 ModuleTranslation::getAliasScope(Operation &opInst,
                                  SymbolRefAttr aliasScopeRef) const {
-  StringRef metadataName = aliasScopeRef.getRootReference();
-  StringRef scopeName = aliasScopeRef.getLeafReference();
+  StringAttr metadataName = aliasScopeRef.getRootReference();
+  StringAttr scopeName = aliasScopeRef.getLeafReference();
   auto metadataOp = SymbolTable::lookupNearestSymbolFrom<LLVM::MetadataOp>(
       opInst.getParentOp(), metadataName);
   Operation *aliasScopeOp =
       SymbolTable::lookupNearestSymbolFrom(metadataOp, scopeName);
   return aliasScopeMetadataMapping.lookup(aliasScopeOp);
 }
 
 void ModuleTranslation::setAliasScopeMetadata(Operation *op,

mlir/test/lib/IR/TestSymbolUses.cpp

void runOnOperation() override {
     for (Operation *op : deadFunctions) {
       // In order to test the SymbolTable::erase method, also erase completely
       // useless functions.
       auto name = SymbolTable::getSymbolName(op);
       assert(table.lookup(name) && "expected no unknown operations");
       table.erase(op);
       assert(!table.lookup(name) &&
              "expected erased operation to be unknown now");
-      module.emitRemark() << name << " function successfully erased";
+      module.emitRemark() << name.getValue() << " function successfully erased";
     }
   }
 };
 
 /// This is a symbol test pass that tests the symbol use replacement
 /// functionality provided by the symbol table.
 struct SymbolReplacementPass
     : public PassWrapper<SymbolReplacementPass, OperationPass<ModuleOp>> {
if (!SymbolTable::getSymbolUses(&module.getBodyRegion()))
       return;
 
     SymbolTableCollection symbolTable;
     SymbolUserMap symbolUsers(symbolTable, module);
     module.getBodyRegion().walk([&](Operation *nestedOp) {
       StringAttr newName = nestedOp->getAttrOfType<StringAttr>("sym.new_name");
       if (!newName)
         return;
-      symbolUsers.replaceAllUsesWith(nestedOp, newName.getValue());
-      SymbolTable::setSymbolName(nestedOp, newName.getValue());
+      symbolUsers.replaceAllUsesWith(nestedOp, newName);
+      SymbolTable::setSymbolName(nestedOp, newName);
     });
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
 void registerSymbolTestPasses() {
   PassRegistration<SymbolUsesPass>();
 
   PassRegistration<SymbolReplacementPass>();
 }
 } // namespace mlir

mlir/test/lib/Rewrite/TestPDLByteCode.cpp

struct TestPDLByteCodePass
   StringRef getDescription() const final {
     return "Test PDL ByteCode functionality";
   }
   void runOnOperation() final {
     ModuleOp module = getOperation();
 
     // The test cases are encompassed via two modules, one containing the
     // patterns and one containing the operations to rewrite.
-    ModuleOp patternModule = module.lookupSymbol<ModuleOp>("patterns");
-    ModuleOp irModule = module.lookupSymbol<ModuleOp>("ir");
+    ModuleOp patternModule = module.lookupSymbol<ModuleOp>(
+        StringAttr::get(module->getContext(), "patterns"));
+    ModuleOp irModule = module.lookupSymbol<ModuleOp>(
+        StringAttr::get(module->getContext(), "ir"));
     if (!patternModule || !irModule)
       return;
 
     // Process the pattern module.
     patternModule.getOperation()->remove();
     PDLPatternModule pdlPattern(patternModule);
     pdlPattern.registerConstraintFunction("multi_entity_constraint",
                                           customMultiEntityConstraint);