[MLIR Core] Cache the empty StringAttr like we do for empty dictionaries. NFC.

[lattner]

Summary

MLIRContext holds a few special case values that occur frequently like empty
dictionary and NoneType, which allow us to avoid taking locks to get an instance
of them. Give the empty StringAttr this treatment as well. This cuts several
percent off compile time for CIRCT.

[rriddle]

mlir/lib/IR/MLIRContext.cpp

322

Can you move this to around 336 with the other attributes?

[lattner]

Good call, thanks for the review!

[lattner]

Move emptyString and rename it to be more similar to other cached attrs.

mlir/include/mlir/IR/BuiltinAttributes.td

def Builtin_StringAttr : Builtin_Attr<"String"> {
   let parameters = (ins StringRefParameter<"">:$value,
                         AttributeSelfTypeParameter<"">:$type);
   let builders = [
     AttrBuilderWithInferredContext<(ins "StringRef":$bytes,
                                         "Type":$type), [{
       return $_get(type.getContext(), bytes, type);
     }]>,
     AttrBuilder<(ins "StringRef":$bytes), [{
+      if (bytes.empty())
+        return get($_ctxt);
       return $_get($_ctxt, bytes, NoneType::get($_ctxt));
-    }]>
+    }]>,
+
+    /// Build an empty string attr with NoneType.
+    AttrBuilder<(ins)>
   ];
-  let extraClassDeclaration = "using ValueType = StringRef;";
+  let extraClassDeclaration = [{
+    using ValueType = StringRef;
+
+  private:
+    /// Return an empty StringAttr with NoneType type. This is a special variant
+    /// of the `get` method that is used by the MLIRContext to cache the
+    /// instance.
+    static StringAttr getEmptyStringAttrUnchecked(MLIRContext *context);
+    friend MLIRContext;
+  public:
+  }];
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolRefAttr
 //===----------------------------------------------------------------------===//
 
 def Builtin_SymbolRefAttr : Builtin_Attr<"SymbolRef"> {

mlir/lib/IR/BuiltinAttributes.cpp

DictionaryAttr::iterator DictionaryAttr::end() const {
   return getValue().end();
 }
 size_t DictionaryAttr::size() const { return getValue().size(); }
 
 DictionaryAttr DictionaryAttr::getEmptyUnchecked(MLIRContext *context) {
   return Base::get(context, ArrayRef<NamedAttribute>());
 }
 
+StringAttr StringAttr::getEmptyStringAttrUnchecked(MLIRContext *context) {
+  return Base::get(context, "", NoneType::get(context));
+}
+
 //===----------------------------------------------------------------------===//
 // FloatAttr
 //===----------------------------------------------------------------------===//
 
 double FloatAttr::getValueAsDouble() const {
   return getValueAsDouble(getValue());
 }
 double FloatAttr::getValueAsDouble(APFloat value) {

mlir/lib/IR/MLIRContext.cpp

#endif
   Float16Type f16Ty;
   Float32Type f32Ty;
   Float64Type f64Ty;
   Float80Type f80Ty;
   Float128Type f128Ty;
   IndexType indexTy;
   IntegerType int1Ty, int8Ty, int16Ty, int32Ty, int64Ty, int128Ty;
   NoneType noneType;
 
   //===--------------------------------------------------------------------===//
   // Attribute uniquing
   //===--------------------------------------------------------------------===//
 
   DenseMap<TypeID, const AbstractAttribute *> registeredAttributes;
   StorageUniquer attributeUniquer;
 
   /// Cached Attribute Instances.
   BoolAttr falseAttr, trueAttr;
   UnitAttr unitAttr;
   UnknownLoc unknownLocAttr;
   DictionaryAttr emptyDictionaryAttr;
+  StringAttr emptyStringAttr;
 
 public:
   MLIRContextImpl() : identifiers(identifierAllocator) {}
   ~MLIRContextImpl() {
     for (auto typeMapping : registeredTypes)
       typeMapping.second->~AbstractType();
     for (auto attrMapping : registeredAttributes)
       attrMapping.second->~AbstractAttribute();
MLIRContext::MLIRContext(const DialectRegistry &registry)
   impl->unknownLocAttr = AttributeUniquer::get<UnknownLoc>(this);
   /// Bool Attributes.
   impl->falseAttr = IntegerAttr::getBoolAttrUnchecked(impl->int1Ty, false);
   impl->trueAttr = IntegerAttr::getBoolAttrUnchecked(impl->int1Ty, true);
   /// Unit Attribute.
   impl->unitAttr = AttributeUniquer::get<UnitAttr>(this);
   /// The empty dictionary attribute.
   impl->emptyDictionaryAttr = DictionaryAttr::getEmptyUnchecked(this);
+  /// The empty string attribute.
+  impl->emptyStringAttr = StringAttr::getEmptyStringAttrUnchecked(this);
 
   // Register the affine storage objects with the uniquer.
   impl->affineUniquer
       .registerParametricStorageType<AffineBinaryOpExprStorage>();
   impl->affineUniquer
       .registerParametricStorageType<AffineConstantExprStorage>();
   impl->affineUniquer.registerParametricStorageType<AffineDimExprStorage>();
 }
UnknownLoc UnknownLoc::get(MLIRContext *context) {
   return context->getImpl().unknownLocAttr;
 }
 
 /// Return empty dictionary.
 DictionaryAttr DictionaryAttr::getEmpty(MLIRContext *context) {
   return context->getImpl().emptyDictionaryAttr;
 }
 
+/// Return an empty string.
+StringAttr StringAttr::get(MLIRContext *context) {
+  return context->getImpl().emptyStringAttr;
+}
+
 //===----------------------------------------------------------------------===//
 // AffineMap uniquing
 //===----------------------------------------------------------------------===//
 
 StorageUniquer &MLIRContext::getAffineUniquer() {
   return getImpl().affineUniquer;
 }