mlir/tools/mlir-tblgen/OmpOpGen.cpp - third_party/llvm-project - Git at Google

 //===- 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"

 using namespace llvm;

 /// The code block defining the base mixin class for combining clause operand
 /// structures.
 static const char *const baseMixinClass = R"(
 namespace detail {
 template <typename... Mixins>
 struct Clauses : public Mixins... {};
 } // namespace detail
 )";

 /// The code block defining operation argument structures.
 static const char *const operationArgStruct = R"(
 using {0}Operands = detail::Clauses<{1}>;
 )";

 /// 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) {
   for (StringRef prefix : prefixes)
     if (str.starts_with(prefix))
       str = str.drop_front(prefix.size());

   for (StringRef suffix : suffixes)
     if (str.ends_with(suffix))
       str = str.drop_back(suffix.size());

   return str;
 }

 /// 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) {
   const Record *ompClause = clause->getRecords().getClass("OpenMP_Clause");
   assert(ompClause && "base OpenMP records expected to be defined");

   StringRef clauseClassName;
   SmallVector<const Record *, 1> clauseSuperClasses;
   clause->getDirectSuperClasses(clauseSuperClasses);

   // Check if OpenMP_Clause is a direct superclass.
   for (const Record *superClass : clauseSuperClasses) {
     if (superClass == ompClause) {
       clauseClassName = clause->getName();
       break;
     }
   }

   // Support indirectly-inherited OpenMP_Clauses.
   if (clauseClassName.empty()) {
     for (auto [superClass, _] : clause->getSuperClasses()) {
       if (superClass->isSubClassOf(ompClause)) {
         clauseClassName = superClass->getName();
         break;
       }
     }
   }

   assert(!clauseClassName.empty() && "clause name must be found");

   // Keep only the OpenMP clause name itself for reporting purposes.
   return stripPrefixAndSuffix(clauseClassName, /*prefixes=*/{"OpenMP_"},
                               /*suffixes=*/{"Skip", "Clause"});
 }

 /// Check that the given argument, identified by its name and initialization
 /// value, is present in the \c arguments `dag`.
 static bool verifyArgument(const DagInit *arguments, StringRef argName,
                            const Init *argInit) {
   auto range = zip_equal(arguments->getArgNames(), arguments->getArgs());
   return llvm::any_of(
       range, [&](std::tuple<const llvm::StringInit *, const llvm::Init *> v) {
         return std::get<0>(v)->getAsUnquotedString() == argName &&
                std::get<1>(v) == 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 = {}) {
   auto opValue = op->getValueAsOptionalString(opValueName);
   auto clauseValue = clause->getValueAsOptionalString(
       clauseValueName.empty() ? opValueName : clauseValueName);

   bool opHasValue = opValue && !opValue->trim().empty();
   bool clauseHasValue = clauseValue && !clauseValue->trim().empty();

   if (!opHasValue)
     return !clauseHasValue;

   return !clauseHasValue || opValue->contains(clauseValue->trim());
 }

 /// 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) {
   StringRef clauseClassName = extractOmpClauseName(clause);

   if (!clause->getValueAsBit("ignoreArgs")) {
     const DagInit *opArguments = op->getValueAsDag("arguments");
     const DagInit *arguments = clause->getValueAsDag("arguments");

     for (auto [name, arg] :
          zip(arguments->getArgNames(), arguments->getArgs())) {
       if (!verifyArgument(opArguments, name->getAsUnquotedString(), arg))
         PrintWarning(
             op->getLoc(),
             "'" + clauseClassName + "' clause-defined argument '" +
                 arg->getAsUnquotedString() + ":$" +
                 name->getAsUnquotedString() +
                 "' not present in operation. Consider `dag arguments = "
                 "!con(clausesArgs, ...)` or explicitly skipping this field.");
     }
   }

   if (!clause->getValueAsBit("ignoreAsmFormat") &&
       !verifyStringValue(op, clause, "assemblyFormat", "reqAssemblyFormat"))
     PrintWarning(
         op->getLoc(),
         "'" + clauseClassName +
             "' clause-defined `reqAssemblyFormat` not present in operation. "
             "Consider concatenating `clauses[{Req,Opt}]AssemblyFormat` or "
             "explicitly skipping this field.");

   if (!clause->getValueAsBit("ignoreAsmFormat") &&
       !verifyStringValue(op, clause, "assemblyFormat", "optAssemblyFormat"))
     PrintWarning(
         op->getLoc(),
         "'" + clauseClassName +
             "' clause-defined `optAssemblyFormat` not present in operation. "
             "Consider concatenating `clauses[{Req,Opt}]AssemblyFormat` or "
             "explicitly skipping this field.");

   if (!clause->getValueAsBit("ignoreDesc") &&
       !verifyStringValue(op, clause, "description"))
     PrintError(op->getLoc(),
                "'" + clauseClassName +
                    "' clause-defined `description` not present in operation. "
                    "Consider concatenating `clausesDescription` or explicitly "
                    "skipping this field.");

   if (!clause->getValueAsBit("ignoreExtraDecl") &&
       !verifyStringValue(op, clause, "extraClassDeclaration"))
     PrintWarning(
         op->getLoc(),
         "'" + clauseClassName +
             "' clause-defined `extraClassDeclaration` not present in "
             "operation. Consider concatenating `clausesExtraClassDeclaration` "
             "or explicitly skipping this field.");
 }

 /// 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,
                                        const StringInit *name, const Init *init,
                                        int &nest, int &rank) {
   const Record *def = cast<DefInit>(init)->getDef();

   llvm::StringSet<> superClasses;
   for (auto [sc, _] : def->getSuperClasses())
     superClasses.insert(sc->getNameInitAsString());

   // Handle wrapper-style superclasses.
   if (superClasses.contains("OptionalAttr"))
     return translateArgumentType(
         loc, name, def->getValue("baseAttr")->getValue(), nest, rank);

   if (superClasses.contains("TypedArrayAttrBase"))
     return translateArgumentType(
         loc, name, def->getValue("elementAttr")->getValue(), ++nest, rank);

   // Handle ElementsAttrBase superclasses.
   if (superClasses.contains("ElementsAttrBase")) {
     // TODO: Obtain the rank from ranked types.
     ++nest;

     if (superClasses.contains("IntElementsAttrBase"))
       return "::llvm::APInt";
     if (superClasses.contains("FloatElementsAttr") ||
         superClasses.contains("RankedFloatElementsAttr"))
       return "::llvm::APFloat";
     if (superClasses.contains("DenseArrayAttrBase"))
       return stripPrefixAndSuffix(def->getValueAsString("returnType"),
                                   {"::llvm::ArrayRef<"}, {">"});

     // Decrease the nesting depth in the case where the base type cannot be
     // inferred, so that the bare storageType is used instead of a vector.
     --nest;
     PrintWarning(
         loc,
         "could not infer array-like attribute element type for argument '" +
             name->getAsUnquotedString() + "', will use bare `storageType`");
   }

   // Handle simple attribute and value types.
   [[maybe_unused]] bool isAttr = superClasses.contains("Attr");
   bool isValue = superClasses.contains("TypeConstraint");
   if (superClasses.contains("Variadic"))
     ++nest;

   if (isValue) {
     assert(!isAttr &&
            "argument can't be simultaneously a value and an attribute");
     return "::mlir::Value";
   }

   assert(isAttr && "argument must be an attribute if it's not a value");
   return nest > 0 ? "::mlir::Attribute"
                   : def->getValueAsString("storageType").trim();
 }

 /// 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) {
   if (clause->isAnonymous())
     return;

   StringRef clauseName = extractOmpClauseName(clause);
   os << "struct " << clauseName << "ClauseOps {\n";

   const DagInit *arguments = clause->getValueAsDag("arguments");
   for (auto [name, arg] :
        zip_equal(arguments->getArgNames(), arguments->getArgs())) {
     int nest = 0, rank = 1;
     StringRef baseType =
         translateArgumentType(clause->getLoc(), name, arg, nest, rank);
     std::string fieldName =
         convertToCamelFromSnakeCase(name->getAsUnquotedString(),
                                     /*capitalizeFirst=*/false);

     os << formatv("  {0}{1}{2} {3};\n",
                   fmt_repeat("::llvm::SmallVector<", nest), baseType,
                   fmt_repeat(">", nest), fieldName);

     if (rank > 1) {
       assert(nest >= 1 && "must be nested if it's a ranked type");
       os << formatv("  {0}::std::tuple<{1}int>{2} {3}Dims;\n",
                     fmt_repeat("::llvm::SmallVector<", nest - 1),
                     fmt_repeat("int, ", rank - 1), fmt_repeat(">", nest - 1),
                     fieldName);
     }
   }

   os << "};\n";
 }

 /// 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) {
   if (op->isAnonymous())
     return;

   SmallVector<std::string> clauseNames;
   for (const Record *clause : op->getValueAsListOfDefs("clauseList"))
     clauseNames.push_back((extractOmpClauseName(clause) + "ClauseOps").str());

   StringRef opName = stripPrefixAndSuffix(
       op->getName(), /*prefixes=*/{"OpenMP_"}, /*suffixes=*/{"Op"});
   os << formatv(operationArgStruct, opName, join(clauseNames, ", "));
 }

 /// 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 &records, raw_ostream &) {
   for (const Record *op : records.getAllDerivedDefinitions("OpenMP_Op")) {
     for (const Record *clause : op->getValueAsListOfDefs("clauseList"))
       verifyClause(op, clause);
   }

   return false;
 }

 /// 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 &records, raw_ostream &os) {
   mlir::tblgen::NamespaceEmitter ns(os, "mlir::omp");
   for (const Record *clause : records.getAllDerivedDefinitions("OpenMP_Clause"))
     genClauseOpsStruct(clause, os);

   // Produce base mixin class.
   os << baseMixinClass;

   for (const Record *op : records.getAllDerivedDefinitions("OpenMP_Op"))
     genOperandsDef(op, os);

   return false;
 }

 // 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);
	//===- 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"

	using namespace llvm;

	/// The code block defining the base mixin class for combining clause operand
	/// structures.
	static const char *const baseMixinClass = R"(
	namespace detail {
	template <typename... Mixins>
	struct Clauses : public Mixins... {};
	} // namespace detail
	)";

	/// The code block defining operation argument structures.
	static const char *const operationArgStruct = R"(
	using {0}Operands = detail::Clauses<{1}>;
	)";

	/// 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) {
	for (StringRef prefix : prefixes)
	if (str.starts_with(prefix))
	str = str.drop_front(prefix.size());

	for (StringRef suffix : suffixes)
	if (str.ends_with(suffix))
	str = str.drop_back(suffix.size());

	return str;
	}

	/// 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) {
	const Record *ompClause = clause->getRecords().getClass("OpenMP_Clause");
	assert(ompClause && "base OpenMP records expected to be defined");

	StringRef clauseClassName;
	SmallVector<const Record *, 1> clauseSuperClasses;
	clause->getDirectSuperClasses(clauseSuperClasses);

	// Check if OpenMP_Clause is a direct superclass.
	for (const Record *superClass : clauseSuperClasses) {
	if (superClass == ompClause) {
	clauseClassName = clause->getName();
	break;
	}
	}

	// Support indirectly-inherited OpenMP_Clauses.
	if (clauseClassName.empty()) {
	for (auto [superClass, _] : clause->getSuperClasses()) {
	if (superClass->isSubClassOf(ompClause)) {
	clauseClassName = superClass->getName();
	break;
	}
	}
	}

	assert(!clauseClassName.empty() && "clause name must be found");

	// Keep only the OpenMP clause name itself for reporting purposes.
	return stripPrefixAndSuffix(clauseClassName, /prefixes=/{"OpenMP_"},
	/suffixes=/{"Skip", "Clause"});
	}

	/// Check that the given argument, identified by its name and initialization
	/// value, is present in the \c arguments `dag`.
	static bool verifyArgument(const DagInit *arguments, StringRef argName,
	const Init *argInit) {
	auto range = zip_equal(arguments->getArgNames(), arguments->getArgs());
	return llvm::any_of(
	range, [&](std::tuple<const llvm::StringInit , const llvm::Init > v) {
	return std::get<0>(v)->getAsUnquotedString() == argName &&
	std::get<1>(v) == 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 = {}) {
	auto opValue = op->getValueAsOptionalString(opValueName);
	auto clauseValue = clause->getValueAsOptionalString(
	clauseValueName.empty() ? opValueName : clauseValueName);

	bool opHasValue = opValue && !opValue->trim().empty();
	bool clauseHasValue = clauseValue && !clauseValue->trim().empty();

	if (!opHasValue)
	return !clauseHasValue;

	return !clauseHasValue \|\| opValue->contains(clauseValue->trim());
	}

	/// 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) {
	StringRef clauseClassName = extractOmpClauseName(clause);

	if (!clause->getValueAsBit("ignoreArgs")) {
	const DagInit *opArguments = op->getValueAsDag("arguments");
	const DagInit *arguments = clause->getValueAsDag("arguments");

	for (auto [name, arg] :
	zip(arguments->getArgNames(), arguments->getArgs())) {
	if (!verifyArgument(opArguments, name->getAsUnquotedString(), arg))
	PrintWarning(
	op->getLoc(),
	"'" + clauseClassName + "' clause-defined argument '" +
	arg->getAsUnquotedString() + ":$" +
	name->getAsUnquotedString() +
	"' not present in operation. Consider `dag arguments = "
	"!con(clausesArgs, ...)` or explicitly skipping this field.");
	}
	}

	if (!clause->getValueAsBit("ignoreAsmFormat") &&
	!verifyStringValue(op, clause, "assemblyFormat", "reqAssemblyFormat"))
	PrintWarning(
	op->getLoc(),
	"'" + clauseClassName +
	"' clause-defined `reqAssemblyFormat` not present in operation. "
	"Consider concatenating `clauses[{Req,Opt}]AssemblyFormat` or "
	"explicitly skipping this field.");

	if (!clause->getValueAsBit("ignoreAsmFormat") &&
	!verifyStringValue(op, clause, "assemblyFormat", "optAssemblyFormat"))
	PrintWarning(
	op->getLoc(),
	"'" + clauseClassName +
	"' clause-defined `optAssemblyFormat` not present in operation. "
	"Consider concatenating `clauses[{Req,Opt}]AssemblyFormat` or "
	"explicitly skipping this field.");

	if (!clause->getValueAsBit("ignoreDesc") &&
	!verifyStringValue(op, clause, "description"))
	PrintError(op->getLoc(),
	"'" + clauseClassName +
	"' clause-defined `description` not present in operation. "
	"Consider concatenating `clausesDescription` or explicitly "
	"skipping this field.");

	if (!clause->getValueAsBit("ignoreExtraDecl") &&
	!verifyStringValue(op, clause, "extraClassDeclaration"))
	PrintWarning(
	op->getLoc(),
	"'" + clauseClassName +
	"' clause-defined `extraClassDeclaration` not present in "
	"operation. Consider concatenating `clausesExtraClassDeclaration` "
	"or explicitly skipping this field.");
	}

	/// 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,
	const StringInit name, const Init init,
	int &nest, int &rank) {
	const Record *def = cast<DefInit>(init)->getDef();

	llvm::StringSet<> superClasses;
	for (auto [sc, _] : def->getSuperClasses())
	superClasses.insert(sc->getNameInitAsString());

	// Handle wrapper-style superclasses.
	if (superClasses.contains("OptionalAttr"))
	return translateArgumentType(
	loc, name, def->getValue("baseAttr")->getValue(), nest, rank);

	if (superClasses.contains("TypedArrayAttrBase"))
	return translateArgumentType(
	loc, name, def->getValue("elementAttr")->getValue(), ++nest, rank);

	// Handle ElementsAttrBase superclasses.
	if (superClasses.contains("ElementsAttrBase")) {
	// TODO: Obtain the rank from ranked types.
	++nest;

	if (superClasses.contains("IntElementsAttrBase"))
	return "::llvm::APInt";
	if (superClasses.contains("FloatElementsAttr") \|\|
	superClasses.contains("RankedFloatElementsAttr"))
	return "::llvm::APFloat";
	if (superClasses.contains("DenseArrayAttrBase"))
	return stripPrefixAndSuffix(def->getValueAsString("returnType"),
	{"::llvm::ArrayRef<"}, {">"});

	// Decrease the nesting depth in the case where the base type cannot be
	// inferred, so that the bare storageType is used instead of a vector.
	--nest;
	PrintWarning(
	loc,
	"could not infer array-like attribute element type for argument '" +
	name->getAsUnquotedString() + "', will use bare `storageType`");
	}

	// Handle simple attribute and value types.
	[[maybe_unused]] bool isAttr = superClasses.contains("Attr");
	bool isValue = superClasses.contains("TypeConstraint");
	if (superClasses.contains("Variadic"))
	++nest;

	if (isValue) {
	assert(!isAttr &&
	"argument can't be simultaneously a value and an attribute");
	return "::mlir::Value";
	}

	assert(isAttr && "argument must be an attribute if it's not a value");
	return nest > 0 ? "::mlir::Attribute"
	: def->getValueAsString("storageType").trim();
	}

	/// 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) {
	if (clause->isAnonymous())
	return;

	StringRef clauseName = extractOmpClauseName(clause);
	os << "struct " << clauseName << "ClauseOps {\n";

	const DagInit *arguments = clause->getValueAsDag("arguments");
	for (auto [name, arg] :
	zip_equal(arguments->getArgNames(), arguments->getArgs())) {
	int nest = 0, rank = 1;
	StringRef baseType =
	translateArgumentType(clause->getLoc(), name, arg, nest, rank);
	std::string fieldName =
	convertToCamelFromSnakeCase(name->getAsUnquotedString(),
	/capitalizeFirst=/false);

	os << formatv(" {0}{1}{2} {3};\n",
	fmt_repeat("::llvm::SmallVector<", nest), baseType,
	fmt_repeat(">", nest), fieldName);

	if (rank > 1) {
	assert(nest >= 1 && "must be nested if it's a ranked type");
	os << formatv(" {0}::std::tuple<{1}int>{2} {3}Dims;\n",
	fmt_repeat("::llvm::SmallVector<", nest - 1),
	fmt_repeat("int, ", rank - 1), fmt_repeat(">", nest - 1),
	fieldName);
	}
	}

	os << "};\n";
	}

	/// 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) {
	if (op->isAnonymous())
	return;

	SmallVector<std::string> clauseNames;
	for (const Record *clause : op->getValueAsListOfDefs("clauseList"))
	clauseNames.push_back((extractOmpClauseName(clause) + "ClauseOps").str());

	StringRef opName = stripPrefixAndSuffix(
	op->getName(), /prefixes=/{"OpenMP_"}, /suffixes=/{"Op"});
	os << formatv(operationArgStruct, opName, join(clauseNames, ", "));
	}

	/// 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 &records, raw_ostream &) {
	for (const Record *op : records.getAllDerivedDefinitions("OpenMP_Op")) {
	for (const Record *clause : op->getValueAsListOfDefs("clauseList"))
	verifyClause(op, clause);
	}

	return false;
	}

	/// 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 &records, raw_ostream &os) {
	mlir::tblgen::NamespaceEmitter ns(os, "mlir::omp");
	for (const Record *clause : records.getAllDerivedDefinitions("OpenMP_Clause"))
	genClauseOpsStruct(clause, os);

	// Produce base mixin class.
	os << baseMixinClass;

	for (const Record *op : records.getAllDerivedDefinitions("OpenMP_Op"))
	genOperandsDef(op, os);

	return false;
	}

	// 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);