[TableGen][NFC] Group tokens with same attribute togather

[wangpc]

Summary

So that we can simplify some code and simplify the implmentation
when we want to add new features (like adding new bang operators).

[fpetrogalli]

llvm/lib/TableGen/TGLexer.h

88

Why are Bit to TrueKW excluded from classification? If they cannot be clustered together, I think it would make sense to move them down to the bottom of the struct, so that that the closing of a group with *LAST would be followed directly by a *START of a new group.

[wangpc]

Address comment.

[fpetrogalli]

This LGTM, thanks.

I have noticed that the "unclustered" values are still not grouped together. I thought it was a matter of just the few I mentioned in my first comment but apparently there are more.

I would have ordered the enum as { unclustered, group1, group2, ....}, just because it would have make it easier to find the cluster. But this is really debatable as it is my personal preference, no need to change it if you do not want to.

Thanks!

Francesco

llvm/lib/TableGen/TGLexer.h

157–158

same for these? Move them to the "unclustered" section?

165–166

same, move them to the unclustered section?

[wangpc]

Address comment.

[fpetrogalli]

LGTM, thanks!

[wangpc]

In D156502#4549969, @fpetrogalli wrote:

This LGTM, thanks.

I have noticed that the "unclustered" values are still not grouped together. I thought it was a matter of just the few I mentioned in my first comment but apparently there are more.

I would have ordered the enum as { unclustered, group1, group2, ....}, just because it would have make it easier to find the cluster. But this is really debatable as it is my personal preference, no need to change it if you do not want to.

Thanks!

Francesco

Yeah I agree with you!

llvm/lib/TableGen/TGLexer.h

enum TokKind {
   semi,      // ;
   comma,     // ,
   dot,       // .
   equal,     // =
   question,  // ?
   paste,     // #
   dotdotdot, // ...
 
+  // Boolean literals.
+  TrueVal,
+  FalseVal,
+
+  // Integer value.
+  IntVal,
+
+  // Binary constant.  Note that these are sized according to the number of
+  // bits given.
+  BinaryIntVal,
+
+  // Preprocessing tokens for internal usage by the lexer.
+  // They are never returned as a result of Lex().
+  Ifdef,
+  Ifndef,
+  Else,
+  Endif,
+  Define,
+
   // Reserved keywords. ('ElseKW' is named to distinguish it from the
   // existing 'Else' that means the preprocessor #else.)
-  Assert,
   Bit,
   Bits,
-  Class,
   Code,
   Dag,
-  Def,
-  Defm,
-  Defset,
-  Defvar,
   ElseKW,
   FalseKW,
   Field,
-  Foreach,
-  If,
   In,
   Include,
   Int,
-  Let,
   List,
-  MultiClass,
   String,
   Then,
   TrueKW,
 
+  // Object start tokens.
+  OBJECT_START_FIRST,
+  Assert = OBJECT_START_FIRST,
+  Class,
+  Def,
+  Defm,
+  Defset,
+  Defvar,
+  Foreach,
+  If,
+  Let,
+  MultiClass,
+  OBJECT_START_LAST = MultiClass,
+
   // Bang operators.
-  XConcat,
+  BANG_OPERATOR_FIRST,
+  XConcat = BANG_OPERATOR_FIRST,
   XADD,
   XSUB,
   XMUL,
   XDIV,
   XNOT,
   XLOG2,
   XAND,
   XOR,
enum TokKind {
   XExists,
   XListRemove,
   XToLower,
   XToUpper,
   XRange,
   XGetDagArg,
   XGetDagName,
   XSetDagArg,
   XSetDagName,
-
-  // Boolean literals.
-  TrueVal,
-  FalseVal,
-
-  // Integer value.
-  IntVal,
-
-  // Binary constant.  Note that these are sized according to the number of
-  // bits given.
-  BinaryIntVal,
+  BANG_OPERATOR_LAST = XSetDagName,
 
