[TableGen] Clean up more .td files

[Paul-C-Anagnostopoulos]

Summary

I am slowly going through the TableGen source files and cleaning them up with respect to the various features that have been added.

llvm/include/llvm/Frontend/Directive/DirectiveBase.td

class DirectiveLanguage {
   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 = 0;
+  bit makeEnumAvailableInNamespace = false;
 
   // Generate include and macro to enable LLVM BitmaskEnum.
-  bit enableBitmaskEnumInNamespace = 0;
+  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 = 0;
+  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 = "";
 
   // Optional class holding value of the clause in clang AST.
   string clangClass = "";
 
   // Optional class holding the clause in flang AST. If left blank, the class
   // is assumed to be the name of the clause with capitalized word and
   // underscores removed.
   // ex: async -> Async
   //     num_threads -> NumThreads
   string flangClass = "";
 
   // Optional class holding value of the clause in flang AST.
   string flangClassValue = "";
 
-  // If set to 1, value is optional. Not optional by default.
-  bit isValueOptional = 0;
+  // 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 1, value class is part of a list. Single class by default.
-  bit isValueList = 0;
+  // 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 = 0;
+  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 = 0;
+  bit isDefault = false;
 }
 
 // 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.
class Directive<string d> {
 
   // List of clauses that are allowed but mutually exclusive.
   list<VersionedClause> allowedExclusiveClauses = [];
 
   // List of clauses that are required.
   list<VersionedClause> requiredClauses = [];
 
   // Set directive used by default when unknown.
-  bit isDefault = 0;
+  bit isDefault = false;
 }

