Loading [MathJax]/extensions/tex2jax.js
CIRCT 22.0.0git
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
FIRRTLVisitors.h
Go to the documentation of this file.
1//===- FIRRTLVisitors.h - FIRRTL Dialect Visitors ---------------*- C++ -*-===//
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//
9// This file defines visitors that make it easier to work with FIRRTL IR.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef CIRCT_DIALECT_FIRRTL_FIRRTLVISITORS_H
14#define CIRCT_DIALECT_FIRRTL_FIRRTLVISITORS_H
15
17#include "mlir/IR/BuiltinOps.h"
18#include "llvm/ADT/TypeSwitch.h"
19
20namespace circt {
21namespace firrtl {
22
23/// ExprVisitor is a visitor for FIRRTL expression nodes.
24template <typename ConcreteType, typename ResultType = void,
25 typename... ExtraArgs>
27public:
28 ResultType dispatchExprVisitor(Operation *op, ExtraArgs... args) {
29 auto *thisCast = static_cast<ConcreteType *>(this);
30 return TypeSwitch<Operation *, ResultType>(op)
31 // Basic Expressions
32 .template Case<
33 ConstantOp, SpecialConstantOp, AggregateConstantOp, InvalidValueOp,
34 SubfieldOp, SubindexOp, SubaccessOp, IsTagOp, SubtagOp,
35 BundleCreateOp, VectorCreateOp, FEnumCreateOp, MultibitMuxOp,
36 TagExtractOp, OpenSubfieldOp, OpenSubindexOp, ObjectSubfieldOp,
37 ObjectAnyRefCastOp,
38 // Arithmetic and Logical Binary Primitives.
39 AddPrimOp, SubPrimOp, MulPrimOp, DivPrimOp, RemPrimOp, AndPrimOp,
40 OrPrimOp, XorPrimOp,
41 // Elementwise operations,
42 ElementwiseOrPrimOp, ElementwiseAndPrimOp, ElementwiseXorPrimOp,
43 // Comparisons.
44 LEQPrimOp, LTPrimOp, GEQPrimOp, GTPrimOp, EQPrimOp, NEQPrimOp,
45 // Misc Binary Primitives.
46 CatPrimOp, DShlPrimOp, DShlwPrimOp, DShrPrimOp,
47 // Unary operators.
48 AsSIntPrimOp, AsUIntPrimOp, AsAsyncResetPrimOp, AsClockPrimOp,
49 CvtPrimOp, NegPrimOp, NotPrimOp, AndRPrimOp, OrRPrimOp, XorRPrimOp,
50 // Intrinsic Expressions.
51 IsXIntrinsicOp, PlusArgsValueIntrinsicOp, PlusArgsTestIntrinsicOp,
52 SizeOfIntrinsicOp, ClockGateIntrinsicOp, ClockInverterIntrinsicOp,
53 ClockDividerIntrinsicOp, LTLAndIntrinsicOp, LTLOrIntrinsicOp,
54 LTLIntersectIntrinsicOp, LTLDelayIntrinsicOp, LTLConcatIntrinsicOp,
55 LTLRepeatIntrinsicOp, LTLGoToRepeatIntrinsicOp,
56 LTLNonConsecutiveRepeatIntrinsicOp, LTLNotIntrinsicOp,
57 LTLImplicationIntrinsicOp, LTLUntilIntrinsicOp,
58 LTLEventuallyIntrinsicOp, LTLClockIntrinsicOp, Mux2CellIntrinsicOp,
59 Mux4CellIntrinsicOp, HasBeenResetIntrinsicOp,
60 // Miscellaneous.
61 BitsPrimOp, HeadPrimOp, MuxPrimOp, PadPrimOp, ShlPrimOp, ShrPrimOp,
62 TailPrimOp, VerbatimExprOp, HWStructCastOp, BitCastOp, RefSendOp,
63 RefResolveOp, RefSubOp, RWProbeOp, XMRRefOp, XMRDerefOp,
64 UnsafeDomainCastOp,
65 // Casts to deal with weird stuff
66 UninferredResetCastOp, ConstCastOp, RefCastOp,
67 // Property expressions.
68 StringConstantOp, FIntegerConstantOp, BoolConstantOp,
69 DoubleConstantOp, ListCreateOp, ListConcatOp, UnresolvedPathOp,
70 PathOp, IntegerAddOp, IntegerMulOp, IntegerShrOp,
71 // Format String expressions
72 TimeOp, HierarchicalModuleNameOp>([&](auto expr) -> ResultType {
73 return thisCast->visitExpr(expr, args...);
74 })
75 .Default([&](auto expr) -> ResultType {
76 return thisCast->visitInvalidExpr(op, args...);
77 });
78 }
79
80 /// This callback is invoked on any non-expression operations.
81 ResultType visitInvalidExpr(Operation *op, ExtraArgs... args) {
82 op->emitOpError("unknown FIRRTL expression");
83 abort();
84 }
85
86 /// This callback is invoked on any expression operations that are not handled
87 /// by the concrete visitor.
88 ResultType visitUnhandledExpr(Operation *op, ExtraArgs... args) {
89 return ResultType();
90 }
91
92 /// This fallback is invoked on any unary expr that isn't explicitly handled.
93 /// The default implementation delegates to the unhandled expression fallback.
94 ResultType visitUnaryExpr(Operation *op, ExtraArgs... args) {
95 return static_cast<ConcreteType *>(this)->visitUnhandledExpr(op, args...);
96 }
97
98 /// This fallback is invoked on any binary expr that isn't explicitly handled.
99 /// The default implementation delegates to the unhandled expression fallback.
100 ResultType visitBinaryExpr(Operation *op, ExtraArgs... args) {
101 return static_cast<ConcreteType *>(this)->visitUnhandledExpr(op, args...);
102 }
103
104#define HANDLE(OPTYPE, OPKIND) \
105 ResultType visitExpr(OPTYPE op, ExtraArgs... args) { \
106 return static_cast<ConcreteType *>(this)->visit##OPKIND##Expr(op, \
107 args...); \
108 }
109
110 // Basic expressions.
111 HANDLE(ConstantOp, Unhandled);
112 HANDLE(SpecialConstantOp, Unhandled);
113 HANDLE(AggregateConstantOp, Unhandled);
114 HANDLE(BundleCreateOp, Unhandled);
115 HANDLE(VectorCreateOp, Unhandled);
116 HANDLE(FEnumCreateOp, Unhandled);
117 HANDLE(SubfieldOp, Unhandled);
118 HANDLE(SubindexOp, Unhandled);
119 HANDLE(SubaccessOp, Unhandled);
120 HANDLE(IsTagOp, Unhandled);
121 HANDLE(SubtagOp, Unhandled);
122 HANDLE(TagExtractOp, Unhandled);
123 HANDLE(MultibitMuxOp, Unhandled);
124 HANDLE(OpenSubfieldOp, Unhandled);
125 HANDLE(OpenSubindexOp, Unhandled);
126 HANDLE(ObjectSubfieldOp, Unhandled);
127 HANDLE(ObjectAnyRefCastOp, Unhandled);
128 HANDLE(CatPrimOp, Unhandled);
129
130 // Arithmetic and Logical Binary Primitives.
131 HANDLE(AddPrimOp, Binary);
132 HANDLE(SubPrimOp, Binary);
133 HANDLE(MulPrimOp, Binary);
134 HANDLE(DivPrimOp, Binary);
135 HANDLE(RemPrimOp, Binary);
136 HANDLE(AndPrimOp, Binary);
137 HANDLE(OrPrimOp, Binary);
138 HANDLE(XorPrimOp, Binary);
139
140 // Comparisons.
141 HANDLE(LEQPrimOp, Binary);
142 HANDLE(LTPrimOp, Binary);
143 HANDLE(GEQPrimOp, Binary);
144 HANDLE(GTPrimOp, Binary);
145 HANDLE(EQPrimOp, Binary);
146 HANDLE(NEQPrimOp, Binary);
147
148 // Misc Binary Primitives.
149 HANDLE(DShlPrimOp, Binary);
150 HANDLE(DShlwPrimOp, Binary);
151 HANDLE(DShrPrimOp, Binary);
152
153 // Unary operators.
154 HANDLE(AsSIntPrimOp, Unary);
155 HANDLE(AsUIntPrimOp, Unary);
156 HANDLE(AsAsyncResetPrimOp, Unary);
157 HANDLE(AsClockPrimOp, Unary);
158 HANDLE(CvtPrimOp, Unary);
159 HANDLE(NegPrimOp, Unary);
160 HANDLE(NotPrimOp, Unary);
161 HANDLE(AndRPrimOp, Unary);
162 HANDLE(OrRPrimOp, Unary);
163 HANDLE(XorRPrimOp, Unary);
164
165 HANDLE(ElementwiseOrPrimOp, Unhandled);
166 HANDLE(ElementwiseAndPrimOp, Unhandled);
167 HANDLE(ElementwiseXorPrimOp, Unhandled);
168
169 // Intrinsic Expr.
170 HANDLE(IsXIntrinsicOp, Unhandled);
171 HANDLE(PlusArgsValueIntrinsicOp, Unhandled);
172 HANDLE(PlusArgsTestIntrinsicOp, Unhandled);
173 HANDLE(SizeOfIntrinsicOp, Unhandled);
174 HANDLE(ClockGateIntrinsicOp, Unhandled);
175 HANDLE(ClockInverterIntrinsicOp, Unhandled);
176 HANDLE(ClockDividerIntrinsicOp, Unhandled);
177 HANDLE(LTLAndIntrinsicOp, Unhandled);
178 HANDLE(LTLOrIntrinsicOp, Unhandled);
179 HANDLE(LTLIntersectIntrinsicOp, Unhandled);
180 HANDLE(LTLDelayIntrinsicOp, Unhandled);
181 HANDLE(LTLConcatIntrinsicOp, Unhandled);
182 HANDLE(LTLRepeatIntrinsicOp, Unhandled);
183 HANDLE(LTLGoToRepeatIntrinsicOp, Unhandled);
184 HANDLE(LTLNonConsecutiveRepeatIntrinsicOp, Unhandled);
185 HANDLE(LTLNotIntrinsicOp, Unhandled);
186 HANDLE(LTLImplicationIntrinsicOp, Unhandled);
187 HANDLE(LTLUntilIntrinsicOp, Unhandled);
188 HANDLE(LTLEventuallyIntrinsicOp, Unhandled);
189 HANDLE(LTLClockIntrinsicOp, Unhandled);
190 HANDLE(Mux4CellIntrinsicOp, Unhandled);
191 HANDLE(Mux2CellIntrinsicOp, Unhandled);
192 HANDLE(HasBeenResetIntrinsicOp, Unhandled);
193
194 // Miscellaneous.
195 HANDLE(BitsPrimOp, Unhandled);
196 HANDLE(HeadPrimOp, Unhandled);
197 HANDLE(InvalidValueOp, Unhandled);
198 HANDLE(MuxPrimOp, Unhandled);
199 HANDLE(PadPrimOp, Unhandled);
200 HANDLE(ShlPrimOp, Unhandled);
201 HANDLE(ShrPrimOp, Unhandled);
202 HANDLE(TailPrimOp, Unhandled);
203 HANDLE(VerbatimExprOp, Unhandled);
204 HANDLE(RefSendOp, Unhandled);
205 HANDLE(RefResolveOp, Unhandled);
206 HANDLE(RefSubOp, Unhandled);
207 HANDLE(RWProbeOp, Unhandled);
208 HANDLE(XMRRefOp, Unhandled);
209 HANDLE(XMRDerefOp, Unhandled);
210 HANDLE(UnsafeDomainCastOp, Unhandled);
211
212 // Conversions.
213 HANDLE(HWStructCastOp, Unhandled);
214 HANDLE(UninferredResetCastOp, Unhandled);
215 HANDLE(ConstCastOp, Unhandled);
216 HANDLE(BitCastOp, Unhandled);
217 HANDLE(RefCastOp, Unhandled);
218
219 // Property expressions.
220 HANDLE(StringConstantOp, Unhandled);
221 HANDLE(FIntegerConstantOp, Unhandled);
222 HANDLE(BoolConstantOp, Unhandled);
223 HANDLE(DoubleConstantOp, Unhandled);
224 HANDLE(ListCreateOp, Unhandled);
225 HANDLE(ListConcatOp, Unhandled);
226 HANDLE(PathOp, Unhandled);
227 HANDLE(UnresolvedPathOp, Unhandled);
228 HANDLE(IntegerAddOp, Unhandled);
229 HANDLE(IntegerMulOp, Unhandled);
230 HANDLE(IntegerShrOp, Unhandled);
231
232 // Format string expressions
233 HANDLE(TimeOp, Unhandled);
234 HANDLE(HierarchicalModuleNameOp, Unhandled);
235#undef HANDLE
236};
237
238/// ExprVisitor is a visitor for FIRRTL statement nodes.
239template <typename ConcreteType, typename ResultType = void,
240 typename... ExtraArgs>
242public:
243 ResultType dispatchStmtVisitor(Operation *op, ExtraArgs... args) {
244 auto *thisCast = static_cast<ConcreteType *>(this);
245 return TypeSwitch<Operation *, ResultType>(op)
246 .template Case<AttachOp, ConnectOp, MatchingConnectOp, RefDefineOp,
247 ForceOp, PrintFOp, FPrintFOp, FFlushOp, SkipOp, StopOp,
248 WhenOp, AssertOp, AssumeOp, CoverOp, PropAssignOp,
249 RefForceOp, RefForceInitialOp, RefReleaseOp,
250 RefReleaseInitialOp, FPGAProbeIntrinsicOp,
251 VerifAssertIntrinsicOp, VerifAssumeIntrinsicOp,
252 UnclockedAssumeIntrinsicOp, VerifCoverIntrinsicOp,
253 VerifRequireIntrinsicOp, VerifEnsureIntrinsicOp,
254 LayerBlockOp, MatchOp, ViewIntrinsicOp, BindOp>(
255 [&](auto opNode) -> ResultType {
256 return thisCast->visitStmt(opNode, args...);
257 })
258 .Default([&](auto expr) -> ResultType {
259 return thisCast->visitInvalidStmt(op, args...);
260 });
261 }
262
263 /// This callback is invoked on any non-Stmt operations.
264 ResultType visitInvalidStmt(Operation *op, ExtraArgs... args) {
265 op->emitOpError("unknown firrtl stmt");
266 abort();
267 }
268
269 /// This callback is invoked on any Stmt operations that are not handled
270 /// by the concrete visitor.
271 ResultType visitUnhandledStmt(Operation *op, ExtraArgs... args) {
272 return ResultType();
273 }
274
275#define HANDLE(OPTYPE) \
276 ResultType visitStmt(OPTYPE op, ExtraArgs... args) { \
277 return static_cast<ConcreteType *>(this)->visitUnhandledStmt(op, args...); \
278 }
279
280 HANDLE(AttachOp);
281 HANDLE(ConnectOp);
282 HANDLE(MatchingConnectOp);
283 HANDLE(RefDefineOp);
284 HANDLE(ForceOp);
285 HANDLE(PrintFOp);
286 HANDLE(FPrintFOp);
287 HANDLE(FFlushOp);
288 HANDLE(SkipOp);
289 HANDLE(StopOp);
290 HANDLE(WhenOp);
291 HANDLE(AssertOp);
292 HANDLE(AssumeOp);
293 HANDLE(CoverOp);
294 HANDLE(PropAssignOp);
295 HANDLE(RefForceOp);
296 HANDLE(RefForceInitialOp);
297 HANDLE(RefReleaseOp);
298 HANDLE(RefReleaseInitialOp);
299 HANDLE(FPGAProbeIntrinsicOp);
300 HANDLE(VerifAssertIntrinsicOp);
301 HANDLE(VerifAssumeIntrinsicOp);
302 HANDLE(VerifCoverIntrinsicOp);
303 HANDLE(VerifRequireIntrinsicOp);
304 HANDLE(VerifEnsureIntrinsicOp);
305 HANDLE(UnclockedAssumeIntrinsicOp);
306 HANDLE(LayerBlockOp);
307 HANDLE(MatchOp);
308 HANDLE(ViewIntrinsicOp);
309 HANDLE(BindOp);
310
311#undef HANDLE
312};
313
314/// ExprVisitor is a visitor for FIRRTL declaration nodes.
315template <typename ConcreteType, typename ResultType = void,
316 typename... ExtraArgs>
318public:
319 ResultType dispatchDeclVisitor(Operation *op, ExtraArgs... args) {
320 auto *thisCast = static_cast<ConcreteType *>(this);
321 return TypeSwitch<Operation *, ResultType>(op)
322 .template Case<InstanceOp, InstanceChoiceOp, ObjectOp, MemOp, NodeOp,
323 RegOp, RegResetOp, WireOp, VerbatimWireOp, ContractOp>(
324 [&](auto opNode) -> ResultType {
325 return thisCast->visitDecl(opNode, args...);
326 })
327 .Default([&](auto expr) -> ResultType {
328 return thisCast->visitInvalidDecl(op, args...);
329 });
330 }
331
332 /// This callback is invoked on any non-Decl operations.
333 ResultType visitInvalidDecl(Operation *op, ExtraArgs... args) {
334 op->emitOpError("unknown firrtl decl");
335 abort();
336 }
337
338 /// This callback is invoked on any Decl operations that are not handled
339 /// by the concrete visitor.
340 ResultType visitUnhandledDecl(Operation *op, ExtraArgs... args) {
341 return ResultType();
342 }
343
344#define HANDLE(OPTYPE) \
345 ResultType visitDecl(OPTYPE op, ExtraArgs... args) { \
346 return static_cast<ConcreteType *>(this)->visitUnhandledDecl(op, args...); \
347 }
348
349 HANDLE(InstanceOp);
350 HANDLE(InstanceChoiceOp);
351 HANDLE(ObjectOp);
352 HANDLE(MemOp);
353 HANDLE(NodeOp);
354 HANDLE(RegOp);
355 HANDLE(RegResetOp);
356 HANDLE(WireOp);
357 HANDLE(VerbatimWireOp);
358 HANDLE(ContractOp);
359#undef HANDLE
360};
361
362/// StmtExprVisitor is a visitor for FIRRTL operation that has an optional
363/// result.
364template <typename ConcreteType, typename ResultType = void,
365 typename... ExtraArgs>
367public:
368 ResultType dispatchStmtExprVisitor(Operation *op, ExtraArgs... args) {
369 auto *thisCast = static_cast<ConcreteType *>(this);
370 return TypeSwitch<Operation *, ResultType>(op)
371 .template Case<GenericIntrinsicOp, DPICallIntrinsicOp>(
372 [&](auto expr) -> ResultType {
373 return thisCast->visitStmtExpr(expr, args...);
374 })
375 .Default([&](auto expr) -> ResultType {
376 return thisCast->visitInvalidStmtExpr(op, args...);
377 });
378 }
379
380 /// This callback is invoked on any non-StmtExpr operations.
381 ResultType visitInvalidStmtExpr(Operation *op, ExtraArgs... args) {
382 op->emitOpError("unknown FIRRTL stmt expression");
383 abort();
384 }
385
386 /// This callback is invoked on any StmtExpr operations that are not handled
387 /// by the concrete visitor.
388 ResultType visitUnhandledStmtExpr(Operation *op, ExtraArgs... args) {
389 return ResultType();
390 }
391
392#define HANDLE(OPTYPE, OPKIND) \
393 ResultType visitStmtExpr(OPTYPE op, ExtraArgs... args) { \
394 return static_cast<ConcreteType *>(this)->visit##OPKIND##StmtExpr( \
395 op, args...); \
396 }
397
398 // Statement expressions.
399 HANDLE(DPICallIntrinsicOp, Unhandled);
400 HANDLE(GenericIntrinsicOp, Unhandled);
401#undef HANDLE
402};
403
404/// FIRRTLVisitor allows you to visit all of the expr/stmt/decls with one class
405/// declaration.
406///
407/// Clients call dispatchVisitor to invoke the dispatch, and may implement
408/// visitInvalidOp() to get notified about non-FIRRTL dialect nodes and
409/// visitUnhandledOp() to get notified about FIRRTL dialect ops that are not
410/// handled specifically.
411template <typename ConcreteType, typename ResultType = void,
412 typename... ExtraArgs>
414 : public ExprVisitor<ConcreteType, ResultType, ExtraArgs...>,
415 public StmtVisitor<ConcreteType, ResultType, ExtraArgs...>,
416 public DeclVisitor<ConcreteType, ResultType, ExtraArgs...>,
417 public StmtExprVisitor<ConcreteType, ResultType, ExtraArgs...> {
418public:
419 /// This is the main entrypoint for the FIRRTLVisitor.
420 ResultType dispatchVisitor(Operation *op, ExtraArgs... args) {
421 return this->dispatchExprVisitor(op, args...);
422 }
423
424 // Chain from each visitor onto the next one.
425 ResultType visitInvalidExpr(Operation *op, ExtraArgs... args) {
426 return this->dispatchStmtVisitor(op, args...);
427 }
428 ResultType visitInvalidStmt(Operation *op, ExtraArgs... args) {
429 return this->dispatchDeclVisitor(op, args...);
430 }
431 ResultType visitInvalidDecl(Operation *op, ExtraArgs... args) {
432 return this->dispatchStmtExprVisitor(op, args...);
433 }
434 ResultType visitInvalidStmtExpr(Operation *op, ExtraArgs... args) {
435 return static_cast<ConcreteType *>(this)->visitInvalidOp(op, args...);
436 }
437
438 // Default to chaining visitUnhandledXXX to visitUnhandledOp.
439 ResultType visitUnhandledExpr(Operation *op, ExtraArgs... args) {
440 return static_cast<ConcreteType *>(this)->visitUnhandledOp(op, args...);
441 }
442 ResultType visitUnhandledStmt(Operation *op, ExtraArgs... args) {
443 return static_cast<ConcreteType *>(this)->visitUnhandledOp(op, args...);
444 }
445 ResultType visitUnhandledDecl(Operation *op, ExtraArgs... args) {
446 return static_cast<ConcreteType *>(this)->visitUnhandledOp(op, args...);
447 }
448 ResultType visitUnhandledStmtExpr(Operation *op, ExtraArgs... args) {
449 return static_cast<ConcreteType *>(this)->visitUnhandledOp(op, args...);
450 }
451
452 /// visitInvalidOp is an override point for non-FIRRTL dialect operations.
453 ResultType visitInvalidOp(Operation *op, ExtraArgs... args) {
454 return ResultType();
455 }
456
457 /// visitUnhandledOp is an override point for FIRRTL dialect ops that the
458 /// concrete visitor didn't bother to implement.
459 ResultType visitUnhandledOp(Operation *op, ExtraArgs... args) {
460 return ResultType();
461 }
462};
463} // namespace firrtl
464} // namespace circt
465
466#endif // CIRCT_DIALECT_FIRRTL_FIRRTLVISITORS_H
ExprVisitor is a visitor for FIRRTL declaration nodes.
ResultType dispatchDeclVisitor(Operation *op, ExtraArgs... args)
HANDLE(InstanceChoiceOp)
ResultType visitInvalidDecl(Operation *op, ExtraArgs... args)
This callback is invoked on any non-Decl operations.
ResultType visitUnhandledDecl(Operation *op, ExtraArgs... args)
This callback is invoked on any Decl operations that are not handled by the concrete visitor.
ExprVisitor is a visitor for FIRRTL expression nodes.
HANDLE(ListCreateOp, Unhandled)
HANDLE(LTLUntilIntrinsicOp, Unhandled)
HANDLE(DoubleConstantOp, Unhandled)
HANDLE(LTLNotIntrinsicOp, Unhandled)
HANDLE(PadPrimOp, Unhandled)
HANDLE(SubPrimOp, Binary)
HANDLE(ElementwiseXorPrimOp, Unhandled)
HANDLE(UnsafeDomainCastOp, Unhandled)
HANDLE(ClockDividerIntrinsicOp, Unhandled)
HANDLE(AddPrimOp, Binary)
HANDLE(BitsPrimOp, Unhandled)
HANDLE(RWProbeOp, Unhandled)
HANDLE(LTLAndIntrinsicOp, Unhandled)
HANDLE(OpenSubfieldOp, Unhandled)
HANDLE(BoolConstantOp, Unhandled)
HANDLE(CatPrimOp, Unhandled)
HANDLE(AndRPrimOp, Unary)
HANDLE(HeadPrimOp, Unhandled)
HANDLE(LTPrimOp, Binary)
HANDLE(ClockInverterIntrinsicOp, Unhandled)
HANDLE(LTLGoToRepeatIntrinsicOp, Unhandled)
HANDLE(LTLNonConsecutiveRepeatIntrinsicOp, Unhandled)
HANDLE(BitCastOp, Unhandled)
HANDLE(SubindexOp, Unhandled)
HANDLE(HasBeenResetIntrinsicOp, Unhandled)
HANDLE(SubfieldOp, Unhandled)
HANDLE(DShrPrimOp, Binary)
HANDLE(AsUIntPrimOp, Unary)
HANDLE(LTLDelayIntrinsicOp, Unhandled)
HANDLE(RefCastOp, Unhandled)
HANDLE(ElementwiseOrPrimOp, Unhandled)
HANDLE(MultibitMuxOp, Unhandled)
HANDLE(XorRPrimOp, Unary)
HANDLE(ConstCastOp, Unhandled)
HANDLE(Mux4CellIntrinsicOp, Unhandled)
HANDLE(StringConstantOp, Unhandled)
HANDLE(LTLConcatIntrinsicOp, Unhandled)
HANDLE(TagExtractOp, Unhandled)
HANDLE(UninferredResetCastOp, Unhandled)
HANDLE(XorPrimOp, Binary)
HANDLE(MulPrimOp, Binary)
HANDLE(LTLImplicationIntrinsicOp, Unhandled)
HANDLE(ListConcatOp, Unhandled)
ResultType visitInvalidExpr(Operation *op, ExtraArgs... args)
This callback is invoked on any non-expression operations.
HANDLE(OrPrimOp, Binary)
ResultType dispatchExprVisitor(Operation *op, ExtraArgs... args)
HANDLE(RefSubOp, Unhandled)
HANDLE(ObjectAnyRefCastOp, Unhandled)
HANDLE(LTLIntersectIntrinsicOp, Unhandled)
HANDLE(RemPrimOp, Binary)
HANDLE(IntegerShrOp, Unhandled)
HANDLE(Mux2CellIntrinsicOp, Unhandled)
HANDLE(TimeOp, Unhandled)
HANDLE(MuxPrimOp, Unhandled)
HANDLE(BundleCreateOp, Unhandled)
HANDLE(PlusArgsTestIntrinsicOp, Unhandled)
HANDLE(FEnumCreateOp, Unhandled)
HANDLE(RefSendOp, Unhandled)
HANDLE(XMRDerefOp, Unhandled)
HANDLE(ShrPrimOp, Unhandled)
HANDLE(IntegerAddOp, Unhandled)
HANDLE(UnresolvedPathOp, Unhandled)
HANDLE(PlusArgsValueIntrinsicOp, Unhandled)
HANDLE(LTLOrIntrinsicOp, Unhandled)
HANDLE(LTLRepeatIntrinsicOp, Unhandled)
HANDLE(FIntegerConstantOp, Unhandled)
HANDLE(HWStructCastOp, Unhandled)
HANDLE(ClockGateIntrinsicOp, Unhandled)
HANDLE(OpenSubindexOp, Unhandled)
HANDLE(ObjectSubfieldOp, Unhandled)
HANDLE(InvalidValueOp, Unhandled)
HANDLE(SubaccessOp, Unhandled)
HANDLE(HierarchicalModuleNameOp, Unhandled)
HANDLE(DShlPrimOp, Binary)
HANDLE(ShlPrimOp, Unhandled)
HANDLE(IsXIntrinsicOp, Unhandled)
HANDLE(RefResolveOp, Unhandled)
HANDLE(NotPrimOp, Unary)
HANDLE(XMRRefOp, Unhandled)
HANDLE(TailPrimOp, Unhandled)
HANDLE(IntegerMulOp, Unhandled)
HANDLE(GTPrimOp, Binary)
HANDLE(LTLClockIntrinsicOp, Unhandled)
HANDLE(GEQPrimOp, Binary)
HANDLE(ElementwiseAndPrimOp, Unhandled)
HANDLE(CvtPrimOp, Unary)
ResultType visitUnaryExpr(Operation *op, ExtraArgs... args)
This fallback is invoked on any unary expr that isn't explicitly handled.
HANDLE(SizeOfIntrinsicOp, Unhandled)
ResultType visitUnhandledExpr(Operation *op, ExtraArgs... args)
This callback is invoked on any expression operations that are not handled by the concrete visitor.
HANDLE(NegPrimOp, Unary)
HANDLE(LEQPrimOp, Binary)
HANDLE(ConstantOp, Unhandled)
HANDLE(AsAsyncResetPrimOp, Unary)
HANDLE(DShlwPrimOp, Binary)
ResultType visitBinaryExpr(Operation *op, ExtraArgs... args)
This fallback is invoked on any binary expr that isn't explicitly handled.
HANDLE(OrRPrimOp, Unary)
HANDLE(AggregateConstantOp, Unhandled)
HANDLE(AndPrimOp, Binary)
HANDLE(AsClockPrimOp, Unary)
HANDLE(SpecialConstantOp, Unhandled)
HANDLE(VectorCreateOp, Unhandled)
HANDLE(LTLEventuallyIntrinsicOp, Unhandled)
HANDLE(DivPrimOp, Binary)
HANDLE(EQPrimOp, Binary)
HANDLE(NEQPrimOp, Binary)
HANDLE(SubtagOp, Unhandled)
HANDLE(VerbatimExprOp, Unhandled)
HANDLE(IsTagOp, Unhandled)
HANDLE(AsSIntPrimOp, Unary)
HANDLE(PathOp, Unhandled)
FIRRTLVisitor allows you to visit all of the expr/stmt/decls with one class declaration.
ResultType dispatchVisitor(Operation *op, ExtraArgs... args)
This is the main entrypoint for the FIRRTLVisitor.
ResultType visitInvalidOp(Operation *op, ExtraArgs... args)
visitInvalidOp is an override point for non-FIRRTL dialect operations.
ResultType visitUnhandledExpr(Operation *op, ExtraArgs... args)
ResultType visitUnhandledOp(Operation *op, ExtraArgs... args)
visitUnhandledOp is an override point for FIRRTL dialect ops that the concrete visitor didn't bother ...
ResultType visitUnhandledStmt(Operation *op, ExtraArgs... args)
ResultType visitUnhandledDecl(Operation *op, ExtraArgs... args)
ResultType visitUnhandledStmtExpr(Operation *op, ExtraArgs... args)
ResultType visitInvalidDecl(Operation *op, ExtraArgs... args)
ResultType visitInvalidExpr(Operation *op, ExtraArgs... args)
ResultType visitInvalidStmtExpr(Operation *op, ExtraArgs... args)
ResultType visitInvalidStmt(Operation *op, ExtraArgs... args)
StmtExprVisitor is a visitor for FIRRTL operation that has an optional result.
HANDLE(DPICallIntrinsicOp, Unhandled)
ResultType visitUnhandledStmtExpr(Operation *op, ExtraArgs... args)
This callback is invoked on any StmtExpr operations that are not handled by the concrete visitor.
ResultType visitInvalidStmtExpr(Operation *op, ExtraArgs... args)
This callback is invoked on any non-StmtExpr operations.
HANDLE(GenericIntrinsicOp, Unhandled)
ResultType dispatchStmtExprVisitor(Operation *op, ExtraArgs... args)
ExprVisitor is a visitor for FIRRTL statement nodes.
HANDLE(VerifCoverIntrinsicOp)
HANDLE(RefForceInitialOp)
ResultType dispatchStmtVisitor(Operation *op, ExtraArgs... args)
HANDLE(UnclockedAssumeIntrinsicOp)
HANDLE(VerifEnsureIntrinsicOp)
HANDLE(VerifAssertIntrinsicOp)
ResultType visitUnhandledStmt(Operation *op, ExtraArgs... args)
This callback is invoked on any Stmt operations that are not handled by the concrete visitor.
HANDLE(RefReleaseInitialOp)
HANDLE(FPGAProbeIntrinsicOp)
HANDLE(MatchingConnectOp)
ResultType visitInvalidStmt(Operation *op, ExtraArgs... args)
This callback is invoked on any non-Stmt operations.
HANDLE(ViewIntrinsicOp)
HANDLE(VerifRequireIntrinsicOp)
HANDLE(VerifAssumeIntrinsicOp)
The InstanceGraph op interface, see InstanceGraphInterface.td for more details.