[DO NOT COMMIT][mlir] modernizer for LLVM dialect type syntax

[ftynse]

Summary

This is a temporary tool to update the syntax of MLIR LLVM dialect
types. Build the mlir-modernize using regular ninja/make and use it to
update the out-of-tree test files that rely on the MLIR LLVM dialect
type syntax. The tool does _not_ parse the IR but operates on strings,
so it is able to update FileCheck lines except the lines containing
incomplete type specification or regex.

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

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/StandardTypes.h"
 
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 using namespace mlir::LLVM;
 
 static constexpr const char kVolatileAttrName[] = "volatile_";
 static constexpr const char kNonTemporalAttrName[] = "nontemporal";
 
 #include "mlir/Dialect/LLVMIR/LLVMOpsEnums.cpp.inc"
 
+namespace {
+/// Support for translating LLVM IR types to MLIR LLVM dialect types.
+class TypeFromLLVMIRTranslator {
+public:
+  /// Constructs a class creating types in the given MLIR context.
+  TypeFromLLVMIRTranslator(MLIRContext &context) : context(context) {}
+
+  /// Translates the given type.
+  LLVM::LLVMType translateType(llvm::Type *type) {
+    if (knownTranslations.count(type))
+      return knownTranslations.lookup(type);
+
+    LLVM::LLVMType translated =
+        llvm::TypeSwitch<llvm::Type *, LLVM::LLVMType>(type)
+            .Case([this](llvm::ArrayType *type) {
+              return translateArrayType(type);
+            })
+            .Case([this](llvm::FunctionType *type) {
+              return translateFunctionType(type);
+            })
+            .Case([this](llvm::IntegerType *type) {
+              return translateIntegerType(type);
+            })
+            .Case([this](llvm::PointerType *type) {
+              return translatePointerType(type);
+            })
+            .Case([this](llvm::StructType *type) {
+              return translateStructType(type);
+            })
+            .Case([this](llvm::FixedVectorType *type) {
+              return translateFixedVectorType(type);
+            })
+            .Case([this](llvm::ScalableVectorType *type) {
+              return translateScalableVectorType(type);
+            })
+            .Default([this](llvm::Type *type) {
+              return translatePrimitiveType(type);
+            });
+    knownTranslations.try_emplace(type, translated);
+    return translated;
+  }
+
+private:
+  /// Translates the given primitive, i.e. non-parametric in MLIR nomenclature,
+  /// type.
+  LLVM::LLVMType translatePrimitiveType(llvm::Type *type) {
+    if (type->isVoidTy())
+      return LLVM::LLVMVoidType::get(&context);
+    if (type->isHalfTy())
+      return LLVM::LLVMHalfType::get(&context);
+    if (type->isBFloatTy())
+      return LLVM::LLVMBFloatType::get(&context);
+    if (type->isFloatTy())
+      return LLVM::LLVMFloatType::get(&context);
+    if (type->isDoubleTy())
+      return LLVM::LLVMDoubleType::get(&context);
+    if (type->isFP128Ty())
+      return LLVM::LLVMFP128Type::get(&context);
+    if (type->isX86_FP80Ty())
+      return LLVM::LLVMX86FP80Type::get(&context);
+    if (type->isPPC_FP128Ty())
+      return LLVM::LLVMPPCFP128Type::get(&context);
+    if (type->isX86_MMXTy())
+      return LLVM::LLVMX86MMXType::get(&context);
+    if (type->isLabelTy())
+      return LLVM::LLVMLabelType::get(&context);
+    if (type->isMetadataTy())
+      return LLVM::LLVMMetadataType::get(&context);
+    llvm_unreachable("not a primitive type");
+  }
+
+  /// Translates the given array type.
+  LLVM::LLVMType translateArrayType(llvm::ArrayType *type) {
+    return LLVM::LLVMArrayType::get(translateType(type->getElementType()),
+                                    type->getNumElements());
+  }
+
+  /// Translates the given function type.
+  LLVM::LLVMType translateFunctionType(llvm::FunctionType *type) {
+    SmallVector<LLVM::LLVMType, 8> paramTypes;
+    translateTypes(type->params(), paramTypes);
+    return LLVM::LLVMFunctionType::get(translateType(type->getReturnType()),
+                                       paramTypes, type->isVarArg());
+  }
+
+  /// Translates the given integer type.
+  LLVM::LLVMType translateIntegerType(llvm::IntegerType *type) {
+    return LLVM::LLVMIntegerType::get(&context, type->getBitWidth());
+  }
+
+  /// Translates the given pointer type.
+  LLVM::LLVMType translatePointerType(llvm::PointerType *type) {
+    return LLVM::LLVMPointerType::get(translateType(type->getElementType()),
+                                      type->getAddressSpace());
+  }
+
+  /// Translates the given structure type.
+  LLVM::LLVMType translateStructType(llvm::StructType *type) {
+    SmallVector<LLVM::LLVMType, 8> subtypes;
+    if (type->isLiteral()) {
+      translateTypes(type->subtypes(), subtypes);
+      return LLVM::LLVMStructType::getLiteral(&context, subtypes,
+                                              type->isPacked());
+    }
+
+    if (type->isOpaque())
+      return LLVM::LLVMStructType::getOpaque(type->getName(), &context);
+
+    LLVM::LLVMStructType translated =
+        LLVM::LLVMStructType::getIdentified(&context, type->getName());
+    knownTranslations.try_emplace(type, translated);
+    translateTypes(type->subtypes(), subtypes);
+    LogicalResult bodySet = translated.setBody(subtypes, type->isPacked());
+    assert(succeeded(bodySet) &&
+           "could not set the body of an identified struct");
+    (void)bodySet;
+    return translated;
+  }
+
+  /// Translates the given fixed-vector type.
+  LLVM::LLVMType translateFixedVectorType(llvm::FixedVectorType *type) {
+    return LLVM::LLVMFixedVectorType::get(translateType(type->getElementType()),
+                                          type->getNumElements());
+  }
+
+  /// Translates the given scalable-vector type.
+  LLVM::LLVMType translateScalableVectorType(llvm::ScalableVectorType *type) {
+    return LLVM::LLVMScalableVectorType::get(
+        translateType(type->getElementType()), type->getMinNumElements());
+  }
+
+  /// Translates a list of types.
+  void translateTypes(ArrayRef<llvm::Type *> types,
+                      SmallVectorImpl<LLVM::LLVMType> &result) {
+    result.reserve(result.size() + types.size());
+    for (llvm::Type *type : types)
+      result.push_back(translateType(type));
+  }
+
+  /// Map of known translations. Serves as a cache and as recursion stopper for
+  /// translating recursive structs.
+  llvm::DenseMap<llvm::Type *, LLVM::LLVMType> knownTranslations;
+
+  /// The context in which MLIR types are created.
+  MLIRContext &context;
+};
+} // end namespace
+
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::CmpOp.
 //===----------------------------------------------------------------------===//
 static void printICmpOp(OpAsmPrinter &p, ICmpOp &op) {
   p << op.getOperationName() << " \"" << stringifyICmpPredicate(op.predicate())
     << "\" " << op.getOperand(0) << ", " << op.getOperand(1);
   p.printOptionalAttrDict(op.getAttrs(), {"predicate"});
   p << " : " << op.lhs().getType();

 llvm::LLVMContext &LLVMDialect::getLLVMContext() { return impl->llvmContext; }
 llvm::Module &LLVMDialect::getLLVMModule() { return impl->module; }
 llvm::sys::SmartMutex<true> &LLVMDialect::getLLVMContextMutex() {
   return impl->mutex;
 }
 
 /// Parse a type registered to this dialect.
 Type LLVMDialect::parseType(DialectAsmParser &parser) const {
-  return detail::parseType(parser);
+  std::string tyData = parser.getFullSymbolSpec().str();
+
+  // LLVM is not thread-safe, so lock access to it.
+  llvm::sys::SmartScopedLock<true> lock(impl->mutex);
+
+  llvm::SMDiagnostic errorMessage;
+  llvm::Type *type = llvm::parseType(tyData, errorMessage, impl->module);
+  if (type)
+    return TypeFromLLVMIRTranslator(*getContext()).translateType(type);
+
+  return nullptr;
 }
 
 /// Print a type registered to this dialect.
 void LLVMDialect::printType(Type type, DialectAsmPrinter &os) const {
   return detail::printType(type.cast<LLVMType>(), os);
 }
 
 /// Verify LLVMIR function argument attributes.

mlir/tools/CMakeLists.txt

 add_subdirectory(mlir-cuda-runner)
 add_subdirectory(mlir-cpu-runner)
 add_subdirectory(mlir-linalg-ods-gen)
+add_subdirectory(mlir-modernize)
 add_subdirectory(mlir-opt)
 add_subdirectory(mlir-reduce)
 add_subdirectory(mlir-rocm-runner)
 add_subdirectory(mlir-shlib)
 add_subdirectory(mlir-translate)
-add_subdirectory(mlir-vulkan-runner)
+add_subdirectory(mlir-vulkan-runner)
 

mlir/tools/mlir-modernize/CMakeLists.txt

+get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+set(LLVM_LINK_COMPONENTS
+  Core
+  Support
+  AsmParser
+  )
+
+set(LIBS
+  ${dialect_libs}
+  MLIRIR
+  MLIRSupport
+  MLIRTransformUtils
+  )
+
+add_llvm_tool(mlir-modernize
+  mlir-modernize.cpp
+
+  DEPENDS
+  ${LIBS}
+  )
+target_link_libraries(mlir-modernize PRIVATE ${LIBS})
+llvm_update_compile_flags(mlir-modernize)

mlir/tools/mlir-modernize/mlir-modernize.cpp

+#include "mlir/InitAllDialects.h"
+#include "mlir/Parser.h"
+#include "mlir/Support/FileUtilities.h"
+#include "llvm/AsmParser/Parser.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Support/raw_ostream.h"
+
+size_t findEndPos(llvm::StringRef str) {
+  if (str[0] == '.') {
+    return str.find_if_not([](char c) { return llvm::isAlnum(c) || c == '_'; },
+                           1);
+  }
+  assert(str[0] == '<');
+  int counter = 0;
+  size_t i = 1;
+  do {
+    char c = str[i++];
+    if (c == '<') {
+      ++counter;
+    } else if (c == '>') {
+      if (counter == 0)
+        return i;
+      --counter;
+    }
+  } while (i < str.size());
+  return str.size();
+}
+
+int main(int argc, char **argv) {
+  llvm::cl::opt<std::string> input_filename(llvm::cl::Positional,
+                                            llvm::cl::desc("<input file>"),
+                                            llvm::cl::init("-"));
+  llvm::InitLLVM init(argc, argv);
+
+  mlir::registerAllDialects();
+  llvm::cl::ParseCommandLineOptions(argc, argv, "modernizer");
+
+  mlir::MLIRContext mlirContext;
+
+  std::string errorMessage;
+  auto inputFile = mlir::openInputFile(input_filename, &errorMessage);
+  if (!inputFile) {
+    llvm::errs() << errorMessage << "\n";
+    return EXIT_FAILURE;
+  }
+
+  llvm::StringRef string = inputFile->getBuffer();
+  llvm::LLVMContext llvmctx;
+  llvm::Module m("module", llvmctx);
+  size_t pos = 0;
+  do {
+    size_t start = string.find("!llvm", pos);
+    if (start == std::string::npos) {
+      llvm::outs() << string.substr(pos);
+      break;
+    }
+    llvm::outs() << string.substr(pos, start - pos);
+
+    llvm::SMDiagnostic errorMessage;
+    size_t prefixLen = llvm::StringRef("!llvm").size();
+    size_t endPos = findEndPos(string.substr(start + prefixLen));
+    auto possibleType =
+        string.substr(start).take_front(prefixLen + endPos).str();
+
+    auto type = mlir::parseType(possibleType, &mlirContext);
+    if (!type) {
+      pos = start + prefixLen;
+      continue;
+    }
+
+    assert(type.isa<mlir::LLVM::LLVMType>());
+    type.print(llvm::outs());
+    pos = start + possibleType.size();
+
+    // auto *type = llvm::parseTypeAtBeginning(string.drop_front(start), read,
+    //                                         errorMessage, m);
+
+  } while (true);
+
+  return 0;
+}