TableGen: Handle nontrivial foreach range bounds

[arsenm]

Summary

This allows using anything that isn't a literal integer as the bounds
for a foreach. Some of the diagnostics aren't perfect, but nobody ever
accused tablegen of having good errors. For example, the existing
wording suggests a bitrange is valid, but as far as I can tell this
has never worked.

Fixes bug 41958.

[hfinkel]

LGTM

lib/TableGen/TGParser.cpp

2495

Unnecessary white space addition?

[arsenm]

r361434

lib/TableGen/TGParser.h

private:  // Parser methods.
   void ParseValueList(SmallVectorImpl<llvm::Init*> &Result, Record *CurRec,
                       Record *ArgsRec = nullptr, RecTy *EltTy = nullptr);
   void ParseDagArgList(
       SmallVectorImpl<std::pair<llvm::Init*, StringInit*>> &Result,
       Record *CurRec);
   bool ParseOptionalRangeList(SmallVectorImpl<unsigned> &Ranges);
   bool ParseOptionalBitList(SmallVectorImpl<unsigned> &Ranges);
   void ParseRangeList(SmallVectorImpl<unsigned> &Result);
-  bool ParseRangePiece(SmallVectorImpl<unsigned> &Ranges);
+  bool ParseRangePiece(SmallVectorImpl<unsigned> &Ranges,
+                       TypedInit *FirstItem = nullptr);
   RecTy *ParseType();
   Init *ParseOperation(Record *CurRec, RecTy *ItemType);
   Init *ParseOperationCond(Record *CurRec, RecTy *ItemType);
   RecTy *ParseOperatorType();
   Init *ParseObjectName(MultiClass *CurMultiClass);
   Record *ParseClassID();
   MultiClass *ParseMultiClassID();
   bool ApplyLetStack(Record *CurRec);
   bool ApplyLetStack(RecordsEntry &Entry);
 };
 
 } // end namespace llvm
 
 #endif

lib/TableGen/TGParser.cpp

ParseSubMultiClassReference(MultiClass *CurMC) {
 
   return Result;
 }
 
 /// ParseRangePiece - Parse a bit/value range.
 ///   RangePiece ::= INTVAL
 ///   RangePiece ::= INTVAL '-' INTVAL
 ///   RangePiece ::= INTVAL INTVAL
