//===- OpDefinitionsGen.cpp - MLIR op definitions 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 // //===----------------------------------------------------------------------===// // // OpDefinitionsGen uses the description of operations to generate C++ // definitions for ops. // //===----------------------------------------------------------------------===// #include "OpClass.h" #include "OpFormatGen.h" #include "OpGenHelpers.h" #include "mlir/TableGen/Argument.h" #include "mlir/TableGen/Attribute.h" #include "mlir/TableGen/Class.h" #include "mlir/TableGen/CodeGenHelpers.h" #include "mlir/TableGen/Format.h" #include "mlir/TableGen/GenInfo.h" #include "mlir/TableGen/Interfaces.h" #include "mlir/TableGen/Operator.h" #include "mlir/TableGen/Property.h" #include "mlir/TableGen/SideEffects.h" #include "mlir/TableGen/Trait.h" #include "llvm/ADT/BitVector.h" #include "llvm/ADT/MapVector.h" #include "llvm/ADT/Sequence.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringSet.h" #include "llvm/Support/Debug.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/Signals.h" #include "llvm/Support/raw_ostream.h" #include "llvm/TableGen/Error.h" #include "llvm/TableGen/Record.h" #include "llvm/TableGen/TableGenBackend.h" #define DEBUG_TYPE … usingnamespacellvm; usingnamespacemlir; usingnamespacemlir::tblgen; static const char *const tblgenNamePrefix = …; static const char *const generatedArgName = …; static const char *const odsBuilder = …; static const char *const builderOpState = …; static const char *const propertyStorage = …; static const char *const propertyValue = …; static const char *const propertyAttr = …; static const char *const propertyDiag = …; /// The names of the implicit attributes that contain variadic operand and /// result segment sizes. static const char *const operandSegmentAttrName = …; static const char *const resultSegmentAttrName = …; /// Code for an Op to lookup an attribute. Uses cached identifiers and subrange /// lookup. /// /// {0}: Code snippet to get the attribute's name or identifier. /// {1}: The lower bound on the sorted subrange. /// {2}: The upper bound on the sorted subrange. /// {3}: Code snippet to get the array of named attributes. /// {4}: "Named" to get the named attribute. static const char *const subrangeGetAttr = …; /// The logic to calculate the actual value range for a declared operand/result /// of an op with variadic operands/results. Note that this logic is not for /// general use; it assumes all variadic operands/results must have the same /// number of values. /// /// {0}: The list of whether each declared operand/result is variadic. /// {1}: The total number of non-variadic operands/results. /// {2}: The total number of variadic operands/results. /// {3}: The total number of actual values. /// {4}: "operand" or "result". static const char *const sameVariadicSizeValueRangeCalcCode = …; /// The logic to calculate the actual value range for a declared operand/result /// of an op with variadic operands/results. Note that this logic is assumes /// the op has an attribute specifying the size of each operand/result segment /// (variadic or not). static const char *const attrSizedSegmentValueRangeCalcCode = …; /// The code snippet to initialize the sizes for the value range calculation. /// /// {0}: The code to get the attribute. static const char *const adapterSegmentSizeAttrInitCode = …; static const char *const adapterSegmentSizeAttrInitCodeProperties = …; /// The code snippet to initialize the sizes for the value range calculation. /// /// {0}: The code to get the attribute. static const char *const opSegmentSizeAttrInitCode = …; /// The logic to calculate the actual value range for a declared operand /// of an op with variadic of variadic operands within the OpAdaptor. /// /// {0}: The name of the segment attribute. /// {1}: The index of the main operand. /// {2}: The range type of adaptor. static const char *const variadicOfVariadicAdaptorCalcCode = …; /// The logic to build a range of either operand or result values. /// /// {0}: The begin iterator of the actual values. /// {1}: The call to generate the start and length of the value range. static const char *const valueRangeReturnCode = …; /// Parse operand/result segment_size property. /// {0}: Number of elements in the segment array static const char *const parseTextualSegmentSizeFormat = …; static const char *const printTextualSegmentSize = …; /// Read operand/result segment_size from bytecode. static const char *const readBytecodeSegmentSizeNative = …; static const char *const readBytecodeSegmentSizeLegacy = …; /// Write operand/result segment_size to bytecode. static const char *const writeBytecodeSegmentSizeNative = …; /// Write operand/result segment_size to bytecode. static const char *const writeBytecodeSegmentSizeLegacy = …; /// A header for indicating code sections. /// /// {0}: Some text, or a class name. /// {1}: Some text. static const char *const opCommentHeader = …; //===----------------------------------------------------------------------===// // Utility structs and functions //===----------------------------------------------------------------------===// // Replaces all occurrences of `match` in `str` with `substitute`. static std::string replaceAllSubstrs(std::string str, const std::string &match, const std::string &substitute) { … } // Returns whether the record has a value of the given name that can be returned // via getValueAsString. static inline bool hasStringAttribute(const Record &record, StringRef fieldName) { … } static std::string getArgumentName(const Operator &op, int index) { … } // Returns true if we can use unwrapped value for the given `attr` in builders. static bool canUseUnwrappedRawValue(const tblgen::Attribute &attr) { … } /// Build an attribute from a parameter value using the constant builder. static std::string constBuildAttrFromParam(const tblgen::Attribute &attr, FmtContext &fctx, StringRef paramName) { … } namespace { /// Metadata on a registered attribute. Given that attributes are stored in /// sorted order on operations, we can use information from ODS to deduce the /// number of required attributes less and and greater than each attribute, /// allowing us to search only a subrange of the attributes in ODS-generated /// getters. struct AttributeMetadata { … }; /// Helper class to select between OpAdaptor and Op code templates. class OpOrAdaptorHelper { … }; } // namespace void OpOrAdaptorHelper::computeAttrMetadata() { … } //===----------------------------------------------------------------------===// // Op emitter //===----------------------------------------------------------------------===// namespace { // Helper class to emit a record into the given output stream. class OpEmitter { … }; } // namespace // Populate the format context `ctx` with substitutions of attributes, operands // and results. static void populateSubstitutions(const OpOrAdaptorHelper &emitHelper, FmtContext &ctx) { … } /// Generate verification on native traits requiring attributes. static void genNativeTraitAttrVerifier(MethodBody &body, const OpOrAdaptorHelper &emitHelper) { … } // Return true if a verifier can be emitted for the attribute: it is not a // derived attribute, it has a predicate, its condition is not empty, and, for // adaptors, the condition does not reference the op. static bool canEmitAttrVerifier(Attribute attr, bool isEmittingForOp) { … } // Generate attribute verification. If an op instance is not available, then // attribute checks that require one will not be emitted. // // Attribute verification is performed as follows: // // 1. Verify that all required attributes are present in sorted order. This // ensures that we can use subrange lookup even with potentially missing // attributes. // 2. Verify native trait attributes so that other attributes may call methods // that depend on the validity of these attributes, e.g. segment size attributes // and operand or result getters. // 3. Verify the constraints on all present attributes. static void genAttributeVerifier(const OpOrAdaptorHelper &emitHelper, FmtContext &ctx, MethodBody &body, const StaticVerifierFunctionEmitter &staticVerifierEmitter, bool useProperties) { … } /// Include declarations specified on NativeTrait static std::string formatExtraDeclarations(const Operator &op) { … } /// Op extra class definitions have a `$cppClass` substitution that is to be /// replaced by the C++ class name. /// Include declarations specified on NativeTrait static std::string formatExtraDefinitions(const Operator &op) { … } OpEmitter::OpEmitter(const Operator &op, const StaticVerifierFunctionEmitter &staticVerifierEmitter) : … { … } void OpEmitter::emitDecl( const Operator &op, raw_ostream &os, const StaticVerifierFunctionEmitter &staticVerifierEmitter) { … } void OpEmitter::emitDef( const Operator &op, raw_ostream &os, const StaticVerifierFunctionEmitter &staticVerifierEmitter) { … } void OpEmitter::emitDecl(raw_ostream &os) { … } void OpEmitter::emitDef(raw_ostream &os) { … } static void errorIfPruned(size_t line, Method *m, const Twine &methodName, const Operator &op) { … } #define ERROR_IF_PRUNED(M, N, O) … void OpEmitter::genAttrNameGetters() { … } // Emit the getter for a named property. // It is templated to be shared between the Op and the adaptor class. template <typename OpClassOrAdaptor> static void emitPropGetter(OpClassOrAdaptor &opClass, const Operator &op, StringRef name, const Property &prop) { … } // Emit the getter for an attribute with the return type specified. // It is templated to be shared between the Op and the adaptor class. template <typename OpClassOrAdaptor> static void emitAttrGetterWithReturnType(FmtContext &fctx, OpClassOrAdaptor &opClass, const Operator &op, StringRef name, Attribute attr) { … } void OpEmitter::genPropertiesSupport() { … } void OpEmitter::genPropertiesSupportForBytecode( ArrayRef<ConstArgument> attrOrProperties) { … } void OpEmitter::genPropGetters() { … } void OpEmitter::genPropSetters() { … } void OpEmitter::genAttrGetters() { … } void OpEmitter::genAttrSetters() { … } void OpEmitter::genOptionalAttrRemovers() { … } // Generates the code to compute the start and end index of an operand or result // range. template <typename RangeT> static void generateValueRangeStartAndEnd( Class &opClass, bool isGenericAdaptorBase, StringRef methodName, int numVariadic, int numNonVariadic, StringRef rangeSizeCall, bool hasAttrSegmentSize, StringRef sizeAttrInit, RangeT &&odsValues) { … } static std::string generateTypeForGetter(const NamedTypeConstraint &value) { … } // Generates the named operand getter methods for the given Operator `op` and // puts them in `opClass`. Uses `rangeType` as the return type of getters that // return a range of operands (individual operands are `Value ` and each // element in the range must also be `Value `); use `rangeBeginCall` to get // an iterator to the beginning of the operand range; use `rangeSizeCall` to // obtain the number of operands. `getOperandCallPattern` contains the code // necessary to obtain a single operand whose position will be substituted // instead of // "{0}" marker in the pattern. Note that the pattern should work for any kind // of ops, in particular for one-operand ops that may not have the // `getOperand(unsigned)` method. static void generateNamedOperandGetters(const Operator &op, Class &opClass, Class *genericAdaptorBase, StringRef sizeAttrInit, StringRef rangeType, StringRef rangeElementType, StringRef rangeBeginCall, StringRef rangeSizeCall, StringRef getOperandCallPattern) { … } void OpEmitter::genNamedOperandGetters() { … } void OpEmitter::genNamedOperandSetters() { … } void OpEmitter::genNamedResultGetters() { … } void OpEmitter::genNamedRegionGetters() { … } void OpEmitter::genNamedSuccessorGetters() { … } static bool canGenerateUnwrappedBuilder(const Operator &op) { … } static bool canInferType(const Operator &op) { … } void OpEmitter::genSeparateArgParamBuilder() { … } void OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() { … } void OpEmitter::genPopulateDefaultAttributes() { … } void OpEmitter::genInferredTypeCollectiveParamBuilder() { … } void OpEmitter::genUseOperandAsResultTypeSeparateParamBuilder() { … } void OpEmitter::genUseAttrAsResultTypeBuilder() { … } /// Returns a signature of the builder. Updates the context `fctx` to enable /// replacement of $_builder and $_state in the body. static SmallVector<MethodParameter> getBuilderSignature(const Builder &builder) { … } void OpEmitter::genBuilder() { … } void OpEmitter::genCollectiveParamBuilder() { … } void OpEmitter::buildParamList(SmallVectorImpl<MethodParameter> ¶mList, llvm::StringSet<> &inferredAttributes, SmallVectorImpl<std::string> &resultTypeNames, TypeParamKind typeParamKind, AttrParamKind attrParamKind) { … } void OpEmitter::genCodeForAddingArgAndRegionForBuilder( MethodBody &body, llvm::StringSet<> &inferredAttributes, bool isRawValueAttr) { … } void OpEmitter::genCanonicalizerDecls() { … } void OpEmitter::genFolderDecls() { … } void OpEmitter::genOpInterfaceMethods(const tblgen::InterfaceTrait *opTrait) { … } Method *OpEmitter::genOpInterfaceMethod(const InterfaceMethod &method, bool declaration) { … } void OpEmitter::genOpInterfaceMethods() { … } void OpEmitter::genSideEffectInterfaceMethods() { … } void OpEmitter::genTypeInterfaceMethods() { … } void OpEmitter::genParser() { … } void OpEmitter::genPrinter() { … } void OpEmitter::genVerifier() { … } void OpEmitter::genCustomVerifier() { … } void OpEmitter::genOperandResultVerifier(MethodBody &body, Operator::const_value_range values, StringRef valueKind) { … } void OpEmitter::genRegionVerifier(MethodBody &body) { … } void OpEmitter::genSuccessorVerifier(MethodBody &body) { … } /// Add a size count trait to the given operation class. static void addSizeCountTrait(OpClass &opClass, StringRef traitKind, int numTotal, int numVariadic) { … } void OpEmitter::genTraits() { … } void OpEmitter::genOpNameGetter() { … } void OpEmitter::genOpAsmInterface() { … } //===----------------------------------------------------------------------===// // OpOperandAdaptor emitter //===----------------------------------------------------------------------===// namespace { // Helper class to emit Op operand adaptors to an output stream. Operand // adaptors are wrappers around random access ranges that provide named operand // getters identical to those defined in the Op. // This currently generates 3 classes per Op: // * A Base class within the 'detail' namespace, which contains all logic and // members independent of the random access range that is indexed into. // In other words, it contains all the attribute and region getters. // * A templated class named '{OpName}GenericAdaptor' with a template parameter // 'RangeT' that is indexed into by the getters to access the operands. // It contains all getters to access operands and inherits from the previous // class. // * A class named '{OpName}Adaptor', which inherits from the 'GenericAdaptor' // with 'mlir::ValueRange' as template parameter. It adds a constructor from // an instance of the op type and a verify function. class OpOperandAdaptorEmitter { … }; } // namespace OpOperandAdaptorEmitter::OpOperandAdaptorEmitter( const Operator &op, const StaticVerifierFunctionEmitter &staticVerifierEmitter) : … { … } void OpOperandAdaptorEmitter::addVerification() { … } void OpOperandAdaptorEmitter::emitDecl( const Operator &op, const StaticVerifierFunctionEmitter &staticVerifierEmitter, raw_ostream &os) { … } void OpOperandAdaptorEmitter::emitDef( const Operator &op, const StaticVerifierFunctionEmitter &staticVerifierEmitter, raw_ostream &os) { … } /// Emit the class declarations or definitions for the given op defs. static void emitOpClasses(const RecordKeeper &recordKeeper, const std::vector<const Record *> &defs, raw_ostream &os, const StaticVerifierFunctionEmitter &staticVerifierEmitter, bool emitDecl) { … } /// Emit the declarations for the provided op classes. static void emitOpClassDecls(const RecordKeeper &recordKeeper, const std::vector<const Record *> &defs, raw_ostream &os) { … } /// Emit the definitions for the provided op classes. static void emitOpClassDefs(const RecordKeeper &recordKeeper, ArrayRef<const Record *> defs, raw_ostream &os, StringRef constraintPrefix = "") { … } /// Emit op declarations for all op records. static bool emitOpDecls(const RecordKeeper &recordKeeper, raw_ostream &os) { … } /// Generate the dialect op registration hook and the op class definitions for a /// shard of ops. static void emitOpDefShard(const RecordKeeper &recordKeeper, ArrayRef<const Record *> defs, const Dialect &dialect, unsigned shardIndex, unsigned shardCount, raw_ostream &os) { … } /// Emit op definitions for all op records. static bool emitOpDefs(const RecordKeeper &recordKeeper, raw_ostream &os) { … } static mlir::GenRegistration genOpDecls("gen-op-decls", "Generate op declarations", [](const RecordKeeper &records, raw_ostream &os) { … }); static mlir::GenRegistration genOpDefs("gen-op-defs", "Generate op definitions", [](const RecordKeeper &records, raw_ostream &os) { … });
Codebase Browser
llvm