//===- OmpOpGen.cpp - OpenMP dialect op specific generators ---------------===// // // 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 // //===----------------------------------------------------------------------===// // // OmpOpGen defines OpenMP dialect operation specific generators. // //===----------------------------------------------------------------------===// #include "mlir/TableGen/GenInfo.h" #include "mlir/TableGen/CodeGenHelpers.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringSet.h" #include "llvm/ADT/TypeSwitch.h" #include "llvm/Support/FormatAdapters.h" #include "llvm/TableGen/Error.h" #include "llvm/TableGen/Record.h" usingnamespacellvm; /// The code block defining the base mixin class for combining clause operand /// structures. static const char *const baseMixinClass = …; /// The code block defining operation argument structures. static const char *const operationArgStruct = …; /// Remove multiple optional prefixes and suffixes from \c str. /// /// Prefixes and suffixes are attempted to be removed once in the order they /// appear in the \c prefixes and \c suffixes arguments. All prefixes are /// processed before suffixes are. This means it will behave as shown in the /// following example: /// - str: "PrePreNameSuf1Suf2" /// - prefixes: ["Pre"] /// - suffixes: ["Suf1", "Suf2"] /// - return: "PreNameSuf1" static StringRef stripPrefixAndSuffix(StringRef str, llvm::ArrayRef<StringRef> prefixes, llvm::ArrayRef<StringRef> suffixes) { … } /// Obtain the name of the OpenMP clause a given record inheriting /// `OpenMP_Clause` refers to. /// /// It supports direct and indirect `OpenMP_Clause` superclasses. Once the /// `OpenMP_Clause` class the record is based on is found, the optional /// "OpenMP_" prefix and "Skip" and "Clause" suffixes are removed to return only /// the clause name, i.e. "OpenMP_CollapseClauseSkip" is returned as "Collapse". static StringRef extractOmpClauseName(const Record *clause) { … } /// Check that the given argument, identified by its name and initialization /// value, is present in the \c arguments `dag`. static bool verifyArgument(DagInit *arguments, StringRef argName, Init *argInit) { … } /// Check that the given string record value, identified by its \c opValueName, /// is either undefined or empty in both the given operation and clause record /// or its contents for the clause record are contained in the operation record. /// Passing a non-empty \c clauseValueName enables checking values named /// differently in the operation and clause records. static bool verifyStringValue(const Record *op, const Record *clause, StringRef opValueName, StringRef clauseValueName = { … } /// Verify that all fields of the given clause not explicitly ignored are /// present in the corresponding operation field. /// /// Print warnings or errors where this is not the case. static void verifyClause(const Record *op, const Record *clause) { … } /// Translate the type of an OpenMP clause's argument to its corresponding /// representation for clause operand structures. /// /// All kinds of values are represented as `mlir::Value` fields, whereas /// attributes are represented based on their `storageType`. /// /// \param[in] name The name of the argument. /// \param[in] init The `DefInit` object representing the argument. /// \param[out] nest Number of levels of array nesting associated with the /// type. Must be initially set to 0. /// \param[out] rank Rank (number of dimensions, if an array type) of the base /// type. Must be initially set to 1. /// /// \return the name of the base type to represent elements of the argument /// type. static StringRef translateArgumentType(ArrayRef<SMLoc> loc, StringInit *name, Init *init, int &nest, int &rank) { … } /// Generate the structure that represents the arguments of the given \c clause /// record of type \c OpenMP_Clause. /// /// It will contain a field for each argument, using the same name translated to /// camel case and the corresponding base type as returned by /// translateArgumentType() optionally wrapped in one or more llvm::SmallVector. /// /// An additional field containing a tuple of integers to hold the size of each /// dimension will also be created for multi-rank types. This is not yet /// supported. static void genClauseOpsStruct(const Record *clause, raw_ostream &os) { … } /// Generate the structure that represents the clause-related arguments of the /// given \c op record of type \c OpenMP_Op. /// /// This structure will be defined in terms of the clause operand structures /// associated to the clauses of the operation. static void genOperandsDef(const Record *op, raw_ostream &os) { … } /// Verify that all properties of `OpenMP_Clause`s of records deriving from /// `OpenMP_Op`s have been inherited by the latter. static bool verifyDecls(const RecordKeeper &recordKeeper, raw_ostream &) { … } /// Generate structures to represent clause-related operands, based on existing /// `OpenMP_Clause` definitions and aggregate them into operation-specific /// structures according to the `clauses` argument of each definition deriving /// from `OpenMP_Op`. static bool genClauseOps(const RecordKeeper &recordKeeper, raw_ostream &os) { … } // Registers the generator to mlir-tblgen. static mlir::GenRegistration verifyOpenmpOps("verify-openmp-ops", "Verify OpenMP operations (produce no output file)", verifyDecls); static mlir::GenRegistration genOpenmpClauseOps("gen-openmp-clause-ops", "Generate OpenMP clause operand structures", genClauseOps);