-bool TGParser::ParseRangePiece(SmallVectorImpl<unsigned> &Ranges) {
-  if (Lex.getCode() != tgtok::IntVal) {
-    TokError("expected integer or bitrange");
-    return true;
-  }
-  int64_t Start = Lex.getCurIntVal();
+bool TGParser::ParseRangePiece(SmallVectorImpl<unsigned> &Ranges,
+                               TypedInit *FirstItem) {
+  Init *CurVal = FirstItem;
+  if (!CurVal)
+    CurVal = ParseValue(nullptr);
+
+  IntInit *II = dyn_cast_or_null<IntInit>(CurVal);
+  if (!II)
+    return TokError("expected integer or bitrange");
+
+  int64_t Start = II->getValue();
   int64_t End;
 
   if (Start < 0)
     return TokError("invalid range, cannot be negative");
 
-  switch (Lex.Lex()) {  // eat first character.
+  switch (Lex.getCode()) {
   default:
     Ranges.push_back(Start);
     return false;
-  case tgtok::minus:
-    if (Lex.Lex() != tgtok::IntVal) {
+  case tgtok::minus: {
+    Lex.Lex(); // eat
+
+    Init *I_End = ParseValue(nullptr);
+    IntInit *II_End = dyn_cast_or_null<IntInit>(I_End);
+    if (!II_End) {
       TokError("expected integer value as end of range");
       return true;
     }
-    End = Lex.getCurIntVal();
+
+    End = II_End->getValue();
     break;
-  case tgtok::IntVal:
+  }
+  case tgtok::IntVal: {
     End = -Lex.getCurIntVal();
+    Lex.Lex();
     break;
   }
+  }
   if (End < 0)
     return TokError("invalid range, cannot be negative");
-  Lex.Lex();
 
   // Add to the range.
   if (Start < End)
     for (; Start <= End; ++Start)
       Ranges.push_back(Start);
   else
     for (; Start >= End; --Start)
       Ranges.push_back(Start);
if (Lex.getCode() != tgtok::equal) {
     return nullptr;
   }
   Lex.Lex();  // Eat the '='
 
   RecTy *IterType = nullptr;
   SmallVector<unsigned, 16> Ranges;
 
   switch (Lex.getCode()) {
-  case tgtok::IntVal: { // RangePiece.
-    if (ParseRangePiece(Ranges))
-      return nullptr;
-    break;
-  }
-
   case tgtok::l_brace: { // '{' RangeList '}'
     Lex.Lex(); // eat the '{'
     ParseRangeList(Ranges);
     if (Lex.getCode() != tgtok::r_brace) {
       TokError("expected '}' at end of bit range list");
       return nullptr;
     }
     Lex.Lex();
     break;
   }
-
   default: {
     SMLoc ValueLoc = Lex.getLoc();
     Init *I = ParseValue(nullptr);
+    if (!I)
+      return nullptr;
+
     TypedInit *TI = dyn_cast<TypedInit>(I);
-    if (!TI || !isa<ListRecTy>(TI->getType())) {
-      std::string Type;
-      if (TI)
-        Type = (Twine("' of type '") + TI->getType()->getAsString()).str();
-      Error(ValueLoc, "expected a list, got '" + I->getAsString() + Type + "'");
-      if (CurMultiClass)
-        PrintNote({}, "references to multiclass template arguments cannot be "
-                      "resolved at this time");
-      return nullptr;
+    if (TI && isa<ListRecTy>(TI->getType())) {
+      ForeachListValue = I;
+      IterType = cast<ListRecTy>(TI->getType())->getElementType();
+      break;
+    }
+
+    if (TI) {
+      if (ParseRangePiece(Ranges, TI))
+        return nullptr;
+      break;
+    }
+
+    if (CurMultiClass) {
     }
-    ForeachListValue = I;
-    IterType = cast<ListRecTy>(TI->getType())->getElementType();
-    break;
+    return nullptr;
   }
   }
 
+
   if (!Ranges.empty()) {
     assert(!IterType && "Type already initialized?");
     IterType = IntRecTy::get();
     std::vector<Init*> Values;
     for (unsigned R : Ranges)
       Values.push_back(IntInit::get(R));
     ForeachListValue = ListInit::get(Values, IterType);
   }

test/TableGen/foreach-range-parse-errors0.td

+// RUN: not llvm-tblgen %s 2>&1 | FileCheck -DFILE=%s %s
+
+class ConstantsImpl {
+  int Zero = 0;
+  int One = 1;
+  int Two = 2;
+  int Three = 3;
+  int Five = 5;
+}
+
+def Constants : ConstantsImpl;
+
+// CHECK-NOT:  error: Unknown token when parsing a value
+// CHECK: [[FILE]]:[[@LINE+3]]:22: error: Unknown token when parsing a value
+// CHECK: [[FILE]]:[[@LINE+2]]:22: error: expected integer value as end of range
+// CHECK: [[FILE]]:[[@LINE+1]]:22: error: expected declaration in for
+foreach Index = 0 -  in {
+
+}

test/TableGen/foreach-range-parse-errors1.td

+// RUN: not llvm-tblgen %s 2>&1 | FileCheck -DFILE=%s %s
+
+// CHECK: [[FILE]]:[[@LINE+2]]:20: error: invalid range, cannot be negative
+// CHECK: [[FILE]]:[[@LINE+1]]:20: error: expected declaration in for
+foreach Index = -1 - 0 in {
+
+}
+

test/TableGen/foreach-range-parse-errors2.td

+// RUN: not llvm-tblgen %s 2>&1 | FileCheck -DFILE=%s %s
+
+class ConstantsImpl {
+  int NegOne = -1;
+}
+
+def Constants : ConstantsImpl;
+
+// CHECK: [[FILE]]:[[@LINE+2]]:38: error: invalid range, cannot be negative
+// CHECK: [[FILE]]:[[@LINE+1]]:38: error: expected declaration in for
+foreach Index = 0 - Constants.NegOne in {
+
+}

test/TableGen/foreach-range-parse-errors3.td

+// RUN: not llvm-tblgen %s 2>&1 | FileCheck -DFILE=%s %s
+
+// CHECK: [[FILE]]:[[@LINE+2]]:21: error: expected integer or bitrange
+// CHECK: [[FILE]]:[[@LINE+1]]:21: error: expected declaration in for
+foreach Index = "0" - 1 in {
+
+}
+

test/TableGen/foreach-range-parse-errors4.td

+// RUN: not llvm-tblgen %s 2>&1 | FileCheck -DFILE=%s %s
+// Make sure there is no crash on undefined variable
+
+// CHECK: [[FILE]]:[[@LINE+2]]:17: error: Variable not defined: 'foo'
+// CHECK: [[FILE]]:[[@LINE+1]]:21: error: expected declaration in for
+foreach Index = foo in {
+  def arst#Index;
+}
+

test/TableGen/foreach-range-parse-errors5.td

+// RUN: not llvm-tblgen %s 2>&1 | FileCheck -DFILE=%s %s
+
+// CHECK: [[FILE]]:[[@LINE+2]]:23: error: expected integer or bitrange
+// CHECK: [[FILE]]:[[@LINE+1]]:23: error: expected declaration in for
+foreach Index = 0b110 - 0b111 in {
+
+}
+

test/TableGen/foreach-variable-range.td

+// RUN: llvm-tblgen %s
+
+class ConstantsImpl {
+  int Zero = 0;
+  int One = 1;
+  int Two = 2;
+  int Three = 3;
+  int Five = 5;
+}
+
+def Constants : ConstantsImpl;
+
+// CHECK-DAG: def var_bound_whitespaceA0
+// CHECK-DAG: def var_bound_whitespaceA1
+// CHECK-DAG: def var_bound_whitespaceA2
+foreach Index = Constants.Zero - Constants.Two in {
+  def var_bound_whitespaceA#Index;
+}
+
+// CHECK-DAG: def var_bound_whitespaceB0
+// CHECK-DAG: def var_bound_whitespaceB1
+// CHECK-DAG: def var_bound_whitespaceB2
+foreach Index = Constants.Zero-Constants.Two in {
+  def var_bounds_whitespaceB#Index;
+}
+
+// CHECK-DAG: def var_bound_whitespaceC0
+// CHECK-DAG: def var_bound_whitespaceC1
+// CHECK-DAG: def var_bound_whitespaceC2
+foreach Index = Constants.Zero -Constants.Two in {
+  def var_bounds_whitespaceC#Index;
+}
+
+// CHECK-DAG: def var_bound_whitespaceD0
+// CHECK-DAG: def var_bound_whitespaceD1
+// CHECK-DAG: def var_bound_whitespaceD2
+foreach Index = Constants.Zero- Constants.Two in {
+  def var_bounds_whitespaceD#Index;
+}
+
+// CHECK-DAG: def const_lower_whitespaceA0
+// CHECK-DAG: def const_lower_whitespaceA1
+// CHECK-DAG: def const_lower_whitespaceA2
+foreach Index = 0 - Constants.Two in {
+  def const_lower_whitespaceA#Index;
+}
+
+// CHECK-DAG: def const_lower_whitespaceB0
+// CHECK-DAG: def const_lower_whitespaceB1
+// CHECK-DAG: def const_lower_whitespaceB2
+foreach Index = 0-Constants.Two in {
+  def const_lower_whitespaceB#Index;
+}
+
+// CHECK-DAG: def const_lower_whitespaceC0
+// CHECK-DAG: def const_lower_whitespaceC1
+// CHECK-DAG: def const_lower_whitespaceC2
+foreach Index = 0 -Constants.Two in {
+  def const_lower_whitespaceC#Index;
+}
+
+// CHECK-DAG: def const_lower_whitespaceD0
+// CHECK-DAG: def const_lower_whitespaceD1
+// CHECK-DAG: def const_lower_whitespaceD2
+foreach Index = 0- Constants.Two in {
+  def const_lower_whitespaceD#Index;
+}
+
+// CHECK-DAG: def const_upper_whitespaceA0
+// CHECK-DAG: def const_upper_whitespaceA1
+// CHECK-DAG: def const_upper_whitespaceA2
+foreach Index = Constants.Zero - 2 in {
+  def const_upper_whitespaceA#Index;
+}
+
+// CHECK-DAG: def const_upper_whitespaceB0
+// CHECK-DAG: def const_upper_whitespaceB1
+// CHECK-DAG: def const_upper_whitespaceB2
+foreach Index = Constants.Zero-2 in {
+  def const_upper_whitespaceB#Index;
+}
+
+// CHECK-DAG: def const_upper_whitespaceC0
+// CHECK-DAG: def const_upper_whitespaceC1
+// CHECK-DAG: def const_upper_whitespaceC2
+foreach Index = Constants.Zero -2 in {
+  def const_upper_whitespaceC#Index;
+}
+
+// CHECK-DAG: def const_upper_whitespaceD0
+// CHECK-DAG: def const_upper_whitespaceD1
+// CHECK-DAG: def const_upper_whitespaceD2
+foreach Index = Constants.Zero- 2 in {
+  def const_upper_whitespaceD#Index;
+}
+
+// CHECK-DAG: def multi_rangeA0
+// CHECK-DAG: def multi_rangeA1
+// CHECK-DAG: def multi_rangeA2
+// CHECK-DAG: def multi_rangeA3
+foreach Index = {Constants.Zero-Constants.One, Constants.Two-Constants.Three} in {
+  def multi_rangeA#Index;
+}
+
+// CHECK-DAG: def multi_rangeB0
+// CHECK-DAG: def multi_rangeB1
+// CHECK-DAG: def multi_rangeB3
+// CHECK-DAG: def multi_rangeB4
+// CHECK-DAG: def multi_rangeB5
+foreach Index = {0-Constants.One, Constants.Three-Constants.Five} in {
+  def multi_rangeB#Index;
+}
+
+// CHECK-DAG: def multi_rangeC0
+// CHECK-DAG: def multi_rangeC1
+// CHECK-DAG: def multi_rangeC2
+// CHECK-DAG: def multi_rangeC3
+foreach Index = {0-Constants.One, 2-Constants.Three} in {
+  def multi_rangeC#Index;
+}
+
+// CHECK-DAG: def multi_rangeD0
+// CHECK-DAG: def multi_rangeD1
+// CHECK-DAG: def multi_rangeD2
+// CHECK-DAG: def multi_rangeD3
+foreach Index = {0-1, Constants.Two-3} in {
+  def multi_rangeD#Index;
+}