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";
}
Codebase Browser
llvm