Diff 500515

mlir/test/CMakeLists.txt

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Lines	set(MLIR_TEST_DEPENDS
FileCheck count not split-file		FileCheck count not split-file
mlir-capi-ir-test		mlir-capi-ir-test
mlir-capi-llvm-test		mlir-capi-llvm-test
mlir-capi-pass-test		mlir-capi-pass-test
mlir-capi-pdl-test		mlir-capi-pdl-test
mlir-capi-quant-test		mlir-capi-quant-test
mlir-capi-sparse-tensor-test		mlir-capi-sparse-tensor-test
mlir-capi-transform-test		mlir-capi-transform-test
		mlir-bc-tblgen
mlir-linalg-ods-yaml-gen		mlir-linalg-ods-yaml-gen
mlir-lsp-server		mlir-lsp-server
mlir-pdll-lsp-server		mlir-pdll-lsp-server
mlir-opt		mlir-opt
mlir-pdll		mlir-pdll
mlir-reduce		mlir-reduce
mlir-tblgen		mlir-tblgen
mlir-translate		mlir-translate
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

mlir/tools/CMakeLists.txt

	add_subdirectory(mlir-lsp-server)			add_subdirectory(mlir-lsp-server)
	add_subdirectory(mlir-opt)			add_subdirectory(mlir-opt)
	add_subdirectory(mlir-parser-fuzzer)			add_subdirectory(mlir-parser-fuzzer)
	add_subdirectory(mlir-pdll-lsp-server)			add_subdirectory(mlir-pdll-lsp-server)
	add_subdirectory(mlir-reduce)			add_subdirectory(mlir-reduce)
	add_subdirectory(mlir-shlib)			add_subdirectory(mlir-shlib)
	add_subdirectory(mlir-spirv-cpu-runner)			add_subdirectory(mlir-spirv-cpu-runner)
	add_subdirectory(mlir-translate)			add_subdirectory(mlir-translate)
	add_subdirectory(mlir-vulkan-runner)			add_subdirectory(mlir-vulkan-runner)
	add_subdirectory(tblgen-lsp-server)			add_subdirectory(tblgen-lsp-server)
				add_subdirectory(mlir-dialect-bytecode-bootstrap)

	# mlir-cpu-runner requires ExecutionEngine.			# mlir-cpu-runner requires ExecutionEngine.
	if(MLIR_ENABLE_EXECUTION_ENGINE)			if(MLIR_ENABLE_EXECUTION_ENGINE)
	add_subdirectory(mlir-cpu-runner)			add_subdirectory(mlir-cpu-runner)
	endif()			endif()

mlir/tools/mlir-dialect-bytecode-bootstrap/BuiltinInc.h

This file was added.

				static LogicalResult readAPIntWithKnownWidth(DialectBytecodeReader &reader,
				unsigned bitWidth, APInt &val) {
				FailureOr<APInt> value = reader.readAPIntWithKnownWidth(bitWidth);
				if (failed(value))
				return failure();
				val = *value;
				return success();
				}

				// Returns the bitwidth if known, else return 0.
				static unsigned getIntegerBitWidth(DialectBytecodeReader &reader, Type type) {
				if (auto intType = dyn_cast<IntegerType>(type)) {
				return intType.getWidth();
				} else if (type.isa<IndexType>()) {
				return IndexType::kInternalStorageBitWidth;
				}
				reader.emitError()
				<< "expected integer or index type for IntegerAttr, but got: " << type;
				return 0;
				}

mlir/tools/mlir-dialect-bytecode-bootstrap/BytecodeAttrType.td

This file was added.

				// Bytecode base classes/defs.
				// Helper classes/defs to help build a reader/writer.

				class Bytecode<string parse="", string build="", string print="", string get="", string t=""> {
				// Template for parsing.
				// {0} == dialect bytecode reader
				// {1} == result type of parsed instance
				// {2} == variable being parsed
				// If parser is not specified, then the parse of members is used.
				string cParser = parse;

				// Template for building from parsed.
				// {0} == result type of parsed instance
				// {1} == args/members comma separated
				string cBuilder = build;

				// Template for printing.
				// {0} == dialect bytecode writer
				// {1} == parent attribute/type name
				// {2} == getter
				string cPrinter = print;

				// Template for getter from in memory form.
				// {0} == attribute/type
				// {1} == member instance
				// {2} == get + UpperCamelFromSnake({1})
				string cGetter = get;

				// Type built.
				// Note: if cType is empty, then name of def is used.
				string cType = t;

				// Predicate guarding parse method as an Attribute/Type could have multiple
				// parse methods, specify predicates to be orthogonal and cover entire
				// "print space" to avoid order dependence.
				// If empty then method is unconditional.
				// {0} == predicate function to apply on value dyn_casted to cType.
				string printerPredicate = "";
				}

				class WithParser<string p="", Bytecode t=Bytecode<>> :
				Bytecode<p, t.cBuilder, t.cPrinter, t.cGetter, t.cType>;
				class WithBuilder<string b="", Bytecode t=Bytecode<>> :
				Bytecode<t.cParser, b, t.cPrinter, t.cGetter, t.cType>;
				class WithPrinter<string p="", Bytecode t=Bytecode<>> :
				Bytecode<t.cParser, t.cBuilder, p, t.cGetter, t.cType>;
				class WithType<string ty="", Bytecode t=Bytecode<>> :
				Bytecode<t.cParser, t.cBuilder, t.cPrinter, t.cGetter, ty>;
				class WithGetter<string g="", Bytecode t=Bytecode<>> :
				Bytecode<t.cParser, t.cBuilder, t.cPrinter, g, t.cType>;

				class CompositeBytecode<string t = ""> : WithType<t>;

				class AttributeKind :
				WithParser <"succeeded({0}.readAttribute({2}))",
				WithBuilder<"{1}",
				WithPrinter<"{0}.writeAttribute({2})">>>;
				def Attribute : AttributeKind;
				class TypeKind :
				WithParser <"succeeded({0}.readType({2}))",
				WithBuilder<"{1}",
				WithPrinter<"{0}.writeType({2})">>>;
				def Type : TypeKind;
				def VarInt :
				WithParser <"succeeded({0}.readVarInt({2}))",
				WithBuilder<"{1}",
				WithPrinter<"{0}.writeVarInt({2})",
				WithType <"uint64_t">>>>;

				class KnownWidthAPInt<string s> :
				WithParser <"succeeded(readAPIntWithKnownWidth({0}, " # s # ", {2}))",
				WithBuilder<"{1}",
				WithPrinter<"{0}.writeAPIntWithKnownWidth({2})",
				WithType <"APInt">>>>;

				// Helper to define variable that is defined later but not parsed nor printed.
				class LocalVar<string t, string d> :
				WithParser <"(({2} = " # d # "), true)",
				WithBuilder<"{1}",
				WithPrinter<"",
				WithType <t>>>>;

				// Array instances.
				class Array<Bytecode t> {
				Bytecode elemT = t;

				string cBuilder = "{1}";
				}

				// Define dialect attribute or type.
				class DialectAttrOrType<string di, int e, dag d> {
				int enum = e;
				// Any members starting with underscore is not fed to create function but
				// treated as purely local variable.
				dag members = d;
				string dialect = di;

				// When needing to specify a custom return type.
				string cType = "";

				// Any post-processing that needs to be done.
				code postProcess = "";
				}

				class DialectAttribute<string di, int e, dag d> : DialectAttrOrType<di, e, d>,
				AttributeKind {
				let cParser = "succeeded({0}.readAttribute<{1}>({2}))";
				let cBuilder = "{0}::get({1})";
				}
				class DialectType<string di, int e, dag d> : DialectAttrOrType<di, e, d>,
				TypeKind {
				let cParser = "succeeded({0}.readAttribute<{1}>({2}))";
				let cBuilder = "{0}::get({1})";
				}

				def Context :
				WithParser <"({2}=context)",
				WithBuilder<"{1}",
				WithPrinter<"",
				WithType <"MLIRContext*">>>>;

				def attr;
				def type;

				// ----------------
				// Builtin dialect.
				// ================

				class BuiltinDialectAttribute<int e, dag d> : DialectAttribute<"Builtin", e, d>;
				class BuiltinDialectType<int e, dag d> : DialectType<"Builtin", e, d>;

				def LocationAttr : AttributeKind;

				def Location : CompositeBytecode {
				dag members = (attr
				WithGetter<"(LocationAttr){0}", WithType<"LocationAttr", LocationAttr>>:$value
				);
				let cBuilder = "Location({1})";
				}

				def String :
				WithParser <"succeeded({0}.readString({2}))",
				WithBuilder<"{1}",
				WithPrinter<"{0}.writeOwnedString({2})",
				WithType <"StringRef">>>>;

				// enum AttributeCode {
				// /// ArrayAttr {
				// /// elements: Attribute[]
				// /// }
				// ///
				// kArrayAttr = 0,
				//

				let cType = "StringAttr" in {
				// /// StringAttr {
				// /// value: string
				// /// }
				// kStringAttr = 2,
				def StringAttr : BuiltinDialectAttribute</enum=/2, (attr
				String:$value
				)> {
				let printerPredicate = "{0}.getType().isa<NoneType>()";
				let cBuilder = "StringAttr::get(context, {1})";
				}

				// /// StringAttrWithType {
				// /// value: string,
				// /// type: Type
				// /// }
				// /// A variant of StringAttr with a type.
				// kStringAttrWithType = 3,
				def StringAttrWithType : BuiltinDialectAttribute</enum=/3, (attr
				String:$value,
				Type:$type
				)> { let printerPredicate = "!{0}.getType().isa<NoneType>()"; }
				}

				// /// DictionaryAttr {
				// /// attrs: <StringAttr, Attribute>[]
				// /// }
				// kDictionaryAttr = 1,
				def NamedAttribute : CompositeBytecode {
				dag members = (attr
				StringAttr:$name,
				Attribute:$value
				);
				let cBuilder = "NamedAttribute({1})";
				}
				def DictionaryAttr : BuiltinDialectAttribute</enum=/1, (attr
				// TODO: handle context constructors a bit nicer.
				Context:$mlirContext,

				Array<NamedAttribute>:$value
				)>;

				// /// FlatSymbolRefAttr {
				// /// rootReference: StringAttr
				// /// }
				// /// A variant of SymbolRefAttr with no leaf references.
				// kFlatSymbolRefAttr = 4,
				def FlatSymbolRefAttr: BuiltinDialectAttribute</enum=/4, (attr
				StringAttr:$rootReference
				)>;

				// /// SymbolRefAttr {
				// /// rootReference: StringAttr,
				// /// leafReferences: FlatSymbolRefAttr[]
				// /// }
				// kSymbolRefAttr = 5,
				def SymbolRefAttr: BuiltinDialectAttribute</enum=/5, (attr
				StringAttr:$rootReference,
				Array<FlatSymbolRefAttr>:$nestedReferences
				)>;

				// /// TypeAttr {
				// /// value: Type
				// /// }
				// kTypeAttr = 6,
				def TypeAttr: BuiltinDialectAttribute</enum=/6, (attr
				Type:$value
				)>;

				// /// UnitAttr {
				// /// }
				// kUnitAttr = 7,
				def UnitAttr: BuiltinDialectAttribute</enum=/7, (attr)>;

				// /// IntegerAttr {
				// /// type: Type
				// /// value: APInt,
				// /// }
				// kIntegerAttr = 8,
				def IntegerAttr: BuiltinDialectAttribute</enum=/8, (attr
				Type:$type,
				LocalVar<"unsigned", "getIntegerBitWidth({0}, type)">:$_width,
				KnownWidthAPInt<"_width">:$value
				)>;

				//
				// /// FloatAttr {
				// /// type: FloatType
				// /// value: APFloat
				// /// }
				// kFloatAttr = 9,
				//
				// /// CallSiteLoc {
				// /// callee: LocationAttr,
				// /// caller: LocationAttr
				// /// }
				// kCallSiteLoc = 10,
				def CallSiteLoc : BuiltinDialectAttribute</enum=/10, (attr
				LocationAttr:$callee,
				LocationAttr:$caller
				)>;

				// /// FileLineColLoc {
				// /// filename: StringAttr,
				// /// line: varint,
				// /// column: varint
				// /// }
				// kFileLineColLoc = 11,
				def FileLineColLoc : BuiltinDialectAttribute</enum=/11, (attr
				StringAttr:$filename,
				VarInt:$line,
				VarInt:$column
				)>;

				let cType = "FusedLoc" in {
				// /// FusedLoc {
				// /// locations: Location[]
				// /// }
				// kFusedLoc = 12,
				def FusedLoc : BuiltinDialectAttribute</enum=/12, (attr
				Array<Location>:$locations
				)> {
				let printerPredicate = "!{0}.getMetadata()";
				let cBuilder = "cast<FusedLoc>(FusedLoc::get(context, {1}))";
				}

				// /// FusedLocWithMetadata {
				// /// locations: LocationAttr[],
				// /// metadata: Attribute
				// /// }
				// /// A variant of FusedLoc with metadata.
				// kFusedLocWithMetadata = 13,
				def FusedLocWithMetadata : BuiltinDialectAttribute</enum=/13, (attr
				Array<Location>:$locations,
				Attribute:$metadata
				)> {
				let printerPredicate = "{0}.getMetadata()";
				let cBuilder = "cast<FusedLoc>(FusedLoc::get(context, {1}))";
				}
				}

				// /// NameLoc {
				// /// name: StringAttr,
				// /// childLoc: LocationAttr
				// /// }
				// kNameLoc = 14,
				def NameLoc : BuiltinDialectAttribute</enum=/14, (attr
				StringAttr:$name,
				LocationAttr:$childLoc
				)>;

				// /// UnknownLoc {
				// /// }
				// kUnknownLoc = 15,
				def UnknownLoc : BuiltinDialectAttribute</enum=/15, (attr)>;

				// /// DenseResourceElementsAttr {
				// /// type: Type,
				// /// handle: ResourceHandle
				// /// }
				// kDenseResourceElementsAttr = 16,
				//
				// /// DenseArrayAttr {
				// /// type: RankedTensorType,
				// /// data: blob
				// /// }
				// kDenseArrayAttr = 17,
				//
				// /// DenseIntOrFPElementsAttr {
				// /// type: ShapedType,
				// /// data: blob
				// /// }
				// kDenseIntOrFPElementsAttr = 18,
				//
				// /// DenseStringElementsAttr {
				// /// type: ShapedType,
				// /// isSplat: varint,
				// /// data: string[]
				// /// }
				// kDenseStringElementsAttr = 19,
				//
				// /// SparseElementsAttr {
				// /// type: ShapedType,
				// /// indices: DenseIntElementsAttr,
				// /// values: DenseElementsAttr
				// /// }
				// kSparseElementsAttr = 20,

				// Types
				// -----

				// enum TypeCode {
				// /// IntegerType {
				// /// widthAndSignedness: varint // (width << 2) \| (signedness)
				// /// }
				// ///
				// kIntegerType = 0,
				def IntegerType : BuiltinDialectType</enum=/0, (type
				// TODO: handle context constructors a bit nicer.
				Context:$mlirContext,

				// Yes not pretty,
				WithParser<"succeeded({0}.readVarInt({2}))",
				WithBuilder<"{1}",
				WithPrinter<"{0}.writeVarInt({1}.getWidth() << 2 \| {1}.getSignedness())",
				WithType <"uint64_t">>>>:$_widthAndSignedness,
				// Split up parsed varint for create method.
				LocalVar<"uint64_t", "_widthAndSignedness >> 2">:$width,
				LocalVar<"IntegerType::SignednessSemantics",
				"static_cast<IntegerType::SignednessSemantics>(_widthAndSignedness & 0x3)">:$signedness
				)>;

				//
				// /// IndexType {
				// /// }
				// ///
				// kIndexType = 1,
				def IndexType : BuiltinDialectType</enum=/1, (type)>;

				// /// FunctionType {
				// /// inputs: Type[],
				// /// results: Type[]
				// /// }
				// ///
				// kFunctionType = 2,
				def FunctionType : BuiltinDialectType</enum=/2, (type
				// TODO: handle context constructors a bit nicer.
				Context:$mlirContext,

				Array<Type>:$inputs,
				Array<Type>:$results
				)>;

				// /// BFloat16Type {
				// /// }
				// ///
				// kBFloat16Type = 3,
				def BFloat16Type : BuiltinDialectType</enum=/3, (type)>;

				// /// Float16Type {
				// /// }
				// ///
				// kFloat16Type = 4,
				def Float16Type : BuiltinDialectType</enum=/4, (type)>;

				// /// Float32Type {
				// /// }
				// ///
				// kFloat32Type = 5,
				def Float32Type : BuiltinDialectType</enum=/5, (type)>;

				// /// Float64Type {
				// /// }
				// ///
				// kFloat64Type = 6,
				def Float64Type : BuiltinDialectType</enum=/6, (type)>;

				// /// Float80Type {
				// /// }
				// ///
				// kFloat80Type = 7,
				def Float80Type : BuiltinDialectType</enum=/7, (type)>;

				// /// Float128Type {
				// /// }
				// ///
				// kFloat128Type = 8,
				def Float128Type : BuiltinDialectType</enum=/8, (type)>;

				// /// ComplexType {
				// /// elementType: Type
				// /// }
				// ///
				// kComplexType = 9,
				def ComplexType : BuiltinDialectType</enum=/9, (type
				Type:$elementType
				)>;

				// /// MemRefType {
				// /// shape: svarint[],
				// /// elementType: Type,
				// /// layout: Attribute
				// /// }
				// ///
				// kMemRefType = 10,
				//
				// /// MemRefTypeWithMemSpace {
				// /// memorySpace: Attribute,
				// /// shape: svarint[],
				// /// elementType: Type,
				// /// layout: Attribute
				// /// }
				// /// Variant of MemRefType with non-default memory space.
				// kMemRefTypeWithMemSpace = 11,
				//
				// /// NoneType {
				// /// }
				// ///
				// kNoneType = 12,
				def NoneType : BuiltinDialectType</enum=/12, (type)>;

				// /// RankedTensorType {
				// /// shape: svarint[],
				// /// elementType: Type,
				// /// }
				// ///
				// kRankedTensorType = 13,
				//
				// /// RankedTensorTypeWithEncoding {
				// /// encoding: Attribute,
				// /// shape: svarint[],
				// /// elementType: Type
				// /// }
				// /// Variant of RankedTensorType with an encoding.
				// kRankedTensorTypeWithEncoding = 14,
				//
				// /// TupleType {
				// /// elementTypes: Type[]
				// /// }
				// kTupleType = 15,
				def TupleType : BuiltinDialectType</enum=/15, (type
				// TODO: handle context constructors a bit nicer.
				Context:$mlirContext,

				Array<Type>:$types
				)>;

				// /// UnrankedMemRefType {
				// /// shape: svarint[]
				// /// }
				// ///
				// kUnrankedMemRefType = 16,
				//
				// /// UnrankedMemRefTypeWithMemSpace {
				// /// memorySpace: Attribute,
				// /// shape: svarint[]
				// /// }
				// /// Variant of UnrankedMemRefType with non-default memory space.
				// kUnrankedMemRefTypeWithMemSpace = 17,
				//
				// /// UnrankedTensorType {
				// /// elementType: Type
				// /// }
				// ///
				// kUnrankedTensorType = 18,
				def UnrankedTensorType : BuiltinDialectType</enum=/18, (type
				Type:$elementType
				)>;

				// /// VectorType {
				// /// shape: svarint[],
				// /// elementType: Type
				// /// }
				// ///
				// kVectorType = 19,
				//
				// /// VectorTypeWithScalableDims {
				// /// numScalableDims: varint,
				// /// shape: svarint[],
				// /// elementType: Type
				// /// }
				// /// Variant of VectorType with scalable dimensions.
				// kVectorTypeWithScalableDims = 20,

mlir/tools/mlir-dialect-bytecode-bootstrap/CMakeLists.txt

This file was added.

				set(LLVM_OPTIONAL_SOURCES
				BuiltinInc.cpp
				)

				add_executable(mlir-bc-tblgen
				mlir-bc-tblgen.cpp
				)
				set_target_properties(mlir-bc-tblgen PROPERTIES FOLDER "Tablegenning")
				target_link_libraries(mlir-bc-tblgen
				PRIVATE
				LLVMDemangle
				LLVMSupport
				LLVMTableGen
				MLIRSupportIndentedOstream
				)
				llvm_update_compile_flags(mlir-bc-tblgen)

mlir/tools/mlir-dialect-bytecode-bootstrap/README.md

This file was added.

				# Dialect bytecode parser bootstrap

				Simple tool to help in bootstrapping the dialect bytecode parsing definitions.
				It is not meant as a full "spec" but rather avoids writing boilerplate.

				It is meant to be retargetable to read/write into other forms and so most
				specialization should happen TableGen side. This is not there yet, currently
				there are hardcoded behavior C++ side that will be removed, but was able to
				switch this between different formats in roughly a day.

				This is a separate binary rather than linked in to mlir-tblgen as this is more a
				simple helper tool that can be copied/modified/retargeted than a core feature.

				This tool is not meant to be run as part of an automated build script.

mlir/tools/mlir-dialect-bytecode-bootstrap/mlir-bc-tblgen.cpp

This file was added.

				//===- mlir-bc-tblgen.cpp - TableGen helper for MLIR bytecode -------------===//
				//
				// 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 <filesystem>
				#include <string>

				#include "mlir/Support/IndentedOstream.h"
				#include "llvm/ADT/MapVector.h"
				#include "llvm/Support/CommandLine.h"
				#include "llvm/Support/FileSystem.h"
				#include "llvm/Support/FormatVariadic.h"
				#include "llvm/Support/InitLLVM.h"
				#include "llvm/Support/Signals.h"
				#include "llvm/Support/ToolOutputFile.h"
				#include "llvm/TableGen/Error.h"
				#include "llvm/TableGen/Main.h"
				#include "llvm/TableGen/Record.h"

				using namespace llvm;

				cl::opt<std::string> selectedDialect("dialect",
				llvm::cl::desc("The dialect to gen for"));

				const char *progName;

				static int reportError(Twine Msg) {
				errs() << progName << ": " << Msg;
				errs().flush();
				return 1;
				}

				// Helper class to generate C++ bytecode parser helpers.
				class Generator {
				public:
				Generator(StringRef dialectName) : dialectName(dialectName) {}

				// Returns whether successfully created output dirs/files.
				void init(const std::filesystem::path &mainFileRoot);

				// Returns whether successfully terminated output files.
				void fin(raw_ostream &os);

				// Returns whether successfully emitted attribute/type parsers.
				void emitParse(StringRef kind, Record &attr);

				// Returns whether successfully emitted attribute/type printers.
				void emitPrint(StringRef kind, StringRef type, ArrayRef<Record *> vec);

				// Emits parse dispatch table.
				void emitParseDispatch(StringRef kind, ArrayRef<Record *> vec);

				// Emits print dispatch table.
				void emitPrintDispatch(StringRef kind, ArrayRef<std::string> vec);

				private:
				// Emits parse calls to construct givin kind.
				void emitParseHelper(StringRef kind, StringRef returnType, StringRef builder,
				ArrayRef<Init *> args, ArrayRef<std::string> argNames,
				StringRef failure, mlir::raw_indented_ostream &ios);

				// Emits print instructions.
				void emitPrintHelper(Record *memberRec, StringRef kind, StringRef parent,
				StringRef name, mlir::raw_indented_ostream &ios);

				StringRef dialectName;
				std::string topStr, bottomStr;
				};

				void Generator::init(const std::filesystem::path &mainFileRoot) {
				// Generate top section.
				raw_string_ostream os(topStr);

				// Inject additional header include file.
				auto incHeaderFileName =
				mainFileRoot / formatv("{0}Inc.h", dialectName).str();
				if (std::filesystem::exists(incHeaderFileName)) {
				auto incFileOr =
				MemoryBuffer::getFile(incHeaderFileName.string(), /IsText=/true,
				/RequiresNullTerminator=/false);
				if (incFileOr) {
				os << incFileOr->get()->getBuffer() << "\n";
				} else {
				PrintFatalError("FAILURE: " + incFileOr.getError().message());
				}
				}
				}

				void Generator::fin(raw_ostream &os) {
				os << topStr << "\n" << StringRef(bottomStr).rtrim() << "\n";
				}

				static std::string capitalize(StringRef str) {
				return ((Twine)toUpper(str[0]) + str.drop_front()).str();
				}

				std::string getCType(Record *def) {
				std::string format = "{0}";
				if (def->isSubClassOf("Array")) {
				def = def->getValueAsDef("elemT");
				format = "SmallVector<{0}>";
				}

				StringRef cType = def->getValueAsString("cType");
				if (cType.empty()) {
				if (def->isAnonymous()) {
				PrintFatalError(def->getLoc(), "Unable to determine cType");
				}

				return formatv(format.c_str(), def->getName().str());
				}
				return formatv(format.c_str(), cType.str());
				}

				void Generator::emitParseDispatch(StringRef kind, ArrayRef<Record *> vec) {
				raw_string_ostream sos(bottomStr);
				mlir::raw_indented_ostream os(sos);
				char const *head =
				R"(static {0} read{0}(MLIRContext* context, DialectBytecodeReader &reader))";
				os << formatv(head, capitalize(kind));
				auto funScope = os.scope(" {\n", "}\n\n");

				os << "uint64_t kind;\n";
				os << "if (failed(reader.readVarInt(kind)))\n"
				<< " return " << capitalize(kind) << "();\n";
				os << "switch (kind) ";
				{
				auto switchScope = os.scope("{\n", "}\n");
				for (Record *it : vec) {
				os << formatv("case /* {0} */ {1}:\n return read{0}(context, reader);\n",
				it->getName(), it->getValueAsInt("enum"));
				}
				os << "default:\n"
				<< " reader.emitError() << \"unknown builtin attribute code: \" "
				<< "<< kind;\n"
				<< " return " << capitalize(kind) << "();\n";
				}
				os << "return " << capitalize(kind) << "();\n";
				}

				void Generator::emitParse(StringRef kind, Record &attr) {
				char const *head =
				R"(static {0} read{1}(MLIRContext* context, DialectBytecodeReader &reader) )";
				raw_string_ostream os(bottomStr);
				mlir::raw_indented_ostream ios(os);
				std::string returnType = getCType(&attr);
				ios << formatv(head, returnType, attr.getName());
				DagInit *members = attr.getValueAsDag("members");
				SmallVector<std::string> argNames =
				llvm::to_vector(map_range(members->getArgNames(), [](StringInit *init) {
				return init->getAsUnquotedString();
				}));
				StringRef builder = attr.getValueAsString("cBuilder");
				emitParseHelper(kind, returnType, builder, members->getArgs(), argNames,
				returnType + "()", ios);
				}

				void Generator::emitParseHelper(StringRef kind, StringRef returnType,
				StringRef builder, ArrayRef<Init *> args,
				ArrayRef<std::string> argNames,
				StringRef failure,
				mlir::raw_indented_ostream &ios) {
				auto funScope = ios.scope("{\n", "}\n\n");

				if (args.empty()) {
				ios << formatv("return {0}::get(context);\n", returnType);
				return;
				}

				// Print decls.
				std::string lastCType = "";
				for (auto [arg, name] : zip(args, argNames)) {
				DefInit *first = dyn_cast<DefInit>(arg);
				if (!first)
				PrintFatalError("Unexpected type for " + name);
				Record *def = first->getDef();

				std::string cType = getCType(def);
				if (lastCType == cType) {
				ios << ", ";
				} else {
				if (!lastCType.empty())
				ios << ";\n";
				ios << cType << " ";
				}
				ios << name;
				lastCType = cType;
				}
				ios << ";\n";

				auto listHelperName = [](StringRef name) {
				return formatv("read{0}", capitalize(name));
				};

				// Emit list helper functions.
				for (auto [arg, name] : zip(args, argNames)) {
				Record *attr = cast<DefInit>(arg)->getDef();
				if (!attr->isSubClassOf("Array"))
				continue;

				// TODO: Dedupe readers.
				Record *def = attr->getValueAsDef("elemT");
				if (!def->isSubClassOf("CompositeBytecode") &&
				(def->isSubClassOf("AttributeKind") \|\| def->isSubClassOf("TypeKind")))
				continue;

				std::string returnType = getCType(def);
				ios << "auto " << listHelperName(name) << " = [&]() -> FailureOr<"
				<< returnType << "> ";
				SmallVector<Init *> args;
				SmallVector<std::string> argNames;
				if (def->isSubClassOf("CompositeBytecode")) {
				DagInit *members = def->getValueAsDag("members");
				args = llvm::to_vector(members->getArgs());
				argNames = llvm::to_vector(
				map_range(members->getArgNames(), [](StringInit *init) {
				return init->getAsUnquotedString();
				}));
				} else {
				args = {def->getDefInit()};
				argNames = {"temp"};
				}
				StringRef builder = def->getValueAsString("cBuilder");
				emitParseHelper(kind, returnType, builder, args, argNames, "failure()",
				ios);
				ios << ";";
				}

				// Print parse conditional.
				{
				ios << "if ";
				auto parenScope = ios.scope("(", ") {");
				ios.indent();

				auto parsedArgs =
				llvm::to_vector(make_filter_range(args, [](Init *const attr) {
				Record *def = cast<DefInit>(attr)->getDef();
				if (def->isSubClassOf("Array"))
				return true;
				return !def->getValueAsString("cParser").empty();
				}));

				interleave(
				zip(parsedArgs, argNames),
				[&](std::tuple<llvm::Init *&, const std::string &> it) {
				Record *attr = cast<DefInit>(std::get<0>(it))->getDef();
				std::string parser;
				if (auto optParser = attr->getValueAsOptionalString("cParser")) {
				parser = *optParser;
				} else if (attr->isSubClassOf("Array")) {
				Record *def = attr->getValueAsDef("elemT");
				bool composite = def->isSubClassOf("CompositeBytecode");
				if (!composite && def->isSubClassOf("AttributeKind"))
				parser = "succeeded({0}.readAttributes({2}))";
				else if (!composite && def->isSubClassOf("TypeKind"))
				parser = "succeeded({0}.readTypes({2}))";
				else
				parser = ("succeeded({0}.readList({2}, " +
				listHelperName(std::get<1>(it)) + "))")
				.str();
				} else {
				PrintFatalError(attr->getLoc(), "No parser specified");
				}
				std::string type = getCType(attr);
				ios << formatv(parser.c_str(), "reader", type, std::get<1>(it));
				},
				[&]() { ios << " &&\n"; });
				}

				// Compute args to pass to create method.
				auto passedArgs = llvm::to_vector(make_filter_range(
				argNames, [](StringRef str) { return !str.starts_with("_"); }));
				std::string argStr;
				raw_string_ostream argStream(argStr);
				interleaveComma(passedArgs, argStream,
				[&](const std::string &str) { argStream << str; });
				// Return the invoked constructor.
				ios << "\nreturn "
				<< formatv(builder.str().c_str(), returnType, argStream.str()) << ";\n";
				ios.unindent();

				// TODO: Emit error in debug.
				// This assumes the result types in error case can always be empty
				// constructed. ios << "}\nreturn mlirBytecodeEmitError(\"invalid " <<
				// attr.getName()
				// << "\");\n";
				ios << "}\nreturn " << failure << ";\n";
				}

				void Generator::emitPrint(StringRef kind, StringRef type,
				ArrayRef<Record *> vec) {
				char const *head =
				R"(static void write({0} {1}, DialectBytecodeWriter &writer) )";
				raw_string_ostream os(bottomStr);
				mlir::raw_indented_ostream ios(os);
				ios << formatv(head, type, kind);
				auto funScope = ios.scope("{\n", "}\n\n");

				// Check that predicates specified if multiple bytecode instances.
				for (Record *rec : vec) {
				StringRef pred = rec->getValueAsString("printerPredicate");
				if (vec.size() > 1 && pred.empty()) {
				for (Record *rec : vec) {
				StringRef pred = rec->getValueAsString("printerPredicate");
				if (vec.size() > 1 && pred.empty())
				PrintError(rec->getLoc(),
				"Requires parsing predicate given common cType");
				}
				PrintFatalError("Unspecified for shared cType " + type);
				}
				}

				for (Record *rec : vec) {
				StringRef pred = rec->getValueAsString("printerPredicate");
				if (!pred.empty()) {
				ios << "if (" << formatv(pred.str().c_str(), kind) << ") {\n";
				ios.indent();
				}

				ios << "writer.writeVarInt(/* " << rec->getName() << " */ "
				<< rec->getValueAsInt("enum") << ");\n";

				DagInit *members = rec->getValueAsDag("members");
				for (auto [arg, name] :
				llvm::zip(members->getArgs(), members->getArgNames())) {
				DefInit *def = dyn_cast<DefInit>(arg);
				assert(def);
				Record *memberRec = def->getDef();
				emitPrintHelper(memberRec, kind, kind, name->getAsUnquotedString(), ios);
				}

				if (!pred.empty()) {
				ios.unindent();
				ios << "}\n";
				}
				}
				}

				void Generator::emitPrintHelper(Record *memberRec, StringRef kind,
				StringRef parent, StringRef name,
				mlir::raw_indented_ostream &ios) {
				std::string getter;
				if (auto cGetter = memberRec->getValueAsOptionalString("cGetter");
				cGetter && !cGetter->empty()) {
				getter = formatv(cGetter->str().c_str(), parent,
				"get" + convertToCamelFromSnakeCase(name, true));
				} else {
				getter =
				formatv("{0}.get{1}()", parent, convertToCamelFromSnakeCase(name, true))
				.str();
				}

				if (memberRec->isSubClassOf("Array")) {
				Record *def = memberRec->getValueAsDef("elemT");
				if (!def->isSubClassOf("CompositeBytecode")) {
				if (def->isSubClassOf("AttributeKind")) {
				ios << "writer.writeAttributes(" << getter << ");\n";
				return;
				}
				if (def->isSubClassOf("TypeKind")) {
				ios << "writer.writeTypes(" << getter << ");\n";
				return;
				}
				}
				std::string returnType = getCType(def);
				ios << "writer.writeList(" << getter << ", [&](" << returnType << " "
				<< kind << ") ";
				auto lambdaScope = ios.scope("{\n", "});\n");
				return emitPrintHelper(def, kind, kind, kind, ios);
				}
				if (memberRec->isSubClassOf("CompositeBytecode")) {
				DagInit *members = memberRec->getValueAsDag("members");
				for (auto [arg, argName] :
				zip(members->getArgs(), members->getArgNames())) {
				DefInit *def = dyn_cast<DefInit>(arg);
				assert(def);
				emitPrintHelper(def->getDef(), kind, parent,
				argName->getAsUnquotedString(), ios);
				}
				}

				if (std::string printer = memberRec->getValueAsString("cPrinter").str();
				!printer.empty())
				ios << formatv(printer.c_str(), "writer", kind, getter) << ";\n";
				}

				void Generator::emitPrintDispatch(StringRef kind, ArrayRef<std::string> vec) {
				raw_string_ostream sos(bottomStr);
				mlir::raw_indented_ostream os(sos);
				char const *head = R"(static LogicalResult write{0}({0} {1},
				DialectBytecodeWriter &writer))";
				os << formatv(head, capitalize(kind), kind);
				auto funScope = os.scope(" {\n", "}\n\n");

				os << "return TypeSwitch<" << capitalize(kind) << ", LogicalResult>(" << kind
				<< ")";
				auto switchScope = os.scope("", "");
				for (StringRef type : vec) {
				os << "\n.Case([&](" << type << " t)";
				auto caseScope = os.scope(" {\n", "})");
				os << "return write(t, writer), success();\n";
				}
				os << "\n.Default([&](" << capitalize(kind) << ") { return failure(); });\n";
				}

				struct AttrOrType {
				std::vector<Record *> attr, type;
				};

				static bool tableGenMain(raw_ostream &os, RecordKeeper &records) {
				MapVector<StringRef, AttrOrType> dialectAttrOrType;
				Record *attr = records.getClass("DialectAttribute");
				Record *type = records.getClass("DialectType");
				for (auto &it : records.getAllDerivedDefinitions("DialectAttrOrType")) {
				if (!selectedDialect.empty() &&
				it->getValueAsString("dialect") != selectedDialect)
				continue;

				if (it->isSubClassOf(attr)) {
				dialectAttrOrType[it->getValueAsString("dialect")].attr.push_back(it);
				} else if (it->isSubClassOf(type)) {
				dialectAttrOrType[it->getValueAsString("dialect")].type.push_back(it);
				}
				}

				if (dialectAttrOrType.size() != 1)
				return reportError("Single dialect per invocation required (either only "
				"one in input file or specified via dialect option)");

				// Compare two records by enum value.
				auto compEnum = [](Record lhs, Record rhs) -> int {
				return lhs->getValueAsInt("enum") < rhs->getValueAsInt("enum");
				};

				auto mainFile =
				std::filesystem::path(records.getInputFilename()).remove_filename();

				auto it = dialectAttrOrType.front();
				Generator gen(it.first);
				gen.init(mainFile);

				SmallVector<std::vector<Record > , 2> vecs;
				SmallVector<std::string, 2> kinds;
				vecs.push_back(&it.second.attr);
				kinds.push_back("attribute");
				vecs.push_back(&it.second.type);
				kinds.push_back("type");
				for (auto [vec, kind] : zip(vecs, kinds)) {
				// Handle Attribute emission.
				std::sort(vec->begin(), vec->end(), compEnum);
				std::map<std::string, std::vector<Record *>> perType;
				for (auto kt : vec)
				perType[getCType(kt)].push_back(kt);
				for (const auto &jt : perType) {
				for (auto *kt : jt.second)
				gen.emitParse(kind, *kt);
				gen.emitPrint(kind, jt.first, jt.second);
				}
				gen.emitParseDispatch(kind, *vec);

				SmallVector<std::string> types;
				for (const auto &it : perType) {
				types.push_back(it.first);
				}
				gen.emitPrintDispatch(kind, types);
				}
				gen.fin(os);

				return false;
				}

				int main(int argc, char **argv) {
				llvm::InitLLVM y(argc, argv);

				cl::ParseCommandLineOptions(argc, argv);
				progName = argv[0];

				return TableGenMain(argv[0], &tableGenMain);
				}

