WIP mutable composite type attribute.

mlir/include/mlir/Dialect/LLVMIR/LLVMAttrs.h

 class DITypeAttr : public DINodeAttr {
 public:
   using DINodeAttr::DINodeAttr;
 
   /// Support LLVM type casting.
   static bool classof(Attribute attr);
 };
 
+namespace detail {
+class DICompositeTypeMutAttrStorage;
+} // namespace detail
+
+/// A mutable debug information attribute that describes a composite type.
+class DICompositeTypeMutAttr
+    : public Attribute::AttrBase<DICompositeTypeMutAttr, DITypeAttr,
+                                 detail::DICompositeTypeMutAttrStorage,
+                                 AttributeTrait::IsMutable> {
+public:
+  /// Inherit base constructors.
+  using Base::Base;
+
+  /// Returns the composite type with the given identifier and name.
+  static DICompositeTypeMutAttr get(MLIRContext *context, int64_t id,
+                                    StringAttr name, DITypeAttr bastType);
+
+  // static DICompositeTypeMutAttr getDistinct(int64_t id, StringAttr name);
+
+  /// Returns the keyword used when printing and parsing the composite type.
+  static constexpr StringLiteral getMnemonic() {
+    return {"di_composite_type_mut"};
+  }
+
+  LogicalResult setElements(ArrayRef<DITypeAttr> elements);
+
+  /// Returns the unique id of the composite type.
+  int64_t getID() const;
+
+  /// Returns the name of the composite type.
+  StringAttr getName() const;
+
+  /// Returns the base type of the composite type.
+  DITypeAttr getBaseType() const;
+
+  /// Returns the element types of the composite type.
+  ArrayRef<DITypeAttr> getElements() const;
+
+  /// Parses an instance of this attribute.
+  static Attribute parse(AsmParser &parser, Type type);
+
+  /// Prints this attribute.
+  void print(AsmPrinter &os) const;
+};
+
 // Inline the LLVM generated Linkage enum and utility.
 // This is only necessary to isolate the "enum generated code" from the
 // attribute definition itself.
 // TODO: this shouldn't be needed after we unify the attribute generation, i.e.
 // --gen-attr-* and --gen-attrdef-*.
 using cconv::CConv;
 using linkage::Linkage;
 } // namespace LLVM

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

 //===----------------------------------------------------------------------===//
 // LLVM Dialect.
 //===----------------------------------------------------------------------===//
 
 def LLVM_Dialect : Dialect {
   let name = "llvm";
   let cppNamespace = "::mlir::LLVM";
 
-  let useDefaultAttributePrinterParser = 1;
+  //let useDefaultAttributePrinterParser = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
   let hasOperationAttrVerify = 1;
   let useFoldAPI = kEmitFoldAdaptorFolder;
 
   let extraClassDeclaration = [{
     /// Name of the data layout attributes.
     static StringRef getDataLayoutAttrName() { return "llvm.data_layout"; }
let extraClassDeclaration = [{
     static bool isCompatibleType(Type);
 
     /// Name of the attribute mapped to LLVM's 'readnone' function attribute.
     /// It is allowed on any FunctionOpInterface operations.
     static StringRef getReadnoneAttrName() {
       return "llvm.readnone";
     }
 
-    Type parseType(DialectAsmParser &p) const override;
-    void printType(Type, DialectAsmPrinter &p) const override;
+    Type parseType(DialectAsmParser &parser) const override;
+    void printType(Type type, DialectAsmPrinter &os) const override;
+
+    Attribute parseAttribute(DialectAsmParser &parser, Type type) const override;
+    void printAttribute(Attribute attr, DialectAsmPrinter &os) const override;
 
   private:
     /// Register all types.
     void registerTypes();
 
     /// A cache storing compatible LLVM types that have been verified. This
     /// can save us lots of verification time if there are many occurrences
     /// of some deeply-nested aggregate types in the program.

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

 //===- LLVMAttrs.cpp - LLVM Attributes registration -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the attribute details for the LLVM IR dialect in MLIR.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/LLVMIR/LLVMAttrs.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/OpDefinition.h"
+#include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/BinaryFormat/Dwarf.h"
+#include <cstdint>
 #include <optional>
 
 using namespace mlir;
 using namespace mlir::LLVM;
 
 #include "mlir/Dialect/LLVMIR/LLVMOpsEnums.cpp.inc"
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/LLVMIR/LLVMOpsAttrDefs.cpp.inc"
 
 //===----------------------------------------------------------------------===//
 // LLVMDialect registration
 //===----------------------------------------------------------------------===//
 
 void LLVMDialect::registerAttributes() {
+  addAttributes<DICompositeTypeMutAttr>();
   addAttributes<
 #define GET_ATTRDEF_LIST
 #include "mlir/Dialect/LLVMIR/LLVMOpsAttrDefs.cpp.inc"
       >();
 }
 
 //===----------------------------------------------------------------------===//
 // DINodeAttr

 }
 
 //===----------------------------------------------------------------------===//
 // DITypeAttr
 //===----------------------------------------------------------------------===//
 
 bool DITypeAttr::classof(Attribute attr) {
   return llvm::isa<DIVoidResultTypeAttr, DIBasicTypeAttr, DICompositeTypeAttr,
-                   DIDerivedTypeAttr, DISubroutineTypeAttr>(attr);
+                   DICompositeTypeMutAttr, DIDerivedTypeAttr,
+                   DISubroutineTypeAttr>(attr);
 }
 
 //===----------------------------------------------------------------------===//
 // DISubroutineTypeAttr
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 DISubroutineTypeAttr::verify(function_ref<InFlightDiagnostic()> emitError,
                              unsigned int callingConventions,
                              ArrayRef<DITypeAttr> types) {
   ArrayRef<DITypeAttr> argumentTypes =
       types.empty() ? types : types.drop_front();
   if (llvm::any_of(argumentTypes, [](DITypeAttr type) {
         return type.isa<DIVoidResultTypeAttr>();
       }))
     return emitError() << "expected subroutine to have non-void argument types";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
+// DICompositeTypeMutAttr
+//===----------------------------------------------------------------------===//
+
+namespace mlir {
+namespace LLVM {
+namespace detail {
+// TODO move to LLVMAttersDetail.h?
+class DICompositeTypeMutAttrStorage : public AttributeStorage {
+public:
+  using KeyTy = std::tuple<int64_t, StringAttr, DITypeAttr>;
+
+  DICompositeTypeMutAttrStorage(int64_t id, StringAttr name,
+                                DITypeAttr baseType)
+      : id(id), name(name), baseType(baseType) {}
+
+  KeyTy getAsKey() const { return KeyTy(id, name, baseType); }
+
+  static llvm::hash_code hashKey(const KeyTy &key) {
+    return llvm::hash_combine(std::get<0>(key), std::get<1>(key),
+                              std::get<2>(key));
+  }
+
+  static DICompositeTypeMutAttrStorage *
+  construct(AttributeStorageAllocator &allocator, const KeyTy &key) {
+    int64_t id = std::get<0>(key);
+    StringAttr name = std::get<1>(key);
+    DITypeAttr baseType = std::get<2>(key);
+    return new (allocator.allocate<DICompositeTypeMutAttrStorage>())
+        DICompositeTypeMutAttrStorage(id, name, baseType);
+  }
+
+  LogicalResult mutate(AttributeStorageAllocator &allocator,
+                       ArrayRef<DITypeAttr> elements) {
+    if (isMutated)
+      return failure();
+
+    ArrayRef<DITypeAttr> allocated = allocator.copyInto(elements);
+    elementsPtr = allocated.data();
+    elementsSize = allocated.size();
+    isMutated = true;
+    return success();
+  }
+
+  bool operator==(const KeyTy &other) const { return getAsKey() == other; }
+
+  /// Returns the list of types contained in an identified struct.
+  ArrayRef<DITypeAttr> getElements() const {
+    return ArrayRef<DITypeAttr>(elementsPtr, elementsSize);
+  }
+
+  // TODO make stuff blow private
+  int64_t id;
+  StringAttr name;
+  DITypeAttr baseType;
+
+  bool isMutated = false;
+  const DITypeAttr *elementsPtr = nullptr;
+  size_t elementsSize = 0;
+};
+} // namespace detail
+} // namespace LLVM
+} // namespace mlir
+
+DICompositeTypeMutAttr DICompositeTypeMutAttr::get(MLIRContext *context,
+                                                   int64_t id, StringAttr name,
+                                                   DITypeAttr baseType) {
+  return Base::get(context, id, name, baseType);
+}
+
+int64_t DICompositeTypeMutAttr::getID() const { return getImpl()->id; }
+
+StringAttr DICompositeTypeMutAttr::getName() const { return getImpl()->name; }
+
+DITypeAttr DICompositeTypeMutAttr::getBaseType() const {
+  return getImpl()->baseType;
+}
+
+LogicalResult
+DICompositeTypeMutAttr::setElements(ArrayRef<DITypeAttr> elements) {
+  return Base::mutate(elements);
+}
+
+ArrayRef<DITypeAttr> DICompositeTypeMutAttr::getElements() const {
+  return getImpl()->getElements();
+}
+
+Attribute DICompositeTypeMutAttr::parse(AsmParser &parser, Type type) {
+  if (parser.parseLess())
+    return {};
+
+  // A helper function to parse a composite type parameter.
+  auto parseParameter =
+      [&](StringRef name, StringRef type, bool &seen,
+          function_ref<ParseResult()> parseFn) -> ParseResult {
+    if (seen) {
+      return parser.emitError(parser.getCurrentLocation())
+             << "struct has duplicate parameter '" << name << "'";
+    }
+    if (failed(parseFn())) {
+      return parser.emitError(parser.getCurrentLocation())
+             << "failed to parse LLVM_DICompositeTypeAttr parameter '" << name
+             << "' which is to be a '" << type << "'";
+    }
+    seen = true;
+    return success();
+  };
+
+  std::pair<int64_t, bool> id = {0, false};
+  std::pair<StringAttr, bool> name = {nullptr, false};
+  std::pair<DITypeAttr, bool> baseType = {nullptr, false};
+  std::pair<SmallVector<DITypeAttr>, bool> elements = {{}, false};
+  do {
+    std::string keyword;
+    if (failed(parser.parseKeywordOrString(&keyword))) {
+      parser.emitError(parser.getCurrentLocation())
+          << "expected a parameter name in struct";
+      return {};
+    }
+    if (parser.parseEqual())
+      return {};
+
+    if (keyword == "id") {
+      if (failed(parseParameter(keyword, "int64_t", id.second, [&]() {
+            return parser.parseInteger(id.first);
+          })))
+        return {};
+    } else if (keyword == "name") {
+      if (failed(parseParameter(keyword, "StringAttr", name.second, [&]() {
+            return parser.parseAttribute(name.first);
+          })))
+        return {};
+    } else if (keyword == "base_type") {
+      if (failed(parseParameter(keyword, "DITypeAttr", baseType.second, [&]() {
+            return parser.parseAttribute(baseType.first);
+          })))
+        return {};
+    } else if (keyword == "elements") {
+      if (failed(parseParameter(
+              keyword, "::llvm::ArrayRef<DINodeAttr>", elements.second, [&]() {
+                return parser.parseCommaSeparatedList([&]() {
+                  return parser.parseAttribute(elements.first.emplace_back());
+                });
+              })))
+        return {};
+    } else {
+      parser.emitError(parser.getCurrentLocation())
+          << "expected a parameter name in struct";
+      return {};
+    }
+  } while (succeeded(parser.parseOptionalComma()));
+
+  if (!id.second) {
+    parser.emitError(parser.getCurrentLocation())
+        << "struct is missing required parameter 'id'";
+    return {};
+  }
+  if (!name.second) {
+    parser.emitError(parser.getCurrentLocation())
+        << "struct is missing required parameter 'name'";
+    return {};
+  }
+
+  if (parser.parseGreater())
+    return {};
+
+  DICompositeTypeMutAttr attr =
+      get(parser.getContext(), id.first, name.first, baseType.first);
+  if (elements.second)
+    if (failed(attr.setElements(elements.first))) {
+      parser.emitError(parser.getCurrentLocation())
+          << "cannot mutate 'elements' twice";
+      return {};
+    }
+  return attr;
+}
+
+void DICompositeTypeMutAttr::print(AsmPrinter &os) const {
+
+  thread_local SetVector<TypeID> knownAttributes;
+  // TODO add stack size assertion?
+
+  os << DICompositeTypeMutAttr::getMnemonic() << "<";
+  os << "id = " << getID();
+  os << ", name = ";
+  os.printStrippedAttrOrType(getName());
+  if (getBaseType()) {
+    os << ", base_type = ";
+    os.printStrippedAttrOrType(getBaseType());
+  }
+  if (getImpl()->isMutated && knownAttributes.count(getTypeID()) == 0) {
+    knownAttributes.insert(getTypeID());
+
+    os << ", elements = ";
+    llvm::interleaveComma(getElements(), os, [&](auto typeAttr) {
+      os.printStrippedAttrOrType(typeAttr);
+    });
+
+    knownAttributes.pop_back();
+  }
+  os << ">";
+}
+
+//===----------------------------------------------------------------------===//
 // LoopOptionsAttrBuilder
 //===----------------------------------------------------------------------===//
 
 LoopOptionsAttrBuilder::LoopOptionsAttrBuilder(LoopOptionsAttr attr)
     : options(attr.getOptions().begin(), attr.getOptions().end()) {}
 
 template <typename T>
 LoopOptionsAttrBuilder &
auto parseLoopOptions = [&]() -> ParseResult {
     return success();
   };
   if (parser.parseCommaSeparatedList(parseLoopOptions) || parser.parseGreater())
     return {};
 
   llvm::sort(options, llvm::less_first());
   return get(parser.getContext(), options);
 }
+
+//===----------------------------------------------------------------------===//
+// LLVMDialect
+//===----------------------------------------------------------------------===//
+
+Attribute LLVMDialect::parseAttribute(DialectAsmParser &parser,
+                                      Type type) const {
+  StringRef mnemonic;
+  Attribute attr;
+  OptionalParseResult result =
+      generatedAttributeParser(parser, &mnemonic, type, attr);
+  if (result.has_value())
+    return attr;
+
+  if (mnemonic == DICompositeTypeMutAttr::getMnemonic())
+    return DICompositeTypeMutAttr::parse(parser, type);
+
+  llvm_unreachable("unhandled LLVM attribute kind");
+}
+
+void LLVMDialect::printAttribute(Attribute attr, DialectAsmPrinter &os) const {
+  if (succeeded(generatedAttributePrinter(attr, os)))
+    return;
+
+  if (auto composite = dyn_cast<DICompositeTypeMutAttr>(attr))
+    composite.print(os);
+  else
+    llvm_unreachable("unhandled LLVM attribute kind");
+}

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

 //===- LLVMDialect.cpp - LLVM IR Ops and Dialect registration -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the types and operation details for the LLVM IR dialect in
 // MLIR, and the LLVM IR dialect.  It also registers the dialect.
 //
 //===----------------------------------------------------------------------===//
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "TypeDetail.h"
+#include "mlir/Dialect/LLVMIR/LLVMAttrs.h"
 #include "mlir/Dialect/LLVMIR/LLVMTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Matchers.h"

 
 namespace {
 struct LLVMOpAsmDialectInterface : public OpAsmDialectInterface {
   using OpAsmDialectInterface::OpAsmDialectInterface;
 
   AliasResult getAlias(Attribute attr, raw_ostream &os) const override {
     return TypeSwitch<Attribute, AliasResult>(attr)
         .Case<DIVoidResultTypeAttr, DIBasicTypeAttr, DICompileUnitAttr,
-              DICompositeTypeAttr, DIDerivedTypeAttr, DIFileAttr,
-              DILexicalBlockAttr, DILexicalBlockFileAttr, DILocalVariableAttr,
-              DISubprogramAttr, DISubroutineTypeAttr>([&](auto attr) {
+              DICompositeTypeAttr, DICompositeTypeMutAttr, DIDerivedTypeAttr,
+              DIFileAttr, DILexicalBlockAttr, DILexicalBlockFileAttr,
+              DILocalVariableAttr, DISubprogramAttr, DISubroutineTypeAttr>(
+            [&](auto attr) {
               os << decltype(attr)::getMnemonic();
               return AliasResult::OverridableAlias;
             })
         .Default([](Attribute) { return AliasResult::NoAlias; });
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // DialectInlinerInterface
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Linalg/IR/LinalgDialect.cpp

 //===- Dialect.cpp - Implementation of the linalg dialect and types -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Linalg dialect types and dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
+#include "mlir/Dialect/LLVMIR/LLVMAttrs.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/FunctionInterfaces.h"

mlir/test/Dialect/LLVMIR/debuginfo_test.mlir

+// RUN: mlir-opt %s | mlir-opt | FileCheck %s
+
+#file = #llvm.di_file<"debuginfo.mlir" in "/test/">
+#cu = #llvm.di_compile_unit<
+  sourceLanguage = DW_LANG_C, file = #file, producer = "MLIR",
+  isOptimized = true, emissionKind = Full
+>
+#void = #llvm.di_void_result_type
+#int0 = #llvm.di_basic_type<
+  tag = DW_TAG_base_type, name = "int0"
+>
+#derived = #llvm.di_derived_type<tag = DW_TAG_pointer_type, baseType = #int0>
+
+
+#comp0 = #llvm.di_composite_type_mut<id = 0, name = "test0", elements = #llvm.di_composite_type_mut<id = 0, name = "test1">>
+
+#comp1 = #llvm.di_composite_type_mut<id = 0, name = "test1", elements = #comp0>
+
+//#comp2 = #llvm.di_composite_type_mut<id = 0, name = "test1", elements = #int0>
+
+// #ptr = #llvm.di_derived_type<tag = DW_TAG_pointer_type, baseType = #int0>
+
+// #comp0 = #llvm.di_composite_type<
+//   tag = DW_TAG_array_type, name = "array0",
+//   line = 10, sizeInBits = 128, alignInBits = 32,
+//   elements = #int0
+// >
+
+#spType0 = #llvm.di_subroutine_type<
+  callingConvention = DW_CC_normal, types = #void, #comp0, #comp1 //, #comp2
+>
+
+#sp0 = #llvm.di_subprogram<
+  // Omit the optional linkageName parameter.
+  compileUnit = #cu, scope = #file, name = "value",
+  file = #file, subprogramFlags = "Definition", type = #spType0
+>
+
+llvm.func @value() {
+  llvm.return
+} loc(fused<#sp0>["foo.mlir":1:1])