//===- SPIRVSerializationGen.cpp - SPIR-V serialization utility generator -===// // // 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 // //===----------------------------------------------------------------------===// // // SPIRVSerializationGen generates common utility functions for SPIR-V // serialization. // //===----------------------------------------------------------------------===// #include "mlir/TableGen/Attribute.h" #include "mlir/TableGen/CodeGenHelpers.h" #include "mlir/TableGen/Format.h" #include "mlir/TableGen/GenInfo.h" #include "mlir/TableGen/Operator.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/Sequence.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringSet.h" #include "llvm/Support/FormatVariadic.h" #include "llvm/Support/raw_ostream.h" #include "llvm/TableGen/Error.h" #include "llvm/TableGen/Record.h" #include "llvm/TableGen/TableGenBackend.h" #include <list> #include <optional> ArrayRef; formatv; raw_ostream; raw_string_ostream; Record; RecordKeeper; SmallVector; SMLoc; StringMap; StringRef; Attribute; EnumAttr; EnumAttrCase; NamedAttribute; NamedTypeConstraint; NamespaceEmitter; Operator; //===----------------------------------------------------------------------===// // Availability Wrapper Class //===----------------------------------------------------------------------===// namespace { // Wrapper class with helper methods for accessing availability defined in // TableGen. class Availability { … }; } // namespace Availability::Availability(const llvm::Record *def) : … { … } StringRef Availability::getClass() const { … } StringRef Availability::getInterfaceClassNamespace() const { … } StringRef Availability::getInterfaceClassName() const { … } StringRef Availability::getInterfaceDescription() const { … } StringRef Availability::getQueryFnRetType() const { … } StringRef Availability::getQueryFnName() const { … } StringRef Availability::getMergeActionCode() const { … } StringRef Availability::getMergeInitializer() const { … } StringRef Availability::getMergeInstanceType() const { … } StringRef Availability::getMergeInstancePreparation() const { … } StringRef Availability::getMergeInstance() const { … } // Returns the availability spec of the given `def`. std::vector<Availability> getAvailabilities(const Record &def) { … } //===----------------------------------------------------------------------===// // Availability Interface Definitions AutoGen //===----------------------------------------------------------------------===// static void emitInterfaceDef(const Availability &availability, raw_ostream &os) { … } static bool emitInterfaceDefs(const RecordKeeper &recordKeeper, raw_ostream &os) { … } //===----------------------------------------------------------------------===// // Availability Interface Declarations AutoGen //===----------------------------------------------------------------------===// static void emitConceptDecl(const Availability &availability, raw_ostream &os) { … } static void emitModelDecl(const Availability &availability, raw_ostream &os) { … } static void emitInterfaceDecl(const Availability &availability, raw_ostream &os) { … } static bool emitInterfaceDecls(const RecordKeeper &recordKeeper, raw_ostream &os) { … } //===----------------------------------------------------------------------===// // Availability Interface Hook Registration //===----------------------------------------------------------------------===// // Registers the operation interface generator to mlir-tblgen. static mlir::GenRegistration genInterfaceDecls("gen-avail-interface-decls", "Generate availability interface declarations", [](const RecordKeeper &records, raw_ostream &os) { … }); // Registers the operation interface generator to mlir-tblgen. static mlir::GenRegistration genInterfaceDefs("gen-avail-interface-defs", "Generate op interface definitions", [](const RecordKeeper &records, raw_ostream &os) { … }); //===----------------------------------------------------------------------===// // Enum Availability Query AutoGen //===----------------------------------------------------------------------===// static void emitAvailabilityQueryForIntEnum(const Record &enumDef, raw_ostream &os) { … } static void emitAvailabilityQueryForBitEnum(const Record &enumDef, raw_ostream &os) { … } static void emitEnumDecl(const Record &enumDef, raw_ostream &os) { … } static bool emitEnumDecls(const RecordKeeper &recordKeeper, raw_ostream &os) { … } static void emitEnumDef(const Record &enumDef, raw_ostream &os) { … } static bool emitEnumDefs(const RecordKeeper &recordKeeper, raw_ostream &os) { … } //===----------------------------------------------------------------------===// // Enum Availability Query Hook Registration //===----------------------------------------------------------------------===// // Registers the enum utility generator to mlir-tblgen. static mlir::GenRegistration genEnumDecls("gen-spirv-enum-avail-decls", "Generate SPIR-V enum availability declarations", [](const RecordKeeper &records, raw_ostream &os) { … }); // Registers the enum utility generator to mlir-tblgen. static mlir::GenRegistration genEnumDefs("gen-spirv-enum-avail-defs", "Generate SPIR-V enum availability definitions", [](const RecordKeeper &records, raw_ostream &os) { … }); //===----------------------------------------------------------------------===// // Serialization AutoGen //===----------------------------------------------------------------------===// // These enums are encoded as <id> to constant values in SPIR-V blob, but we // directly use the constant value as attribute in SPIR-V dialect. So need // to handle them separately from normal enum attributes. constexpr llvm::StringLiteral constantIdEnumAttrs[] = …; /// Generates code to serialize attributes of a SPIRV_Op `op` into `os`. The /// generates code extracts the attribute with name `attrName` from /// `operandList` of `op`. static void emitAttributeSerialization(const Attribute &attr, ArrayRef<SMLoc> loc, StringRef tabs, StringRef opVar, StringRef operandList, StringRef attrName, raw_ostream &os) { … } /// Generates code to serialize the operands of a SPIRV_Op `op` into `os`. The /// generated queries the SSA-ID if operand is a SSA-Value, or serializes the /// attributes. The `operands` vector is updated appropriately. `elidedAttrs` /// updated as well to include the serialized attributes. static void emitArgumentSerialization(const Operator &op, ArrayRef<SMLoc> loc, StringRef tabs, StringRef opVar, StringRef operands, StringRef elidedAttrs, raw_ostream &os) { … } /// Generates code to serializes the result of SPIRV_Op `op` into `os`. The /// generated gets the ID for the type of the result (if any), the SSA-ID of /// the result and updates `resultID` with the SSA-ID. static void emitResultSerialization(const Operator &op, ArrayRef<SMLoc> loc, StringRef tabs, StringRef opVar, StringRef operands, StringRef resultID, raw_ostream &os) { … } /// Generates code to serialize attributes of SPIRV_Op `op` that become /// decorations on the `resultID` of the serialized operation `opVar` in the /// SPIR-V binary. static void emitDecorationSerialization(const Operator &op, StringRef tabs, StringRef opVar, StringRef elidedAttrs, StringRef resultID, raw_ostream &os) { … } /// Generates code to serialize an SPIRV_Op `op` into `os`. static void emitSerializationFunction(const Record *attrClass, const Record *record, const Operator &op, raw_ostream &os) { … } /// Generates the prologue for the function that dispatches the serialization of /// the operation `opVar` based on its opcode. static void initDispatchSerializationFn(StringRef opVar, raw_ostream &os) { … } /// Generates the body of the dispatch function. This function generates the /// check that if satisfied, will call the serialization function generated for /// the `op`. static void emitSerializationDispatch(const Operator &op, StringRef tabs, StringRef opVar, raw_ostream &os) { … } /// Generates the epilogue for the function that dispatches the serialization of /// the operation. static void finalizeDispatchSerializationFn(StringRef opVar, raw_ostream &os) { … } /// Generates code to deserialize the attribute of a SPIRV_Op into `os`. The /// generated code reads the `words` of the serialized instruction at /// position `wordIndex` and adds the deserialized attribute into `attrList`. static void emitAttributeDeserialization(const Attribute &attr, ArrayRef<SMLoc> loc, StringRef tabs, StringRef attrList, StringRef attrName, StringRef words, StringRef wordIndex, raw_ostream &os) { … } /// Generates the code to deserialize the result of an SPIRV_Op `op` into /// `os`. The generated code gets the type of the result specified at /// `words`[`wordIndex`], the SSA ID for the result at position `wordIndex` + 1 /// and updates the `resultType` and `valueID` with the parsed type and SSA ID, /// respectively. static void emitResultDeserialization(const Operator &op, ArrayRef<SMLoc> loc, StringRef tabs, StringRef words, StringRef wordIndex, StringRef resultTypes, StringRef valueID, raw_ostream &os) { … } /// Generates the code to deserialize the operands of an SPIRV_Op `op` into /// `os`. The generated code reads the `words` of the binary instruction, from /// position `wordIndex` to the end, and either gets the Value corresponding to /// the ID encoded, or deserializes the attributes encoded. The parsed /// operand(attribute) is added to the `operands` list or `attributes` list. static void emitOperandDeserialization(const Operator &op, ArrayRef<SMLoc> loc, StringRef tabs, StringRef words, StringRef wordIndex, StringRef operands, StringRef attributes, raw_ostream &os) { … } /// Generates code to update the `attributes` vector with the attributes /// obtained from parsing the decorations in the SPIR-V binary associated with /// an <id> `valueID` static void emitDecorationDeserialization(const Operator &op, StringRef tabs, StringRef valueID, StringRef attributes, raw_ostream &os) { … } /// Generates code to deserialize an SPIRV_Op `op` into `os`. static void emitDeserializationFunction(const Record *attrClass, const Record *record, const Operator &op, raw_ostream &os) { … } /// Generates the prologue for the function that dispatches the deserialization /// based on the `opcode`. static void initDispatchDeserializationFn(StringRef opcode, StringRef words, raw_ostream &os) { … } /// Generates the body of the dispatch function, by generating the case label /// for an opcode and the call to the method to perform the deserialization. static void emitDeserializationDispatch(const Operator &op, const Record *def, StringRef tabs, StringRef words, raw_ostream &os) { … } /// Generates the epilogue for the function that dispatches the deserialization /// of the operation. static void finalizeDispatchDeserializationFn(StringRef opcode, raw_ostream &os) { … } static void initExtendedSetDeserializationDispatch(StringRef extensionSetName, StringRef instructionID, StringRef words, raw_ostream &os) { … } static void emitExtendedSetDeserializationDispatch(const RecordKeeper &recordKeeper, raw_ostream &os) { … } /// Emits all the autogenerated serialization/deserializations functions for the /// SPIRV_Ops. static bool emitSerializationFns(const RecordKeeper &recordKeeper, raw_ostream &os) { … } //===----------------------------------------------------------------------===// // Serialization Hook Registration //===----------------------------------------------------------------------===// static mlir::GenRegistration genSerialization( "gen-spirv-serialization", "Generate SPIR-V (de)serialization utilities and functions", [](const RecordKeeper &records, raw_ostream &os) { … }); //===----------------------------------------------------------------------===// // Op Utils AutoGen //===----------------------------------------------------------------------===// static void emitEnumGetAttrNameFnDecl(raw_ostream &os) { … } static void emitEnumGetAttrNameFnDefn(const EnumAttr &enumAttr, raw_ostream &os) { … } static bool emitAttrUtils(const RecordKeeper &recordKeeper, raw_ostream &os) { … } //===----------------------------------------------------------------------===// // Op Utils Hook Registration //===----------------------------------------------------------------------===// static mlir::GenRegistration genOpUtils("gen-spirv-attr-utils", "Generate SPIR-V attribute utility definitions", [](const RecordKeeper &records, raw_ostream &os) { … }); //===----------------------------------------------------------------------===// // SPIR-V Availability Impl AutoGen //===----------------------------------------------------------------------===// static void emitAvailabilityImpl(const Operator &srcOp, raw_ostream &os) { … } static bool emitAvailabilityImpl(const RecordKeeper &recordKeeper, raw_ostream &os) { … } //===----------------------------------------------------------------------===// // Op Availability Implementation Hook Registration //===----------------------------------------------------------------------===// static mlir::GenRegistration genOpAvailabilityImpl("gen-spirv-avail-impls", "Generate SPIR-V operation utility definitions", [](const RecordKeeper &records, raw_ostream &os) { … }); //===----------------------------------------------------------------------===// // SPIR-V Capability Implication AutoGen //===----------------------------------------------------------------------===// static bool emitCapabilityImplication(const RecordKeeper &recordKeeper, raw_ostream &os) { … } //===----------------------------------------------------------------------===// // SPIR-V Capability Implication Hook Registration //===----------------------------------------------------------------------===// static mlir::GenRegistration genCapabilityImplication("gen-spirv-capability-implication", "Generate utility function to return implied " "capabilities for a given capability", [](const RecordKeeper &records, raw_ostream &os) { … });
Codebase Browser
llvm