MLIR  19.0.0git
Nodes.cpp
Go to the documentation of this file.
1 //===- Nodes.cpp ----------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
11 #include "llvm/ADT/SmallPtrSet.h"
12 #include "llvm/ADT/TypeSwitch.h"
13 #include <optional>
14 
15 using namespace mlir;
16 using namespace mlir::pdll::ast;
17 
18 /// Copy a string reference into the context with a null terminator.
19 static StringRef copyStringWithNull(Context &ctx, StringRef str) {
20  if (str.empty())
21  return str;
22 
23  char *data = ctx.getAllocator().Allocate<char>(str.size() + 1);
24  std::copy(str.begin(), str.end(), data);
25  data[str.size()] = 0;
26  return StringRef(data, str.size());
27 }
28 
29 //===----------------------------------------------------------------------===//
30 // Name
31 //===----------------------------------------------------------------------===//
32 
33 const Name &Name::create(Context &ctx, StringRef name, SMRange location) {
34  return *new (ctx.getAllocator().Allocate<Name>())
35  Name(copyStringWithNull(ctx, name), location);
36 }
37 
38 //===----------------------------------------------------------------------===//
39 // Node
40 //===----------------------------------------------------------------------===//
41 
42 namespace {
43 class NodeVisitor {
44 public:
45  explicit NodeVisitor(function_ref<void(const Node *)> visitFn)
46  : visitFn(visitFn) {}
47 
48  void visit(const Node *node) {
49  if (!node || !alreadyVisited.insert(node).second)
50  return;
51 
52  visitFn(node);
54  .Case<
55  // Statements.
56  const CompoundStmt, const EraseStmt, const LetStmt,
57  const ReplaceStmt, const ReturnStmt, const RewriteStmt,
58 
59  // Expressions.
60  const AttributeExpr, const CallExpr, const DeclRefExpr,
61  const MemberAccessExpr, const OperationExpr, const RangeExpr,
62  const TupleExpr, const TypeExpr,
63 
64  // Core Constraint Decls.
68 
69  // Decls.
70  const NamedAttributeDecl, const OpNameDecl, const PatternDecl,
72 
73  const Module>(
74  [&](auto derivedNode) { this->visitImpl(derivedNode); })
75  .Default([](const Node *) { llvm_unreachable("unknown AST node"); });
76  }
77 
78 private:
79  void visitImpl(const CompoundStmt *stmt) {
80  for (const Node *child : stmt->getChildren())
81  visit(child);
82  }
83  void visitImpl(const EraseStmt *stmt) { visit(stmt->getRootOpExpr()); }
84  void visitImpl(const LetStmt *stmt) { visit(stmt->getVarDecl()); }
85  void visitImpl(const ReplaceStmt *stmt) {
86  visit(stmt->getRootOpExpr());
87  for (const Node *child : stmt->getReplExprs())
88  visit(child);
89  }
90  void visitImpl(const ReturnStmt *stmt) { visit(stmt->getResultExpr()); }
91  void visitImpl(const RewriteStmt *stmt) {
92  visit(stmt->getRootOpExpr());
93  visit(stmt->getRewriteBody());
94  }
95 
96  void visitImpl(const AttributeExpr *expr) {}
97  void visitImpl(const CallExpr *expr) {
98  visit(expr->getCallableExpr());
99  for (const Node *child : expr->getArguments())
100  visit(child);
101  }
102  void visitImpl(const DeclRefExpr *expr) { visit(expr->getDecl()); }
103  void visitImpl(const MemberAccessExpr *expr) { visit(expr->getParentExpr()); }
104  void visitImpl(const OperationExpr *expr) {
105  visit(expr->getNameDecl());
106  for (const Node *child : expr->getOperands())
107  visit(child);
108  for (const Node *child : expr->getResultTypes())
109  visit(child);
110  for (const Node *child : expr->getAttributes())
111  visit(child);
112  }
113  void visitImpl(const RangeExpr *expr) {
114  for (const Node *child : expr->getElements())
115  visit(child);
116  }
117  void visitImpl(const TupleExpr *expr) {
118  for (const Node *child : expr->getElements())
119  visit(child);
120  }
121  void visitImpl(const TypeExpr *expr) {}
122 
123  void visitImpl(const AttrConstraintDecl *decl) { visit(decl->getTypeExpr()); }
124  void visitImpl(const OpConstraintDecl *decl) { visit(decl->getNameDecl()); }
125  void visitImpl(const TypeConstraintDecl *decl) {}
126  void visitImpl(const TypeRangeConstraintDecl *decl) {}
127  void visitImpl(const ValueConstraintDecl *decl) {
128  visit(decl->getTypeExpr());
129  }
130  void visitImpl(const ValueRangeConstraintDecl *decl) {
131  visit(decl->getTypeExpr());
132  }
133 
134  void visitImpl(const NamedAttributeDecl *decl) { visit(decl->getValue()); }
135  void visitImpl(const OpNameDecl *decl) {}
136  void visitImpl(const PatternDecl *decl) { visit(decl->getBody()); }
137  void visitImpl(const UserConstraintDecl *decl) {
138  for (const Node *child : decl->getInputs())
139  visit(child);
140  for (const Node *child : decl->getResults())
141  visit(child);
142  visit(decl->getBody());
143  }
144  void visitImpl(const UserRewriteDecl *decl) {
145  for (const Node *child : decl->getInputs())
146  visit(child);
147  for (const Node *child : decl->getResults())
148  visit(child);
149  visit(decl->getBody());
150  }
151  void visitImpl(const VariableDecl *decl) {
152  visit(decl->getInitExpr());
153  for (const ConstraintRef &child : decl->getConstraints())
154  visit(child.constraint);
155  }
156 
157  void visitImpl(const Module *module) {
158  for (const Node *child : module->getChildren())
159  visit(child);
160  }
161 
162  function_ref<void(const Node *)> visitFn;
163  SmallPtrSet<const Node *, 16> alreadyVisited;
164 };
165 } // namespace
166 
167 void Node::walk(function_ref<void(const Node *)> walkFn) const {
168  return NodeVisitor(walkFn).visit(this);
169 }
170 
171 //===----------------------------------------------------------------------===//
172 // DeclScope
173 //===----------------------------------------------------------------------===//
174 
175 void DeclScope::add(Decl *decl) {
176  const Name *name = decl->getName();
177  assert(name && "expected a named decl");
178  assert(!decls.count(name->getName()) && "decl with this name already exists");
179  decls.try_emplace(name->getName(), decl);
180 }
181 
182 Decl *DeclScope::lookup(StringRef name) {
183  if (Decl *decl = decls.lookup(name))
184  return decl;
185  return parent ? parent->lookup(name) : nullptr;
186 }
187 
188 //===----------------------------------------------------------------------===//
189 // CompoundStmt
190 //===----------------------------------------------------------------------===//
191 
193  ArrayRef<Stmt *> children) {
194  unsigned allocSize = CompoundStmt::totalSizeToAlloc<Stmt *>(children.size());
195  void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(CompoundStmt));
196 
197  CompoundStmt *stmt = new (rawData) CompoundStmt(loc, children.size());
198  std::uninitialized_copy(children.begin(), children.end(),
199  stmt->getChildren().begin());
200  return stmt;
201 }
202 
203 //===----------------------------------------------------------------------===//
204 // LetStmt
205 //===----------------------------------------------------------------------===//
206 
207 LetStmt *LetStmt::create(Context &ctx, SMRange loc, VariableDecl *varDecl) {
208  return new (ctx.getAllocator().Allocate<LetStmt>()) LetStmt(loc, varDecl);
209 }
210 
211 //===----------------------------------------------------------------------===//
212 // OpRewriteStmt
213 //===----------------------------------------------------------------------===//
214 
215 //===----------------------------------------------------------------------===//
216 // EraseStmt
217 
218 EraseStmt *EraseStmt::create(Context &ctx, SMRange loc, Expr *rootOp) {
219  return new (ctx.getAllocator().Allocate<EraseStmt>()) EraseStmt(loc, rootOp);
220 }
221 
222 //===----------------------------------------------------------------------===//
223 // ReplaceStmt
224 
225 ReplaceStmt *ReplaceStmt::create(Context &ctx, SMRange loc, Expr *rootOp,
226  ArrayRef<Expr *> replExprs) {
227  unsigned allocSize = ReplaceStmt::totalSizeToAlloc<Expr *>(replExprs.size());
228  void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(ReplaceStmt));
229 
230  ReplaceStmt *stmt = new (rawData) ReplaceStmt(loc, rootOp, replExprs.size());
231  std::uninitialized_copy(replExprs.begin(), replExprs.end(),
232  stmt->getReplExprs().begin());
233  return stmt;
234 }
235 
236 //===----------------------------------------------------------------------===//
237 // RewriteStmt
238 
239 RewriteStmt *RewriteStmt::create(Context &ctx, SMRange loc, Expr *rootOp,
240  CompoundStmt *rewriteBody) {
241  return new (ctx.getAllocator().Allocate<RewriteStmt>())
242  RewriteStmt(loc, rootOp, rewriteBody);
243 }
244 
245 //===----------------------------------------------------------------------===//
246 // ReturnStmt
247 //===----------------------------------------------------------------------===//
248 
249 ReturnStmt *ReturnStmt::create(Context &ctx, SMRange loc, Expr *resultExpr) {
250  return new (ctx.getAllocator().Allocate<ReturnStmt>())
251  ReturnStmt(loc, resultExpr);
252 }
253 
254 //===----------------------------------------------------------------------===//
255 // AttributeExpr
256 //===----------------------------------------------------------------------===//
257 
259  StringRef value) {
260  return new (ctx.getAllocator().Allocate<AttributeExpr>())
261  AttributeExpr(ctx, loc, copyStringWithNull(ctx, value));
262 }
263 
264 //===----------------------------------------------------------------------===//
265 // CallExpr
266 //===----------------------------------------------------------------------===//
267 
268 CallExpr *CallExpr::create(Context &ctx, SMRange loc, Expr *callable,
269  ArrayRef<Expr *> arguments, Type resultType,
270  bool isNegated) {
271  unsigned allocSize = CallExpr::totalSizeToAlloc<Expr *>(arguments.size());
272  void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(CallExpr));
273 
274  CallExpr *expr = new (rawData)
275  CallExpr(loc, resultType, callable, arguments.size(), isNegated);
276  std::uninitialized_copy(arguments.begin(), arguments.end(),
277  expr->getArguments().begin());
278  return expr;
279 }
280 
281 //===----------------------------------------------------------------------===//
282 // DeclRefExpr
283 //===----------------------------------------------------------------------===//
284 
285 DeclRefExpr *DeclRefExpr::create(Context &ctx, SMRange loc, Decl *decl,
286  Type type) {
287  return new (ctx.getAllocator().Allocate<DeclRefExpr>())
288  DeclRefExpr(loc, decl, type);
289 }
290 
291 //===----------------------------------------------------------------------===//
292 // MemberAccessExpr
293 //===----------------------------------------------------------------------===//
294 
296  const Expr *parentExpr,
297  StringRef memberName, Type type) {
298  return new (ctx.getAllocator().Allocate<MemberAccessExpr>()) MemberAccessExpr(
299  loc, parentExpr, memberName.copy(ctx.getAllocator()), type);
300 }
301 
302 //===----------------------------------------------------------------------===//
303 // OperationExpr
304 //===----------------------------------------------------------------------===//
305 
307 OperationExpr::create(Context &ctx, SMRange loc, const ods::Operation *odsOp,
308  const OpNameDecl *name, ArrayRef<Expr *> operands,
309  ArrayRef<Expr *> resultTypes,
310  ArrayRef<NamedAttributeDecl *> attributes) {
311  unsigned allocSize =
312  OperationExpr::totalSizeToAlloc<Expr *, NamedAttributeDecl *>(
313  operands.size() + resultTypes.size(), attributes.size());
314  void *rawData =
315  ctx.getAllocator().Allocate(allocSize, alignof(OperationExpr));
316 
317  Type resultType = OperationType::get(ctx, name->getName(), odsOp);
318  OperationExpr *opExpr = new (rawData)
319  OperationExpr(loc, resultType, name, operands.size(), resultTypes.size(),
320  attributes.size(), name->getLoc());
321  std::uninitialized_copy(operands.begin(), operands.end(),
322  opExpr->getOperands().begin());
323  std::uninitialized_copy(resultTypes.begin(), resultTypes.end(),
324  opExpr->getResultTypes().begin());
325  std::uninitialized_copy(attributes.begin(), attributes.end(),
326  opExpr->getAttributes().begin());
327  return opExpr;
328 }
329 
330 std::optional<StringRef> OperationExpr::getName() const {
331  return getNameDecl()->getName();
332 }
333 
334 //===----------------------------------------------------------------------===//
335 // RangeExpr
336 //===----------------------------------------------------------------------===//
337 
339  ArrayRef<Expr *> elements, RangeType type) {
340  unsigned allocSize = RangeExpr::totalSizeToAlloc<Expr *>(elements.size());
341  void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(TupleExpr));
342 
343  RangeExpr *expr = new (rawData) RangeExpr(loc, type, elements.size());
344  std::uninitialized_copy(elements.begin(), elements.end(),
345  expr->getElements().begin());
346  return expr;
347 }
348 
349 //===----------------------------------------------------------------------===//
350 // TupleExpr
351 //===----------------------------------------------------------------------===//
352 
354  ArrayRef<Expr *> elements,
355  ArrayRef<StringRef> names) {
356  unsigned allocSize = TupleExpr::totalSizeToAlloc<Expr *>(elements.size());
357  void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(TupleExpr));
358 
359  auto elementTypes = llvm::map_range(
360  elements, [](const Expr *expr) { return expr->getType(); });
361  TupleType type = TupleType::get(ctx, llvm::to_vector(elementTypes), names);
362 
363  TupleExpr *expr = new (rawData) TupleExpr(loc, type);
364  std::uninitialized_copy(elements.begin(), elements.end(),
365  expr->getElements().begin());
366  return expr;
367 }
368 
369 //===----------------------------------------------------------------------===//
370 // TypeExpr
371 //===----------------------------------------------------------------------===//
372 
373 TypeExpr *TypeExpr::create(Context &ctx, SMRange loc, StringRef value) {
374  return new (ctx.getAllocator().Allocate<TypeExpr>())
375  TypeExpr(ctx, loc, copyStringWithNull(ctx, value));
376 }
377 
378 //===----------------------------------------------------------------------===//
379 // Decl
380 //===----------------------------------------------------------------------===//
381 
382 void Decl::setDocComment(Context &ctx, StringRef comment) {
383  docComment = comment.copy(ctx.getAllocator());
384 }
385 
386 //===----------------------------------------------------------------------===//
387 // AttrConstraintDecl
388 //===----------------------------------------------------------------------===//
389 
391  Expr *typeExpr) {
392  return new (ctx.getAllocator().Allocate<AttrConstraintDecl>())
394 }
395 
396 //===----------------------------------------------------------------------===//
397 // OpConstraintDecl
398 //===----------------------------------------------------------------------===//
399 
401  const OpNameDecl *nameDecl) {
402  if (!nameDecl)
403  nameDecl = OpNameDecl::create(ctx, SMRange());
404 
405  return new (ctx.getAllocator().Allocate<OpConstraintDecl>())
407 }
408 
409 std::optional<StringRef> OpConstraintDecl::getName() const {
410  return getNameDecl()->getName();
411 }
412 
413 //===----------------------------------------------------------------------===//
414 // TypeConstraintDecl
415 //===----------------------------------------------------------------------===//
416 
418  return new (ctx.getAllocator().Allocate<TypeConstraintDecl>())
419  TypeConstraintDecl(loc);
420 }
421 
422 //===----------------------------------------------------------------------===//
423 // TypeRangeConstraintDecl
424 //===----------------------------------------------------------------------===//
425 
427  SMRange loc) {
428  return new (ctx.getAllocator().Allocate<TypeRangeConstraintDecl>())
430 }
431 
432 //===----------------------------------------------------------------------===//
433 // ValueConstraintDecl
434 //===----------------------------------------------------------------------===//
435 
437  Expr *typeExpr) {
438  return new (ctx.getAllocator().Allocate<ValueConstraintDecl>())
440 }
441 
442 //===----------------------------------------------------------------------===//
443 // ValueRangeConstraintDecl
444 //===----------------------------------------------------------------------===//
445 
447 ValueRangeConstraintDecl::create(Context &ctx, SMRange loc, Expr *typeExpr) {
448  return new (ctx.getAllocator().Allocate<ValueRangeConstraintDecl>())
450 }
451 
452 //===----------------------------------------------------------------------===//
453 // UserConstraintDecl
454 //===----------------------------------------------------------------------===//
455 
456 std::optional<StringRef>
458  return hasNativeInputTypes ? getTrailingObjects<StringRef>()[index]
459  : std::optional<StringRef>();
460 }
461 
462 UserConstraintDecl *UserConstraintDecl::createImpl(
463  Context &ctx, const Name &name, ArrayRef<VariableDecl *> inputs,
464  ArrayRef<StringRef> nativeInputTypes, ArrayRef<VariableDecl *> results,
465  std::optional<StringRef> codeBlock, const CompoundStmt *body,
466  Type resultType) {
467  bool hasNativeInputTypes = !nativeInputTypes.empty();
468  assert(!hasNativeInputTypes || nativeInputTypes.size() == inputs.size());
469 
470  unsigned allocSize =
471  UserConstraintDecl::totalSizeToAlloc<VariableDecl *, StringRef>(
472  inputs.size() + results.size(),
473  hasNativeInputTypes ? inputs.size() : 0);
474  void *rawData =
475  ctx.getAllocator().Allocate(allocSize, alignof(UserConstraintDecl));
476  if (codeBlock)
477  codeBlock = codeBlock->copy(ctx.getAllocator());
478 
479  UserConstraintDecl *decl = new (rawData)
480  UserConstraintDecl(name, inputs.size(), hasNativeInputTypes,
481  results.size(), codeBlock, body, resultType);
482  std::uninitialized_copy(inputs.begin(), inputs.end(),
483  decl->getInputs().begin());
484  std::uninitialized_copy(results.begin(), results.end(),
485  decl->getResults().begin());
486  if (hasNativeInputTypes) {
487  StringRef *nativeInputTypesPtr = decl->getTrailingObjects<StringRef>();
488  for (unsigned i = 0, e = inputs.size(); i < e; ++i)
489  nativeInputTypesPtr[i] = nativeInputTypes[i].copy(ctx.getAllocator());
490  }
491 
492  return decl;
493 }
494 
495 //===----------------------------------------------------------------------===//
496 // NamedAttributeDecl
497 //===----------------------------------------------------------------------===//
498 
500  Expr *value) {
501  return new (ctx.getAllocator().Allocate<NamedAttributeDecl>())
502  NamedAttributeDecl(name, value);
503 }
504 
505 //===----------------------------------------------------------------------===//
506 // OpNameDecl
507 //===----------------------------------------------------------------------===//
508 
510  return new (ctx.getAllocator().Allocate<OpNameDecl>()) OpNameDecl(name);
511 }
512 OpNameDecl *OpNameDecl::create(Context &ctx, SMRange loc) {
513  return new (ctx.getAllocator().Allocate<OpNameDecl>()) OpNameDecl(loc);
514 }
515 
516 //===----------------------------------------------------------------------===//
517 // PatternDecl
518 //===----------------------------------------------------------------------===//
519 
520 PatternDecl *PatternDecl::create(Context &ctx, SMRange loc, const Name *name,
521  std::optional<uint16_t> benefit,
522  bool hasBoundedRecursion,
523  const CompoundStmt *body) {
524  return new (ctx.getAllocator().Allocate<PatternDecl>())
525  PatternDecl(loc, name, benefit, hasBoundedRecursion, body);
526 }
527 
528 //===----------------------------------------------------------------------===//
529 // UserRewriteDecl
530 //===----------------------------------------------------------------------===//
531 
532 UserRewriteDecl *UserRewriteDecl::createImpl(Context &ctx, const Name &name,
534  ArrayRef<VariableDecl *> results,
535  std::optional<StringRef> codeBlock,
536  const CompoundStmt *body,
537  Type resultType) {
538  unsigned allocSize = UserRewriteDecl::totalSizeToAlloc<VariableDecl *>(
539  inputs.size() + results.size());
540  void *rawData =
541  ctx.getAllocator().Allocate(allocSize, alignof(UserRewriteDecl));
542  if (codeBlock)
543  codeBlock = codeBlock->copy(ctx.getAllocator());
544 
545  UserRewriteDecl *decl = new (rawData) UserRewriteDecl(
546  name, inputs.size(), results.size(), codeBlock, body, resultType);
547  std::uninitialized_copy(inputs.begin(), inputs.end(),
548  decl->getInputs().begin());
549  std::uninitialized_copy(results.begin(), results.end(),
550  decl->getResults().begin());
551  return decl;
552 }
553 
554 //===----------------------------------------------------------------------===//
555 // VariableDecl
556 //===----------------------------------------------------------------------===//
557 
559  Expr *initExpr,
560  ArrayRef<ConstraintRef> constraints) {
561  unsigned allocSize =
562  VariableDecl::totalSizeToAlloc<ConstraintRef>(constraints.size());
563  void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(VariableDecl));
564 
565  VariableDecl *varDecl =
566  new (rawData) VariableDecl(name, type, initExpr, constraints.size());
567  std::uninitialized_copy(constraints.begin(), constraints.end(),
568  varDecl->getConstraints().begin());
569  return varDecl;
570 }
571 
572 //===----------------------------------------------------------------------===//
573 // Module
574 //===----------------------------------------------------------------------===//
575 
576 Module *Module::create(Context &ctx, SMLoc loc, ArrayRef<Decl *> children) {
577  unsigned allocSize = Module::totalSizeToAlloc<Decl *>(children.size());
578  void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(Module));
579 
580  Module *module = new (rawData) Module(loc, children.size());
581  std::uninitialized_copy(children.begin(), children.end(),
582  module->getChildren().begin());
583  return module;
584 }
static void copy(Location loc, Value dst, Value src, Value size, OpBuilder &builder)
Copies the given number of bytes from src to dst pointers.
static void visit(Operation *op, DenseSet< Operation * > &visited)
Visits all the pdl.operand(s), pdl.result(s), and pdl.operation(s) connected to the given operation.
Definition: PDL.cpp:63
static StringRef copyStringWithNull(Context &ctx, StringRef str)
Copy a string reference into the context with a null terminator.
Definition: Nodes.cpp:19
The class represents an Attribute constraint, and constrains a variable to be an Attribute.
Definition: Nodes.h:749
Expr * typeExpr
An optional type that the attribute is constrained to.
Definition: Nodes.h:763
static AttrConstraintDecl * create(Context &ctx, SMRange loc, Expr *typeExpr=nullptr)
Definition: Nodes.cpp:390
Expr * getTypeExpr()
Return the optional type the attribute is constrained to.
Definition: Nodes.h:755
AttrConstraintDecl(SMRange loc, Expr *typeExpr)
Definition: Nodes.h:759
This expression represents a literal MLIR Attribute, and contains the textual assembly format of that...
Definition: Nodes.h:367
static AttributeExpr * create(Context &ctx, SMRange loc, StringRef value)
Definition: Nodes.cpp:258
This expression represents a call to a decl, such as a UserConstraintDecl/UserRewriteDecl.
Definition: Nodes.h:390
Expr * getCallableExpr() const
Return the callable of this call.
Definition: Nodes.h:397
MutableArrayRef< Expr * > getArguments()
Return the arguments of this call.
Definition: Nodes.h:400
static CallExpr * create(Context &ctx, SMRange loc, Expr *callable, ArrayRef< Expr * > arguments, Type resultType, bool isNegated=false)
Definition: Nodes.cpp:268
This statement represents a compound statement, which contains a collection of other statements.
Definition: Nodes.h:179
MutableArrayRef< Stmt * > getChildren()
Return the children of this compound statement.
Definition: Nodes.h:185
static CompoundStmt * create(Context &ctx, SMRange location, ArrayRef< Stmt * > children)
Definition: Nodes.cpp:192
This class represents the main context of the PDLL AST.
Definition: Context.h:25
llvm::BumpPtrAllocator & getAllocator()
Return the allocator owned by this context.
Definition: Context.h:32
This expression represents a reference to a Decl node.
Definition: Nodes.h:434
static DeclRefExpr * create(Context &ctx, SMRange loc, Decl *decl, Type type)
Definition: Nodes.cpp:285
Decl * getDecl() const
Get the decl referenced by this expression.
Definition: Nodes.h:439
Decl * lookup(StringRef name)
Lookup a decl with the given name starting from this scope.
Definition: Nodes.cpp:182
void add(Decl *decl)
Add a new decl to the scope.
Definition: Nodes.cpp:175
This class represents the base Decl node.
Definition: Nodes.h:669
const Name * getName() const
Return the name of the decl, or nullptr if it doesn't have one.
Definition: Nodes.h:672
void setDocComment(Context &ctx, StringRef comment)
Set the documentation comment for this decl.
Definition: Nodes.cpp:382
This statement represents the erase statement in PDLL.
Definition: Nodes.h:254
static EraseStmt * create(Context &ctx, SMRange loc, Expr *rootOp)
Definition: Nodes.cpp:218
This class represents a base AST Expression node.
Definition: Nodes.h:345
Type getType() const
Return the type of this expression.
Definition: Nodes.h:348
This statement represents a let statement in PDLL.
Definition: Nodes.h:211
VariableDecl * getVarDecl() const
Return the variable defined by this statement.
Definition: Nodes.h:216
static LetStmt * create(Context &ctx, SMRange loc, VariableDecl *varDecl)
Definition: Nodes.cpp:207
This expression represents a named member or field access of a given parent expression.
Definition: Nodes.h:455
static MemberAccessExpr * create(Context &ctx, SMRange loc, const Expr *parentExpr, StringRef memberName, Type type)
Definition: Nodes.cpp:295
const Expr * getParentExpr() const
Get the parent expression of this access.
Definition: Nodes.h:462
This class represents a top-level AST module.
Definition: Nodes.h:1291
MutableArrayRef< Decl * > getChildren()
Return the children of this module.
Definition: Nodes.h:1296
static Module * create(Context &ctx, SMLoc loc, ArrayRef< Decl * > children)
Definition: Nodes.cpp:576
This Decl represents a NamedAttribute, and contains a string name and attribute value.
Definition: Nodes.h:992
Expr * getValue() const
Return value of the attribute.
Definition: Nodes.h:1001
static NamedAttributeDecl * create(Context &ctx, const Name &name, Expr *value)
Definition: Nodes.cpp:499
This class represents a base AST node.
Definition: Nodes.h:108
void walk(function_ref< void(const Node *)> walkFn) const
Walk all of the nodes including, and nested under, this node in pre-order.
Definition: Nodes.cpp:167
The class represents an Operation constraint, and constrains a variable to be an Operation.
Definition: Nodes.h:772
static OpConstraintDecl * create(Context &ctx, SMRange loc, const OpNameDecl *nameDecl=nullptr)
Definition: Nodes.cpp:400
std::optional< StringRef > getName() const
Return the name of the operation, or std::nullopt if there isn't one.
Definition: Nodes.cpp:409
OpConstraintDecl(SMRange loc, const OpNameDecl *nameDecl)
Definition: Nodes.h:784
const OpNameDecl * getNameDecl() const
Return the declaration of the operation name.
Definition: Nodes.h:781
const OpNameDecl * nameDecl
The operation name of this constraint.
Definition: Nodes.h:788
This Decl represents an OperationName.
Definition: Nodes.h:1016
std::optional< StringRef > getName() const
Return the name of this operation, or std::nullopt if the name is unknown.
Definition: Nodes.h:1022
static OpNameDecl * create(Context &ctx, const Name &name)
Definition: Nodes.cpp:509
This expression represents the structural form of an MLIR Operation.
Definition: Nodes.h:512
MutableArrayRef< Expr * > getResultTypes()
Return the result types of this operation.
Definition: Nodes.h:540
MutableArrayRef< NamedAttributeDecl * > getAttributes()
Return the attributes of this operation.
Definition: Nodes.h:548
const OpNameDecl * getNameDecl() const
Return the declaration of the operation name.
Definition: Nodes.h:525
MutableArrayRef< Expr * > getOperands()
Return the operands of this operation.
Definition: Nodes.h:532
static OperationExpr * create(Context &ctx, SMRange loc, const ods::Operation *odsOp, const OpNameDecl *nameDecl, ArrayRef< Expr * > operands, ArrayRef< Expr * > resultTypes, ArrayRef< NamedAttributeDecl * > attributes)
Definition: Nodes.cpp:307
std::optional< StringRef > getName() const
Return the name of the operation, or std::nullopt if there isn't one.
Definition: Nodes.cpp:330
static OperationType get(Context &context, std::optional< StringRef > name=std::nullopt, const ods::Operation *odsOp=nullptr)
Return an instance of the Operation type with an optional operation name.
Definition: Types.cpp:73
This Decl represents a single Pattern.
Definition: Nodes.h:1037
const CompoundStmt * getBody() const
Return the body of this pattern.
Definition: Nodes.h:1051
static PatternDecl * create(Context &ctx, SMRange location, const Name *name, std::optional< uint16_t > benefit, bool hasBoundedRecursion, const CompoundStmt *body)
Definition: Nodes.cpp:520
This expression builds a range from a set of element values (which may be ranges themselves).
Definition: Nodes.h:586
static RangeExpr * create(Context &ctx, SMRange loc, ArrayRef< Expr * > elements, RangeType type)
Definition: Nodes.cpp:338
MutableArrayRef< Expr * > getElements()
Return the element expressions of this range.
Definition: Nodes.h:592
This class represents a PDLL type that corresponds to a range of elements with a given element type.
Definition: Types.h:188
This statement represents the replace statement in PDLL.
Definition: Nodes.h:269
MutableArrayRef< Expr * > getReplExprs()
Return the replacement values of this statement.
Definition: Nodes.h:275
static ReplaceStmt * create(Context &ctx, SMRange loc, Expr *rootOp, ArrayRef< Expr * > replExprs)
Definition: Nodes.cpp:225
This statement represents a return from a "callable" like decl, e.g.
Definition: Nodes.h:321
static ReturnStmt * create(Context &ctx, SMRange loc, Expr *resultExpr)
Definition: Nodes.cpp:249
Expr * getResultExpr()
Return the result expression of this statement.
Definition: Nodes.h:326
This statement represents an operation rewrite that contains a block of nested rewrite commands.
Definition: Nodes.h:299
static RewriteStmt * create(Context &ctx, SMRange loc, Expr *rootOp, CompoundStmt *rewriteBody)
Definition: Nodes.cpp:239
CompoundStmt * getRewriteBody() const
Return the compound rewrite body.
Definition: Nodes.h:305
This expression builds a tuple from a set of element values.
Definition: Nodes.h:619
MutableArrayRef< Expr * > getElements()
Return the element expressions of this tuple.
Definition: Nodes.h:625
static TupleExpr * create(Context &ctx, SMRange loc, ArrayRef< Expr * > elements, ArrayRef< StringRef > elementNames)
Definition: Nodes.cpp:353
This class represents a PDLL tuple type, i.e.
Definition: Types.h:249
static TupleType get(Context &context, ArrayRef< Type > elementTypes, ArrayRef< StringRef > elementNames)
Return an instance of the Tuple type.
Definition: Types.cpp:142
The class represents a Type constraint, and constrains a variable to be a Type.
Definition: Nodes.h:797
static TypeConstraintDecl * create(Context &ctx, SMRange loc)
Definition: Nodes.cpp:417
This expression represents a literal MLIR Type, and contains the textual assembly format of that type...
Definition: Nodes.h:648
static TypeExpr * create(Context &ctx, SMRange loc, StringRef value)
Definition: Nodes.cpp:373
The class represents a TypeRange constraint, and constrains a variable to be a TypeRange.
Definition: Nodes.h:811
static TypeRangeConstraintDecl * create(Context &ctx, SMRange loc)
Definition: Nodes.cpp:426
This decl represents a user defined constraint.
Definition: Nodes.h:882
MutableArrayRef< VariableDecl * > getInputs()
Return the input arguments of this constraint.
Definition: Nodes.h:908
std::optional< StringRef > getNativeInputType(unsigned index) const
Return the explicit native type to use for the given input.
Definition: Nodes.cpp:457
MutableArrayRef< VariableDecl * > getResults()
Return the explicit results of the constraint declaration.
Definition: Nodes.h:921
const CompoundStmt * getBody() const
Return the body of this constraint if this constraint is a PDLL constraint, otherwise returns nullptr...
Definition: Nodes.h:934
This decl represents a user defined rewrite.
Definition: Nodes.h:1092
const CompoundStmt * getBody() const
Return the body of this rewrite if this rewrite is a PDLL rewrite, otherwise returns nullptr.
Definition: Nodes.h:1140
MutableArrayRef< VariableDecl * > getInputs()
Return the input arguments of this rewrite.
Definition: Nodes.h:1118
MutableArrayRef< VariableDecl * > getResults()
Return the explicit results of the rewrite declaration.
Definition: Nodes.h:1127
The class represents a Value constraint, and constrains a variable to be a Value.
Definition: Nodes.h:825
static ValueConstraintDecl * create(Context &ctx, SMRange loc, Expr *typeExpr)
Definition: Nodes.cpp:436
Expr * typeExpr
An optional type that the value is constrained to.
Definition: Nodes.h:838
ValueConstraintDecl(SMRange loc, Expr *typeExpr)
Definition: Nodes.h:834
Expr * getTypeExpr()
Return the optional type the value is constrained to.
Definition: Nodes.h:830
The class represents a ValueRange constraint, and constrains a variable to be a ValueRange.
Definition: Nodes.h:847
Expr * getTypeExpr()
Return the optional type the value range is constrained to.
Definition: Nodes.h:853
static ValueRangeConstraintDecl * create(Context &ctx, SMRange loc, Expr *typeExpr=nullptr)
Definition: Nodes.cpp:447
ValueRangeConstraintDecl(SMRange loc, Expr *typeExpr)
Definition: Nodes.h:857
Expr * typeExpr
An optional type that the value range is constrained to.
Definition: Nodes.h:861
This Decl represents the definition of a PDLL variable.
Definition: Nodes.h:1242
Expr * getInitExpr() const
Return the initializer expression of this statement, or nullptr if there was no initializer.
Definition: Nodes.h:1258
static VariableDecl * create(Context &ctx, const Name &name, Type type, Expr *initExpr, ArrayRef< ConstraintRef > constraints)
Definition: Nodes.cpp:558
MutableArrayRef< ConstraintRef > getConstraints()
Return the constraints of this variable.
Definition: Nodes.h:1249
This class provides an ODS representation of a specific operation.
Definition: Operation.h:125
Include the generated interface declarations.
This class represents a reference to a constraint, and contains a constraint and the location of the ...
Definition: Nodes.h:716
This class provides a convenient API for interacting with source names.
Definition: Nodes.h:37
StringRef getName() const
Return the raw string name.
Definition: Nodes.h:41
static const Name & create(Context &ctx, StringRef name, SMRange location)
Definition: Nodes.cpp:33