   // String valued tokens.
-  Id,
+  STRING_VALUE_FIRST,
+  Id = STRING_VALUE_FIRST,
   StrVal,
   VarName,
   CodeFragment,
-
-  // Preprocessing tokens for internal usage by the lexer.
-  // They are never returned as a result of Lex().
-  Ifdef,
-  Ifndef,
-  Else,
-  Endif,
-  Define
+  STRING_VALUE_LAST = CodeFragment,
 };
+
+/// isBangOperator - Return true if this is a bang operator.
+static inline bool isBangOperator(tgtok::TokKind Kind) {
+  return tgtok::BANG_OPERATOR_FIRST <= Kind && Kind <= BANG_OPERATOR_LAST;
+}
+
+/// isObjectStart - Return true if this is a valid first token for a statement.
+static inline bool isObjectStart(tgtok::TokKind Kind) {
+  return tgtok::OBJECT_START_FIRST <= Kind && Kind <= OBJECT_START_LAST;
+}
+
+/// isStringValue - Return true if this is a string value.
+static inline bool isStringValue(tgtok::TokKind Kind) {
+  return tgtok::STRING_VALUE_FIRST <= Kind && Kind <= STRING_VALUE_LAST;
 }
+} // namespace tgtok
 
 /// TGLexer - TableGen Lexer class.
 class TGLexer {
   SourceMgr &SrcMgr;
 
   const char *CurPtr = nullptr;
   StringRef CurBuf;
 
public:
 
   const DependenciesSetTy &getDependencies() const {
     return Dependencies;
   }
 
   tgtok::TokKind getCode() const { return CurCode; }
 
   const std::string &getCurStrVal() const {
-    assert((CurCode == tgtok::Id || CurCode == tgtok::StrVal ||
-            CurCode == tgtok::VarName || CurCode == tgtok::CodeFragment) &&
+    assert(tgtok::isStringValue(CurCode) &&
            "This token doesn't have a string value");
     return CurStrVal;
   }
   int64_t getCurIntVal() const {
     assert(CurCode == tgtok::IntVal && "This token isn't an integer");
     return CurIntVal;
   }
   std::pair<int64_t, unsigned> getCurBinaryIntVal() const {

llvm/lib/TableGen/TGParser.cpp

return resolveArguments(
       &MC->Rec, ArgValues, Loc,
       [&](Init *Name, Init *Value) { Substs.emplace_back(Name, Value); });
 }
 
 //===----------------------------------------------------------------------===//
 // Parser Code
 //===----------------------------------------------------------------------===//
 
-/// isObjectStart - Return true if this is a valid first token for a statement.
-static bool isObjectStart(tgtok::TokKind K) {
-  return K == tgtok::Assert || K == tgtok::Class || K == tgtok::Def ||
-         K == tgtok::Defm || K == tgtok::Defset || K == tgtok::Defvar ||
-         K == tgtok::Foreach || K == tgtok::If || K == tgtok::Let ||
-         K == tgtok::MultiClass;
-}
-
 bool TGParser::consume(tgtok::TokKind K) {
   if (Lex.getCode() == K) {
     Lex.Lex();
     return true;
   }
   return false;
 }
 

 ///   SimpleValue ::= RANGE '(' Value ')'
 ///   SimpleValue ::= RANGE '(' Value ',' Value ')'
 ///   SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= COND '(' [Value ':' Value,]+ ')'
 ///
 Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
                                  IDParseMode Mode) {
   Init *R = nullptr;
-  switch (Lex.getCode()) {
+  tgtok::TokKind Code = Lex.getCode();
+
+  // Parse bang operators.
+  if (tgtok::isBangOperator(Code))
+    return ParseOperation(CurRec, ItemType);
+
+  switch (Code) {
   default: TokError("Unknown or reserved token when parsing a value"); break;
 
   case tgtok::TrueVal:
     R = IntInit::get(Records, 1);
     Lex.Lex();
     break;
   case tgtok::FalseVal:
     R = IntInit::get(Records, 0);
case tgtok::l_paren: {         // Value ::= '(' IDValue DagArgList ')'
 
     if (!consume(tgtok::r_paren)) {
       TokError("expected ')' in dag init");
       return nullptr;
     }
 
     return DagInit::get(Operator, OperatorName, DagArgs);
   }
-
-  case tgtok::XHead:
-  case tgtok::XTail:
-  case tgtok::XSize:
-  case tgtok::XEmpty:
-  case tgtok::XCast:
-  case tgtok::XToLower:
-  case tgtok::XToUpper:
-  case tgtok::XGetDagOp: // Value ::= !unop '(' Value ')'
-  case tgtok::XExists:
-  case tgtok::XIsA:
-  case tgtok::XConcat:
-  case tgtok::XDag:
-  case tgtok::XADD:
-  case tgtok::XSUB:
-  case tgtok::XMUL:
-  case tgtok::XDIV:
-  case tgtok::XNOT:
-  case tgtok::XLOG2:
-  case tgtok::XAND:
-  case tgtok::XOR:
-  case tgtok::XXOR:
-  case tgtok::XSRA:
-  case tgtok::XSRL:
-  case tgtok::XSHL:
-  case tgtok::XEq:
-  case tgtok::XNe:
-  case tgtok::XLe:
-  case tgtok::XLt:
-  case tgtok::XGe:
-  case tgtok::XGt:
-  case tgtok::XListConcat:
-  case tgtok::XListSplat:
-  case tgtok::XListRemove:
-  case tgtok::XRange:
-  case tgtok::XStrConcat:
-  case tgtok::XInterleave:
-  case tgtok::XGetDagArg:
-  case tgtok::XGetDagName:
-  case tgtok::XSetDagOp: // Value ::= !binop '(' Value ',' Value ')'
-  case tgtok::XSetDagArg:
-  case tgtok::XSetDagName:
-  case tgtok::XIf:
-  case tgtok::XCond:
-  case tgtok::XFoldl:
-  case tgtok::XForEach:
-  case tgtok::XFilter:
-  case tgtok::XSubst:
-  case tgtok::XSubstr:
-  case tgtok::XFind: { // Value ::= !ternop '(' Value ',' Value ',' Value ')'
-    return ParseOperation(CurRec, ItemType);
-  }
   }
 
   return R;
 }
 
 /// ParseValue - Parse a TableGen value. This returns null on error.
 ///
 ///   Value       ::= SimpleValue ValueSuffix*
if (!Loops.empty())
       return TokError("multiclass is not allowed inside foreach loop");
     return ParseMultiClass();
   }
 }
 
 /// ParseObjectList
 ///   ObjectList :== Object*
 bool TGParser::ParseObjectList(MultiClass *MC) {
-  while (isObjectStart(Lex.getCode())) {
+  while (tgtok::isObjectStart(Lex.getCode())) {
     if (ParseObject(MC))
       return true;
   }
   return false;
 }
 
 bool TGParser::ParseFile() {
   Lex.Lex(); // Prime the lexer.