[TableGen] [test] Change integer ranges to use new '...' punctuation.

[Paul-C-Anagnostopoulos]

Summary

I missed a few test files when I updated them to use the '...' punctuation instead of '.' in integer ranges.

I will auto-LGTM this revision in 24 hours.

[nhaehnle]

Does this mean it's time to remove the lo-hi syntax altogether?

[Paul-C-Anagnostopoulos]

There are two problems with doing that. I did not have the nerve to go through every .td file in LLVM and change the '-' to '...'. Even more importantly, I think we need to keep deprecated features for at least one version so that we do not screw up external users of TableGen, such as the fellow below.

But that does bring up the general question of deprecation policy. Do we concern ourselves with external users?

https://www.embecosm.com/2015/04/14/utilizing-tablegen-for-non-compiling-processes/

llvm/test/TableGen/Common/reg-with-subregs-common.td

class Indexes<int N> {
   list<int> slice =
     !foldl([]<int>, all, acc, cur,
            !listconcat(acc, !if(!lt(cur, N), [cur], [])));
 }
 
 #ifdef USE_NAMESPACE
   let Namespace = "TestNamespace" in {
 #endif
-foreach Index = 0-31 in {
+foreach Index = 0...31 in {
   def sub#Index : SubRegIndex<32, !shl(Index, 5)>;
 }
 
 foreach Size = {2,4,8,16} in {
   foreach Index = Indexes<!add(33, !mul(Size, -1))>.slice in {
     def !foldl("", Indexes<Size>.slice, acc, cur,
                !strconcat(acc#!if(!eq(acc,""),"","_"), "sub"#!add(cur, Index))) :
       SubRegIndex<!mul(Size, 32), !shl(Index, 5)> {
       let CoveringSubRegIndices =
         !foldl([]<SubRegIndex>, Indexes<Size>.slice, acc, cur,
                !listconcat(acc, [!cast<SubRegIndex>(sub#!add(cur, Index))]));
     }
   }
 }
 
-foreach Index = 0-255 in {
+foreach Index = 0...255 in {
   def R#Index : Register <"r"#Index>;
 }
 #ifdef USE_NAMESPACE
 }
 #endif
 
 def GPR32 : RegisterClass<"TestTarget", [i32], 32,
                           (add (sequence "R%u", 0, 255))>;

llvm/test/TableGen/FixedLenDecoderEmitter/InitValue.td

 let OutOperandList = (outs), Size = 2 in {
 
 def foo : Instruction {
     let InOperandList = (ins i32imm:$factor);
     field bits<16> Inst;
     field bits<16> SoftFail = 0;
     bits<8> factor;
     let factor{0} = 0; // zero initial value
-    let Inst{15-8} = factor{7-0};
+    let Inst{15...8} = factor{7...0};
     }
 
 def bar : Instruction {
     let InOperandList = (ins i32imm:$factor);
     field bits<16> Inst;
     field bits<16> SoftFail = 0;
     bits<8> factor;
     let factor{0} = 1; // non-zero initial value
-    let Inst{15-8} = factor{7-0};
+    let Inst{15...8} = factor{7...0};
     }
 
 def bax : Instruction {
     let InOperandList = (ins i32imm:$factor);
     field bits<16> Inst;
     field bits<16> SoftFail = 0;
     bits<33> factor;
     let factor{32} = 1; // non-zero initial value
-    let Inst{15-8} = factor{32-25};
+    let Inst{15...8} = factor{32...25};
     }
 
 }
 
 // CHECK: tmp = fieldFromInstruction(insn, 9, 7) << 1;
 // CHECK: tmp = 0x1;
 // CHECK: tmp |= fieldFromInstruction(insn, 9, 7) << 1;
 // CHECK: tmp = 0x100000000;
 // CHECK: tmp |= fieldFromInstruction(insn, 8, 7) << 25;

llvm/test/TableGen/FixedLenDecoderEmitter/conflict.td

class I<dag OOps, dag IOps, list<dag> Pat>
   let InOperandList = IOps;
   let Pattern = Pat;
   bits<32> Inst;
   bits<32> SoftFail;
 }
 
 def A : I<(outs GPR32:$dst), (ins GPR32:$src1), []> {
   let Size = 4;
-  let Inst{31-0} = 0;
+  let Inst{31...0} = 0;
 }
 def B : I<(outs GPR32:$dst), (ins GPR32:$src1), []> {
   let Size = 4;
-  let Inst{31-0} = 0;
+  let Inst{31...0} = 0;
 }
 
 // CHECK: Decoding Conflict:
 // CHECK:   00000000000000000000000000000000
 // CHECK:   ................................
 // CHECK: A 00000000000000000000000000000000
 // CHECK: B 00000000000000000000000000000000

llvm/unittests/TableGen/Automata.td

 
 // Emit those as a C++ enum using SearchableTables.
 def SymKind : GenericEnum {
   let FilterClass = "SymKindTy";
 }
 
 // Define a transition implementation.
 class SimpleTransition<bits<2> State, SymKindTy A> : Transition {
-  let NewState{1-0} = State;
+  let NewState{1...0} = State;
   SymKindTy ActionSym = A;
 }
 
 // Token SK_a sets bit 0b01.
 def : SimpleTransition<0b01, SK_a>;
 // Token SK_b sets bits 0b10.
 def : SimpleTransition<0b10, SK_b>;
 // Token SK_c sets both bits 0b11.
 def : SimpleTransition<0b11, SK_c>;
 
 def SimpleAutomaton : GenericAutomaton {
   let TransitionClass = "SimpleTransition";
   let SymbolFields = ["ActionSym"];
   // Override the type of ActionSym from SymKindTy to the C++ type SymKind.
   string TypeOf_ActionSym = "SymKind";
 }
 
 //===----------------------------------------------------------------------===//
 // TupleActionAutomaton test implementation
 
 // Define a transition implementation.
 class TupleTransition<bits<2> State, SymKindTy s1, SymKindTy s2, string s3> : Transition {
-  let NewState{1-0} = State;
+  let NewState{1...0} = State;
   SymKindTy S1 = s1;
   SymKindTy S2 = s2;
   string S3 = s3;
 }
 
 def : TupleTransition<0b01, SK_a, SK_b, "yeet">;
 def : TupleTransition<0b10, SK_b, SK_b, "foo">;
 def : TupleTransition<0b10, SK_c, SK_a, "foo">;
 
 def TupleAutomaton : GenericAutomaton {
   let TransitionClass = "TupleTransition";
   let SymbolFields = ["S1", "S2", "S3"];
   string TypeOf_S1 = "SymKind";
   string TypeOf_S2 = "SymKind";
 }
 
 //===----------------------------------------------------------------------===//
 // NfaAutomaton test implementation
 
 class NfaTransition<bits<2> State, SymKindTy S> : Transition {
-  let NewState{1-0} = State;
+  let NewState{1...0} = State;
   SymKindTy A = S;
 }
 
 // Symbols a and b can transition to 0b01 or 0b11 (sets bit 0).
 def : NfaTransition<0b01, SK_a>;
 def : NfaTransition<0b01, SK_b>;
 // Symbols a and b can also transition to 0b10 or 0b11 (sets bit 1).
 def : NfaTransition<0b10, SK_a>;