llvm-project/llvm/unittests/TableGen/Automata.td

include "llvm/TableGen/Automaton.td"
include "llvm/TableGen/SearchableTable.td"

// Define a set of input token symbols.
class SymKindTy;
def SK_a : SymKindTy;
def SK_b : SymKindTy;
def SK_c : SymKindTy;
def SK_d : SymKindTy;

// 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;
  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;
  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;
  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>;
def : NfaTransition<0b10, SK_b>;

def NfaAutomaton : GenericAutomaton {
  let TransitionClass = "NfaTransition";
  let SymbolFields = ["A"];
  string TypeOf_A = "SymKind";
}

//===----------------------------------------------------------------------===//
// BinPacker test implementation
//===----------------------------------------------------------------------===//
// This test generates an automaton that can pack values into bins subject to
// constraints. There are 6 possible bins, and the input tokens are constraint
// types. Some input types span two bins.

// The symbol type for a bin constraint. We use lists of ints as a tblgen hack
// to conditionally generate defs within multiclasses based on record
// information. A bin is nonempty (has a dummy one-element value) if enabled.
class BinRequirementKind {
  list<int> Bin0 = [];
  list<int> Bin1 = [];
  list<int> Bin2 = [];
  list<int> Bin3 = [];
  list<int> Bin4 = [];
  list<int> Bin5 = [];
}
// Can use bins {0-3}
def BRK_0_to_4    : BinRequirementKind { let Bin0 = [1]; let Bin1 = [1]; let Bin2 = [1]; let Bin3 = [1]; }
// Can use bins {0-3} but only evens (0 and 2).
def BRK_0_to_4_lo : BinRequirementKind { let Bin0 = [1]; let Bin2 = [1]; }
// Can use bins {0-3} but only odds (1 and 3).
def BRK_0_to_4_hi : BinRequirementKind { let Bin1 = [1]; let Bin3 = [1]; }
// Can use bins {0-3} but only even-odd pairs (0+1 or 1+2).
def BRK_0_to_4_dbl : BinRequirementKind { let Bin0 = [1]; let Bin2 = [1]; }
def BRK_0_to_6 :    BinRequirementKind { let Bin0 = [1]; let Bin1 = [1]; let Bin2 = [1];
                                         let Bin3 = [1]; let Bin4 = [1]; let Bin5 = [1]; }
def BRK_0_to_6_lo : BinRequirementKind { let Bin0 = [1]; let Bin2 = [1]; let Bin4 = [1]; }
def BRK_0_to_6_hi : BinRequirementKind { let Bin1 = [1]; let Bin3 = [1]; let Bin5 = [1]; }
def BRK_0_to_6_dbl : BinRequirementKind { let Bin0 = [1]; let Bin2 = [1]; let Bin4 = [1]; }
def BRK_2_to_6 :    BinRequirementKind { let Bin2 = [1];
                                         let Bin3 = [1]; let Bin4 = [1]; let Bin5 = [1]; }
def BRK_2_to_6_lo : BinRequirementKind { let Bin2 = [1]; let Bin4 = [1]; }
def BRK_2_to_6_hi : BinRequirementKind { let Bin3 = [1]; let Bin5 = [1];}
def BRK_2_to_6_dbl : BinRequirementKind { let Bin2 = [1]; let Bin4 = [1]; }
def BRK_2_to_4 :    BinRequirementKind { let Bin2 = [1]; let Bin3 = [1]; }
def BRK_2_to_4_lo : BinRequirementKind { let Bin2 = [1]; }
def BRK_2_to_4_hi : BinRequirementKind { let Bin3 = [1]; }
def BRK_2_to_4_dbl : BinRequirementKind { let Bin2 = [1]; }

def BinRequirementKindEnum : GenericEnum {
  let FilterClass = "BinRequirementKind";
}

// The transition class is trivial; it just contains the constraint symbol.
class BinTransition : Transition {
  BinRequirementKind Sym;
}

// Mixin that occupies a single bin.
class Bin0 : BinTransition { let NewState{0} = 1; }
class Bin1 : BinTransition { let NewState{1} = 1; }
class Bin2 : BinTransition { let NewState{2} = 1;}
class Bin3 : BinTransition { let NewState{3} = 1; }
class Bin4 : BinTransition { let NewState{4} = 1;}
class Bin5 : BinTransition { let NewState{5} = 1; }
// Mixin that occupies a pair of bins (even-odd pairs).
class Bin01 : BinTransition { let NewState{0,1} = 0b11; }
class Bin23 : BinTransition { let NewState{2,3} = 0b11; }
class Bin45 : BinTransition { let NewState{4,5} = 0b11; }

// Instantiate all possible bin assignments for E.
multiclass BinAssignments<BinRequirementKind E> {
  let Sym = E in {
    // Note the tablegen hack to conditionally instantiate a def based on E.
    foreach x = E.Bin0 in { def : Bin0; }
    foreach x = E.Bin1 in { def : Bin1; }
    foreach x = E.Bin2 in { def : Bin2; }
    foreach x = E.Bin3 in { def : Bin3; }
    foreach x = E.Bin4 in { def : Bin4; }
    foreach x = E.Bin5 in { def : Bin5; }
  }
}

// Instantiate all possible bin assignments for E, which spans even-odd pairs.
multiclass DblBinAssignments<BinRequirementKind E> {
  let Sym = E in {
    foreach x = E.Bin0 in { def : Bin01; }
    foreach x = E.Bin2 in { def : Bin23; }
    foreach x = E.Bin4 in { def : Bin45; }
  }
}

defm : BinAssignments<BRK_0_to_4>;
defm : DblBinAssignments<BRK_0_to_4_dbl>;
defm : BinAssignments<BRK_0_to_4_lo>;
defm : BinAssignments<BRK_0_to_4_hi>;
defm : BinAssignments<BRK_0_to_6>;
defm : DblBinAssignments<BRK_0_to_6_dbl>;
defm : BinAssignments<BRK_0_to_6_lo>;
defm : BinAssignments<BRK_0_to_6_hi>;
defm : BinAssignments<BRK_2_to_6>;
defm : DblBinAssignments<BRK_2_to_6_dbl>;
defm : BinAssignments<BRK_2_to_6_lo>;
defm : BinAssignments<BRK_2_to_6_hi>;
defm : BinAssignments<BRK_2_to_4>;
defm : DblBinAssignments<BRK_2_to_4_dbl>;
defm : BinAssignments<BRK_2_to_4_lo>;
defm : BinAssignments<BRK_2_to_4_hi>;

def BinPackerAutomaton : GenericAutomaton {
  let TransitionClass = "BinTransition";
  let SymbolFields = ["Sym"];
  string TypeOf_Sym = "BinRequirementKindEnum";
}