LLZK 3.0.0
An open-source IR for Zero Knowledge (ZK) circuits
Loading...
Searching...
No Matches
Ops.capi.cpp.inc
Go to the documentation of this file.
1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Op C API Definitions *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* From: Ops.td *|
7|* *|
8\*===----------------------------------------------------------------------===*/
9
10
11#include <limits>
12
13using namespace mlir;
14using namespace llvm;
15
16MlirOperation llzkBool_ExistsOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue sort) {
17 MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.exists"), location);
18 mlirOperationStateEnableResultTypeInference(&state);
19 mlirOperationStateAddOperands(&state, 1, &sort);
20 llvm::SmallVector<MlirRegion, 1> regions;
21 regions.push_back(mlirRegionCreate());
22 mlirOperationStateAddOwnedRegions(&state, regions.size(), regions.data());
23
24 return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
25}
26
27bool llzkOperationIsA_Bool_ExistsOp(MlirOperation inp) {
28 return llvm::isa<ExistsOp>(unwrap(inp));
29}
30
31MlirValue llzkBool_ExistsOpGetSort(MlirOperation op) {
32 auto range = llvm::cast<ExistsOp>(unwrap(op)).getODSOperandIndexAndLength(0);
33 assert(range.second == 1 && "expected fixed operand segment size");
34 assert(
35 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
36 "operand index exceeds intptr_t range"
37 );
38 return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
39}
40
41void llzkBool_ExistsOpSetSort(MlirOperation op, MlirValue value) {
42 auto range = llvm::cast<ExistsOp>(unwrap(op)).getODSOperandIndexAndLength(0);
43 assert(range.second == 1 && "expected fixed operand segment size");
44 assert(
45 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
46 "operand index exceeds intptr_t range"
47 );
48 mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
49}
50
51MlirValue llzkBool_ExistsOpGetResult(MlirOperation op) {
52 return mlirOperationGetResult(op, 0);
53}
54
55MlirRegion llzkBool_ExistsOpGetRegion(MlirOperation op) {
56 return mlirOperationGetRegion(op, 0);
57}
58
59MlirOperation llzkBool_ForAllOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue sort) {
60 MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.forall"), location);
61 mlirOperationStateEnableResultTypeInference(&state);
62 mlirOperationStateAddOperands(&state, 1, &sort);
63 llvm::SmallVector<MlirRegion, 1> regions;
64 regions.push_back(mlirRegionCreate());
65 mlirOperationStateAddOwnedRegions(&state, regions.size(), regions.data());
66
67 return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
68}
69
70bool llzkOperationIsA_Bool_ForAllOp(MlirOperation inp) {
71 return llvm::isa<ForAllOp>(unwrap(inp));
72}
73
74MlirValue llzkBool_ForAllOpGetSort(MlirOperation op) {
75 auto range = llvm::cast<ForAllOp>(unwrap(op)).getODSOperandIndexAndLength(0);
76 assert(range.second == 1 && "expected fixed operand segment size");
77 assert(
78 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
79 "operand index exceeds intptr_t range"
80 );
81 return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
82}
83
84void llzkBool_ForAllOpSetSort(MlirOperation op, MlirValue value) {
85 auto range = llvm::cast<ForAllOp>(unwrap(op)).getODSOperandIndexAndLength(0);
86 assert(range.second == 1 && "expected fixed operand segment size");
87 assert(
88 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
89 "operand index exceeds intptr_t range"
90 );
91 mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
92}
93
94MlirValue llzkBool_ForAllOpGetResult(MlirOperation op) {
95 return mlirOperationGetResult(op, 0);
96}
97
98MlirRegion llzkBool_ForAllOpGetRegion(MlirOperation op) {
99 return mlirOperationGetRegion(op, 0);
100}
101
102MlirOperation llzkBool_AndBoolOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs) {
103 MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.and"), location);
104 mlirOperationStateEnableResultTypeInference(&state);
105 mlirOperationStateAddOperands(&state, 1, &lhs);
106 mlirOperationStateAddOperands(&state, 1, &rhs);
107
108 return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
109}
110
111bool llzkOperationIsA_Bool_AndBoolOp(MlirOperation inp) {
112 return llvm::isa<AndBoolOp>(unwrap(inp));
113}
114
115MlirValue llzkBool_AndBoolOpGetLhs(MlirOperation op) {
116 auto range = llvm::cast<AndBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
117 assert(range.second == 1 && "expected fixed operand segment size");
118 assert(
119 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
120 "operand index exceeds intptr_t range"
121 );
122 return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
123}
124
125void llzkBool_AndBoolOpSetLhs(MlirOperation op, MlirValue value) {
126 auto range = llvm::cast<AndBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
127 assert(range.second == 1 && "expected fixed operand segment size");
128 assert(
129 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
130 "operand index exceeds intptr_t range"
131 );
132 mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
133}
134
135MlirValue llzkBool_AndBoolOpGetRhs(MlirOperation op) {
136 auto range = llvm::cast<AndBoolOp>(unwrap(op)).getODSOperandIndexAndLength(1);
137 assert(range.second == 1 && "expected fixed operand segment size");
138 assert(
139 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
140 "operand index exceeds intptr_t range"
141 );
142 return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
143}
144
145void llzkBool_AndBoolOpSetRhs(MlirOperation op, MlirValue value) {
146 auto range = llvm::cast<AndBoolOp>(unwrap(op)).getODSOperandIndexAndLength(1);
147 assert(range.second == 1 && "expected fixed operand segment size");
148 assert(
149 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
150 "operand index exceeds intptr_t range"
151 );
152 mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
153}
154
155MlirValue llzkBool_AndBoolOpGetResult(MlirOperation op) {
156 return mlirOperationGetResult(op, 0);
157}
158
159MlirOperation llzkBool_AssertOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue condition, MlirIdentifier msg) {
160 MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.assert"), location);
161 mlirOperationStateAddOperands(&state, 1, &condition);
162 MlirContext ctx = mlirOpBuilderGetContext(builder);
163 llvm::SmallVector<MlirNamedAttribute, 1> attributes;
164 if (!mlirAttributeIsNull(reinterpret_cast<MlirAttribute&>(msg))) {
165 attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("msg")), reinterpret_cast<MlirAttribute&>(msg)));
166 }
167 mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
168
169 return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
170}
171
172bool llzkOperationIsA_Bool_AssertOp(MlirOperation inp) {
173 return llvm::isa<AssertOp>(unwrap(inp));
174}
175
176MlirValue llzkBool_AssertOpGetCondition(MlirOperation op) {
177 auto range = llvm::cast<AssertOp>(unwrap(op)).getODSOperandIndexAndLength(0);
178 assert(range.second == 1 && "expected fixed operand segment size");
179 assert(
180 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
181 "operand index exceeds intptr_t range"
182 );
183 return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
184}
185
186void llzkBool_AssertOpSetCondition(MlirOperation op, MlirValue value) {
187 auto range = llvm::cast<AssertOp>(unwrap(op)).getODSOperandIndexAndLength(0);
188 assert(range.second == 1 && "expected fixed operand segment size");
189 assert(
190 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
191 "operand index exceeds intptr_t range"
192 );
193 mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
194}
195
196MlirAttribute llzkBool_AssertOpGetMsg(MlirOperation op) {
197 return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("msg"));
198}
199
200void llzkBool_AssertOpSetMsg(MlirOperation op, MlirAttribute attr) {
201 mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("msg"), attr);
202}
203
204MlirOperation llzkBool_CmpOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs, MlirAttribute predicate) {
205 MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.cmp"), location);
206 mlirOperationStateEnableResultTypeInference(&state);
207 mlirOperationStateAddOperands(&state, 1, &lhs);
208 mlirOperationStateAddOperands(&state, 1, &rhs);
209 MlirContext ctx = mlirOpBuilderGetContext(builder);
210 llvm::SmallVector<MlirNamedAttribute, 1> attributes;
211 if (!mlirAttributeIsNull(predicate)) {
212 attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("predicate")), predicate));
213 }
214 mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
215
216 return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
217}
218
219bool llzkOperationIsA_Bool_CmpOp(MlirOperation inp) {
220 return llvm::isa<CmpOp>(unwrap(inp));
221}
222
223MlirValue llzkBool_CmpOpGetLhs(MlirOperation op) {
224 auto range = llvm::cast<CmpOp>(unwrap(op)).getODSOperandIndexAndLength(0);
225 assert(range.second == 1 && "expected fixed operand segment size");
226 assert(
227 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
228 "operand index exceeds intptr_t range"
229 );
230 return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
231}
232
233void llzkBool_CmpOpSetLhs(MlirOperation op, MlirValue value) {
234 auto range = llvm::cast<CmpOp>(unwrap(op)).getODSOperandIndexAndLength(0);
235 assert(range.second == 1 && "expected fixed operand segment size");
236 assert(
237 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
238 "operand index exceeds intptr_t range"
239 );
240 mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
241}
242
243MlirValue llzkBool_CmpOpGetRhs(MlirOperation op) {
244 auto range = llvm::cast<CmpOp>(unwrap(op)).getODSOperandIndexAndLength(1);
245 assert(range.second == 1 && "expected fixed operand segment size");
246 assert(
247 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
248 "operand index exceeds intptr_t range"
249 );
250 return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
251}
252
253void llzkBool_CmpOpSetRhs(MlirOperation op, MlirValue value) {
254 auto range = llvm::cast<CmpOp>(unwrap(op)).getODSOperandIndexAndLength(1);
255 assert(range.second == 1 && "expected fixed operand segment size");
256 assert(
257 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
258 "operand index exceeds intptr_t range"
259 );
260 mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
261}
262
263MlirAttribute llzkBool_CmpOpGetPredicate(MlirOperation op) {
264 return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("predicate"));
265}
266
267void llzkBool_CmpOpSetPredicate(MlirOperation op, MlirAttribute attr) {
268 mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("predicate"), attr);
269}
270
271MlirValue llzkBool_CmpOpGetResult(MlirOperation op) {
272 return mlirOperationGetResult(op, 0);
273}
274
275MlirOperation llzkBool_NotBoolOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue operand) {
276 MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.not"), location);
277 mlirOperationStateEnableResultTypeInference(&state);
278 mlirOperationStateAddOperands(&state, 1, &operand);
279
280 return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
281}
282
283bool llzkOperationIsA_Bool_NotBoolOp(MlirOperation inp) {
284 return llvm::isa<NotBoolOp>(unwrap(inp));
285}
286
287MlirValue llzkBool_NotBoolOpGetOperand(MlirOperation op) {
288 auto range = llvm::cast<NotBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
289 assert(range.second == 1 && "expected fixed operand segment size");
290 assert(
291 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
292 "operand index exceeds intptr_t range"
293 );
294 return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
295}
296
297void llzkBool_NotBoolOpSetOperand(MlirOperation op, MlirValue value) {
298 auto range = llvm::cast<NotBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
299 assert(range.second == 1 && "expected fixed operand segment size");
300 assert(
301 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
302 "operand index exceeds intptr_t range"
303 );
304 mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
305}
306
307MlirValue llzkBool_NotBoolOpGetResult(MlirOperation op) {
308 return mlirOperationGetResult(op, 0);
309}
310
311MlirOperation llzkBool_OrBoolOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs) {
312 MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.or"), location);
313 mlirOperationStateEnableResultTypeInference(&state);
314 mlirOperationStateAddOperands(&state, 1, &lhs);
315 mlirOperationStateAddOperands(&state, 1, &rhs);
316
317 return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
318}
319
320bool llzkOperationIsA_Bool_OrBoolOp(MlirOperation inp) {
321 return llvm::isa<OrBoolOp>(unwrap(inp));
322}
323
324MlirValue llzkBool_OrBoolOpGetLhs(MlirOperation op) {
325 auto range = llvm::cast<OrBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
326 assert(range.second == 1 && "expected fixed operand segment size");
327 assert(
328 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
329 "operand index exceeds intptr_t range"
330 );
331 return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
332}
333
334void llzkBool_OrBoolOpSetLhs(MlirOperation op, MlirValue value) {
335 auto range = llvm::cast<OrBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
336 assert(range.second == 1 && "expected fixed operand segment size");
337 assert(
338 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
339 "operand index exceeds intptr_t range"
340 );
341 mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
342}
343
344MlirValue llzkBool_OrBoolOpGetRhs(MlirOperation op) {
345 auto range = llvm::cast<OrBoolOp>(unwrap(op)).getODSOperandIndexAndLength(1);
346 assert(range.second == 1 && "expected fixed operand segment size");
347 assert(
348 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
349 "operand index exceeds intptr_t range"
350 );
351 return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
352}
353
354void llzkBool_OrBoolOpSetRhs(MlirOperation op, MlirValue value) {
355 auto range = llvm::cast<OrBoolOp>(unwrap(op)).getODSOperandIndexAndLength(1);
356 assert(range.second == 1 && "expected fixed operand segment size");
357 assert(
358 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
359 "operand index exceeds intptr_t range"
360 );
361 mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
362}
363
364MlirValue llzkBool_OrBoolOpGetResult(MlirOperation op) {
365 return mlirOperationGetResult(op, 0);
366}
367
368MlirOperation llzkBool_XorBoolOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs) {
369 MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.xor"), location);
370 mlirOperationStateEnableResultTypeInference(&state);
371 mlirOperationStateAddOperands(&state, 1, &lhs);
372 mlirOperationStateAddOperands(&state, 1, &rhs);
373
374 return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
375}
376
377bool llzkOperationIsA_Bool_XorBoolOp(MlirOperation inp) {
378 return llvm::isa<XorBoolOp>(unwrap(inp));
379}
380
381MlirValue llzkBool_XorBoolOpGetLhs(MlirOperation op) {
382 auto range = llvm::cast<XorBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
383 assert(range.second == 1 && "expected fixed operand segment size");
384 assert(
385 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
386 "operand index exceeds intptr_t range"
387 );
388 return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
389}
390
391void llzkBool_XorBoolOpSetLhs(MlirOperation op, MlirValue value) {
392 auto range = llvm::cast<XorBoolOp>(unwrap(op)).getODSOperandIndexAndLength(0);
393 assert(range.second == 1 && "expected fixed operand segment size");
394 assert(
395 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
396 "operand index exceeds intptr_t range"
397 );
398 mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
399}
400
401MlirValue llzkBool_XorBoolOpGetRhs(MlirOperation op) {
402 auto range = llvm::cast<XorBoolOp>(unwrap(op)).getODSOperandIndexAndLength(1);
403 assert(range.second == 1 && "expected fixed operand segment size");
404 assert(
405 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
406 "operand index exceeds intptr_t range"
407 );
408 return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
409}
410
411void llzkBool_XorBoolOpSetRhs(MlirOperation op, MlirValue value) {
412 auto range = llvm::cast<XorBoolOp>(unwrap(op)).getODSOperandIndexAndLength(1);
413 assert(range.second == 1 && "expected fixed operand segment size");
414 assert(
415 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
416 "operand index exceeds intptr_t range"
417 );
418 mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
419}
420
421MlirValue llzkBool_XorBoolOpGetResult(MlirOperation op) {
422 return mlirOperationGetResult(op, 0);
423}
424
425MlirOperation llzkBool_YieldOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue value) {
426 MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("bool.yield"), location);
427 mlirOperationStateAddOperands(&state, 1, &value);
428
429 return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
430}
431
432bool llzkOperationIsA_Bool_YieldOp(MlirOperation inp) {
433 return llvm::isa<YieldOp>(unwrap(inp));
434}
435
436MlirValue llzkBool_YieldOpGetValue(MlirOperation op) {
437 auto range = llvm::cast<YieldOp>(unwrap(op)).getODSOperandIndexAndLength(0);
438 assert(range.second == 1 && "expected fixed operand segment size");
439 assert(
440 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
441 "operand index exceeds intptr_t range"
442 );
443 return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
444}
445
446void llzkBool_YieldOpSetValue(MlirOperation op, MlirValue value) {
447 auto range = llvm::cast<YieldOp>(unwrap(op)).getODSOperandIndexAndLength(0);
448 assert(range.second == 1 && "expected fixed operand segment size");
449 assert(
450 static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
451 "operand index exceeds intptr_t range"
452 );
453 mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
454}
llzkBool_YieldOpSetValue
void llzkBool_YieldOpSetValue(MlirOperation op, MlirValue value)
Set Value operand of llzk::boolean::YieldOp Operation.
Definition Ops.capi.cpp.inc:446
llzkBool_AssertOpBuild
MlirOperation llzkBool_AssertOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue condition, MlirIdentifier msg)
Build a llzk::boolean::AssertOp Operation.
Definition Ops.capi.cpp.inc:159
llzkBool_ExistsOpSetSort
void llzkBool_ExistsOpSetSort(MlirOperation op, MlirValue value)
Set Sort operand of llzk::boolean::ExistsOp Operation.
Definition Ops.capi.cpp.inc:41
llzkBool_XorBoolOpBuild
MlirOperation llzkBool_XorBoolOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs)
Build a llzk::boolean::XorBoolOp Operation.
Definition Ops.capi.cpp.inc:368
llzkBool_ExistsOpBuild
MlirOperation llzkBool_ExistsOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue sort)
Build a llzk::boolean::ExistsOp Operation.
Definition Ops.capi.cpp.inc:16
llzkBool_XorBoolOpSetLhs
void llzkBool_XorBoolOpSetLhs(MlirOperation op, MlirValue value)
Set Lhs operand of llzk::boolean::XorBoolOp Operation.
Definition Ops.capi.cpp.inc:391
llzkBool_NotBoolOpGetOperand
MlirValue llzkBool_NotBoolOpGetOperand(MlirOperation op)
Get Operand operand from llzk::boolean::NotBoolOp Operation.
Definition Ops.capi.cpp.inc:287
llzkBool_ExistsOpGetSort
MlirValue llzkBool_ExistsOpGetSort(MlirOperation op)
Get Sort operand from llzk::boolean::ExistsOp Operation.
Definition Ops.capi.cpp.inc:31
llzkBool_ForAllOpGetSort
MlirValue llzkBool_ForAllOpGetSort(MlirOperation op)
Get Sort operand from llzk::boolean::ForAllOp Operation.
Definition Ops.capi.cpp.inc:74
llzkOperationIsA_Bool_CmpOp
bool llzkOperationIsA_Bool_CmpOp(MlirOperation inp)
Returns true if the Operation is a llzk::boolean::CmpOp.
Definition Ops.capi.cpp.inc:219
llzkBool_OrBoolOpGetLhs
MlirValue llzkBool_OrBoolOpGetLhs(MlirOperation op)
Get Lhs operand from llzk::boolean::OrBoolOp Operation.
Definition Ops.capi.cpp.inc:324
llzkBool_AssertOpGetCondition
MlirValue llzkBool_AssertOpGetCondition(MlirOperation op)
Get Condition operand from llzk::boolean::AssertOp Operation.
Definition Ops.capi.cpp.inc:176
llzkOperationIsA_Bool_AssertOp
bool llzkOperationIsA_Bool_AssertOp(MlirOperation inp)
Returns true if the Operation is a llzk::boolean::AssertOp.
Definition Ops.capi.cpp.inc:172
llzkBool_XorBoolOpGetResult
MlirValue llzkBool_XorBoolOpGetResult(MlirOperation op)
Get Result result from llzk::boolean::XorBoolOp Operation.
Definition Ops.capi.cpp.inc:421
llzkBool_CmpOpGetResult
MlirValue llzkBool_CmpOpGetResult(MlirOperation op)
Get Result result from llzk::boolean::CmpOp Operation.
Definition Ops.capi.cpp.inc:271
llzkBool_OrBoolOpBuild
MlirOperation llzkBool_OrBoolOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs)
Build a llzk::boolean::OrBoolOp Operation.
Definition Ops.capi.cpp.inc:311
llzkBool_XorBoolOpSetRhs
void llzkBool_XorBoolOpSetRhs(MlirOperation op, MlirValue value)
Set Rhs operand of llzk::boolean::XorBoolOp Operation.
Definition Ops.capi.cpp.inc:411
llzkOperationIsA_Bool_ExistsOp
bool llzkOperationIsA_Bool_ExistsOp(MlirOperation inp)
Returns true if the Operation is a llzk::boolean::ExistsOp.
Definition Ops.capi.cpp.inc:27
llzkBool_AndBoolOpGetRhs
MlirValue llzkBool_AndBoolOpGetRhs(MlirOperation op)
Get Rhs operand from llzk::boolean::AndBoolOp Operation.
Definition Ops.capi.cpp.inc:135
llzkBool_ForAllOpBuild
MlirOperation llzkBool_ForAllOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue sort)
Build a llzk::boolean::ForAllOp Operation.
Definition Ops.capi.cpp.inc:59
llzkOperationIsA_Bool_XorBoolOp
bool llzkOperationIsA_Bool_XorBoolOp(MlirOperation inp)
Returns true if the Operation is a llzk::boolean::XorBoolOp.
Definition Ops.capi.cpp.inc:377
llzkBool_CmpOpBuild
MlirOperation llzkBool_CmpOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs, MlirAttribute predicate)
Build a llzk::boolean::CmpOp Operation.
Definition Ops.capi.cpp.inc:204
llzkBool_CmpOpSetPredicate
void llzkBool_CmpOpSetPredicate(MlirOperation op, MlirAttribute attr)
Set Predicate attribute of llzk::boolean::CmpOp Operation.
Definition Ops.capi.cpp.inc:267
llzkOperationIsA_Bool_NotBoolOp
bool llzkOperationIsA_Bool_NotBoolOp(MlirOperation inp)
Returns true if the Operation is a llzk::boolean::NotBoolOp.
Definition Ops.capi.cpp.inc:283
llzkBool_NotBoolOpSetOperand
void llzkBool_NotBoolOpSetOperand(MlirOperation op, MlirValue value)
Set Operand operand of llzk::boolean::NotBoolOp Operation.
Definition Ops.capi.cpp.inc:297
llzkOperationIsA_Bool_ForAllOp
bool llzkOperationIsA_Bool_ForAllOp(MlirOperation inp)
Returns true if the Operation is a llzk::boolean::ForAllOp.
Definition Ops.capi.cpp.inc:70
llzkBool_AssertOpGetMsg
MlirAttribute llzkBool_AssertOpGetMsg(MlirOperation op)
Get Msg attribute from llzk::boolean::AssertOp Operation.
Definition Ops.capi.cpp.inc:196
llzkBool_OrBoolOpGetResult
MlirValue llzkBool_OrBoolOpGetResult(MlirOperation op)
Get Result result from llzk::boolean::OrBoolOp Operation.
Definition Ops.capi.cpp.inc:364
llzkBool_OrBoolOpGetRhs
MlirValue llzkBool_OrBoolOpGetRhs(MlirOperation op)
Get Rhs operand from llzk::boolean::OrBoolOp Operation.
Definition Ops.capi.cpp.inc:344
llzkBool_AndBoolOpSetLhs
void llzkBool_AndBoolOpSetLhs(MlirOperation op, MlirValue value)
Set Lhs operand of llzk::boolean::AndBoolOp Operation.
Definition Ops.capi.cpp.inc:125
llzkBool_AndBoolOpSetRhs
void llzkBool_AndBoolOpSetRhs(MlirOperation op, MlirValue value)
Set Rhs operand of llzk::boolean::AndBoolOp Operation.
Definition Ops.capi.cpp.inc:145
llzkBool_NotBoolOpBuild
MlirOperation llzkBool_NotBoolOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue operand)
Build a llzk::boolean::NotBoolOp Operation.
Definition Ops.capi.cpp.inc:275
llzkOperationIsA_Bool_YieldOp
bool llzkOperationIsA_Bool_YieldOp(MlirOperation inp)
Returns true if the Operation is a llzk::boolean::YieldOp.
Definition Ops.capi.cpp.inc:432
llzkBool_AndBoolOpGetLhs
MlirValue llzkBool_AndBoolOpGetLhs(MlirOperation op)
Get Lhs operand from llzk::boolean::AndBoolOp Operation.
Definition Ops.capi.cpp.inc:115
llzkBool_OrBoolOpSetLhs
void llzkBool_OrBoolOpSetLhs(MlirOperation op, MlirValue value)
Set Lhs operand of llzk::boolean::OrBoolOp Operation.
Definition Ops.capi.cpp.inc:334
llzkBool_ExistsOpGetResult
MlirValue llzkBool_ExistsOpGetResult(MlirOperation op)
Get Result result from llzk::boolean::ExistsOp Operation.
Definition Ops.capi.cpp.inc:51
llzkBool_ForAllOpSetSort
void llzkBool_ForAllOpSetSort(MlirOperation op, MlirValue value)
Set Sort operand of llzk::boolean::ForAllOp Operation.
Definition Ops.capi.cpp.inc:84
llzkBool_AssertOpSetCondition
void llzkBool_AssertOpSetCondition(MlirOperation op, MlirValue value)
Set Condition operand of llzk::boolean::AssertOp Operation.
Definition Ops.capi.cpp.inc:186
llzkBool_CmpOpGetLhs
MlirValue llzkBool_CmpOpGetLhs(MlirOperation op)
Get Lhs operand from llzk::boolean::CmpOp Operation.
Definition Ops.capi.cpp.inc:223
llzkBool_ForAllOpGetRegion
MlirRegion llzkBool_ForAllOpGetRegion(MlirOperation op)
Get Region region from llzk::boolean::ForAllOp Operation.
Definition Ops.capi.cpp.inc:98
llzkBool_ExistsOpGetRegion
MlirRegion llzkBool_ExistsOpGetRegion(MlirOperation op)
Get Region region from llzk::boolean::ExistsOp Operation.
Definition Ops.capi.cpp.inc:55
llzkBool_XorBoolOpGetRhs
MlirValue llzkBool_XorBoolOpGetRhs(MlirOperation op)
Get Rhs operand from llzk::boolean::XorBoolOp Operation.
Definition Ops.capi.cpp.inc:401
llzkBool_AndBoolOpGetResult
MlirValue llzkBool_AndBoolOpGetResult(MlirOperation op)
Get Result result from llzk::boolean::AndBoolOp Operation.
Definition Ops.capi.cpp.inc:155
llzkBool_OrBoolOpSetRhs
void llzkBool_OrBoolOpSetRhs(MlirOperation op, MlirValue value)
Set Rhs operand of llzk::boolean::OrBoolOp Operation.
Definition Ops.capi.cpp.inc:354
llzkBool_CmpOpGetPredicate
MlirAttribute llzkBool_CmpOpGetPredicate(MlirOperation op)
Get Predicate attribute from llzk::boolean::CmpOp Operation.
Definition Ops.capi.cpp.inc:263
llzkBool_NotBoolOpGetResult
MlirValue llzkBool_NotBoolOpGetResult(MlirOperation op)
Get Result result from llzk::boolean::NotBoolOp Operation.
Definition Ops.capi.cpp.inc:307
llzkBool_AssertOpSetMsg
void llzkBool_AssertOpSetMsg(MlirOperation op, MlirAttribute attr)
Set Msg attribute of llzk::boolean::AssertOp Operation.
Definition Ops.capi.cpp.inc:200
llzkOperationIsA_Bool_OrBoolOp
bool llzkOperationIsA_Bool_OrBoolOp(MlirOperation inp)
Returns true if the Operation is a llzk::boolean::OrBoolOp.
Definition Ops.capi.cpp.inc:320
llzkBool_ForAllOpGetResult
MlirValue llzkBool_ForAllOpGetResult(MlirOperation op)
Get Result result from llzk::boolean::ForAllOp Operation.
Definition Ops.capi.cpp.inc:94
llzkBool_CmpOpGetRhs
MlirValue llzkBool_CmpOpGetRhs(MlirOperation op)
Get Rhs operand from llzk::boolean::CmpOp Operation.
Definition Ops.capi.cpp.inc:243
llzkBool_XorBoolOpGetLhs
MlirValue llzkBool_XorBoolOpGetLhs(MlirOperation op)
Get Lhs operand from llzk::boolean::XorBoolOp Operation.
Definition Ops.capi.cpp.inc:381
llzkOperationIsA_Bool_AndBoolOp
bool llzkOperationIsA_Bool_AndBoolOp(MlirOperation inp)
Returns true if the Operation is a llzk::boolean::AndBoolOp.
Definition Ops.capi.cpp.inc:111
llzkBool_YieldOpBuild
MlirOperation llzkBool_YieldOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue value)
Build a llzk::boolean::YieldOp Operation.
Definition Ops.capi.cpp.inc:425
llzkBool_AndBoolOpBuild
MlirOperation llzkBool_AndBoolOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue lhs, MlirValue rhs)
Build a llzk::boolean::AndBoolOp Operation.
Definition Ops.capi.cpp.inc:102
llzkBool_CmpOpSetRhs
void llzkBool_CmpOpSetRhs(MlirOperation op, MlirValue value)
Set Rhs operand of llzk::boolean::CmpOp Operation.
Definition Ops.capi.cpp.inc:253
llzkBool_YieldOpGetValue
MlirValue llzkBool_YieldOpGetValue(MlirOperation op)
Get Value operand from llzk::boolean::YieldOp Operation.
Definition Ops.capi.cpp.inc:436
llzkBool_CmpOpSetLhs
void llzkBool_CmpOpSetLhs(MlirOperation op, MlirValue value)
Set Lhs operand of llzk::boolean::CmpOp Operation.
Definition Ops.capi.cpp.inc:233
mlirOpBuilderGetContext
MlirContext mlirOpBuilderGetContext(MlirOpBuilder builder)
Returns the MLIR context associated with builder.
Definition Builder.cpp:95
mlirOpBuilderInsert
MlirOperation mlirOpBuilderInsert(MlirOpBuilder builder, MlirOperation op)
Inserts op at the current insertion point of builder and returns it.
Definition Builder.cpp:167