This is an archive of the discontinued LLVM Phabricator instance.

[mlir] Dialect type/attr bytecode read/write generator.
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 500515

mlir/test/CMakeLists.txt

mlir/tools/CMakeLists.txt

mlir/tools/mlir-dialect-bytecode-bootstrap/BuiltinInc.h

mlir/tools/mlir-dialect-bytecode-bootstrap/BytecodeAttrType.td

mlir/tools/mlir-dialect-bytecode-bootstrap/CMakeLists.txt

mlir/tools/mlir-dialect-bytecode-bootstrap/README.md

mlir/tools/mlir-dialect-bytecode-bootstrap/mlir-bc-tblgen.cpp

This is an archive of the discontinued LLVM Phabricator instance.

[mlir] Dialect type/attr bytecode read/write generator.ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 500515

mlir/test/CMakeLists.txt

mlir/tools/CMakeLists.txt

mlir/tools/mlir-dialect-bytecode-bootstrap/BuiltinInc.h

mlir/tools/mlir-dialect-bytecode-bootstrap/BytecodeAttrType.td

mlir/tools/mlir-dialect-bytecode-bootstrap/CMakeLists.txt

mlir/tools/mlir-dialect-bytecode-bootstrap/README.md

mlir/tools/mlir-dialect-bytecode-bootstrap/mlir-bc-tblgen.cpp

[mlir] Dialect type/attr bytecode read/write generator.
ClosedPublic