+++ /dev/null
-diff --git a/mlir/examples/standalone/standalone-translate/standalone-translate.cpp b/mlir/examples/standalone/standalone-translate/standalone-translate.cpp
-index 2c2f275..31ddef4 100644
---- a/mlir/examples/standalone/standalone-translate/standalone-translate.cpp
-+++ b/mlir/examples/standalone/standalone-translate/standalone-translate.cpp
-@@ -1,27 +1,34 @@
- //===- standalone-translate.cpp ---------------------------------*- C++ -*-===//
- //
- // This file is licensed 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 is a command line utility that translates a file from/to MLIR using one
- // of the registered translations.
- //
- //===----------------------------------------------------------------------===//
-
-+#include "Standalone/StandaloneDialect.h"
-+#include "mlir/IR/BuiltinOps.h"
- #include "mlir/InitAllTranslations.h"
- #include "mlir/Support/LogicalResult.h"
- #include "mlir/Tools/mlir-translate/MlirTranslateMain.h"
--
--#include "Standalone/StandaloneDialect.h"
-+#include "mlir/Tools/mlir-translate/Translation.h"
-
- int main(int argc, char **argv) {
- mlir::registerAllTranslations();
-
- // TODO: Register standalone translations here.
-+ mlir::TranslateFromMLIRRegistration withdescription(
-+ "option", "different from option",
-+ [](mlir::ModuleOp op, llvm::raw_ostream &output) {
-+ return mlir::LogicalResult::success();
-+ },
-+ [](mlir::DialectRegistry &a) {});
-
- return failed(
- mlir::mlirTranslateMain(argc, argv, "MLIR Translation Testing Tool"));
- }
-diff --git a/mlir/include/mlir/Tools/mlir-translate/Translation.h b/mlir/include/mlir/Tools/mlir-translate/Translation.h
-index d91e479..c8b5b70 100644
---- a/mlir/include/mlir/Tools/mlir-translate/Translation.h
-+++ b/mlir/include/mlir/Tools/mlir-translate/Translation.h
-@@ -1,102 +1,103 @@
- //===- Translation.h - Translation registry ---------------------*- C++ -*-===//
- //
- // 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
- //
- //===----------------------------------------------------------------------===//
- //
- // Registry for user-provided translations.
- //
- //===----------------------------------------------------------------------===//
-
- #ifndef MLIR_TOOLS_MLIRTRANSLATE_TRANSLATION_H
- #define MLIR_TOOLS_MLIRTRANSLATE_TRANSLATION_H
-
- #include "llvm/Support/CommandLine.h"
-
- namespace llvm {
- class MemoryBuffer;
- class SourceMgr;
- class StringRef;
- } // namespace llvm
-
- namespace mlir {
- class DialectRegistry;
- struct LogicalResult;
- class MLIRContext;
- class ModuleOp;
- template <typename OpTy>
- class OwningOpRef;
-
- /// Interface of the function that translates the sources managed by `sourceMgr`
- /// to MLIR. The source manager has at least one buffer. The implementation
- /// should create a new MLIR ModuleOp in the given context and return a pointer
- /// to it, or a nullptr in case of any error.
- using TranslateSourceMgrToMLIRFunction = std::function<OwningOpRef<ModuleOp>(
- llvm::SourceMgr &sourceMgr, MLIRContext *)>;
-
- /// Interface of the function that translates the given string to MLIR. The
- /// implementation should create a new MLIR ModuleOp in the given context. If
- /// source-related error reporting is required from within the function, use
- /// TranslateSourceMgrToMLIRFunction instead.
- using TranslateStringRefToMLIRFunction =
- std::function<OwningOpRef<ModuleOp>(llvm::StringRef, MLIRContext *)>;
-
- /// Interface of the function that translates MLIR to a different format and
- /// outputs the result to a stream. It is allowed to modify the module.
- using TranslateFromMLIRFunction =
- std::function<LogicalResult(ModuleOp, llvm::raw_ostream &output)>;
-
- /// Interface of the function that performs file-to-file translation involving
- /// MLIR. The input file is held in the given MemoryBuffer; the output file
- /// should be written to the given raw_ostream. The implementation should create
- /// all MLIR constructs needed during the process inside the given context. This
- /// can be used for round-tripping external formats through the MLIR system.
- using TranslateFunction = std::function<LogicalResult(
- llvm::SourceMgr &sourceMgr, llvm::raw_ostream &output, MLIRContext *)>;
-
- /// Use Translate[ToMLIR|FromMLIR]Registration as an initializer that
- /// registers a function and associates it with name. This requires that a
- /// translation has not been registered to a given name.
- ///
- /// Usage:
- ///
- /// // At file scope.
- /// namespace mlir {
- /// void registerTRexToMLIRRegistration() {
- /// TranslateToMLIRRegistration Unused(&MySubCommand, [] { ... });
- /// }
- /// } // namespace mlir
- ///
- /// \{
- struct TranslateToMLIRRegistration {
-- TranslateToMLIRRegistration(llvm::StringRef name,
-+ TranslateToMLIRRegistration(llvm::StringRef name, llvm::StringRef description,
- const TranslateSourceMgrToMLIRFunction &function);
-- TranslateToMLIRRegistration(llvm::StringRef name,
-+ TranslateToMLIRRegistration(llvm::StringRef name, llvm::StringRef description,
- const TranslateStringRefToMLIRFunction &function);
- };
-
- struct TranslateFromMLIRRegistration {
- TranslateFromMLIRRegistration(
-- llvm::StringRef name, const TranslateFromMLIRFunction &function,
-+ llvm::StringRef name, llvm::StringRef description,
-+ const TranslateFromMLIRFunction &function,
- const std::function<void(DialectRegistry &)> &dialectRegistration =
- [](DialectRegistry &) {});
- };
- struct TranslateRegistration {
-- TranslateRegistration(llvm::StringRef name,
-+ TranslateRegistration(llvm::StringRef name, llvm::StringRef description,
- const TranslateFunction &function);
- };
- /// \}
-
- /// A command line parser for translation functions.
- struct TranslationParser : public llvm::cl::parser<const TranslateFunction *> {
- TranslationParser(llvm::cl::Option &opt);
-
- void printOptionInfo(const llvm::cl::Option &o,
- size_t globalWidth) const override;
- };
-
- } // namespace mlir
-
- #endif // MLIR_TOOLS_MLIRTRANSLATE_TRANSLATION_H
-# diff --git a/mlir/lib/Target/Cpp/TranslateRegistration.cpp b/mlir/lib/Target/Cpp/TranslateRegistration.cpp
-# index c4d26ea..c85dd0d 100644
-# --- a/mlir/lib/Target/Cpp/TranslateRegistration.cpp
-# +++ b/mlir/lib/Target/Cpp/TranslateRegistration.cpp
-# @@ -1,54 +1,54 @@
-# //===- TranslateRegistration.cpp - Register translation -------------------===//
-# //
-# // 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
-# //
-# //===----------------------------------------------------------------------===//
-
-# #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-# #include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
-# #include "mlir/Dialect/EmitC/IR/EmitC.h"
-# #include "mlir/Dialect/Func/IR/FuncOps.h"
-# #include "mlir/Dialect/Math/IR/Math.h"
-# #include "mlir/Dialect/SCF/IR/SCF.h"
-# #include "mlir/IR/BuiltinOps.h"
-# #include "mlir/IR/Dialect.h"
-# #include "mlir/Target/Cpp/CppEmitter.h"
-# #include "mlir/Tools/mlir-translate/Translation.h"
-# #include "llvm/Support/CommandLine.h"
-
-# using namespace mlir;
-
-# namespace mlir {
-
-# //===----------------------------------------------------------------------===//
-# // Cpp registration
-# //===----------------------------------------------------------------------===//
-
-# void registerToCppTranslation() {
-# static llvm::cl::opt<bool> declareVariablesAtTop(
-# "declare-variables-at-top",
-# llvm::cl::desc("Declare variables at top when emitting C/C++"),
-# llvm::cl::init(false));
-
-# TranslateFromMLIRRegistration reg(
-# - "mlir-to-cpp",
-# + "mlir-to-cpp", "translate mlir to cpp",
-# [](ModuleOp module, raw_ostream &output) {
-# return emitc::translateToCpp(
-# module, output,
-# /*declareVariablesAtTop=*/declareVariablesAtTop);
-# },
-# [](DialectRegistry ®istry) {
-# // clang-format off
-# registry.insert<arith::ArithmeticDialect,
-# cf::ControlFlowDialect,
-# emitc::EmitCDialect,
-# func::FuncDialect,
-# math::MathDialect,
-# scf::SCFDialect>();
-# // clang-format on
-# });
-# }
-
-# } // namespace mlir
-# diff --git a/mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp b/mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp
-# index 9c47d36..b839bba 100644
-# --- a/mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp
-# +++ b/mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp
-# @@ -1,1415 +1,1416 @@
-# //===- ConvertFromLLVMIR.cpp - MLIR to LLVM IR conversion -----------------===//
-# //
-# // 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 a translation between LLVM IR and the MLIR LLVM dialect.
-# //
-# //===----------------------------------------------------------------------===//
-
-# #include "mlir/Target/LLVMIR/Import.h"
-
-# #include "mlir/Dialect/DLTI/DLTI.h"
-# #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-# #include "mlir/IR/Builders.h"
-# #include "mlir/IR/BuiltinOps.h"
-# #include "mlir/IR/BuiltinTypes.h"
-# #include "mlir/IR/MLIRContext.h"
-# #include "mlir/Interfaces/DataLayoutInterfaces.h"
-# #include "mlir/Target/LLVMIR/TypeFromLLVM.h"
-# #include "mlir/Tools/mlir-translate/Translation.h"
-
-# #include "llvm/ADT/StringSet.h"
-# #include "llvm/ADT/TypeSwitch.h"
-# #include "llvm/IR/Attributes.h"
-# #include "llvm/IR/Constants.h"
-# #include "llvm/IR/DerivedTypes.h"
-# #include "llvm/IR/Function.h"
-# #include "llvm/IR/InlineAsm.h"
-# #include "llvm/IR/Instructions.h"
-# #include "llvm/IR/Intrinsics.h"
-# #include "llvm/IR/Type.h"
-# #include "llvm/IRReader/IRReader.h"
-# #include "llvm/Support/Error.h"
-# #include "llvm/Support/SourceMgr.h"
-
-# using namespace mlir;
-# using namespace mlir::LLVM;
-
-# #include "mlir/Dialect/LLVMIR/LLVMConversionEnumsFromLLVM.inc"
-
-# // Utility to print an LLVM value as a string for passing to emitError().
-# // FIXME: Diagnostic should be able to natively handle types that have
-# // operator << (raw_ostream&) defined.
-# static std::string diag(llvm::Value &v) {
-# std::string s;
-# llvm::raw_string_ostream os(s);
-# os << v;
-# return os.str();
-# }
-
-# /// Creates an attribute containing ABI and preferred alignment numbers parsed
-# /// a string. The string may be either "abi:preferred" or just "abi". In the
-# /// latter case, the prefrred alignment is considered equal to ABI alignment.
-# static DenseIntElementsAttr parseDataLayoutAlignment(MLIRContext &ctx,
-# StringRef spec) {
-# auto i32 = IntegerType::get(&ctx, 32);
-
-# StringRef abiString, preferredString;
-# std::tie(abiString, preferredString) = spec.split(':');
-# int abi, preferred;
-# if (abiString.getAsInteger(/*Radix=*/10, abi))
-# return nullptr;
-
-# if (preferredString.empty())
-# preferred = abi;
-# else if (preferredString.getAsInteger(/*Radix=*/10, preferred))
-# return nullptr;
-
-# return DenseIntElementsAttr::get(VectorType::get({2}, i32), {abi, preferred});
-# }
-
-# /// Returns a supported MLIR floating point type of the given bit width or null
-# /// if the bit width is not supported.
-# static FloatType getDLFloatType(MLIRContext &ctx, int32_t bitwidth) {
-# switch (bitwidth) {
-# case 16:
-# return FloatType::getF16(&ctx);
-# case 32:
-# return FloatType::getF32(&ctx);
-# case 64:
-# return FloatType::getF64(&ctx);
-# case 80:
-# return FloatType::getF80(&ctx);
-# case 128:
-# return FloatType::getF128(&ctx);
-# default:
-# return nullptr;
-# }
-# }
-
-# DataLayoutSpecInterface
-# mlir::translateDataLayout(const llvm::DataLayout &dataLayout,
-# MLIRContext *context) {
-# assert(context && "expected MLIR context");
-# std::string layoutstr = dataLayout.getStringRepresentation();
-
-# // Remaining unhandled default layout defaults
-# // e (little endian if not set)
-# // p[n]:64:64:64 (non zero address spaces have 64-bit properties)
-# std::string append =
-# "p:64:64:64-S0-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f16:16:16-f64:"
-# "64:64-f128:128:128-v64:64:64-v128:128:128-a:0:64";
-# if (layoutstr.empty())
-# layoutstr = append;
-# else
-# layoutstr = layoutstr + "-" + append;
-
-# StringRef layout(layoutstr);
-
-# SmallVector<DataLayoutEntryInterface> entries;
-# StringSet<> seen;
-# while (!layout.empty()) {
-# // Split at '-'.
-# std::pair<StringRef, StringRef> split = layout.split('-');
-# StringRef current;
-# std::tie(current, layout) = split;
-
-# // Split at ':'.
-# StringRef kind, spec;
-# std::tie(kind, spec) = current.split(':');
-# if (seen.contains(kind))
-# continue;
-# seen.insert(kind);
-
-# char symbol = kind.front();
-# StringRef parameter = kind.substr(1);
-
-# if (symbol == 'i' || symbol == 'f') {
-# unsigned bitwidth;
-# if (parameter.getAsInteger(/*Radix=*/10, bitwidth))
-# return nullptr;
-# DenseIntElementsAttr params = parseDataLayoutAlignment(*context, spec);
-# if (!params)
-# return nullptr;
-# auto entry = DataLayoutEntryAttr::get(
-# symbol == 'i' ? static_cast<Type>(IntegerType::get(context, bitwidth))
-# : getDLFloatType(*context, bitwidth),
-# params);
-# entries.emplace_back(entry);
-# } else if (symbol == 'e' || symbol == 'E') {
-# auto value = StringAttr::get(
-# context, symbol == 'e' ? DLTIDialect::kDataLayoutEndiannessLittle
-# : DLTIDialect::kDataLayoutEndiannessBig);
-# auto entry = DataLayoutEntryAttr::get(
-# StringAttr::get(context, DLTIDialect::kDataLayoutEndiannessKey),
-# value);
-# entries.emplace_back(entry);
-# }
-# }
-
-# return DataLayoutSpecAttr::get(context, entries);
-# }
-
-# // Handles importing globals and functions from an LLVM module.
-# namespace {
-# class Importer {
-# public:
-# Importer(MLIRContext *context, ModuleOp module)
-# : b(context), context(context), module(module),
-# unknownLoc(FileLineColLoc::get(context, "imported-bitcode", 0, 0)),
-# typeTranslator(*context) {
-# b.setInsertionPointToStart(module.getBody());
-# }
-
-# /// Imports `f` into the current module.
-# LogicalResult processFunction(llvm::Function *f);
-
-# /// Converts function attributes of LLVM Function \p f
-# /// into LLVM dialect attributes of LLVMFuncOp \p funcOp.
-# void processFunctionAttributes(llvm::Function *f, LLVMFuncOp funcOp);
-
-# /// Imports GV as a GlobalOp, creating it if it doesn't exist.
-# GlobalOp processGlobal(llvm::GlobalVariable *gv);
-
-# private:
-# /// Returns personality of `f` as a FlatSymbolRefAttr.
-# FlatSymbolRefAttr getPersonalityAsAttr(llvm::Function *f);
-# /// Imports `bb` into `block`, which must be initially empty.
-# LogicalResult processBasicBlock(llvm::BasicBlock *bb, Block *block);
-# /// Imports `inst` and populates instMap[inst] with the imported Value.
-# LogicalResult processInstruction(llvm::Instruction *inst);
-# /// Creates an LLVM-compatible MLIR type for `type`.
-# Type processType(llvm::Type *type);
-# /// `value` is an SSA-use. Return the remapped version of `value` or a
-# /// placeholder that will be remapped later if this is an instruction that
-# /// has not yet been visited.
-# Value processValue(llvm::Value *value);
-# /// Create the most accurate Location possible using a llvm::DebugLoc and
-# /// possibly an llvm::Instruction to narrow the Location if debug information
-# /// is unavailable.
-# Location processDebugLoc(const llvm::DebugLoc &loc,
-# llvm::Instruction *inst = nullptr);
-# /// `br` branches to `target`. Append the block arguments to attach to the
-# /// generated branch op to `blockArguments`. These should be in the same order
-# /// as the PHIs in `target`.
-# LogicalResult processBranchArgs(llvm::Instruction *br,
-# llvm::BasicBlock *target,
-# SmallVectorImpl<Value> &blockArguments);
-# /// Returns the builtin type equivalent to be used in attributes for the given
-# /// LLVM IR dialect type.
-# Type getStdTypeForAttr(Type type);
-# /// Return `value` as an attribute to attach to a GlobalOp.
-# Attribute getConstantAsAttr(llvm::Constant *value);
-# /// Return `c` as an MLIR Value. This could either be a ConstantOp, or
-# /// an expanded sequence of ops in the current function's entry block (for
-# /// ConstantExprs or ConstantGEPs).
-# Value processConstant(llvm::Constant *c);
-
-# /// The current builder, pointing at where the next Instruction should be
-# /// generated.
-# OpBuilder b;
-# /// The current context.
-# MLIRContext *context;
-# /// The current module being created.
-# ModuleOp module;
-# /// The entry block of the current function being processed.
-# Block *currentEntryBlock = nullptr;
-
-# /// Globals are inserted before the first function, if any.
-# Block::iterator getGlobalInsertPt() {
-# auto it = module.getBody()->begin();
-# auto endIt = module.getBody()->end();
-# while (it != endIt && !isa<LLVMFuncOp>(it))
-# ++it;
-# return it;
-# }
-
-# /// Functions are always inserted before the module terminator.
-# Block::iterator getFuncInsertPt() {
-# return std::prev(module.getBody()->end());
-# }
-
-# /// Remapped blocks, for the current function.
-# DenseMap<llvm::BasicBlock *, Block *> blocks;
-# /// Remapped values. These are function-local.
-# DenseMap<llvm::Value *, Value> instMap;
-# /// Instructions that had not been defined when first encountered as a use.
-# /// Maps to the dummy Operation that was created in processValue().
-# DenseMap<llvm::Value *, Operation *> unknownInstMap;
-# /// Uniquing map of GlobalVariables.
-# DenseMap<llvm::GlobalVariable *, GlobalOp> globals;
-# /// Cached FileLineColLoc::get("imported-bitcode", 0, 0).
-# Location unknownLoc;
-# /// The stateful type translator (contains named structs).
-# LLVM::TypeFromLLVMIRTranslator typeTranslator;
-# };
-# } // namespace
-
-# Location Importer::processDebugLoc(const llvm::DebugLoc &loc,
-# llvm::Instruction *inst) {
-# if (!loc)
-# return unknownLoc;
-
-# // FIXME: Obtain the filename from DILocationInfo.
-# return FileLineColLoc::get(context, "imported-bitcode", loc.getLine(),
-# loc.getCol());
-# }
-
-# Type Importer::processType(llvm::Type *type) {
-# if (Type result = typeTranslator.translateType(type))
-# return result;
-
-# // FIXME: Diagnostic should be able to natively handle types that have
-# // operator<<(raw_ostream&) defined.
-# std::string s;
-# llvm::raw_string_ostream os(s);
-# os << *type;
-# emitError(unknownLoc) << "unhandled type: " << os.str();
-# return nullptr;
-# }
-
-# // We only need integers, floats, doubles, and vectors and tensors thereof for
-# // attributes. Scalar and vector types are converted to the standard
-# // equivalents. Array types are converted to ranked tensors; nested array types
-# // are converted to multi-dimensional tensors or vectors, depending on the
-# // innermost type being a scalar or a vector.
-# Type Importer::getStdTypeForAttr(Type type) {
-# if (!type)
-# return nullptr;
-
-# if (type.isa<IntegerType, FloatType>())
-# return type;
-
-# // LLVM vectors can only contain scalars.
-# if (LLVM::isCompatibleVectorType(type)) {
-# auto numElements = LLVM::getVectorNumElements(type);
-# if (numElements.isScalable()) {
-# emitError(unknownLoc) << "scalable vectors not supported";
-# return nullptr;
-# }
-# Type elementType = getStdTypeForAttr(LLVM::getVectorElementType(type));
-# if (!elementType)
-# return nullptr;
-# return VectorType::get(numElements.getKnownMinValue(), elementType);
-# }
-
-# // LLVM arrays can contain other arrays or vectors.
-# if (auto arrayType = type.dyn_cast<LLVMArrayType>()) {
-# // Recover the nested array shape.
-# SmallVector<int64_t, 4> shape;
-# shape.push_back(arrayType.getNumElements());
-# while (arrayType.getElementType().isa<LLVMArrayType>()) {
-# arrayType = arrayType.getElementType().cast<LLVMArrayType>();
-# shape.push_back(arrayType.getNumElements());
-# }
-
-# // If the innermost type is a vector, use the multi-dimensional vector as
-# // attribute type.
-# if (LLVM::isCompatibleVectorType(arrayType.getElementType())) {
-# auto numElements = LLVM::getVectorNumElements(arrayType.getElementType());
-# if (numElements.isScalable()) {
-# emitError(unknownLoc) << "scalable vectors not supported";
-# return nullptr;
-# }
-# shape.push_back(numElements.getKnownMinValue());
-
-# Type elementType = getStdTypeForAttr(
-# LLVM::getVectorElementType(arrayType.getElementType()));
-# if (!elementType)
-# return nullptr;
-# return VectorType::get(shape, elementType);
-# }
-
-# // Otherwise use a tensor.
-# Type elementType = getStdTypeForAttr(arrayType.getElementType());
-# if (!elementType)
-# return nullptr;
-# return RankedTensorType::get(shape, elementType);
-# }
-
-# return nullptr;
-# }
-
-# // Get the given constant as an attribute. Not all constants can be represented
-# // as attributes.
-# Attribute Importer::getConstantAsAttr(llvm::Constant *value) {
-# if (auto *ci = dyn_cast<llvm::ConstantInt>(value))
-# return b.getIntegerAttr(
-# IntegerType::get(context, ci->getType()->getBitWidth()),
-# ci->getValue());
-# if (auto *c = dyn_cast<llvm::ConstantDataArray>(value))
-# if (c->isString())
-# return b.getStringAttr(c->getAsString());
-# if (auto *c = dyn_cast<llvm::ConstantFP>(value)) {
-# auto *type = c->getType();
-# FloatType floatTy;
-# if (type->isBFloatTy())
-# floatTy = FloatType::getBF16(context);
-# else
-# floatTy = getDLFloatType(*context, type->getScalarSizeInBits());
-# assert(floatTy && "unsupported floating point type");
-# return b.getFloatAttr(floatTy, c->getValueAPF());
-# }
-# if (auto *f = dyn_cast<llvm::Function>(value))
-# return SymbolRefAttr::get(b.getContext(), f->getName());
-
-# // Convert constant data to a dense elements attribute.
-# if (auto *cd = dyn_cast<llvm::ConstantDataSequential>(value)) {
-# Type type = processType(cd->getElementType());
-# if (!type)
-# return nullptr;
-
-# auto attrType = getStdTypeForAttr(processType(cd->getType()))
-# .dyn_cast_or_null<ShapedType>();
-# if (!attrType)
-# return nullptr;
-
-# if (type.isa<IntegerType>()) {
-# SmallVector<APInt, 8> values;
-# values.reserve(cd->getNumElements());
-# for (unsigned i = 0, e = cd->getNumElements(); i < e; ++i)
-# values.push_back(cd->getElementAsAPInt(i));
-# return DenseElementsAttr::get(attrType, values);
-# }
-
-# if (type.isa<Float32Type, Float64Type>()) {
-# SmallVector<APFloat, 8> values;
-# values.reserve(cd->getNumElements());
-# for (unsigned i = 0, e = cd->getNumElements(); i < e; ++i)
-# values.push_back(cd->getElementAsAPFloat(i));
-# return DenseElementsAttr::get(attrType, values);
-# }
-
-# return nullptr;
-# }
-
-# // Unpack constant aggregates to create dense elements attribute whenever
-# // possible. Return nullptr (failure) otherwise.
-# if (isa<llvm::ConstantAggregate>(value)) {
-# auto outerType = getStdTypeForAttr(processType(value->getType()))
-# .dyn_cast_or_null<ShapedType>();
-# if (!outerType)
-# return nullptr;
-
-# SmallVector<Attribute, 8> values;
-# SmallVector<int64_t, 8> shape;
-
-# for (unsigned i = 0, e = value->getNumOperands(); i < e; ++i) {
-# auto nested = getConstantAsAttr(value->getAggregateElement(i))
-# .dyn_cast_or_null<DenseElementsAttr>();
-# if (!nested)
-# return nullptr;
-
-# values.append(nested.value_begin<Attribute>(),
-# nested.value_end<Attribute>());
-# }
-
-# return DenseElementsAttr::get(outerType, values);
-# }
-
-# return nullptr;
-# }
-
-# GlobalOp Importer::processGlobal(llvm::GlobalVariable *gv) {
-# auto it = globals.find(gv);
-# if (it != globals.end())
-# return it->second;
-
-# OpBuilder b(module.getBody(), getGlobalInsertPt());
-# Attribute valueAttr;
-# if (gv->hasInitializer())
-# valueAttr = getConstantAsAttr(gv->getInitializer());
-# Type type = processType(gv->getValueType());
-# if (!type)
-# return nullptr;
-
-# uint64_t alignment = 0;
-# llvm::MaybeAlign maybeAlign = gv->getAlign();
-# if (maybeAlign.has_value()) {
-# llvm::Align align = maybeAlign.value();
-# alignment = align.value();
-# }
-
-# GlobalOp op = b.create<GlobalOp>(
-# UnknownLoc::get(context), type, gv->isConstant(),
-# convertLinkageFromLLVM(gv->getLinkage()), gv->getName(), valueAttr,
-# alignment, /*addr_space=*/gv->getAddressSpace(),
-# /*dso_local=*/gv->isDSOLocal(), /*thread_local=*/gv->isThreadLocal());
-
-# if (gv->hasInitializer() && !valueAttr) {
-# Region &r = op.getInitializerRegion();
-# currentEntryBlock = b.createBlock(&r);
-# b.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
-# Value v = processConstant(gv->getInitializer());
-# if (!v)
-# return nullptr;
-# b.create<ReturnOp>(op.getLoc(), ArrayRef<Value>({v}));
-# }
-# if (gv->hasAtLeastLocalUnnamedAddr())
-# op.setUnnamedAddrAttr(UnnamedAddrAttr::get(
-# context, convertUnnamedAddrFromLLVM(gv->getUnnamedAddr())));
-# if (gv->hasSection())
-# op.setSectionAttr(b.getStringAttr(gv->getSection()));
-
-# return globals[gv] = op;
-# }
-
-# Value Importer::processConstant(llvm::Constant *c) {
-# OpBuilder bEntry(currentEntryBlock, currentEntryBlock->begin());
-# if (Attribute attr = getConstantAsAttr(c)) {
-# // These constants can be represented as attributes.
-# OpBuilder b(currentEntryBlock, currentEntryBlock->begin());
-# Type type = processType(c->getType());
-# if (!type)
-# return nullptr;
-# if (auto symbolRef = attr.dyn_cast<FlatSymbolRefAttr>())
-# return bEntry.create<AddressOfOp>(unknownLoc, type, symbolRef.getValue());
-# return bEntry.create<ConstantOp>(unknownLoc, type, attr);
-# }
-# if (auto *cn = dyn_cast<llvm::ConstantPointerNull>(c)) {
-# Type type = processType(cn->getType());
-# if (!type)
-# return nullptr;
-# return bEntry.create<NullOp>(unknownLoc, type);
-# }
-# if (auto *gv = dyn_cast<llvm::GlobalVariable>(c))
-# return bEntry.create<AddressOfOp>(UnknownLoc::get(context),
-# processGlobal(gv));
-
-# if (auto *ce = dyn_cast<llvm::ConstantExpr>(c)) {
-# llvm::Instruction *i = ce->getAsInstruction();
-# OpBuilder::InsertionGuard guard(b);
-# b.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
-# if (failed(processInstruction(i)))
-# return nullptr;
-# assert(instMap.count(i));
-
-# // If we don't remove entry of `i` here, it's totally possible that the
-# // next time llvm::ConstantExpr::getAsInstruction is called again, which
-# // always allocates a new Instruction, memory address of the newly
-# // created Instruction might be the same as `i`. Making processInstruction
-# // falsely believe that the new Instruction has been processed before
-# // and raised an assertion error.
-# Value value = instMap[i];
-# instMap.erase(i);
-# // Remove this zombie LLVM instruction now, leaving us only with the MLIR
-# // op.
-# i->deleteValue();
-# return value;
-# }
-# if (auto *ue = dyn_cast<llvm::UndefValue>(c)) {
-# Type type = processType(ue->getType());
-# if (!type)
-# return nullptr;
-# return bEntry.create<UndefOp>(UnknownLoc::get(context), type);
-# }
-
-# if (isa<llvm::ConstantAggregate>(c) || isa<llvm::ConstantAggregateZero>(c)) {
-# unsigned numElements = c->getNumOperands();
-# std::function<llvm::Constant *(unsigned)> getElement =
-# [&](unsigned index) -> llvm::Constant * {
-# return c->getAggregateElement(index);
-# };
-# // llvm::ConstantAggregateZero doesn't take any operand
-# // so its getNumOperands is always zero.
-# if (auto *caz = dyn_cast<llvm::ConstantAggregateZero>(c)) {
-# numElements = caz->getElementCount().getFixedValue();
-# // We want to capture the pointer rather than reference
-# // to the pointer since the latter will become dangling upon
-# // exiting the scope.
-# getElement = [=](unsigned index) -> llvm::Constant * {
-# return caz->getElementValue(index);
-# };
-# }
-
-# // Generate a llvm.undef as the root value first.
-# Type rootType = processType(c->getType());
-# if (!rootType)
-# return nullptr;
-# bool useInsertValue = rootType.isa<LLVMArrayType, LLVMStructType>();
-# assert((useInsertValue || LLVM::isCompatibleVectorType(rootType)) &&
-# "unrecognized aggregate type");
-# Value root = bEntry.create<UndefOp>(unknownLoc, rootType);
-# for (unsigned i = 0; i < numElements; ++i) {
-# llvm::Constant *element = getElement(i);
-# Value elementValue = processConstant(element);
-# if (!elementValue)
-# return nullptr;
-# if (useInsertValue) {
-# root = bEntry.create<InsertValueOp>(UnknownLoc::get(context), root,
-# elementValue, i);
-# } else {
-# Attribute indexAttr = bEntry.getI32IntegerAttr(static_cast<int32_t>(i));
-# Value indexValue = bEntry.create<ConstantOp>(
-# unknownLoc, bEntry.getI32Type(), indexAttr);
-# if (!indexValue)
-# return nullptr;
-# root = bEntry.create<InsertElementOp>(
-# UnknownLoc::get(context), rootType, root, elementValue, indexValue);
-# }
-# }
-# return root;
-# }
-
-# emitError(unknownLoc) << "unhandled constant: " << diag(*c);
-# return nullptr;
-# }
-
-# Value Importer::processValue(llvm::Value *value) {
-# auto it = instMap.find(value);
-# if (it != instMap.end())
-# return it->second;
-
-# // We don't expect to see instructions in dominator order. If we haven't seen
-# // this instruction yet, create an unknown op and remap it later.
-# if (isa<llvm::Instruction>(value)) {
-# Type type = processType(value->getType());
-# if (!type)
-# return nullptr;
-# unknownInstMap[value] =
-# b.create(UnknownLoc::get(context), b.getStringAttr("llvm.unknown"),
-# /*operands=*/{}, type);
-# return unknownInstMap[value]->getResult(0);
-# }
-
-# if (auto *c = dyn_cast<llvm::Constant>(value))
-# return processConstant(c);
-
-# emitError(unknownLoc) << "unhandled value: " << diag(*value);
-# return nullptr;
-# }
-
-# /// Return the MLIR OperationName for the given LLVM opcode.
-# static StringRef lookupOperationNameFromOpcode(unsigned opcode) {
-# // Maps from LLVM opcode to MLIR OperationName. This is deliberately ordered
-# // as in llvm/IR/Instructions.def to aid comprehension and spot missing
-# // instructions.
-# #define INST(llvm_n, mlir_n) \
-# { llvm::Instruction::llvm_n, LLVM::mlir_n##Op::getOperationName() }
-# static const DenseMap<unsigned, StringRef> opcMap = {
-# // clang-format off
-# INST(Ret, Return),
-# // Br is handled specially.
-# // Switch is handled specially.
-# // FIXME: indirectbr
-# // Invoke is handled specially.
-# INST(Resume, Resume),
-# INST(Unreachable, Unreachable),
-# // FIXME: cleanupret
-# // FIXME: catchret
-# // FIXME: catchswitch
-# // FIXME: callbr
-# INST(FNeg, FNeg),
-# INST(Add, Add),
-# INST(FAdd, FAdd),
-# INST(Sub, Sub),
-# INST(FSub, FSub),
-# INST(Mul, Mul),
-# INST(FMul, FMul),
-# INST(UDiv, UDiv),
-# INST(SDiv, SDiv),
-# INST(FDiv, FDiv),
-# INST(URem, URem),
-# INST(SRem, SRem),
-# INST(FRem, FRem),
-# INST(Shl, Shl),
-# INST(LShr, LShr),
-# INST(AShr, AShr),
-# INST(And, And),
-# INST(Or, Or),
-# INST(Xor, XOr),
-# INST(ExtractElement, ExtractElement),
-# INST(InsertElement, InsertElement),
-# // ShuffleVector is handled specially.
-# // ExtractValue is handled specially.
-# // InsertValue is handled specially.
-# INST(Alloca, Alloca),
-# INST(Load, Load),
-# INST(Store, Store),
-# INST(Fence, Fence),
-# // AtomicCmpXchg is handled specially.
-# // AtomicRMW is handled specially.
-# // Getelementptr is handled specially.
-# INST(Trunc, Trunc),
-# INST(ZExt, ZExt),
-# INST(SExt, SExt),
-# INST(FPToUI, FPToUI),
-# INST(FPToSI, FPToSI),
-# INST(UIToFP, UIToFP),
-# INST(SIToFP, SIToFP),
-# INST(FPTrunc, FPTrunc),
-# INST(FPExt, FPExt),
-# INST(PtrToInt, PtrToInt),
-# INST(IntToPtr, IntToPtr),
-# INST(BitCast, Bitcast),
-# INST(AddrSpaceCast, AddrSpaceCast),
-# // ICmp is handled specially.
-# // FCmp is handled specially.
-# // PHI is handled specially.
-# INST(Select, Select),
-# INST(Freeze, Freeze),
-# INST(Call, Call),
-# // FIXME: vaarg
-# // FIXME: landingpad
-# // FIXME: catchpad
-# // FIXME: cleanuppad
-# // clang-format on
-# };
-# #undef INST
-
-# return opcMap.lookup(opcode);
-# }
-
-# /// Return the MLIR OperationName for the given LLVM intrinsic ID.
-# static StringRef lookupOperationNameFromIntrinsicID(unsigned id) {
-# // Maps from LLVM intrinsic ID to MLIR OperationName.
-# static const DenseMap<unsigned, StringRef> intrMap = {
-# #include "mlir/Dialect/LLVMIR/LLVMIntrinsicToLLVMIROpPairs.inc"
-# };
-# return intrMap.lookup(id);
-# }
-
-# static ICmpPredicate getICmpPredicate(llvm::CmpInst::Predicate p) {
-# switch (p) {
-# default:
-# llvm_unreachable("incorrect comparison predicate");
-# case llvm::CmpInst::Predicate::ICMP_EQ:
-# return LLVM::ICmpPredicate::eq;
-# case llvm::CmpInst::Predicate::ICMP_NE:
-# return LLVM::ICmpPredicate::ne;
-# case llvm::CmpInst::Predicate::ICMP_SLT:
-# return LLVM::ICmpPredicate::slt;
-# case llvm::CmpInst::Predicate::ICMP_SLE:
-# return LLVM::ICmpPredicate::sle;
-# case llvm::CmpInst::Predicate::ICMP_SGT:
-# return LLVM::ICmpPredicate::sgt;
-# case llvm::CmpInst::Predicate::ICMP_SGE:
-# return LLVM::ICmpPredicate::sge;
-# case llvm::CmpInst::Predicate::ICMP_ULT:
-# return LLVM::ICmpPredicate::ult;
-# case llvm::CmpInst::Predicate::ICMP_ULE:
-# return LLVM::ICmpPredicate::ule;
-# case llvm::CmpInst::Predicate::ICMP_UGT:
-# return LLVM::ICmpPredicate::ugt;
-# case llvm::CmpInst::Predicate::ICMP_UGE:
-# return LLVM::ICmpPredicate::uge;
-# }
-# llvm_unreachable("incorrect integer comparison predicate");
-# }
-
-# static FCmpPredicate getFCmpPredicate(llvm::CmpInst::Predicate p) {
-# switch (p) {
-# default:
-# llvm_unreachable("incorrect comparison predicate");
-# case llvm::CmpInst::Predicate::FCMP_FALSE:
-# return LLVM::FCmpPredicate::_false;
-# case llvm::CmpInst::Predicate::FCMP_TRUE:
-# return LLVM::FCmpPredicate::_true;
-# case llvm::CmpInst::Predicate::FCMP_OEQ:
-# return LLVM::FCmpPredicate::oeq;
-# case llvm::CmpInst::Predicate::FCMP_ONE:
-# return LLVM::FCmpPredicate::one;
-# case llvm::CmpInst::Predicate::FCMP_OLT:
-# return LLVM::FCmpPredicate::olt;
-# case llvm::CmpInst::Predicate::FCMP_OLE:
-# return LLVM::FCmpPredicate::ole;
-# case llvm::CmpInst::Predicate::FCMP_OGT:
-# return LLVM::FCmpPredicate::ogt;
-# case llvm::CmpInst::Predicate::FCMP_OGE:
-# return LLVM::FCmpPredicate::oge;
-# case llvm::CmpInst::Predicate::FCMP_ORD:
-# return LLVM::FCmpPredicate::ord;
-# case llvm::CmpInst::Predicate::FCMP_ULT:
-# return LLVM::FCmpPredicate::ult;
-# case llvm::CmpInst::Predicate::FCMP_ULE:
-# return LLVM::FCmpPredicate::ule;
-# case llvm::CmpInst::Predicate::FCMP_UGT:
-# return LLVM::FCmpPredicate::ugt;
-# case llvm::CmpInst::Predicate::FCMP_UGE:
-# return LLVM::FCmpPredicate::uge;
-# case llvm::CmpInst::Predicate::FCMP_UNO:
-# return LLVM::FCmpPredicate::uno;
-# case llvm::CmpInst::Predicate::FCMP_UEQ:
-# return LLVM::FCmpPredicate::ueq;
-# case llvm::CmpInst::Predicate::FCMP_UNE:
-# return LLVM::FCmpPredicate::une;
-# }
-# llvm_unreachable("incorrect floating point comparison predicate");
-# }
-
-# static AtomicOrdering getLLVMAtomicOrdering(llvm::AtomicOrdering ordering) {
-# switch (ordering) {
-# case llvm::AtomicOrdering::NotAtomic:
-# return LLVM::AtomicOrdering::not_atomic;
-# case llvm::AtomicOrdering::Unordered:
-# return LLVM::AtomicOrdering::unordered;
-# case llvm::AtomicOrdering::Monotonic:
-# return LLVM::AtomicOrdering::monotonic;
-# case llvm::AtomicOrdering::Acquire:
-# return LLVM::AtomicOrdering::acquire;
-# case llvm::AtomicOrdering::Release:
-# return LLVM::AtomicOrdering::release;
-# case llvm::AtomicOrdering::AcquireRelease:
-# return LLVM::AtomicOrdering::acq_rel;
-# case llvm::AtomicOrdering::SequentiallyConsistent:
-# return LLVM::AtomicOrdering::seq_cst;
-# }
-# llvm_unreachable("incorrect atomic ordering");
-# }
-
-# static AtomicBinOp getLLVMAtomicBinOp(llvm::AtomicRMWInst::BinOp binOp) {
-# switch (binOp) {
-# case llvm::AtomicRMWInst::Xchg:
-# return LLVM::AtomicBinOp::xchg;
-# case llvm::AtomicRMWInst::Add:
-# return LLVM::AtomicBinOp::add;
-# case llvm::AtomicRMWInst::Sub:
-# return LLVM::AtomicBinOp::sub;
-# case llvm::AtomicRMWInst::And:
-# return LLVM::AtomicBinOp::_and;
-# case llvm::AtomicRMWInst::Nand:
-# return LLVM::AtomicBinOp::nand;
-# case llvm::AtomicRMWInst::Or:
-# return LLVM::AtomicBinOp::_or;
-# case llvm::AtomicRMWInst::Xor:
-# return LLVM::AtomicBinOp::_xor;
-# case llvm::AtomicRMWInst::Max:
-# return LLVM::AtomicBinOp::max;
-# case llvm::AtomicRMWInst::Min:
-# return LLVM::AtomicBinOp::min;
-# case llvm::AtomicRMWInst::UMax:
-# return LLVM::AtomicBinOp::umax;
-# case llvm::AtomicRMWInst::UMin:
-# return LLVM::AtomicBinOp::umin;
-# case llvm::AtomicRMWInst::FAdd:
-# return LLVM::AtomicBinOp::fadd;
-# case llvm::AtomicRMWInst::FSub:
-# return LLVM::AtomicBinOp::fsub;
-# default:
-# llvm_unreachable("unsupported atomic binary operation");
-# }
-# }
-
-# // `br` branches to `target`. Return the branch arguments to `br`, in the
-# // same order of the PHIs in `target`.
-# LogicalResult
-# Importer::processBranchArgs(llvm::Instruction *br, llvm::BasicBlock *target,
-# SmallVectorImpl<Value> &blockArguments) {
-# for (auto inst = target->begin(); isa<llvm::PHINode>(inst); ++inst) {
-# auto *pn = cast<llvm::PHINode>(&*inst);
-# Value value = processValue(pn->getIncomingValueForBlock(br->getParent()));
-# if (!value)
-# return failure();
-# blockArguments.push_back(value);
-# }
-# return success();
-# }
-
-# LogicalResult Importer::processInstruction(llvm::Instruction *inst) {
-# // FIXME: Support uses of SubtargetData. Currently inbounds GEPs, fast-math
-# // flags and call / operand attributes are not supported.
-# Location loc = processDebugLoc(inst->getDebugLoc(), inst);
-# assert(!instMap.count(inst) &&
-# "processInstruction must be called only once per instruction!");
-# switch (inst->getOpcode()) {
-# default:
-# return emitError(loc) << "unknown instruction: " << diag(*inst);
-# case llvm::Instruction::Add:
-# case llvm::Instruction::FAdd:
-# case llvm::Instruction::Sub:
-# case llvm::Instruction::FSub:
-# case llvm::Instruction::Mul:
-# case llvm::Instruction::FMul:
-# case llvm::Instruction::UDiv:
-# case llvm::Instruction::SDiv:
-# case llvm::Instruction::FDiv:
-# case llvm::Instruction::URem:
-# case llvm::Instruction::SRem:
-# case llvm::Instruction::FRem:
-# case llvm::Instruction::Shl:
-# case llvm::Instruction::LShr:
-# case llvm::Instruction::AShr:
-# case llvm::Instruction::And:
-# case llvm::Instruction::Or:
-# case llvm::Instruction::Xor:
-# case llvm::Instruction::Load:
-# case llvm::Instruction::Store:
-# case llvm::Instruction::Ret:
-# case llvm::Instruction::Resume:
-# case llvm::Instruction::Trunc:
-# case llvm::Instruction::ZExt:
-# case llvm::Instruction::SExt:
-# case llvm::Instruction::FPToUI:
-# case llvm::Instruction::FPToSI:
-# case llvm::Instruction::UIToFP:
-# case llvm::Instruction::SIToFP:
-# case llvm::Instruction::FPTrunc:
-# case llvm::Instruction::FPExt:
-# case llvm::Instruction::PtrToInt:
-# case llvm::Instruction::IntToPtr:
-# case llvm::Instruction::AddrSpaceCast:
-# case llvm::Instruction::Freeze:
-# case llvm::Instruction::BitCast:
-# case llvm::Instruction::ExtractElement:
-# case llvm::Instruction::InsertElement:
-# case llvm::Instruction::Select:
-# case llvm::Instruction::FNeg:
-# case llvm::Instruction::Unreachable: {
-# OperationState state(loc, lookupOperationNameFromOpcode(inst->getOpcode()));
-# SmallVector<Value, 4> ops;
-# ops.reserve(inst->getNumOperands());
-# for (auto *op : inst->operand_values()) {
-# Value value = processValue(op);
-# if (!value)
-# return failure();
-# ops.push_back(value);
-# }
-# state.addOperands(ops);
-# if (!inst->getType()->isVoidTy()) {
-# Type type = processType(inst->getType());
-# if (!type)
-# return failure();
-# state.addTypes(type);
-# }
-# Operation *op = b.create(state);
-# if (!inst->getType()->isVoidTy())
-# instMap[inst] = op->getResult(0);
-# return success();
-# }
-# case llvm::Instruction::Alloca: {
-# Value size = processValue(inst->getOperand(0));
-# if (!size)
-# return failure();
-
-# auto *allocaInst = cast<llvm::AllocaInst>(inst);
-# instMap[inst] =
-# b.create<AllocaOp>(loc, processType(inst->getType()),
-# processType(allocaInst->getAllocatedType()), size,
-# allocaInst->getAlign().value());
-# return success();
-# }
-# case llvm::Instruction::ICmp: {
-# Value lhs = processValue(inst->getOperand(0));
-# Value rhs = processValue(inst->getOperand(1));
-# if (!lhs || !rhs)
-# return failure();
-# instMap[inst] = b.create<ICmpOp>(
-# loc, getICmpPredicate(cast<llvm::ICmpInst>(inst)->getPredicate()), lhs,
-# rhs);
-# return success();
-# }
-# case llvm::Instruction::FCmp: {
-# Value lhs = processValue(inst->getOperand(0));
-# Value rhs = processValue(inst->getOperand(1));
-# if (!lhs || !rhs)
-# return failure();
-
-# if (lhs.getType() != rhs.getType())
-# return failure();
-
-# Type boolType = b.getI1Type();
-# Type resType = boolType;
-# if (LLVM::isCompatibleVectorType(lhs.getType())) {
-# unsigned numElements =
-# LLVM::getVectorNumElements(lhs.getType()).getFixedValue();
-# resType = VectorType::get({numElements}, boolType);
-# }
-
-# instMap[inst] = b.create<FCmpOp>(
-# loc, resType,
-# getFCmpPredicate(cast<llvm::FCmpInst>(inst)->getPredicate()), lhs, rhs);
-# return success();
-# }
-# case llvm::Instruction::Br: {
-# auto *brInst = cast<llvm::BranchInst>(inst);
-# OperationState state(loc,
-# brInst->isConditional() ? "llvm.cond_br" : "llvm.br");
-# if (brInst->isConditional()) {
-# Value condition = processValue(brInst->getCondition());
-# if (!condition)
-# return failure();
-# state.addOperands(condition);
-# }
-
-# std::array<int32_t, 3> operandSegmentSizes = {1, 0, 0};
-# for (int i : llvm::seq<int>(0, brInst->getNumSuccessors())) {
-# auto *succ = brInst->getSuccessor(i);
-# SmallVector<Value, 4> blockArguments;
-# if (failed(processBranchArgs(brInst, succ, blockArguments)))
-# return failure();
-# state.addSuccessors(blocks[succ]);
-# state.addOperands(blockArguments);
-# operandSegmentSizes[i + 1] = blockArguments.size();
-# }
-
-# if (brInst->isConditional()) {
-# state.addAttribute(LLVM::CondBrOp::getOperandSegmentSizeAttr(),
-# b.getDenseI32ArrayAttr(operandSegmentSizes));
-# }
-
-# b.create(state);
-# return success();
-# }
-# case llvm::Instruction::Switch: {
-# auto *swInst = cast<llvm::SwitchInst>(inst);
-# // Process the condition value.
-# Value condition = processValue(swInst->getCondition());
-# if (!condition)
-# return failure();
-
-# SmallVector<Value> defaultBlockArgs;
-# // Process the default case.
-# llvm::BasicBlock *defaultBB = swInst->getDefaultDest();
-# if (failed(processBranchArgs(swInst, defaultBB, defaultBlockArgs)))
-# return failure();
-
-# // Process the cases.
-# unsigned numCases = swInst->getNumCases();
-# SmallVector<SmallVector<Value>> caseOperands(numCases);
-# SmallVector<ValueRange> caseOperandRefs(numCases);
-# SmallVector<int32_t> caseValues(numCases);
-# SmallVector<Block *> caseBlocks(numCases);
-# for (const auto &en : llvm::enumerate(swInst->cases())) {
-# const llvm::SwitchInst::CaseHandle &caseHandle = en.value();
-# unsigned i = en.index();
-# llvm::BasicBlock *succBB = caseHandle.getCaseSuccessor();
-# if (failed(processBranchArgs(swInst, succBB, caseOperands[i])))
-# return failure();
-# caseOperandRefs[i] = caseOperands[i];
-# caseValues[i] = caseHandle.getCaseValue()->getSExtValue();
-# caseBlocks[i] = blocks[succBB];
-# }
-
-# b.create<SwitchOp>(loc, condition, blocks[defaultBB], defaultBlockArgs,
-# caseValues, caseBlocks, caseOperandRefs);
-# return success();
-# }
-# case llvm::Instruction::PHI: {
-# Type type = processType(inst->getType());
-# if (!type)
-# return failure();
-# instMap[inst] = b.getInsertionBlock()->addArgument(
-# type, processDebugLoc(inst->getDebugLoc(), inst));
-# return success();
-# }
-# case llvm::Instruction::Call: {
-# llvm::CallInst *ci = cast<llvm::CallInst>(inst);
-# SmallVector<Value, 4> ops;
-# ops.reserve(inst->getNumOperands());
-# for (auto &op : ci->args()) {
-# Value arg = processValue(op.get());
-# if (!arg)
-# return failure();
-# ops.push_back(arg);
-# }
-
-# SmallVector<Type, 2> tys;
-# if (!ci->getType()->isVoidTy()) {
-# Type type = processType(inst->getType());
-# if (!type)
-# return failure();
-# tys.push_back(type);
-# }
-# Operation *op;
-# if (llvm::Function *callee = ci->getCalledFunction()) {
-# // For all intrinsics, try to generate to the corresponding op.
-# if (callee->isIntrinsic()) {
-# auto id = callee->getIntrinsicID();
-# StringRef opName = lookupOperationNameFromIntrinsicID(id);
-# if (!opName.empty()) {
-# OperationState state(loc, opName);
-# state.addOperands(ops);
-# state.addTypes(tys);
-# Operation *op = b.create(state);
-# if (!inst->getType()->isVoidTy())
-# instMap[inst] = op->getResult(0);
-# return success();
-# }
-# }
-# op = b.create<CallOp>(
-# loc, tys, SymbolRefAttr::get(b.getContext(), callee->getName()), ops);
-# } else {
-# Value calledValue = processValue(ci->getCalledOperand());
-# if (!calledValue)
-# return failure();
-# ops.insert(ops.begin(), calledValue);
-# op = b.create<CallOp>(loc, tys, ops);
-# }
-# if (!ci->getType()->isVoidTy())
-# instMap[inst] = op->getResult(0);
-# return success();
-# }
-# case llvm::Instruction::LandingPad: {
-# llvm::LandingPadInst *lpi = cast<llvm::LandingPadInst>(inst);
-# SmallVector<Value, 4> ops;
-
-# for (unsigned i = 0, ie = lpi->getNumClauses(); i < ie; i++)
-# ops.push_back(processConstant(lpi->getClause(i)));
-
-# Type ty = processType(lpi->getType());
-# if (!ty)
-# return failure();
-
-# instMap[inst] = b.create<LandingpadOp>(loc, ty, lpi->isCleanup(), ops);
-# return success();
-# }
-# case llvm::Instruction::Invoke: {
-# llvm::InvokeInst *ii = cast<llvm::InvokeInst>(inst);
-
-# SmallVector<Type, 2> tys;
-# if (!ii->getType()->isVoidTy())
-# tys.push_back(processType(inst->getType()));
-
-# SmallVector<Value, 4> ops;
-# ops.reserve(inst->getNumOperands() + 1);
-# for (auto &op : ii->args())
-# ops.push_back(processValue(op.get()));
-
-# SmallVector<Value, 4> normalArgs, unwindArgs;
-# (void)processBranchArgs(ii, ii->getNormalDest(), normalArgs);
-# (void)processBranchArgs(ii, ii->getUnwindDest(), unwindArgs);
-
-# Operation *op;
-# if (llvm::Function *callee = ii->getCalledFunction()) {
-# op = b.create<InvokeOp>(
-# loc, tys, SymbolRefAttr::get(b.getContext(), callee->getName()), ops,
-# blocks[ii->getNormalDest()], normalArgs, blocks[ii->getUnwindDest()],
-# unwindArgs);
-# } else {
-# ops.insert(ops.begin(), processValue(ii->getCalledOperand()));
-# op = b.create<InvokeOp>(loc, tys, ops, blocks[ii->getNormalDest()],
-# normalArgs, blocks[ii->getUnwindDest()],
-# unwindArgs);
-# }
-
-# if (!ii->getType()->isVoidTy())
-# instMap[inst] = op->getResult(0);
-# return success();
-# }
-# case llvm::Instruction::Fence: {
-# StringRef syncscope;
-# SmallVector<StringRef, 4> ssNs;
-# llvm::LLVMContext &llvmContext = inst->getContext();
-# llvm::FenceInst *fence = cast<llvm::FenceInst>(inst);
-# llvmContext.getSyncScopeNames(ssNs);
-# int fenceSyncScopeID = fence->getSyncScopeID();
-# for (unsigned i = 0, e = ssNs.size(); i != e; i++) {
-# if (fenceSyncScopeID == llvmContext.getOrInsertSyncScopeID(ssNs[i])) {
-# syncscope = ssNs[i];
-# break;
-# }
-# }
-# b.create<FenceOp>(loc, getLLVMAtomicOrdering(fence->getOrdering()),
-# syncscope);
-# return success();
-# }
-# case llvm::Instruction::AtomicRMW: {
-# auto *atomicInst = cast<llvm::AtomicRMWInst>(inst);
-# Value ptr = processValue(atomicInst->getPointerOperand());
-# Value val = processValue(atomicInst->getValOperand());
-# if (!ptr || !val)
-# return failure();
-
-# LLVM::AtomicBinOp binOp = getLLVMAtomicBinOp(atomicInst->getOperation());
-# LLVM::AtomicOrdering ordering =
-# getLLVMAtomicOrdering(atomicInst->getOrdering());
-
-# Type type = processType(inst->getType());
-# if (!type)
-# return failure();
-
-# instMap[inst] = b.create<AtomicRMWOp>(loc, type, binOp, ptr, val, ordering);
-# return success();
-# }
-# case llvm::Instruction::AtomicCmpXchg: {
-# auto *cmpXchgInst = cast<llvm::AtomicCmpXchgInst>(inst);
-# Value ptr = processValue(cmpXchgInst->getPointerOperand());
-# Value cmpVal = processValue(cmpXchgInst->getCompareOperand());
-# Value newVal = processValue(cmpXchgInst->getNewValOperand());
-# if (!ptr || !cmpVal || !newVal)
-# return failure();
-
-# LLVM::AtomicOrdering ordering =
-# getLLVMAtomicOrdering(cmpXchgInst->getSuccessOrdering());
-# LLVM::AtomicOrdering failOrdering =
-# getLLVMAtomicOrdering(cmpXchgInst->getFailureOrdering());
-
-# Type type = processType(inst->getType());
-# if (!type)
-# return failure();
-
-# instMap[inst] = b.create<AtomicCmpXchgOp>(loc, type, ptr, cmpVal, newVal,
-# ordering, failOrdering);
-# return success();
-# }
-# case llvm::Instruction::GetElementPtr: {
-# // FIXME: Support inbounds GEPs.
-# llvm::GetElementPtrInst *gep = cast<llvm::GetElementPtrInst>(inst);
-# Value basePtr = processValue(gep->getOperand(0));
-# Type sourceElementType = processType(gep->getSourceElementType());
-
-# // Treat every indices as dynamic since GEPOp::build will refine those
-# // indices into static attributes later. One small downside of this
-# // approach is that many unused `llvm.mlir.constant` would be emitted
-# // at first place.
-# SmallVector<GEPArg> indices;
-# for (llvm::Value *operand : llvm::drop_begin(gep->operand_values())) {
-# Value val = processValue(operand);
-# if (!val)
-# return failure();
-# indices.push_back(val);
-# }
-
-# Type type = processType(inst->getType());
-# if (!type)
-# return failure();
-# instMap[inst] =
-# b.create<GEPOp>(loc, type, sourceElementType, basePtr, indices);
-# return success();
-# }
-# case llvm::Instruction::InsertValue: {
-# auto *ivInst = cast<llvm::InsertValueInst>(inst);
-# Value inserted = processValue(ivInst->getInsertedValueOperand());
-# if (!inserted)
-# return failure();
-# Value aggOperand = processValue(ivInst->getAggregateOperand());
-# if (!aggOperand)
-# return failure();
-
-# SmallVector<int64_t> indices;
-# llvm::append_range(indices, ivInst->getIndices());
-# instMap[inst] = b.create<InsertValueOp>(loc, aggOperand, inserted, indices);
-# return success();
-# }
-# case llvm::Instruction::ExtractValue: {
-# auto *evInst = cast<llvm::ExtractValueInst>(inst);
-# Value aggOperand = processValue(evInst->getAggregateOperand());
-# if (!aggOperand)
-# return failure();
-
-# Type type = processType(inst->getType());
-# if (!type)
-# return failure();
-
-# SmallVector<int64_t> indices;
-# llvm::append_range(indices, evInst->getIndices());
-# instMap[inst] = b.create<ExtractValueOp>(loc, aggOperand, indices);
-# return success();
-# }
-# case llvm::Instruction::ShuffleVector: {
-# auto *svInst = cast<llvm::ShuffleVectorInst>(inst);
-# Value vec1 = processValue(svInst->getOperand(0));
-# if (!vec1)
-# return failure();
-# Value vec2 = processValue(svInst->getOperand(1));
-# if (!vec2)
-# return failure();
-
-# SmallVector<int32_t> mask(svInst->getShuffleMask());
-# instMap[inst] = b.create<ShuffleVectorOp>(loc, vec1, vec2, mask);
-# return success();
-# }
-# }
-# }
-
-# FlatSymbolRefAttr Importer::getPersonalityAsAttr(llvm::Function *f) {
-# if (!f->hasPersonalityFn())
-# return nullptr;
-
-# llvm::Constant *pf = f->getPersonalityFn();
-
-# // If it directly has a name, we can use it.
-# if (pf->hasName())
-# return SymbolRefAttr::get(b.getContext(), pf->getName());
-
-# // If it doesn't have a name, currently, only function pointers that are
-# // bitcast to i8* are parsed.
-# if (auto *ce = dyn_cast<llvm::ConstantExpr>(pf)) {
-# if (ce->getOpcode() == llvm::Instruction::BitCast &&
-# ce->getType() == llvm::Type::getInt8PtrTy(f->getContext())) {
-# if (auto *func = dyn_cast<llvm::Function>(ce->getOperand(0)))
-# return SymbolRefAttr::get(b.getContext(), func->getName());
-# }
-# }
-# return FlatSymbolRefAttr();
-# }
-
-# void Importer::processFunctionAttributes(llvm::Function *func,
-# LLVMFuncOp funcOp) {
-# auto addNamedUnitAttr = [&](StringRef name) {
-# return funcOp->setAttr(name, UnitAttr::get(context));
-# };
-# if (func->hasFnAttribute(llvm::Attribute::ReadNone))
-# addNamedUnitAttr(LLVMDialect::getReadnoneAttrName());
-# }
-
-# LogicalResult Importer::processFunction(llvm::Function *f) {
-# blocks.clear();
-# instMap.clear();
-# unknownInstMap.clear();
-
-# auto functionType =
-# processType(f->getFunctionType()).dyn_cast<LLVMFunctionType>();
-# if (!functionType)
-# return failure();
-
-# if (f->isIntrinsic()) {
-# StringRef opName = lookupOperationNameFromIntrinsicID(f->getIntrinsicID());
-# // Skip the intrinsic decleration if we could found a corresponding op.
-# if (!opName.empty())
-# return success();
-# }
-
-# bool dsoLocal = f->hasLocalLinkage();
-# CConv cconv = convertCConvFromLLVM(f->getCallingConv());
-
-# b.setInsertionPoint(module.getBody(), getFuncInsertPt());
-# LLVMFuncOp fop = b.create<LLVMFuncOp>(
-# UnknownLoc::get(context), f->getName(), functionType,
-# convertLinkageFromLLVM(f->getLinkage()), dsoLocal, cconv);
-
-# for (const auto &arg : llvm::enumerate(functionType.getParams())) {
-# llvm::SmallVector<NamedAttribute, 1> argAttrs;
-# if (auto *type = f->getParamByValType(arg.index())) {
-# auto mlirType = processType(type);
-# argAttrs.push_back(
-# NamedAttribute(b.getStringAttr(LLVMDialect::getByValAttrName()),
-# TypeAttr::get(mlirType)));
-# }
-# if (auto *type = f->getParamByRefType(arg.index())) {
-# auto mlirType = processType(type);
-# argAttrs.push_back(
-# NamedAttribute(b.getStringAttr(LLVMDialect::getByRefAttrName()),
-# TypeAttr::get(mlirType)));
-# }
-# if (auto *type = f->getParamStructRetType(arg.index())) {
-# auto mlirType = processType(type);
-# argAttrs.push_back(
-# NamedAttribute(b.getStringAttr(LLVMDialect::getStructRetAttrName()),
-# TypeAttr::get(mlirType)));
-# }
-# if (auto *type = f->getParamInAllocaType(arg.index())) {
-# auto mlirType = processType(type);
-# argAttrs.push_back(
-# NamedAttribute(b.getStringAttr(LLVMDialect::getInAllocaAttrName()),
-# TypeAttr::get(mlirType)));
-# }
-
-# fop.setArgAttrs(arg.index(), argAttrs);
-# }
-
-# if (FlatSymbolRefAttr personality = getPersonalityAsAttr(f))
-# fop->setAttr(b.getStringAttr("personality"), personality);
-# else if (f->hasPersonalityFn())
-# emitWarning(UnknownLoc::get(context),
-# "could not deduce personality, skipping it");
-
-# if (f->hasGC())
-# fop.setGarbageCollectorAttr(b.getStringAttr(f->getGC()));
-
-# // Handle Function attributes.
-# processFunctionAttributes(f, fop);
-
-# if (f->isDeclaration())
-# return success();
-
-# // Eagerly create all blocks.
-# SmallVector<Block *, 4> blockList;
-# for (llvm::BasicBlock &bb : *f) {
-# blockList.push_back(b.createBlock(&fop.getBody(), fop.getBody().end()));
-# blocks[&bb] = blockList.back();
-# }
-# currentEntryBlock = blockList[0];
-
-# // Add function arguments to the entry block.
-# for (const auto &kv : llvm::enumerate(f->args())) {
-# instMap[&kv.value()] = blockList[0]->addArgument(
-# functionType.getParamType(kv.index()), fop.getLoc());
-# }
-
-# for (auto bbs : llvm::zip(*f, blockList)) {
-# if (failed(processBasicBlock(&std::get<0>(bbs), std::get<1>(bbs))))
-# return failure();
-# }
-
-# // Now that all instructions are guaranteed to have been visited, ensure
-# // any unknown uses we encountered are remapped.
-# for (auto &llvmAndUnknown : unknownInstMap) {
-# assert(instMap.count(llvmAndUnknown.first));
-# Value newValue = instMap[llvmAndUnknown.first];
-# Value oldValue = llvmAndUnknown.second->getResult(0);
-# oldValue.replaceAllUsesWith(newValue);
-# llvmAndUnknown.second->erase();
-# }
-# return success();
-# }
-
-# LogicalResult Importer::processBasicBlock(llvm::BasicBlock *bb, Block *block) {
-# b.setInsertionPointToStart(block);
-# for (llvm::Instruction &inst : *bb) {
-# if (failed(processInstruction(&inst)))
-# return failure();
-# }
-# return success();
-# }
-
-# OwningOpRef<ModuleOp>
-# mlir::translateLLVMIRToModule(std::unique_ptr<llvm::Module> llvmModule,
-# MLIRContext *context) {
-# context->loadDialect<LLVMDialect>();
-# context->loadDialect<DLTIDialect>();
-# OwningOpRef<ModuleOp> module(ModuleOp::create(
-# FileLineColLoc::get(context, "", /*line=*/0, /*column=*/0)));
-
-# DataLayoutSpecInterface dlSpec =
-# translateDataLayout(llvmModule->getDataLayout(), context);
-# if (!dlSpec) {
-# emitError(UnknownLoc::get(context), "can't translate data layout");
-# return {};
-# }
-
-# module.get()->setAttr(DLTIDialect::kDataLayoutAttrName, dlSpec);
-
-# Importer deserializer(context, module.get());
-# for (llvm::GlobalVariable &gv : llvmModule->globals()) {
-# if (!deserializer.processGlobal(&gv))
-# return {};
-# }
-# for (llvm::Function &f : llvmModule->functions()) {
-# if (failed(deserializer.processFunction(&f)))
-# return {};
-# }
-
-# return module;
-# }
-
- // Deserializes the LLVM bitcode stored in `input` into an MLIR module in the
- // LLVM dialect.
- OwningOpRef<ModuleOp> translateLLVMIRToModule(llvm::SourceMgr &sourceMgr,
- MLIRContext *context) {
- llvm::SMDiagnostic err;
- llvm::LLVMContext llvmContext;
- std::unique_ptr<llvm::Module> llvmModule = llvm::parseIR(
- *sourceMgr.getMemoryBuffer(sourceMgr.getMainFileID()), err, llvmContext);
- if (!llvmModule) {
- std::string errStr;
- llvm::raw_string_ostream errStream(errStr);
- err.print(/*ProgName=*/"", errStream);
- emitError(UnknownLoc::get(context)) << errStream.str();
- return {};
- }
- return translateLLVMIRToModule(std::move(llvmModule), context);
- }
-
- namespace mlir {
- void registerFromLLVMIRTranslation() {
- TranslateToMLIRRegistration fromLLVM(
-- "import-llvm", [](llvm::SourceMgr &sourceMgr, MLIRContext *context) {
-+ "import-llvm", "from llvm to mlir",
-+ [](llvm::SourceMgr &sourceMgr, MLIRContext *context) {
- return ::translateLLVMIRToModule(sourceMgr, context);
- });
- }
- } // namespace mlir
-diff --git a/mlir/lib/Target/LLVMIR/ConvertToLLVMIR.cpp b/mlir/lib/Target/LLVMIR/ConvertToLLVMIR.cpp
-index 70f86d2..1ae7b83 100644
---- a/mlir/lib/Target/LLVMIR/ConvertToLLVMIR.cpp
-+++ b/mlir/lib/Target/LLVMIR/ConvertToLLVMIR.cpp
-@@ -1,42 +1,42 @@
- //===- ConvertToLLVMIR.cpp - MLIR to LLVM IR conversion -------------------===//
- //
- // 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 a translation between the MLIR LLVM dialect and LLVM IR.
- //
- //===----------------------------------------------------------------------===//
-
- #include "mlir/Dialect/DLTI/DLTI.h"
- #include "mlir/Dialect/Func/IR/FuncOps.h"
- #include "mlir/IR/BuiltinOps.h"
- #include "mlir/Target/LLVMIR/Dialect/All.h"
- #include "mlir/Target/LLVMIR/Export.h"
- #include "mlir/Tools/mlir-translate/Translation.h"
- #include "llvm/IR/LLVMContext.h"
- #include "llvm/IR/Module.h"
-
- using namespace mlir;
-
- namespace mlir {
- void registerToLLVMIRTranslation() {
- TranslateFromMLIRRegistration registration(
-- "mlir-to-llvmir",
-+ "mlir-to-llvmir", "translate mlir to llvmir",
- [](ModuleOp module, raw_ostream &output) {
- llvm::LLVMContext llvmContext;
- auto llvmModule = translateModuleToLLVMIR(module, llvmContext);
- if (!llvmModule)
- return failure();
-
- llvmModule->print(output, nullptr);
- return success();
- },
- [](DialectRegistry ®istry) {
- registry.insert<DLTIDialect, func::FuncDialect>();
- registerAllToLLVMIRTranslations(registry);
- });
- }
- } // namespace mlir
-diff --git a/mlir/lib/Target/SPIRV/TranslateRegistration.cpp b/mlir/lib/Target/SPIRV/TranslateRegistration.cpp
-index 664b796..d24e578 100644
---- a/mlir/lib/Target/SPIRV/TranslateRegistration.cpp
-+++ b/mlir/lib/Target/SPIRV/TranslateRegistration.cpp
-@@ -1,184 +1,184 @@
- //===- TranslateRegistration.cpp - hooks to mlir-translate ----------------===//
- //
- // 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 a translation from SPIR-V binary module to MLIR SPIR-V
- // ModuleOp.
- //
- //===----------------------------------------------------------------------===//
-
- #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
- #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
- #include "mlir/IR/Builders.h"
- #include "mlir/IR/BuiltinOps.h"
- #include "mlir/IR/Dialect.h"
- #include "mlir/IR/Verifier.h"
- #include "mlir/Parser/Parser.h"
- #include "mlir/Support/FileUtilities.h"
- #include "mlir/Target/SPIRV/Deserialization.h"
- #include "mlir/Target/SPIRV/Serialization.h"
- #include "mlir/Tools/mlir-translate/Translation.h"
- #include "llvm/ADT/StringRef.h"
- #include "llvm/Support/MemoryBuffer.h"
- #include "llvm/Support/SMLoc.h"
- #include "llvm/Support/SourceMgr.h"
- #include "llvm/Support/ToolOutputFile.h"
-
- using namespace mlir;
-
- //===----------------------------------------------------------------------===//
- // Deserialization registration
- //===----------------------------------------------------------------------===//
-
- // Deserializes the SPIR-V binary module stored in the file named as
- // `inputFilename` and returns a module containing the SPIR-V module.
- static OwningOpRef<ModuleOp> deserializeModule(const llvm::MemoryBuffer *input,
- MLIRContext *context) {
- context->loadDialect<spirv::SPIRVDialect>();
-
- // Make sure the input stream can be treated as a stream of SPIR-V words
- auto *start = input->getBufferStart();
- auto size = input->getBufferSize();
- if (size % sizeof(uint32_t) != 0) {
- emitError(UnknownLoc::get(context))
- << "SPIR-V binary module must contain integral number of 32-bit words";
- return {};
- }
-
- auto binary = llvm::makeArrayRef(reinterpret_cast<const uint32_t *>(start),
- size / sizeof(uint32_t));
-
- OwningOpRef<spirv::ModuleOp> spirvModule =
- spirv::deserialize(binary, context);
- if (!spirvModule)
- return {};
-
- OwningOpRef<ModuleOp> module(ModuleOp::create(FileLineColLoc::get(
- context, input->getBufferIdentifier(), /*line=*/0, /*column=*/0)));
- module->getBody()->push_front(spirvModule.release());
-
- return module;
- }
-
- namespace mlir {
- void registerFromSPIRVTranslation() {
- TranslateToMLIRRegistration fromBinary(
-- "deserialize-spirv",
-+ "deserialize-spirv", "deserializes the SPIR-V module",
- [](llvm::SourceMgr &sourceMgr, MLIRContext *context) {
- assert(sourceMgr.getNumBuffers() == 1 && "expected one buffer");
- return deserializeModule(
- sourceMgr.getMemoryBuffer(sourceMgr.getMainFileID()), context);
- });
- }
- } // namespace mlir
-
- //===----------------------------------------------------------------------===//
- // Serialization registration
- //===----------------------------------------------------------------------===//
-
- static LogicalResult serializeModule(ModuleOp module, raw_ostream &output) {
- if (!module)
- return failure();
-
- SmallVector<uint32_t, 0> binary;
-
- SmallVector<spirv::ModuleOp, 1> spirvModules;
- module.walk([&](spirv::ModuleOp op) { spirvModules.push_back(op); });
-
- if (spirvModules.empty())
- return module.emitError("found no 'spirv.module' op");
-
- if (spirvModules.size() != 1)
- return module.emitError("found more than one 'spirv.module' op");
-
- if (failed(spirv::serialize(spirvModules[0], binary)))
- return failure();
-
- output.write(reinterpret_cast<char *>(binary.data()),
- binary.size() * sizeof(uint32_t));
-
- return mlir::success();
- }
-
- namespace mlir {
- void registerToSPIRVTranslation() {
- TranslateFromMLIRRegistration toBinary(
-- "serialize-spirv",
-+ "serialize-spirv", "serialize SPIR-V dialect",
- [](ModuleOp module, raw_ostream &output) {
- return serializeModule(module, output);
- },
- [](DialectRegistry ®istry) {
- registry.insert<spirv::SPIRVDialect>();
- });
- }
- } // namespace mlir
-
- //===----------------------------------------------------------------------===//
- // Round-trip registration
- //===----------------------------------------------------------------------===//
-
- static LogicalResult roundTripModule(ModuleOp srcModule, bool emitDebugInfo,
- raw_ostream &output) {
- SmallVector<uint32_t, 0> binary;
- MLIRContext *context = srcModule.getContext();
- auto spirvModules = srcModule.getOps<spirv::ModuleOp>();
-
- if (spirvModules.begin() == spirvModules.end())
- return srcModule.emitError("found no 'spirv.module' op");
-
- if (std::next(spirvModules.begin()) != spirvModules.end())
- return srcModule.emitError("found more than one 'spirv.module' op");
-
- spirv::SerializationOptions options;
- options.emitDebugInfo = emitDebugInfo;
- if (failed(spirv::serialize(*spirvModules.begin(), binary, options)))
- return failure();
-
- MLIRContext deserializationContext(context->getDialectRegistry());
- // TODO: we should only load the required dialects instead of all dialects.
- deserializationContext.loadAllAvailableDialects();
- // Then deserialize to get back a SPIR-V module.
- OwningOpRef<spirv::ModuleOp> spirvModule =
- spirv::deserialize(binary, &deserializationContext);
- if (!spirvModule)
- return failure();
-
- // Wrap around in a new MLIR module.
- OwningOpRef<ModuleOp> dstModule(ModuleOp::create(
- FileLineColLoc::get(&deserializationContext,
- /*filename=*/"", /*line=*/0, /*column=*/0)));
- dstModule->getBody()->push_front(spirvModule.release());
- if (failed(verify(*dstModule)))
- return failure();
- dstModule->print(output);
-
- return mlir::success();
- }
-
- namespace mlir {
- void registerTestRoundtripSPIRV() {
- TranslateFromMLIRRegistration roundtrip(
-- "test-spirv-roundtrip",
-+ "test-spirv-roundtrip", "test roundtrip in SPIR-V dialect",
- [](ModuleOp module, raw_ostream &output) {
- return roundTripModule(module, /*emitDebugInfo=*/false, output);
- },
- [](DialectRegistry ®istry) {
- registry.insert<spirv::SPIRVDialect>();
- });
- }
-
- void registerTestRoundtripDebugSPIRV() {
- TranslateFromMLIRRegistration roundtrip(
-- "test-spirv-roundtrip-debug",
-+ "test-spirv-roundtrip-debug", "test roundtrip debug in SPIR-V",
- [](ModuleOp module, raw_ostream &output) {
- return roundTripModule(module, /*emitDebugInfo=*/true, output);
- },
- [](DialectRegistry ®istry) {
- registry.insert<spirv::SPIRVDialect>();
- });
- }
- } // namespace mlir
-diff --git a/mlir/lib/Tools/mlir-translate/Translation.cpp b/mlir/lib/Tools/mlir-translate/Translation.cpp
-index 50b8547..7517ae0 100644
---- a/mlir/lib/Tools/mlir-translate/Translation.cpp
-+++ b/mlir/lib/Tools/mlir-translate/Translation.cpp
-@@ -1,126 +1,140 @@
- //===- Translation.cpp - Translation registry -----------------------------===//
- //
- // 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
- //
- //===----------------------------------------------------------------------===//
- //
- // Definitions of the translation registry.
- //
- //===----------------------------------------------------------------------===//
-
- #include "mlir/Tools/mlir-translate/Translation.h"
- #include "mlir/IR/AsmState.h"
- #include "mlir/IR/BuiltinOps.h"
- #include "mlir/IR/Dialect.h"
- #include "mlir/IR/Verifier.h"
- #include "mlir/Parser/Parser.h"
- #include "llvm/Support/SourceMgr.h"
-
- using namespace mlir;
-
- //===----------------------------------------------------------------------===//
- // Translation Registry
- //===----------------------------------------------------------------------===//
-
-+struct TranslationBundle {
-+ TranslateFunction translateFunction;
-+ StringRef translateDescription;
-+};
-+
- /// Get the mutable static map between registered file-to-file MLIR translations
--/// and the TranslateFunctions that perform those translations.
--static llvm::StringMap<TranslateFunction> &getTranslationRegistry() {
-- static llvm::StringMap<TranslateFunction> translationRegistry;
-- return translationRegistry;
-+/// and TranslateFunctions with its description that perform those translations.
-+static llvm::StringMap<TranslationBundle> &getTranslationRegistry() {
-+ static llvm::StringMap<TranslationBundle> translationBundle;
-+ return translationBundle;
- }
-
- /// Register the given translation.
--static void registerTranslation(StringRef name,
-+static void registerTranslation(StringRef name, StringRef description,
- const TranslateFunction &function) {
- auto &translationRegistry = getTranslationRegistry();
- if (translationRegistry.find(name) != translationRegistry.end())
- llvm::report_fatal_error(
- "Attempting to overwrite an existing <file-to-file> function");
- assert(function &&
- "Attempting to register an empty translate <file-to-file> function");
-- translationRegistry[name] = function;
-+ translationRegistry[name].translateFunction = function;
-+ translationRegistry[name].translateDescription = description;
- }
-
- TranslateRegistration::TranslateRegistration(
-- StringRef name, const TranslateFunction &function) {
-- registerTranslation(name, function);
-+ StringRef name, StringRef description, const TranslateFunction &function) {
-+ registerTranslation(name, description, function);
- }
-
- //===----------------------------------------------------------------------===//
- // Translation to MLIR
- //===----------------------------------------------------------------------===//
-
- // Puts `function` into the to-MLIR translation registry unless there is already
- // a function registered for the same name.
- static void registerTranslateToMLIRFunction(
-- StringRef name, const TranslateSourceMgrToMLIRFunction &function) {
-+ StringRef name, StringRef description,
-+ const TranslateSourceMgrToMLIRFunction &function) {
- auto wrappedFn = [function](llvm::SourceMgr &sourceMgr, raw_ostream &output,
- MLIRContext *context) {
- OwningOpRef<ModuleOp> module = function(sourceMgr, context);
- if (!module || failed(verify(*module)))
- return failure();
- module->print(output);
- return success();
- };
-- registerTranslation(name, wrappedFn);
-+ registerTranslation(name, description, wrappedFn);
- }
-
- TranslateToMLIRRegistration::TranslateToMLIRRegistration(
-- StringRef name, const TranslateSourceMgrToMLIRFunction &function) {
-- registerTranslateToMLIRFunction(name, function);
-+ StringRef name, StringRef description,
-+ const TranslateSourceMgrToMLIRFunction &function) {
-+ registerTranslateToMLIRFunction(name, description, function);
- }
--
- /// Wraps `function` with a lambda that extracts a StringRef from a source
- /// manager and registers the wrapper lambda as a to-MLIR conversion.
- TranslateToMLIRRegistration::TranslateToMLIRRegistration(
-- StringRef name, const TranslateStringRefToMLIRFunction &function) {
-+ StringRef name, StringRef description,
-+ const TranslateStringRefToMLIRFunction &function) {
- registerTranslateToMLIRFunction(
-- name, [function](llvm::SourceMgr &sourceMgr, MLIRContext *ctx) {
-+ name, description,
-+ [function](llvm::SourceMgr &sourceMgr, MLIRContext *ctx) {
- const llvm::MemoryBuffer *buffer =
- sourceMgr.getMemoryBuffer(sourceMgr.getMainFileID());
- return function(buffer->getBuffer(), ctx);
- });
- }
-
- //===----------------------------------------------------------------------===//
- // Translation from MLIR
- //===----------------------------------------------------------------------===//
-
- TranslateFromMLIRRegistration::TranslateFromMLIRRegistration(
-- StringRef name, const TranslateFromMLIRFunction &function,
-+ StringRef name, StringRef description,
-+ const TranslateFromMLIRFunction &function,
- const std::function<void(DialectRegistry &)> &dialectRegistration) {
-- registerTranslation(name, [function, dialectRegistration](
-- llvm::SourceMgr &sourceMgr, raw_ostream &output,
-- MLIRContext *context) {
-- DialectRegistry registry;
-- dialectRegistration(registry);
-- context->appendDialectRegistry(registry);
-- auto module = parseSourceFile<ModuleOp>(sourceMgr, context);
-- if (!module || failed(verify(*module)))
-- return failure();
-- return function(module.get(), output);
-- });
-+ registerTranslation(name, description,
-+ [function, dialectRegistration](
-+ llvm::SourceMgr &sourceMgr, raw_ostream &output,
-+ MLIRContext *context) {
-+ DialectRegistry registry;
-+ dialectRegistration(registry);
-+ context->appendDialectRegistry(registry);
-+ auto module =
-+ parseSourceFile<ModuleOp>(sourceMgr, context);
-+ if (!module || failed(verify(*module)))
-+ return failure();
-+ return function(module.get(), output);
-+ });
- }
-
- //===----------------------------------------------------------------------===//
- // Translation Parser
- //===----------------------------------------------------------------------===//
-
- TranslationParser::TranslationParser(llvm::cl::Option &opt)
- : llvm::cl::parser<const TranslateFunction *>(opt) {
-- for (const auto &kv : getTranslationRegistry())
-- addLiteralOption(kv.first(), &kv.second, kv.first());
-+ for (const auto &kv : getTranslationRegistry()) {
-+ addLiteralOption(kv.first(), &kv.second.translateFunction,
-+ kv.second.translateDescription);
-+ }
- }
-
- void TranslationParser::printOptionInfo(const llvm::cl::Option &o,
- size_t globalWidth) const {
- TranslationParser *tp = const_cast<TranslationParser *>(this);
- llvm::array_pod_sort(tp->Values.begin(), tp->Values.end(),
- [](const TranslationParser::OptionInfo *lhs,
- const TranslationParser::OptionInfo *rhs) {
- return lhs->Name.compare(rhs->Name);
- });
- llvm::cl::parser<const TranslateFunction *>::printOptionInfo(o, globalWidth);
- }
projects / platform / upstream / llvm.git / commitdiff