llvm/include/llvm/Frontend/OpenACC/ACC.td

 // Definition of general OpenACC information
 //===----------------------------------------------------------------------===//
 
 def OpenACC : DirectiveLanguage {
   let name = "OpenACC";
   let cppNamespace = "acc"; // final namespace will be llvm::acc
   let directivePrefix = "ACCD_";
   let clausePrefix = "ACCC_";
-  let makeEnumAvailableInNamespace = 1;
-  let enableBitmaskEnumInNamespace = 1;
+  let makeEnumAvailableInNamespace = true;
+  let enableBitmaskEnumInNamespace = true;
   let includeHeader = "llvm/Frontend/OpenACC/ACC.h.inc";
   let clauseEnumSetClass = "AccClauseSet";
   let flangClauseBaseClass = "AccClause";
 }
 
 //===----------------------------------------------------------------------===//
 // Definition of OpenACC clauses
 //===----------------------------------------------------------------------===//
 
 // 2.16.1
 def ACCC_Async : Clause<"async"> {
   let flangClassValue = "ScalarIntExpr";
-  let isValueOptional = 1;
+  let isValueOptional = true;
 }
 
 // 2.9.6
 def ACCC_Auto : Clause<"auto"> {}
 
 // 2.7.11
 def ACCC_Attach : Clause<"attach"> {
   let flangClassValue = "AccObjectList";

 def ACCC_DeviceResident : Clause<"device_resident"> {
   let flangClassValue = "AccObjectList";
 }
 
 // 2.4
 def ACCC_DeviceType : Clause<"device_type"> {
   let flangClassValue = "ScalarIntExpr";
   let defaultValue = "*";
-  let isValueOptional = 1;
-  let isValueList = 1;
+  let isValueOptional = true;
+  let isValueList = true;
 }
 
 // 2.6.6
 def ACCC_Finalize : Clause<"finalize"> {}
 
 // 2.5.12
 def ACCC_FirstPrivate : Clause<"firstprivate"> {
   let flangClassValue = "AccObjectList";
 }
 
 // 2.9.2
 def ACCC_Gang : Clause<"gang"> {
   let flangClassValue = "AccGangArgument";
-  let isValueOptional = 1;
+  let isValueOptional = true;
 }
 
 // 2.14.4
 def ACCC_Host : Clause<"host"> {
   let flangClassValue = "AccObjectList";
 }
 
 // 2.5.4

 // 2.5.13
 def ACCC_Reduction : Clause<"reduction"> {
   let flangClassValue = "AccObjectListWithReduction";
 }
 
 // 2.5.5
 def ACCC_Self : Clause<"self"> {
   let flangClassValue = "ScalarLogicalExpr";
-  let isValueOptional = 1;
+  let isValueOptional = true;
 }
 
 // 2.9.5
 def ACCC_Seq : Clause<"seq"> {}
 
 // 2.9.4
 def ACCC_Vector : Clause<"vector"> {
   let flangClassValue = "ScalarIntExpr";
-  let isValueOptional = 1;
+  let isValueOptional = true;
 }
 
 // 2.5.10
 def ACCC_VectorLength : Clause<"vector_length"> {
   let flangClassValue = "ScalarIntExpr";
 }
 
 // 2.16.2
 def ACCC_Wait : Clause<"wait"> {
   let flangClassValue = "AccWaitArgument";
-  let isValueOptional = 1;
+  let isValueOptional = true;
 }
 
 // 2.9.3
 def ACCC_Worker: Clause<"worker"> {
   let flangClassValue = "ScalarIntExpr";
-  let isValueOptional = 1;
+  let isValueOptional = true;
 }
 
 // 2.12
 def ACCC_Write : Clause<"write"> {}
 
 def ACCC_Unknown : Clause<"unknown"> {
-  let isDefault = 1;
+  let isDefault = true;
 }
 
 //===----------------------------------------------------------------------===//
 // Definition of OpenACC directives
 //===----------------------------------------------------------------------===//
 
 // 2.12
 def ACC_Atomic : Directive<"atomic"> {}
def ACC_SerialLoop : Directive<"serial loop"> {
   let allowedExclusiveClauses = [
     VersionedClause<ACCC_Auto>,
     VersionedClause<ACCC_Independent>,
     VersionedClause<ACCC_Seq>
   ];
 }
 
 def ACC_Unknown : Directive<"unknown"> {
-  let isDefault = 1;
+  let isDefault = true;
 }

llvm/include/llvm/Frontend/OpenMP/OMP.td

 // Definition of general OpenMP information
 //===----------------------------------------------------------------------===//
 
 def OpenMP : DirectiveLanguage {
   let name = "OpenMP";
   let cppNamespace = "omp"; // final namespace will be llvm::omp
   let directivePrefix = "OMPD_";
   let clausePrefix = "OMPC_";
-  let makeEnumAvailableInNamespace = 1;
-  let enableBitmaskEnumInNamespace = 1;
+  let makeEnumAvailableInNamespace = true;
+  let enableBitmaskEnumInNamespace = true;
   let includeHeader = "llvm/Frontend/OpenMP/OMP.h.inc";
   let clauseEnumSetClass = "OmpClauseSet";
   let flangClauseBaseClass = "OmpClause";
 }
 
 //===----------------------------------------------------------------------===//
 // Definition of OpenMP clauses
 //===----------------------------------------------------------------------===//

 def OMPC_CopyPrivate : Clause<"copyprivate"> {
   let clangClass = "OMPCopyprivateClause";
   let flangClassValue = "OmpObjectList";
 }
 def OMP_PROC_BIND_master : ClauseVal<"master",2,1> {}
 def OMP_PROC_BIND_close : ClauseVal<"close",3,1> {}
 def OMP_PROC_BIND_spread : ClauseVal<"spread",4,1> {}
 def OMP_PROC_BIND_default : ClauseVal<"default",5,0> {}
-def OMP_PROC_BIND_unknown : ClauseVal<"unknown",6,0> { let isDefault = 1; }
+def OMP_PROC_BIND_unknown : ClauseVal<"unknown",6,0> { let isDefault = true; }
 def OMPC_ProcBind : Clause<"proc_bind"> {
   let clangClass = "OMPProcBindClause";
   let flangClass = "OmpProcBindClause";
   let enumClauseValue = "ProcBindKind";
   let allowedClauseValues = [
     OMP_PROC_BIND_master,
     OMP_PROC_BIND_close,
     OMP_PROC_BIND_spread,
     OMP_PROC_BIND_default,
     OMP_PROC_BIND_unknown
   ];
 }
 def OMPC_Schedule : Clause<"schedule"> {
   let clangClass = "OMPScheduleClause";
   let flangClass = "OmpScheduleClause";
 }
 def OMPC_Ordered : Clause<"ordered"> {
   let clangClass = "OMPOrderedClause";
   let flangClassValue = "ScalarIntConstantExpr";
-  let isValueOptional = 1;
+  let isValueOptional = true;
 }
 def OMPC_NoWait : Clause<"nowait"> {
   let clangClass = "OMPNowaitClause";
   let flangClass = "OmpNowait";
 }
 def OMPC_Untied : Clause<"untied"> { let clangClass = "OMPUntiedClause"; }
 def OMPC_Mergeable : Clause<"mergeable"> {
   let clangClass = "OMPMergeableClause";

 def OMPC_Hint : Clause<"hint"> {
   let clangClass = "OMPHintClause";
   let flangClass = "ConstantExpr";
 }
 def OMPC_DistSchedule : Clause<"dist_schedule"> {
   let clangClass = "OMPDistScheduleClause";
   let flangClass = "OmpDistScheduleClause";
   let flangClassValue = "ScalarIntExpr";
-  let isValueOptional = 1;
+  let isValueOptional = true;
 }
 def OMPC_DefaultMap : Clause<"defaultmap"> {
   let clangClass = "OMPDefaultmapClause";
   let flangClass = "OmpDefaultmapClause";
 }
 def OMPC_To : Clause<"to"> {
   let clangClass = "OMPToClause";
   let flangClassValue = "OmpObjectList";
 }
 def OMPC_From : Clause<"from"> {
   let clangClass = "OMPFromClause";
   let flangClassValue = "OmpObjectList";
 }
 def OMPC_UseDevicePtr : Clause<"use_device_ptr"> {
   let clangClass = "OMPUseDevicePtrClause";
   let flangClassValue = "Name";
-  let isValueList = 1;
+  let isValueList = true;
 }
 def OMPC_IsDevicePtr : Clause<"is_device_ptr"> {
   let clangClass = "OMPIsDevicePtrClause";
   let flangClassValue = "Name";
-  let isValueList = 1;
+  let isValueList = true;
 }
 def OMPC_TaskReduction : Clause<"task_reduction"> {
   let clangClass = "OMPTaskReductionClause";
 }
 def OMPC_InReduction : Clause<"in_reduction"> {
   let clangClass = "OMPInReductionClause";
 }
 def OMPC_UnifiedAddress : Clause<"unified_address"> {

 def OMPC_Affinity : Clause<"affinity"> {
   let clangClass = "OMPAffinityClause";
 }
 def OMPC_UseDeviceAddr : Clause<"use_device_addr"> {
   let clangClass = "OMPUseDeviceAddrClause";
 }
 def OMPC_Uniform : Clause<"uniform"> {
   let flangClassValue = "Name";
-  let isValueList = 1;
+  let isValueList = true;
 }
 def OMPC_DeviceType : Clause<"device_type"> {}
 def OMPC_Match : Clause<"match"> {}
 def OMPC_Depobj : Clause<"depobj"> {
   let clangClass = "OMPDepobjClause";
-  let isImplicit = 1;
+  let isImplicit = true;
 }
 def OMPC_Flush : Clause<"flush"> {
   let clangClass = "OMPFlushClause";
-  let isImplicit = 1;
+  let isImplicit = true;
 }
 def OMPC_ThreadPrivate : Clause<"threadprivate"> {
   let alternativeName = "threadprivate or thread local";
-  let isImplicit = 1;
+  let isImplicit = true;
 }
 def OMPC_Unknown : Clause<"unknown"> {
-  let isImplicit = 1;
-  let isDefault = 1;
+  let isImplicit = true;
+  let isDefault = true;
 }
 def OMPC_Link : Clause<"link"> {
   let flangClassValue = "OmpObjectList";
 }
 def OMPC_Inbranch : Clause<"inbranch"> {}
 def OMPC_Notinbranch : Clause<"notinbranch"> {}
 
 //===----------------------------------------------------------------------===//

 }
 def OMP_Workshare : Directive<"workshare"> {}
 def OMP_EndDo : Directive<"end do"> {}
 def OMP_EndDoSimd : Directive<"end do simd"> {}
 def OMP_EndSections : Directive<"end sections"> {}
 def OMP_EndSingle : Directive<"end single"> {}
 def OMP_EndWorkshare : Directive<"end workshare"> {}
 def OMP_Unknown : Directive<"unknown"> {
-  let isDefault = 1;
+  let isDefault = true;
 }

llvm/include/llvm/Option/OptParser.td

 //===--- OptParser.td - Common Option Parsing Interfaces ------------------===//
 //
 // 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 file defines the common interfaces used by the option parsing TableGen
 //  backend.
 //
 //===----------------------------------------------------------------------===//
 
 // Define the kinds of options.
 
-class OptionKind<string name, int precedence = 0, bit sentinel = 0> {
+class OptionKind<string name, int precedence = 0, bit sentinel = false> {
   string Name = name;
   // The kind precedence, kinds with lower precedence are matched first.
   int Precedence = precedence;
   // Indicate a sentinel option.
   bit Sentinel = sentinel;
 }
 
 // An option group.
 def KIND_GROUP : OptionKind<"Group">;
 // The input option kind.
-def KIND_INPUT : OptionKind<"Input", 1, 1>;
+def KIND_INPUT : OptionKind<"Input", 1, true>;
 // The unknown option kind.
-def KIND_UNKNOWN : OptionKind<"Unknown", 2, 1>;
+def KIND_UNKNOWN : OptionKind<"Unknown", 2, true>;
 // A flag with no values.
 def KIND_FLAG : OptionKind<"Flag">;
 // An option which prefixes its (single) value.
 def KIND_JOINED : OptionKind<"Joined", 1>;
 // An option which is followed by its value.
 def KIND_SEPARATE : OptionKind<"Separate">;
 // An option followed by its values, which are separated by commas.
 def KIND_COMMAJOINED : OptionKind<"CommaJoined">;
class Option<list<string> prefixes, string name, OptionKind kind> {
   string Values = ?;
   code ValuesCode = ?;
   list<OptionFlag> Flags = [];
   OptionGroup Group = ?;
   Option Alias = ?;
   list<string> AliasArgs = [];
   code KeyPath = ?;
   code DefaultValue = ?;
-  bit ShouldAlwaysEmit = 0;
+  bit ShouldAlwaysEmit = false;
   code NormalizerRetTy = ?;
   code NormalizedValuesScope = "";
   code Normalizer = "";
   code Denormalizer = "";
   code ValueMerger = "mergeForwardValue";
   code ValueExtractor = "extractForwardValue";
   list<code> NormalizedValues = ?;
 }
class MarshallingInfoBitfieldFlag<code keypath, code value>
   code ValueExtractor = "(extractMaskValue<unsigned, decltype("#value#"), "#value#">)";
 }
 
 // Mixins for additional marshalling attributes.
 
 class IsNegative {
   // todo: create & apply a normalizer for negative flags
 }
-class AlwaysEmit { bit ShouldAlwaysEmit = 1; }
+class AlwaysEmit { bit ShouldAlwaysEmit = true; }
 class Normalizer<code normalizer> { code Normalizer = normalizer; }
 class Denormalizer<code denormalizer> { code Denormalizer = denormalizer; }
 class NormalizedValuesScope<code scope> { code NormalizedValuesScope = scope; }
 class NormalizedValues<list<code> definitions> { list<code> NormalizedValues = definitions; } 
 class DenormalizeString { code Denormalizer = "denormalizeString"; }
 class AutoNormalizeEnum {
   code Normalizer = "normalizeSimpleEnum";
   code Denormalizer = "denormalizeSimpleEnum";

llvm/include/llvm/TableGen/SearchableTable.td

class GenericTable {
 
   // (Optional) List of fields that make up the primary key.
   list<string> PrimaryKey;
 
   // (Optional) Name of the primary key search function.
   string PrimaryKeyName;
 
   // See SearchIndex.EarlyOut
-  bit PrimaryKeyEarlyOut = 0;
+  bit PrimaryKeyEarlyOut = false;
 }
 
 // Define a record derived from this class to generate an additional search
 // index for a generic table that has been defined earlier.
 //
 // The name of the record will be used as the name of the C++ lookup function.
 class SearchIndex {
   // Table that this search index refers to.
   GenericTable Table;
 
   // List of fields that make up the key.
   list<string> Key;
 
   // If true, the lookup function will check the first field of the key against
   // the minimum and maximum values in the index before entering the binary
   // search. This is convenient for tables that add extended data for a subset
   // of a larger enum-based space, e.g. extended data about a subset of
   // instructions.
   //
   // Can only be used when the first field is an integral (non-string) type.
-  bit EarlyOut = 0;
+  bit EarlyOut = false;
 }
 
 // Legacy table type with integrated enum.
 class SearchableTable {
   list<string> SearchableFields;
   string EnumNameField = "Name";
   string EnumValueField;
 }