@@ -12,7 +12,7 @@ include "mlir/IR/AttrTypeBase.td"
1212include "mlir/IR/OpBase.td"
1313
1414def Nbdl_Dialect : Dialect {
15- let name = "nbdl_gen ";
15+ let name = "nbdl ";
1616 let useDefaultTypePrinterParser = 1;
1717}
1818
@@ -28,9 +28,19 @@ class Nbdl_TypeBase<string name, string type_mnemonic,
2828
2929def Nbdl_OpaqueType : Nbdl_TypeBase<"OpaqueType", "opaque_type"> {
3030 let description = [{
31- If a C++ type is denoted without any additional semantic
32- information, then we call it opaque. This can be useful
33- for visitor functions, keys etc.
31+ Represent an unknown C++ type.
32+ }];
33+ }
34+
35+ def Nbdl_Struct : Nbdl_TypeBase<"Struct", "struct"> {
36+ let summary = "C++ semiregular aggregate type";
37+ let description = [{
38+ Represent C++ semiregular types whose members
39+ are accessed by their name.
40+
41+ Struct is equivalent to State except that there is no
42+ way to access the members without reflection or generated
43+ code.
3444 }];
3545}
3646
@@ -59,52 +69,80 @@ def Nbdl_Tag : Nbdl_TypeBase<"Tag", "tag_type"> {
5969 }];
6070}
6171
62- def Nbdl_Type : AnyTypeOf<[Nbdl_OpaqueType,
63- Nbdl_Store,
64- Nbdl_State,
65- Nbdl_Tag]>;
72+ def Nbdl_Symbol : Nbdl_TypeBase<"Symbol", "symbol_type"> {
73+ let summary = "Nbdl symbol type";
74+ let description = [{
75+ Represent a string that is a valid C++ identifier.
76+ The intended primary use case is to specify a member of a Struct.
77+ }];
78+ }
6679
6780// Keys are optional, but we are using variadic arguments
6881// so we resort to using this sum type.
69- def Nbdl_Key : AnyTypeOf<[Nbdl_OpaqueType, NoneType]>;
82+ def Nbdl_KeyType : AnyTypeOf<[Nbdl_OpaqueType, Nbdl_Tag,
83+ Nbdl_Symbol, NoneType]>;
84+
85+ def Nbdl_Type : AnyTypeOf<[Nbdl_OpaqueType,
86+ Nbdl_Store,
87+ Nbdl_Struct,
88+ Nbdl_State,
89+ Nbdl_Tag]>;
90+
91+ def Nbdl_TagAttr : AttrDef<Nbdl_Dialect, "tag_attr"> {
92+ let attrName = "nbdl.tag_attr";
93+ let parameters = (ins "::mlir::StringAttr":$cppTypeName);
94+ }
95+
96+ def Nbdl_TypenameAttr : AttrDef<Nbdl_Dialect, "typename_attr"> {
97+ let attrName = "nbdl.typename_attr";
98+ let parameters = (ins "::mlir::StringAttr":$cppTypeName);
99+ }
100+
101+ def Nbdl_SymbolAttr : AttrDef<Nbdl_Dialect, "symbol_attr"> {
102+ let attrName = "nbdl.symbol_attr";
103+ let parameters = (ins "::mlir::StringAttr":$cppIdentifier);
104+ }
105+
106+ def Nbdl_KeyAttr : AnyAttrOf<[Nbdl_TagAttr,
107+ Nbdl_TypenameAttr,
108+ Nbdl_SymbolAttr]>;
70109
71110class Nbdl_Op<string mnemonic, list<Trait> traits = []> :
72111 Op<Nbdl_Dialect, mnemonic, traits>;
73112
74- def Nbdl_TagOp : Nbdl_Op<"tag", []> {
75- let summary = "tag";
113+ // FIXME I think KeyOp is redundant with KeyAttr
114+ /*
115+ def Nbdl_KeyOp : Nbdl_Op<"key", []> {
116+ let summary = "key";
76117 let description = [{
77- Create an instance of a tag_type.
78- These are intended primarily for use as
79- keys and allow avoiding capture of stateless
80- values.
118+ Create an instance of a stateless key object.
119+ These are intended primarily to allow avoiding
120+ capture of stateless values.
81121 }];
82122
83- let results = (outs Nbdl_Tag:$result);
123+ let arguments = (ins Nbdl_KeyAttr:$key);
124+ let results = (outs Nbdl_Keytype:$result);
84125}
126+ */
85127
86128def Nbdl_GetOp : Nbdl_Op<"get", []> {
87129 let summary = "get";
88130 let description = [{
89131 }];
90132 let arguments = (ins Nbdl_State:$state,
91- Nbdl_Key :$key);
133+ Nbdl_KeyType :$key);
92134 let results = (outs Nbdl_OpaqueType:$result);
93135}
94136
95137def Nbdl_MatchOp : Nbdl_Op<"match", [Terminator, NoTerminator]> {
96138 let summary = "match";
97139 let description = [{
98- Given a continuation function, a nbdl::Store and, optionally, a key,
140+ Given a nbdl::Store and, optionally, a key,
99141 `match` visits an element contained within that Store using a
100- continuation for each of the possible typed alternatives .
142+ continuation for each of the possible specified overloads .
101143
102- Stores match values of different types, so a region is
103- used to provide the continuation for each possible
104- alternative which is checked linearly.
105-
106- It is an error for the matched object to not have a matching
107- alternative.
144+ It is an error if there exists an alternative for which there
145+ exists no matching overload.
108146
109147 For an example, a `std::unordered_map<int, std::string>` is a store
110148 that can provide access to a contained element with a key `5`. If the
@@ -113,33 +151,39 @@ def Nbdl_MatchOp : Nbdl_Op<"match", [Terminator, NoTerminator]> {
113151 also provides access to its contained element without a key
114152 (ie it is just unwrapped). This requires a visitor to be overloaded
115153 with every possible alternative.
116-
117- Each region receives fn, store, and the captures as their
118- arguments.
119154 }];
120- let arguments = (ins Nbdl_OpaqueType:$fn,
121- AnyTypeOf<[Nbdl_Store, Nbdl_State]>:$store,
122- Nbdl_Key:$key,
123- Variadic<Nbdl_Type>:$captures);
155+ // FIXME $store should only be a Nbdl_Store right?
156+ let arguments = (ins Nbdl_Store:$store,
157+ Nbdl_KeyType:$key);
124158 let results = (outs);
125159 let regions = (region SizedRegion<1>:$overloads);
126160}
127161
128162def Nbdl_OverloadOp : Nbdl_Op<"overload", []> {
129163 let description = [{
130164 In the region of a MatchOp we specify a function overload of the
131- given Nbdl_OpaqueType using OverloadOp.
132- Each overload is checked linearly (sequentially) and a valid
133- overload serves as a continuation.
134- It is an error if no overload matches the matched alternative.
165+ given Nbdl_TypenameAttr using OverloadOp.
166+ The body of the overload takes an argument that is the matched
167+ object and the rest of the arguments are the captures.
135168 }];
136- let arguments = (ins Nbdl_Type:$arg ,
169+ let arguments = (ins Nbdl_TypenameAttr:$typeName ,
137170 Variadic<Nbdl_Type>:$captures);
138171 let results = (outs);
172+ let regions = (region SizedRegion<1>:$body);
173+ }
174+
175+ def Nbdl_MatchIfOp : Nbdl_Op<"match_if", [Terminator]> {
176+ let description = [{
177+ Apply a predicate to an object and branch on the result
178+ like an if/else statement.
179+ }];
180+
181+ let arguments = (ins Nbdl_Type:$obj, Nbdl_OpaqueType:$pred);
182+ let regions = (region SizedRegion<1>:$thenRegion,
183+ SizedRegion<1>:$elseRegion);
139184}
140185
141186def Nbdl_ContOp : Nbdl_Op<"cont", [Terminator]> {
142- let summary = "cont";
143187 let description = [{
144188 ContOp represents the call to an opaque continuation object
145189 passing the resolved object and any additional captures
@@ -151,4 +195,12 @@ def Nbdl_ContOp : Nbdl_Op<"cont", [Terminator]> {
151195 let results = (outs);
152196}
153197
198+ def Nbdl_ConstexprOp : Nbdl_Op<"constexpr", []> {
199+ let description = [{
200+ The result of a constant expression in C++.
201+ }];
202+ let arguments = (ins StrAttr:$expr);
203+ let results = (outs Nbdl_OpaqueType:$result);
204+ }
205+
154206#endif
0 commit comments