EIC code displayed by LXR master/​include/​llvm/​Frontend/​Directive/​DirectiveBase.td	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

Warning, /include/llvm/Frontend/Directive/DirectiveBase.td is written in an unsupported language. File is not indexed.

 //===-- DirectiveBase.td - Base directive definition file --*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the base definition file directives and clauses.
 //
 //===----------------------------------------------------------------------===//
 
 
 // General information about the directive language.
 class DirectiveLanguage {
   // Name of the directive language such as omp or acc.
   string name = ?;
 
   // The C++ namespace that code of this directive language should be placed
   // into. This namespace is nested in llvm namespace.
   //
   // By default, uses the name of the directive language as the only namespace.
   // To avoid placing in any namespace, use "". To specify nested namespaces,
   // use "::" as the delimiter, e.g., given "A::B", ops will be placed in
   // `namespace A { namespace B { <directives-clauses> } }`.
   string cppNamespace = name;
 
   // Optional prefix used for the generation of the enumerator in the Directive
   // enum.
   string directivePrefix = "";
 
   // Optional prefix used for the generation of the enumerator in the Clause
   // enum.
   string clausePrefix = "";
 
   // Make the enum values available in the namespace. This allows us to
   // write something like Enum_X if we have a `using namespace cppNamespace`.
   bit makeEnumAvailableInNamespace = false;
 
   // Generate include and macro to enable LLVM BitmaskEnum.
   bit enableBitmaskEnumInNamespace = false;
 
   // Header file included in the implementation code generated. Ususally the
   // output file of the declaration code generation. Can be left blank.
   string includeHeader = "";
 
   // EnumSet class name used for clauses to generated the allowed clauses map.
   string clauseEnumSetClass = "";
 
   // Class holding the clauses in the flang parse-tree.
   string flangClauseBaseClass = "";
 }
 
 // Information about values accepted by enum-like clauses
 class ClauseVal<string n, int v, bit uv> {
   // Name of the clause value.
   string name = n;
 
   // Integer value of the clause.
   int value = v;
 
   // Can user specify this value?
   bit isUserValue = uv;
 
   // Set clause value used by default when unknown.
   bit isDefault = false;
 }
 
 // Information about a specific clause.
 class Clause<string c> {
   // Name of the clause.
   string name = c;
 
   // Define an alternative name return in get<LanguageName>ClauseName function.
   string alternativeName = "";
 
   // Define aliases used in the parser.
   list<string> aliases = [];
 
   // Optional class holding value of the clause in clang AST.
   string clangClass = "";
 
   // Optional class holding value of the clause in flang AST.
   string flangClass = "";
 
   // If set to true, value is optional. Not optional by default.
   bit isValueOptional = false;
 
   // Name of enum when there is a list of allowed clause values.
   string enumClauseValue = "";
 
   // List of allowed clause values
   list<ClauseVal> allowedClauseValues = [];
 
   // If set to true, value class is part of a list. Single class by default.
   bit isValueList = false;
 
   // Define a default value such as "*".
   string defaultValue = "";
 
   // Is clause implicit? If clause is set as implicit, the default kind will
   // be return in get<LanguageName>ClauseKind instead of their own kind.
   bit isImplicit = false;
 
   // Set clause used by default when unknown. Function returning the kind
   // of enumeration will use this clause as the default.
   bit isDefault = false;
 
   // Prefix before the actual value. Used in the parser generation.
   // `clause(prefix: value)`
   string prefix = "";
 
   // Set the prefix as optional.
   // `clause([prefix]: value)`
   bit isPrefixOptional = true;
 }
 
 // Hold information about clause validity by version.
 class VersionedClause<Clause c, int min = 1, int max = 0x7FFFFFFF> {
   // Actual clause.
   Clause clause = c;
 
   // Mininum version number where this clause is valid.
   int minVersion = min;
 
   // Maximum version number where this clause is valid.
   int maxVersion = max;
 }
 
 // Kinds of directive associations.
 class Association<string n> {
   string name = n;  // Name of the enum value in enum class Association.
 }
 // All of the AS_Xyz names are recognized by TableGen in order to calculate
 // the association in the AS_FromLeaves case.
 def AS_None : Association<"None"> {}              // No association
 def AS_Block : Association<"Block"> {}            // Block (incl. single
                                                   // statement)
 def AS_Declaration : Association<"Declaration"> {}   // Declaration
 def AS_Delimited : Association<"Delimited"> {}    // Region delimited with
                                                   // begin/end
 def AS_Loop : Association<"Loop"> {}              // Loop
 def AS_Separating : Association<"Separating"> {}  // Separates parts of a
                                                   // construct
 
 def AS_FromLeaves : Association<"FromLeaves"> {}    // See below
 // AS_FromLeaves can be used for combined/composite directives, and the actual
 // association will be computed based on associations of the leaf constructs:
 //   (x + y) + z = x + (y + z)
 //   x + y = y + x
 //   x + x = x
 //   AS_None + x = x
 //   AS_Block + AS_Loop = AS_Loop
 // Other combinations are not allowed.
 // This association is not valid for leaf constructs.
 // The name "AS_FromLeaves" is recognized by TableGen, and there is no enum
 // generated for it.
 
 // Kinds of directive categories.
 class Category<string n> {
   string name = n;  // Name of the enum value in enum class Category.
 }
 
 def CA_Declarative: Category<"Declarative"> {}
 def CA_Executable: Category<"Executable"> {}
 def CA_Informational: Category<"Informational"> {}
 def CA_Meta: Category<"Meta"> {}
 def CA_Subsidiary: Category<"Subsidiary"> {}
 def CA_Utility: Category<"Utility"> {}
 
 // Information about a specific directive.
 class Directive<string d> {
   // Name of the directive. Can be composite directive sepearted by whitespace.
   string name = d;
 
   // Define an alternative name return in get<LanguageName>DirectiveName
   // function.
   string alternativeName = "";
 
   // Clauses cannot appear twice in the three allowed lists below. Also, since
   // required implies allowed, the same clause cannot appear in both the
   // allowedClauses and requiredClauses lists.
 
   // List of allowed clauses for the directive.
   list<VersionedClause>  allowedClauses = [];
 
   // List of clauses that are allowed to appear only once.
   list<VersionedClause> allowedOnceClauses = [];
 
   // List of clauses that are allowed but mutually exclusive.
   list<VersionedClause> allowedExclusiveClauses = [];
 
   // List of clauses that are required.
   list<VersionedClause> requiredClauses = [];
 
   // List of leaf constituent directives in the order in which they appear
   // in the combined/composite directive.
   list<Directive> leafConstructs = [];
 
   // Set directive used by default when unknown.
   bit isDefault = false;
 
   // What the directive is associated with.
   Association association = AS_FromLeaves;
 
   // The category of the directive.
   Category category = ?;
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team