1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Op Declarations *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* From: LLVMAllOps.td *|
7|* *|
8\*===----------------------------------------------------------------------===*/
9
10namespace mlir::LLVM {
11
12class ACosOp;
13
14} // namespace mlir::LLVM
15namespace mlir::LLVM {
16
17class AShrOp;
18
19} // namespace mlir::LLVM
20namespace mlir::LLVM {
21
22class ASinOp;
23
24} // namespace mlir::LLVM
25namespace mlir::LLVM {
26
27class ATan2Op;
28
29} // namespace mlir::LLVM
30namespace mlir::LLVM {
31
32class ATanOp;
33
34} // namespace mlir::LLVM
35namespace mlir::LLVM {
36
37class AbsOp;
38
39} // namespace mlir::LLVM
40namespace mlir::LLVM {
41
42class AddOp;
43
44} // namespace mlir::LLVM
45namespace mlir::LLVM {
46
47class AddrSpaceCastOp;
48
49} // namespace mlir::LLVM
50namespace mlir::LLVM {
51
52class AddressOfOp;
53
54} // namespace mlir::LLVM
55namespace mlir::LLVM {
56
57class AliasOp;
58
59} // namespace mlir::LLVM
60namespace mlir::LLVM {
61
62class AllocaOp;
63
64} // namespace mlir::LLVM
65namespace mlir::LLVM {
66
67class AndOp;
68
69} // namespace mlir::LLVM
70namespace mlir::LLVM {
71
72class Annotation;
73
74} // namespace mlir::LLVM
75namespace mlir::LLVM {
76
77class ArithmeticFenceOp;
78
79} // namespace mlir::LLVM
80namespace mlir::LLVM {
81
82class AssumeOp;
83
84} // namespace mlir::LLVM
85namespace mlir::LLVM {
86
87class AtomicCmpXchgOp;
88
89} // namespace mlir::LLVM
90namespace mlir::LLVM {
91
92class AtomicRMWOp;
93
94} // namespace mlir::LLVM
95namespace mlir::LLVM {
96
97class BitReverseOp;
98
99} // namespace mlir::LLVM
100namespace mlir::LLVM {
101
102class BitcastOp;
103
104} // namespace mlir::LLVM
105namespace mlir::LLVM {
106
107class BlockAddressOp;
108
109} // namespace mlir::LLVM
110namespace mlir::LLVM {
111
112class BlockTagOp;
113
114} // namespace mlir::LLVM
115namespace mlir::LLVM {
116
117class BrOp;
118
119} // namespace mlir::LLVM
120namespace mlir::LLVM {
121
122class ByteSwapOp;
123
124} // namespace mlir::LLVM
125namespace mlir::LLVM {
126
127class CallIntrinsicOp;
128
129} // namespace mlir::LLVM
130namespace mlir::LLVM {
131
132class CallOp;
133
134} // namespace mlir::LLVM
135namespace mlir::LLVM {
136
137class ClmulOp;
138
139} // namespace mlir::LLVM
140namespace mlir::LLVM {
141
142class ComdatOp;
143
144} // namespace mlir::LLVM
145namespace mlir::LLVM {
146
147class ComdatSelectorOp;
148
149} // namespace mlir::LLVM
150namespace mlir::LLVM {
151
152class CondBrOp;
153
154} // namespace mlir::LLVM
155namespace mlir::LLVM {
156
157class ConstantOp;
158
159} // namespace mlir::LLVM
160namespace mlir::LLVM {
161
162class ConstrainedACosIntr;
163
164} // namespace mlir::LLVM
165namespace mlir::LLVM {
166
167class ConstrainedASinIntr;
168
169} // namespace mlir::LLVM
170namespace mlir::LLVM {
171
172class ConstrainedATan2Intr;
173
174} // namespace mlir::LLVM
175namespace mlir::LLVM {
176
177class ConstrainedATanIntr;
178
179} // namespace mlir::LLVM
180namespace mlir::LLVM {
181
182class ConstrainedCeilIntr;
183
184} // namespace mlir::LLVM
185namespace mlir::LLVM {
186
187class ConstrainedCosIntr;
188
189} // namespace mlir::LLVM
190namespace mlir::LLVM {
191
192class ConstrainedCoshIntr;
193
194} // namespace mlir::LLVM
195namespace mlir::LLVM {
196
197class ConstrainedExp2Intr;
198
199} // namespace mlir::LLVM
200namespace mlir::LLVM {
201
202class ConstrainedExpIntr;
203
204} // namespace mlir::LLVM
205namespace mlir::LLVM {
206
207class ConstrainedFAddIntr;
208
209} // namespace mlir::LLVM
210namespace mlir::LLVM {
211
212class ConstrainedFCmpIntr;
213
214} // namespace mlir::LLVM
215namespace mlir::LLVM {
216
217class ConstrainedFCmpSIntr;
218
219} // namespace mlir::LLVM
220namespace mlir::LLVM {
221
222class ConstrainedFDivIntr;
223
224} // namespace mlir::LLVM
225namespace mlir::LLVM {
226
227class ConstrainedFMAIntr;
228
229} // namespace mlir::LLVM
230namespace mlir::LLVM {
231
232class ConstrainedFMulAddIntr;
233
234} // namespace mlir::LLVM
235namespace mlir::LLVM {
236
237class ConstrainedFMulIntr;
238
239} // namespace mlir::LLVM
240namespace mlir::LLVM {
241
242class ConstrainedFPExtIntr;
243
244} // namespace mlir::LLVM
245namespace mlir::LLVM {
246
247class ConstrainedFPToSIIntr;
248
249} // namespace mlir::LLVM
250namespace mlir::LLVM {
251
252class ConstrainedFPToUIIntr;
253
254} // namespace mlir::LLVM
255namespace mlir::LLVM {
256
257class ConstrainedFPTruncIntr;
258
259} // namespace mlir::LLVM
260namespace mlir::LLVM {
261
262class ConstrainedFRemIntr;
263
264} // namespace mlir::LLVM
265namespace mlir::LLVM {
266
267class ConstrainedFSubIntr;
268
269} // namespace mlir::LLVM
270namespace mlir::LLVM {
271
272class ConstrainedFloorIntr;
273
274} // namespace mlir::LLVM
275namespace mlir::LLVM {
276
277class ConstrainedLLRintIntr;
278
279} // namespace mlir::LLVM
280namespace mlir::LLVM {
281
282class ConstrainedLLRoundIntr;
283
284} // namespace mlir::LLVM
285namespace mlir::LLVM {
286
287class ConstrainedLRintIntr;
288
289} // namespace mlir::LLVM
290namespace mlir::LLVM {
291
292class ConstrainedLRoundIntr;
293
294} // namespace mlir::LLVM
295namespace mlir::LLVM {
296
297class ConstrainedLdexpIntr;
298
299} // namespace mlir::LLVM
300namespace mlir::LLVM {
301
302class ConstrainedLog10Intr;
303
304} // namespace mlir::LLVM
305namespace mlir::LLVM {
306
307class ConstrainedLog2Intr;
308
309} // namespace mlir::LLVM
310namespace mlir::LLVM {
311
312class ConstrainedLogIntr;
313
314} // namespace mlir::LLVM
315namespace mlir::LLVM {
316
317class ConstrainedMaxNumIntr;
318
319} // namespace mlir::LLVM
320namespace mlir::LLVM {
321
322class ConstrainedMaximumIntr;
323
324} // namespace mlir::LLVM
325namespace mlir::LLVM {
326
327class ConstrainedMinNumIntr;
328
329} // namespace mlir::LLVM
330namespace mlir::LLVM {
331
332class ConstrainedMinimumIntr;
333
334} // namespace mlir::LLVM
335namespace mlir::LLVM {
336
337class ConstrainedNearbyIntIntr;
338
339} // namespace mlir::LLVM
340namespace mlir::LLVM {
341
342class ConstrainedPowIIntr;
343
344} // namespace mlir::LLVM
345namespace mlir::LLVM {
346
347class ConstrainedPowIntr;
348
349} // namespace mlir::LLVM
350namespace mlir::LLVM {
351
352class ConstrainedRIntIntr;
353
354} // namespace mlir::LLVM
355namespace mlir::LLVM {
356
357class ConstrainedRoundEvenIntr;
358
359} // namespace mlir::LLVM
360namespace mlir::LLVM {
361
362class ConstrainedRoundIntr;
363
364} // namespace mlir::LLVM
365namespace mlir::LLVM {
366
367class ConstrainedSIToFP;
368
369} // namespace mlir::LLVM
370namespace mlir::LLVM {
371
372class ConstrainedSinIntr;
373
374} // namespace mlir::LLVM
375namespace mlir::LLVM {
376
377class ConstrainedSinhIntr;
378
379} // namespace mlir::LLVM
380namespace mlir::LLVM {
381
382class ConstrainedSqrtIntr;
383
384} // namespace mlir::LLVM
385namespace mlir::LLVM {
386
387class ConstrainedTanIntr;
388
389} // namespace mlir::LLVM
390namespace mlir::LLVM {
391
392class ConstrainedTanhIntr;
393
394} // namespace mlir::LLVM
395namespace mlir::LLVM {
396
397class ConstrainedTruncIntr;
398
399} // namespace mlir::LLVM
400namespace mlir::LLVM {
401
402class ConstrainedUIToFP;
403
404} // namespace mlir::LLVM
405namespace mlir::LLVM {
406
407class CopySignOp;
408
409} // namespace mlir::LLVM
410namespace mlir::LLVM {
411
412class CoroAlignOp;
413
414} // namespace mlir::LLVM
415namespace mlir::LLVM {
416
417class CoroAllocOp;
418
419} // namespace mlir::LLVM
420namespace mlir::LLVM {
421
422class CoroAwaitSuspendBoolOp;
423
424} // namespace mlir::LLVM
425namespace mlir::LLVM {
426
427class CoroAwaitSuspendHandleOp;
428
429} // namespace mlir::LLVM
430namespace mlir::LLVM {
431
432class CoroAwaitSuspendVoidOp;
433
434} // namespace mlir::LLVM
435namespace mlir::LLVM {
436
437class CoroBeginOp;
438
439} // namespace mlir::LLVM
440namespace mlir::LLVM {
441
442class CoroDeadOp;
443
444} // namespace mlir::LLVM
445namespace mlir::LLVM {
446
447class CoroDestroyOp;
448
449} // namespace mlir::LLVM
450namespace mlir::LLVM {
451
452class CoroDoneOp;
453
454} // namespace mlir::LLVM
455namespace mlir::LLVM {
456
457class CoroEndOp;
458
459} // namespace mlir::LLVM
460namespace mlir::LLVM {
461
462class CoroFrameOp;
463
464} // namespace mlir::LLVM
465namespace mlir::LLVM {
466
467class CoroFreeOp;
468
469} // namespace mlir::LLVM
470namespace mlir::LLVM {
471
472class CoroIdOp;
473
474} // namespace mlir::LLVM
475namespace mlir::LLVM {
476
477class CoroIsInRampOp;
478
479} // namespace mlir::LLVM
480namespace mlir::LLVM {
481
482class CoroNoopOp;
483
484} // namespace mlir::LLVM
485namespace mlir::LLVM {
486
487class CoroPromiseOp;
488
489} // namespace mlir::LLVM
490namespace mlir::LLVM {
491
492class CoroResumeOp;
493
494} // namespace mlir::LLVM
495namespace mlir::LLVM {
496
497class CoroSaveOp;
498
499} // namespace mlir::LLVM
500namespace mlir::LLVM {
501
502class CoroSizeOp;
503
504} // namespace mlir::LLVM
505namespace mlir::LLVM {
506
507class CoroSuspendOp;
508
509} // namespace mlir::LLVM
510namespace mlir::LLVM {
511
512class CosOp;
513
514} // namespace mlir::LLVM
515namespace mlir::LLVM {
516
517class CoshOp;
518
519} // namespace mlir::LLVM
520namespace mlir::LLVM {
521
522class CountLeadingZerosOp;
523
524} // namespace mlir::LLVM
525namespace mlir::LLVM {
526
527class CountTrailingZerosOp;
528
529} // namespace mlir::LLVM
530namespace mlir::LLVM {
531
532class CtPopOp;
533
534} // namespace mlir::LLVM
535namespace mlir::LLVM {
536
537class DSOLocalEquivalentOp;
538
539} // namespace mlir::LLVM
540namespace mlir::LLVM {
541
542class DbgDeclareOp;
543
544} // namespace mlir::LLVM
545namespace mlir::LLVM {
546
547class DbgLabelOp;
548
549} // namespace mlir::LLVM
550namespace mlir::LLVM {
551
552class DbgValueOp;
553
554} // namespace mlir::LLVM
555namespace mlir::LLVM {
556
557class DebugTrap;
558
559} // namespace mlir::LLVM
560namespace mlir::LLVM {
561
562class EhTypeidForOp;
563
564} // namespace mlir::LLVM
565namespace mlir::LLVM {
566
567class Exp10Op;
568
569} // namespace mlir::LLVM
570namespace mlir::LLVM {
571
572class Exp2Op;
573
574} // namespace mlir::LLVM
575namespace mlir::LLVM {
576
577class ExpOp;
578
579} // namespace mlir::LLVM
580namespace mlir::LLVM {
581
582class ExpectOp;
583
584} // namespace mlir::LLVM
585namespace mlir::LLVM {
586
587class ExpectWithProbabilityOp;
588
589} // namespace mlir::LLVM
590namespace mlir::LLVM {
591
592class ExtractElementOp;
593
594} // namespace mlir::LLVM
595namespace mlir::LLVM {
596
597class FAbsOp;
598
599} // namespace mlir::LLVM
600namespace mlir::LLVM {
601
602class FAddOp;
603
604} // namespace mlir::LLVM
605namespace mlir::LLVM {
606
607class FCeilOp;
608
609} // namespace mlir::LLVM
610namespace mlir::LLVM {
611
612class FCmpOp;
613
614} // namespace mlir::LLVM
615namespace mlir::LLVM {
616
617class FDivOp;
618
619} // namespace mlir::LLVM
620namespace mlir::LLVM {
621
622class FFloorOp;
623
624} // namespace mlir::LLVM
625namespace mlir::LLVM {
626
627class FMAOp;
628
629} // namespace mlir::LLVM
630namespace mlir::LLVM {
631
632class FMulAddOp;
633
634} // namespace mlir::LLVM
635namespace mlir::LLVM {
636
637class FMulOp;
638
639} // namespace mlir::LLVM
640namespace mlir::LLVM {
641
642class FNegOp;
643
644} // namespace mlir::LLVM
645namespace mlir::LLVM {
646
647class FPExtOp;
648
649} // namespace mlir::LLVM
650namespace mlir::LLVM {
651
652class FPToSIOp;
653
654} // namespace mlir::LLVM
655namespace mlir::LLVM {
656
657class FPToUIOp;
658
659} // namespace mlir::LLVM
660namespace mlir::LLVM {
661
662class FPTruncOp;
663
664} // namespace mlir::LLVM
665namespace mlir::LLVM {
666
667class FRemOp;
668
669} // namespace mlir::LLVM
670namespace mlir::LLVM {
671
672class FSubOp;
673
674} // namespace mlir::LLVM
675namespace mlir::LLVM {
676
677class FTruncOp;
678
679} // namespace mlir::LLVM
680namespace mlir::LLVM {
681
682class FakeUseOp;
683
684} // namespace mlir::LLVM
685namespace mlir::LLVM {
686
687class FenceOp;
688
689} // namespace mlir::LLVM
690namespace mlir::LLVM {
691
692class FractionExpOp;
693
694} // namespace mlir::LLVM
695namespace mlir::LLVM {
696
697class FreezeOp;
698
699} // namespace mlir::LLVM
700namespace mlir::LLVM {
701
702class FshlOp;
703
704} // namespace mlir::LLVM
705namespace mlir::LLVM {
706
707class FshrOp;
708
709} // namespace mlir::LLVM
710namespace mlir::LLVM {
711
712class GEPOp;
713
714} // namespace mlir::LLVM
715namespace mlir::LLVM {
716
717class GetActiveLaneMaskOp;
718
719} // namespace mlir::LLVM
720namespace mlir::LLVM {
721
722class GlobalCtorsOp;
723
724} // namespace mlir::LLVM
725namespace mlir::LLVM {
726
727class GlobalDtorsOp;
728
729} // namespace mlir::LLVM
730namespace mlir::LLVM {
731
732class GlobalOp;
733
734} // namespace mlir::LLVM
735namespace mlir::LLVM {
736
737class ICmpOp;
738
739} // namespace mlir::LLVM
740namespace mlir::LLVM {
741
742class IFuncOp;
743
744} // namespace mlir::LLVM
745namespace mlir::LLVM {
746
747class IndirectBrOp;
748
749} // namespace mlir::LLVM
750namespace mlir::LLVM {
751
752class InlineAsmOp;
753
754} // namespace mlir::LLVM
755namespace mlir::LLVM {
756
757class InsertElementOp;
758
759} // namespace mlir::LLVM
760namespace mlir::LLVM {
761
762class IntToPtrOp;
763
764} // namespace mlir::LLVM
765namespace mlir::LLVM {
766
767class InvariantEndOp;
768
769} // namespace mlir::LLVM
770namespace mlir::LLVM {
771
772class InvariantStartOp;
773
774} // namespace mlir::LLVM
775namespace mlir::LLVM {
776
777class InvokeOp;
778
779} // namespace mlir::LLVM
780namespace mlir::LLVM {
781
782class IsConstantOp;
783
784} // namespace mlir::LLVM
785namespace mlir::LLVM {
786
787class IsFPClass;
788
789} // namespace mlir::LLVM
790namespace mlir::LLVM {
791
792class LLVMFuncOp;
793
794} // namespace mlir::LLVM
795namespace mlir::LLVM {
796
797class LShrOp;
798
799} // namespace mlir::LLVM
800namespace mlir::LLVM {
801
802class LandingpadOp;
803
804} // namespace mlir::LLVM
805namespace mlir::LLVM {
806
807class LaunderInvariantGroupOp;
808
809} // namespace mlir::LLVM
810namespace mlir::LLVM {
811
812class LifetimeEndOp;
813
814} // namespace mlir::LLVM
815namespace mlir::LLVM {
816
817class LifetimeStartOp;
818
819} // namespace mlir::LLVM
820namespace mlir::LLVM {
821
822class LinkerOptionsOp;
823
824} // namespace mlir::LLVM
825namespace mlir::LLVM {
826
827class LlrintOp;
828
829} // namespace mlir::LLVM
830namespace mlir::LLVM {
831
832class LlroundOp;
833
834} // namespace mlir::LLVM
835namespace mlir::LLVM {
836
837class LoadExpOp;
838
839} // namespace mlir::LLVM
840namespace mlir::LLVM {
841
842class LoadOp;
843
844} // namespace mlir::LLVM
845namespace mlir::LLVM {
846
847class Log10Op;
848
849} // namespace mlir::LLVM
850namespace mlir::LLVM {
851
852class Log2Op;
853
854} // namespace mlir::LLVM
855namespace mlir::LLVM {
856
857class LogOp;
858
859} // namespace mlir::LLVM
860namespace mlir::LLVM {
861
862class LrintOp;
863
864} // namespace mlir::LLVM
865namespace mlir::LLVM {
866
867class LroundOp;
868
869} // namespace mlir::LLVM
870namespace mlir::LLVM {
871
872class MaskedLoadOp;
873
874} // namespace mlir::LLVM
875namespace mlir::LLVM {
876
877class MaskedStoreOp;
878
879} // namespace mlir::LLVM
880namespace mlir::LLVM {
881
882class MatrixColumnMajorLoadOp;
883
884} // namespace mlir::LLVM
885namespace mlir::LLVM {
886
887class MatrixColumnMajorStoreOp;
888
889} // namespace mlir::LLVM
890namespace mlir::LLVM {
891
892class MatrixMultiplyOp;
893
894} // namespace mlir::LLVM
895namespace mlir::LLVM {
896
897class MatrixTransposeOp;
898
899} // namespace mlir::LLVM
900namespace mlir::LLVM {
901
902class MaxNumOp;
903
904} // namespace mlir::LLVM
905namespace mlir::LLVM {
906
907class MaximumNumOp;
908
909} // namespace mlir::LLVM
910namespace mlir::LLVM {
911
912class MaximumOp;
913
914} // namespace mlir::LLVM
915namespace mlir::LLVM {
916
917class MemcpyInlineOp;
918
919} // namespace mlir::LLVM
920namespace mlir::LLVM {
921
922class MemcpyOp;
923
924} // namespace mlir::LLVM
925namespace mlir::LLVM {
926
927class MemmoveOp;
928
929} // namespace mlir::LLVM
930namespace mlir::LLVM {
931
932class MemsetInlineOp;
933
934} // namespace mlir::LLVM
935namespace mlir::LLVM {
936
937class MemsetOp;
938
939} // namespace mlir::LLVM
940namespace mlir::LLVM {
941
942class MetadataAsValueOp;
943
944} // namespace mlir::LLVM
945namespace mlir::LLVM {
946
947class MinNumOp;
948
949} // namespace mlir::LLVM
950namespace mlir::LLVM {
951
952class MinimumNumOp;
953
954} // namespace mlir::LLVM
955namespace mlir::LLVM {
956
957class MinimumOp;
958
959} // namespace mlir::LLVM
960namespace mlir::LLVM {
961
962class ModfOp;
963
964} // namespace mlir::LLVM
965namespace mlir::LLVM {
966
967class ModuleFlagsOp;
968
969} // namespace mlir::LLVM
970namespace mlir::LLVM {
971
972class MulOp;
973
974} // namespace mlir::LLVM
975namespace mlir::LLVM {
976
977class NamedMetadataOp;
978
979} // namespace mlir::LLVM
980namespace mlir::LLVM {
981
982class NearbyintOp;
983
984} // namespace mlir::LLVM
985namespace mlir::LLVM {
986
987class NoAliasScopeDeclOp;
988
989} // namespace mlir::LLVM
990namespace mlir::LLVM {
991
992class NoneTokenOp;
993
994} // namespace mlir::LLVM
995namespace mlir::LLVM {
996
997class OrOp;
998
999} // namespace mlir::LLVM
1000namespace mlir::LLVM {
1001
1002class PdepOp;
1003
1004} // namespace mlir::LLVM
1005namespace mlir::LLVM {
1006
1007class PextOp;
1008
1009} // namespace mlir::LLVM
1010namespace mlir::LLVM {
1011
1012class PoisonOp;
1013
1014} // namespace mlir::LLVM
1015namespace mlir::LLVM {
1016
1017class PowIOp;
1018
1019} // namespace mlir::LLVM
1020namespace mlir::LLVM {
1021
1022class PowOp;
1023
1024} // namespace mlir::LLVM
1025namespace mlir::LLVM {
1026
1027class Prefetch;
1028
1029} // namespace mlir::LLVM
1030namespace mlir::LLVM {
1031
1032class PtrAnnotation;
1033
1034} // namespace mlir::LLVM
1035namespace mlir::LLVM {
1036
1037class PtrMaskOp;
1038
1039} // namespace mlir::LLVM
1040namespace mlir::LLVM {
1041
1042class PtrToAddrOp;
1043
1044} // namespace mlir::LLVM
1045namespace mlir::LLVM {
1046
1047class PtrToIntOp;
1048
1049} // namespace mlir::LLVM
1050namespace mlir::LLVM {
1051
1052class ResumeOp;
1053
1054} // namespace mlir::LLVM
1055namespace mlir::LLVM {
1056
1057class ReturnOp;
1058
1059} // namespace mlir::LLVM
1060namespace mlir::LLVM {
1061
1062class RintOp;
1063
1064} // namespace mlir::LLVM
1065namespace mlir::LLVM {
1066
1067class RoundEvenOp;
1068
1069} // namespace mlir::LLVM
1070namespace mlir::LLVM {
1071
1072class RoundOp;
1073
1074} // namespace mlir::LLVM
1075namespace mlir::LLVM {
1076
1077class SAddSat;
1078
1079} // namespace mlir::LLVM
1080namespace mlir::LLVM {
1081
1082class SAddWithOverflowOp;
1083
1084} // namespace mlir::LLVM
1085namespace mlir::LLVM {
1086
1087class SCmpOp;
1088
1089} // namespace mlir::LLVM
1090namespace mlir::LLVM {
1091
1092class SDivOp;
1093
1094} // namespace mlir::LLVM
1095namespace mlir::LLVM {
1096
1097class SExtOp;
1098
1099} // namespace mlir::LLVM
1100namespace mlir::LLVM {
1101
1102class SIToFPOp;
1103
1104} // namespace mlir::LLVM
1105namespace mlir::LLVM {
1106
1107class SMaxOp;
1108
1109} // namespace mlir::LLVM
1110namespace mlir::LLVM {
1111
1112class SMinOp;
1113
1114} // namespace mlir::LLVM
1115namespace mlir::LLVM {
1116
1117class SMulHOp;
1118
1119} // namespace mlir::LLVM
1120namespace mlir::LLVM {
1121
1122class SMulWithOverflowOp;
1123
1124} // namespace mlir::LLVM
1125namespace mlir::LLVM {
1126
1127class SRemOp;
1128
1129} // namespace mlir::LLVM
1130namespace mlir::LLVM {
1131
1132class SSACopyOp;
1133
1134} // namespace mlir::LLVM
1135namespace mlir::LLVM {
1136
1137class SSHLSat;
1138
1139} // namespace mlir::LLVM
1140namespace mlir::LLVM {
1141
1142class SSubSat;
1143
1144} // namespace mlir::LLVM
1145namespace mlir::LLVM {
1146
1147class SSubWithOverflowOp;
1148
1149} // namespace mlir::LLVM
1150namespace mlir::LLVM {
1151
1152class SelectOp;
1153
1154} // namespace mlir::LLVM
1155namespace mlir::LLVM {
1156
1157class ShlOp;
1158
1159} // namespace mlir::LLVM
1160namespace mlir::LLVM {
1161
1162class ShuffleVectorOp;
1163
1164} // namespace mlir::LLVM
1165namespace mlir::LLVM {
1166
1167class SinOp;
1168
1169} // namespace mlir::LLVM
1170namespace mlir::LLVM {
1171
1172class SincosOp;
1173
1174} // namespace mlir::LLVM
1175namespace mlir::LLVM {
1176
1177class SinhOp;
1178
1179} // namespace mlir::LLVM
1180namespace mlir::LLVM {
1181
1182class SqrtOp;
1183
1184} // namespace mlir::LLVM
1185namespace mlir::LLVM {
1186
1187class StackRestoreOp;
1188
1189} // namespace mlir::LLVM
1190namespace mlir::LLVM {
1191
1192class StackSaveOp;
1193
1194} // namespace mlir::LLVM
1195namespace mlir::LLVM {
1196
1197class StepVectorOp;
1198
1199} // namespace mlir::LLVM
1200namespace mlir::LLVM {
1201
1202class StoreOp;
1203
1204} // namespace mlir::LLVM
1205namespace mlir::LLVM {
1206
1207class SubOp;
1208
1209} // namespace mlir::LLVM
1210namespace mlir::LLVM {
1211
1212class SwitchOp;
1213
1214} // namespace mlir::LLVM
1215namespace mlir::LLVM {
1216
1217class TanOp;
1218
1219} // namespace mlir::LLVM
1220namespace mlir::LLVM {
1221
1222class TanhOp;
1223
1224} // namespace mlir::LLVM
1225namespace mlir::LLVM {
1226
1227class ThreadlocalAddressOp;
1228
1229} // namespace mlir::LLVM
1230namespace mlir::LLVM {
1231
1232class Trap;
1233
1234} // namespace mlir::LLVM
1235namespace mlir::LLVM {
1236
1237class TruncOp;
1238
1239} // namespace mlir::LLVM
1240namespace mlir::LLVM {
1241
1242class UAddSat;
1243
1244} // namespace mlir::LLVM
1245namespace mlir::LLVM {
1246
1247class UAddWithOverflowOp;
1248
1249} // namespace mlir::LLVM
1250namespace mlir::LLVM {
1251
1252class UBSanTrap;
1253
1254} // namespace mlir::LLVM
1255namespace mlir::LLVM {
1256
1257class UCmpOp;
1258
1259} // namespace mlir::LLVM
1260namespace mlir::LLVM {
1261
1262class UDivOp;
1263
1264} // namespace mlir::LLVM
1265namespace mlir::LLVM {
1266
1267class UIToFPOp;
1268
1269} // namespace mlir::LLVM
1270namespace mlir::LLVM {
1271
1272class UMaxOp;
1273
1274} // namespace mlir::LLVM
1275namespace mlir::LLVM {
1276
1277class UMinOp;
1278
1279} // namespace mlir::LLVM
1280namespace mlir::LLVM {
1281
1282class UMulHOp;
1283
1284} // namespace mlir::LLVM
1285namespace mlir::LLVM {
1286
1287class UMulWithOverflowOp;
1288
1289} // namespace mlir::LLVM
1290namespace mlir::LLVM {
1291
1292class URemOp;
1293
1294} // namespace mlir::LLVM
1295namespace mlir::LLVM {
1296
1297class USHLSat;
1298
1299} // namespace mlir::LLVM
1300namespace mlir::LLVM {
1301
1302class USubSat;
1303
1304} // namespace mlir::LLVM
1305namespace mlir::LLVM {
1306
1307class USubWithOverflowOp;
1308
1309} // namespace mlir::LLVM
1310namespace mlir::LLVM {
1311
1312class UndefOp;
1313
1314} // namespace mlir::LLVM
1315namespace mlir::LLVM {
1316
1317class UnreachableOp;
1318
1319} // namespace mlir::LLVM
1320namespace mlir::LLVM {
1321
1322class VPLoadOp;
1323
1324} // namespace mlir::LLVM
1325namespace mlir::LLVM {
1326
1327class VPMergeMinOp;
1328
1329} // namespace mlir::LLVM
1330namespace mlir::LLVM {
1331
1332class VPReduceAddOp;
1333
1334} // namespace mlir::LLVM
1335namespace mlir::LLVM {
1336
1337class VPReduceAndOp;
1338
1339} // namespace mlir::LLVM
1340namespace mlir::LLVM {
1341
1342class VPReduceFAddOp;
1343
1344} // namespace mlir::LLVM
1345namespace mlir::LLVM {
1346
1347class VPReduceFMaxOp;
1348
1349} // namespace mlir::LLVM
1350namespace mlir::LLVM {
1351
1352class VPReduceFMaximumOp;
1353
1354} // namespace mlir::LLVM
1355namespace mlir::LLVM {
1356
1357class VPReduceFMinOp;
1358
1359} // namespace mlir::LLVM
1360namespace mlir::LLVM {
1361
1362class VPReduceFMinimumOp;
1363
1364} // namespace mlir::LLVM
1365namespace mlir::LLVM {
1366
1367class VPReduceFMulOp;
1368
1369} // namespace mlir::LLVM
1370namespace mlir::LLVM {
1371
1372class VPReduceMulOp;
1373
1374} // namespace mlir::LLVM
1375namespace mlir::LLVM {
1376
1377class VPReduceOrOp;
1378
1379} // namespace mlir::LLVM
1380namespace mlir::LLVM {
1381
1382class VPReduceSMaxOp;
1383
1384} // namespace mlir::LLVM
1385namespace mlir::LLVM {
1386
1387class VPReduceSMinOp;
1388
1389} // namespace mlir::LLVM
1390namespace mlir::LLVM {
1391
1392class VPReduceUMaxOp;
1393
1394} // namespace mlir::LLVM
1395namespace mlir::LLVM {
1396
1397class VPReduceUMinOp;
1398
1399} // namespace mlir::LLVM
1400namespace mlir::LLVM {
1401
1402class VPReduceXorOp;
1403
1404} // namespace mlir::LLVM
1405namespace mlir::LLVM {
1406
1407class VPSDivOp;
1408
1409} // namespace mlir::LLVM
1410namespace mlir::LLVM {
1411
1412class VPSRemOp;
1413
1414} // namespace mlir::LLVM
1415namespace mlir::LLVM {
1416
1417class VPStoreOp;
1418
1419} // namespace mlir::LLVM
1420namespace mlir::LLVM {
1421
1422class VPStridedLoadOp;
1423
1424} // namespace mlir::LLVM
1425namespace mlir::LLVM {
1426
1427class VPStridedStoreOp;
1428
1429} // namespace mlir::LLVM
1430namespace mlir::LLVM {
1431
1432class VPUDivOp;
1433
1434} // namespace mlir::LLVM
1435namespace mlir::LLVM {
1436
1437class VPURemOp;
1438
1439} // namespace mlir::LLVM
1440namespace mlir::LLVM {
1441
1442class VaArgOp;
1443
1444} // namespace mlir::LLVM
1445namespace mlir::LLVM {
1446
1447class VaCopyOp;
1448
1449} // namespace mlir::LLVM
1450namespace mlir::LLVM {
1451
1452class VaEndOp;
1453
1454} // namespace mlir::LLVM
1455namespace mlir::LLVM {
1456
1457class VaStartOp;
1458
1459} // namespace mlir::LLVM
1460namespace mlir::LLVM {
1461
1462class VarAnnotation;
1463
1464} // namespace mlir::LLVM
1465namespace mlir::LLVM {
1466
1467class XOrOp;
1468
1469} // namespace mlir::LLVM
1470namespace mlir::LLVM {
1471
1472class ZExtOp;
1473
1474} // namespace mlir::LLVM
1475namespace mlir::LLVM {
1476
1477class ZeroOp;
1478
1479} // namespace mlir::LLVM
1480namespace mlir::LLVM {
1481
1482class masked_compressstore;
1483
1484} // namespace mlir::LLVM
1485namespace mlir::LLVM {
1486
1487class masked_expandload;
1488
1489} // namespace mlir::LLVM
1490namespace mlir::LLVM {
1491
1492class masked_gather;
1493
1494} // namespace mlir::LLVM
1495namespace mlir::LLVM {
1496
1497class masked_scatter;
1498
1499} // namespace mlir::LLVM
1500namespace mlir::LLVM {
1501
1502class vector_deinterleave2;
1503
1504} // namespace mlir::LLVM
1505namespace mlir::LLVM {
1506
1507class vector_extract;
1508
1509} // namespace mlir::LLVM
1510namespace mlir::LLVM {
1511
1512class vector_insert;
1513
1514} // namespace mlir::LLVM
1515namespace mlir::LLVM {
1516
1517class vector_interleave2;
1518
1519} // namespace mlir::LLVM
1520namespace mlir::LLVM {
1521
1522class vector_reduce_add;
1523
1524} // namespace mlir::LLVM
1525namespace mlir::LLVM {
1526
1527class vector_reduce_and;
1528
1529} // namespace mlir::LLVM
1530namespace mlir::LLVM {
1531
1532class vector_reduce_fadd;
1533
1534} // namespace mlir::LLVM
1535namespace mlir::LLVM {
1536
1537class vector_reduce_fmax;
1538
1539} // namespace mlir::LLVM
1540namespace mlir::LLVM {
1541
1542class vector_reduce_fmaximum;
1543
1544} // namespace mlir::LLVM
1545namespace mlir::LLVM {
1546
1547class vector_reduce_fmaximumnum;
1548
1549} // namespace mlir::LLVM
1550namespace mlir::LLVM {
1551
1552class vector_reduce_fmin;
1553
1554} // namespace mlir::LLVM
1555namespace mlir::LLVM {
1556
1557class vector_reduce_fminimum;
1558
1559} // namespace mlir::LLVM
1560namespace mlir::LLVM {
1561
1562class vector_reduce_fminimumnum;
1563
1564} // namespace mlir::LLVM
1565namespace mlir::LLVM {
1566
1567class vector_reduce_fmul;
1568
1569} // namespace mlir::LLVM
1570namespace mlir::LLVM {
1571
1572class vector_reduce_mul;
1573
1574} // namespace mlir::LLVM
1575namespace mlir::LLVM {
1576
1577class vector_reduce_or;
1578
1579} // namespace mlir::LLVM
1580namespace mlir::LLVM {
1581
1582class vector_reduce_smax;
1583
1584} // namespace mlir::LLVM
1585namespace mlir::LLVM {
1586
1587class vector_reduce_smin;
1588
1589} // namespace mlir::LLVM
1590namespace mlir::LLVM {
1591
1592class vector_reduce_umax;
1593
1594} // namespace mlir::LLVM
1595namespace mlir::LLVM {
1596
1597class vector_reduce_umin;
1598
1599} // namespace mlir::LLVM
1600namespace mlir::LLVM {
1601
1602class vector_reduce_xor;
1603
1604} // namespace mlir::LLVM
1605namespace mlir::LLVM {
1606
1607class vector_repeat;
1608
1609} // namespace mlir::LLVM
1610namespace mlir::LLVM {
1611
1612class vscale;
1613
1614} // namespace mlir::LLVM
1615namespace mlir::LLVM {
1616
1617/// Extract a value from an LLVM struct.
1618class ExtractValueOp;
1619
1620} // namespace mlir::LLVM
1621namespace mlir::LLVM {
1622
1623/// Insert a value into an LLVM struct.
1624class InsertValueOp;
1625
1626} // namespace mlir::LLVM
1627#ifdef GET_OP_CLASSES
1628#undef GET_OP_CLASSES
1629
1630#include "mlir/Bytecode/BytecodeOpInterface.h"
1631#include "mlir/IR/BuiltinAttributes.h"
1632#include "mlir/IR/OpDefinition.h"
1633#include "mlir/IR/Types.h"
1634#include "mlir/Interfaces/InferTypeOpInterface.h"
1635#include "mlir/Interfaces/SideEffectInterfaces.h"
1636
1637namespace mlir::LLVM {
1638
1639
1640//===----------------------------------------------------------------------===//
1641// ::mlir::LLVM::ExtractValueOp declarations
1642//===----------------------------------------------------------------------===//
1643
1644namespace detail {
1645
1646class ExtractValueOpGenericAdaptorBase {
1647public:
1648 struct Properties {
1649 using positionTy = ::mlir::DenseI64ArrayAttr;
1650 positionTy position;
1651
1652 auto getPosition() const {
1653 auto &propStorage = this->position;
1654 return ::llvm::cast<::mlir::DenseI64ArrayAttr>(Val: propStorage);
1655 }
1656 void setPosition(const ::mlir::DenseI64ArrayAttr &propValue) {
1657 this->position = propValue;
1658 }
1659 bool operator==(const Properties &rhs) const {
1660 return
1661 rhs.position == this->position &&
1662 true;
1663 }
1664 bool operator!=(const Properties &rhs) const {
1665 return !(*this == rhs);
1666 }
1667 };
1668protected:
1669 ::mlir::DictionaryAttr odsAttrs;
1670 ::std::optional<::mlir::OperationName> odsOpName;
1671 Properties properties;
1672 ::mlir::RegionRange odsRegions;
1673public:
1674 ExtractValueOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
1675 odsOpName.emplace(args: "llvm.extractvalue", args: odsAttrs.getContext());
1676 }
1677
1678 ExtractValueOpGenericAdaptorBase(ExtractValueOp op);
1679
1680 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
1681 return {index, 1};
1682 }
1683
1684 const Properties &getProperties() {
1685 return properties;
1686 }
1687
1688 ::mlir::DictionaryAttr getAttributes() {
1689 return odsAttrs;
1690 }
1691
1692 ::mlir::DenseI64ArrayAttr getPositionAttr() {
1693 auto attr = ::llvm::cast<::mlir::DenseI64ArrayAttr>(Val: getProperties().position);
1694 return attr;
1695 }
1696
1697 ::llvm::ArrayRef<int64_t> getPosition();
1698};
1699
1700} // namespace detail
1701template <typename RangeT>
1702class ExtractValueOpGenericAdaptor : public detail::ExtractValueOpGenericAdaptorBase {
1703 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
1704 using Base = detail::ExtractValueOpGenericAdaptorBase;
1705 static constexpr int odsIndex_container = 0;
1706public:
1707 ExtractValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
1708
1709 ExtractValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ExtractValueOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
1710
1711 ExtractValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ExtractValueOpGenericAdaptor(values, attrs, Properties{}, {}) {}
1712
1713 ExtractValueOpGenericAdaptor(RangeT values, const ExtractValueOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
1714
1715 template <typename LateInst = ExtractValueOp, typename = std::enable_if_t<std::is_same_v<LateInst, ExtractValueOp>>>
1716 ExtractValueOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
1717
1718 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
1719 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
1720 }
1721
1722 RangeT getODSOperands(unsigned index) {
1723 auto valueRange = getODSOperandIndexAndLength(index);
1724 return {std::next(odsOperands.begin(), valueRange.first),
1725 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
1726 }
1727
1728 ValueT getContainer() {
1729 return (*getODSOperands(index: 0).begin());
1730 }
1731
1732 RangeT getOperands() {
1733 return odsOperands;
1734 }
1735
1736private:
1737 RangeT odsOperands;
1738};
1739class ExtractValueOpAdaptor : public ExtractValueOpGenericAdaptor<::mlir::ValueRange> {
1740public:
1741 using ExtractValueOpGenericAdaptor::ExtractValueOpGenericAdaptor;
1742 ExtractValueOpAdaptor(ExtractValueOp op);
1743
1744 ::llvm::LogicalResult verify(::mlir::Location loc);
1745};
1746class ExtractValueOp : public ::mlir::Op<ExtractValueOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
1747public:
1748 using Op::Op;
1749 using Op::print;
1750 using Adaptor = ExtractValueOpAdaptor;
1751 template <typename RangeT>
1752 using GenericAdaptor = ExtractValueOpGenericAdaptor<RangeT>;
1753 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
1754 static constexpr int odsIndex_container = 0;
1755 static constexpr int odsIndex_res = 0;
1756 using Properties = FoldAdaptor::Properties;
1757 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
1758 static ::llvm::StringRef attrNames[] = {::llvm::StringRef("position")};
1759 return ::llvm::ArrayRef(attrNames);
1760 }
1761
1762 ::mlir::StringAttr getPositionAttrName() {
1763 return getAttributeNameForIndex(index: 0);
1764 }
1765
1766 static ::mlir::StringAttr getPositionAttrName(::mlir::OperationName name) {
1767 return getAttributeNameForIndex(name, index: 0);
1768 }
1769
1770 static constexpr ::llvm::StringLiteral getOperationName() {
1771 return ::llvm::StringLiteral("llvm.extractvalue");
1772 }
1773
1774 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
1775 return {index, 1};
1776 }
1777
1778 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
1779 auto [start, length] = getODSOperandIndexAndLength(index);
1780 return getOperation()->getOperands().slice(n: start, m: length);
1781 }
1782
1783 ::mlir::TypedValue<::mlir::Type> getContainer() {
1784 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSOperands(index: 0).begin());
1785 }
1786
1787 ::mlir::OpOperand &getContainerMutable() {
1788 auto range = getODSOperandIndexAndLength(index: 0);
1789 return getOperation()->getOpOperand(idx: range.first);
1790 }
1791
1792 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
1793 return {index, 1};
1794 }
1795
1796 ::mlir::Operation::result_range getODSResults(unsigned index) {
1797 auto valueRange = getODSResultIndexAndLength(index);
1798 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
1799 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
1800 }
1801
1802 ::mlir::TypedValue<::mlir::Type> getRes() {
1803 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSResults(index: 0).begin());
1804 }
1805
1806 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
1807 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
1808 static llvm::hash_code computePropertiesHash(const Properties &prop);
1809 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
1810 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
1811 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
1812 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
1813 static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state);
1814 void writeProperties(::mlir::DialectBytecodeWriter &writer);
1815 ::mlir::DenseI64ArrayAttr getPositionAttr() {
1816 return ::llvm::cast<::mlir::DenseI64ArrayAttr>(Val&: getProperties().position);
1817 }
1818
1819 ::llvm::ArrayRef<int64_t> getPosition();
1820 void setPositionAttr(::mlir::DenseI64ArrayAttr attr) {
1821 getProperties().position = attr;
1822 }
1823
1824 void setPosition(::llvm::ArrayRef<int64_t> attrValue);
1825 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value container, ArrayRef<int64_t> position);
1826 static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value container, ArrayRef<int64_t> position);
1827 static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, Value container, ArrayRef<int64_t> position);
1828 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value container, ::mlir::DenseI64ArrayAttr position);
1829 static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value container, ::mlir::DenseI64ArrayAttr position);
1830 static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value container, ::mlir::DenseI64ArrayAttr position);
1831 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::DenseI64ArrayAttr position);
1832 static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::DenseI64ArrayAttr position);
1833 static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::DenseI64ArrayAttr position);
1834 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value container, ::llvm::ArrayRef<int64_t> position);
1835 static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value container, ::llvm::ArrayRef<int64_t> position);
1836 static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value container, ::llvm::ArrayRef<int64_t> position);
1837 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::llvm::ArrayRef<int64_t> position);
1838 static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::llvm::ArrayRef<int64_t> position);
1839 static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::llvm::ArrayRef<int64_t> position);
1840 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
1841 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
1842 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
1843 static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
1844 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
1845 static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
1846 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
1847 static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
1848 static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
1849 ::llvm::LogicalResult verifyInvariantsImpl();
1850 ::llvm::LogicalResult verifyInvariants();
1851 ::llvm::LogicalResult verify();
1852 ::mlir::OpFoldResult fold(FoldAdaptor adaptor);
1853 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
1854 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
1855 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
1856private:
1857 ::mlir::StringAttr getAttributeNameForIndex(unsigned index) {
1858 return getAttributeNameForIndex(name: (*this)->getName(), index);
1859 }
1860
1861 static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) {
1862 assert(index < 1 && "invalid attribute index");
1863 assert(name.getStringRef() == getOperationName() && "invalid operation name");
1864 assert(name.isRegistered() && "Operation isn't registered, missing a "
1865 "dependent dialect loading?");
1866 return name.getAttributeNames()[index];
1867 }
1868
1869 static void buildPropertiesAndDiscardableAttributes(::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes);
1870public:
1871};
1872
1873} // namespace mlir::LLVM
1874MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ExtractValueOp)
1875MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::ExtractValueOpGenericAdaptorBase::Properties)
1876
1877namespace mlir::LLVM {
1878
1879
1880//===----------------------------------------------------------------------===//
1881// ::mlir::LLVM::InsertValueOp declarations
1882//===----------------------------------------------------------------------===//
1883
1884namespace detail {
1885
1886class InsertValueOpGenericAdaptorBase {
1887public:
1888 struct Properties {
1889 using positionTy = ::mlir::DenseI64ArrayAttr;
1890 positionTy position;
1891
1892 auto getPosition() const {
1893 auto &propStorage = this->position;
1894 return ::llvm::cast<::mlir::DenseI64ArrayAttr>(Val: propStorage);
1895 }
1896 void setPosition(const ::mlir::DenseI64ArrayAttr &propValue) {
1897 this->position = propValue;
1898 }
1899 bool operator==(const Properties &rhs) const {
1900 return
1901 rhs.position == this->position &&
1902 true;
1903 }
1904 bool operator!=(const Properties &rhs) const {
1905 return !(*this == rhs);
1906 }
1907 };
1908protected:
1909 ::mlir::DictionaryAttr odsAttrs;
1910 ::std::optional<::mlir::OperationName> odsOpName;
1911 Properties properties;
1912 ::mlir::RegionRange odsRegions;
1913public:
1914 InsertValueOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
1915 odsOpName.emplace(args: "llvm.insertvalue", args: odsAttrs.getContext());
1916 }
1917
1918 InsertValueOpGenericAdaptorBase(InsertValueOp op);
1919
1920 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
1921 return {index, 1};
1922 }
1923
1924 const Properties &getProperties() {
1925 return properties;
1926 }
1927
1928 ::mlir::DictionaryAttr getAttributes() {
1929 return odsAttrs;
1930 }
1931
1932 ::mlir::DenseI64ArrayAttr getPositionAttr() {
1933 auto attr = ::llvm::cast<::mlir::DenseI64ArrayAttr>(Val: getProperties().position);
1934 return attr;
1935 }
1936
1937 ::llvm::ArrayRef<int64_t> getPosition();
1938};
1939
1940} // namespace detail
1941template <typename RangeT>
1942class InsertValueOpGenericAdaptor : public detail::InsertValueOpGenericAdaptorBase {
1943 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
1944 using Base = detail::InsertValueOpGenericAdaptorBase;
1945 static constexpr int odsIndex_container = 0;
1946 static constexpr int odsIndex_value = 1;
1947public:
1948 InsertValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
1949
1950 InsertValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : InsertValueOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
1951
1952 InsertValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : InsertValueOpGenericAdaptor(values, attrs, Properties{}, {}) {}
1953
1954 InsertValueOpGenericAdaptor(RangeT values, const InsertValueOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
1955
1956 template <typename LateInst = InsertValueOp, typename = std::enable_if_t<std::is_same_v<LateInst, InsertValueOp>>>
1957 InsertValueOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
1958
1959 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
1960 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
1961 }
1962
1963 RangeT getODSOperands(unsigned index) {
1964 auto valueRange = getODSOperandIndexAndLength(index);
1965 return {std::next(odsOperands.begin(), valueRange.first),
1966 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
1967 }
1968
1969 ValueT getContainer() {
1970 return (*getODSOperands(index: 0).begin());
1971 }
1972
1973 ValueT getValue() {
1974 return (*getODSOperands(index: 1).begin());
1975 }
1976
1977 RangeT getOperands() {
1978 return odsOperands;
1979 }
1980
1981private:
1982 RangeT odsOperands;
1983};
1984class InsertValueOpAdaptor : public InsertValueOpGenericAdaptor<::mlir::ValueRange> {
1985public:
1986 using InsertValueOpGenericAdaptor::InsertValueOpGenericAdaptor;
1987 InsertValueOpAdaptor(InsertValueOp op);
1988
1989 ::llvm::LogicalResult verify(::mlir::Location loc);
1990};
1991class InsertValueOp : public ::mlir::Op<InsertValueOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> {
1992public:
1993 using Op::Op;
1994 using Op::print;
1995 using Adaptor = InsertValueOpAdaptor;
1996 template <typename RangeT>
1997 using GenericAdaptor = InsertValueOpGenericAdaptor<RangeT>;
1998 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
1999 static constexpr int odsIndex_container = 0;
2000 static constexpr int odsIndex_value = 1;
2001 static constexpr int odsIndex_res = 0;
2002 using Properties = FoldAdaptor::Properties;
2003 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
2004 static ::llvm::StringRef attrNames[] = {::llvm::StringRef("position")};
2005 return ::llvm::ArrayRef(attrNames);
2006 }
2007
2008 ::mlir::StringAttr getPositionAttrName() {
2009 return getAttributeNameForIndex(index: 0);
2010 }
2011
2012 static ::mlir::StringAttr getPositionAttrName(::mlir::OperationName name) {
2013 return getAttributeNameForIndex(name, index: 0);
2014 }
2015
2016 static constexpr ::llvm::StringLiteral getOperationName() {
2017 return ::llvm::StringLiteral("llvm.insertvalue");
2018 }
2019
2020 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
2021 return {index, 1};
2022 }
2023
2024 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
2025 auto [start, length] = getODSOperandIndexAndLength(index);
2026 return getOperation()->getOperands().slice(n: start, m: length);
2027 }
2028
2029 ::mlir::TypedValue<::mlir::Type> getContainer() {
2030 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSOperands(index: 0).begin());
2031 }
2032
2033 ::mlir::TypedValue<::mlir::Type> getValue() {
2034 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSOperands(index: 1).begin());
2035 }
2036
2037 ::mlir::OpOperand &getContainerMutable() {
2038 auto range = getODSOperandIndexAndLength(index: 0);
2039 return getOperation()->getOpOperand(idx: range.first);
2040 }
2041
2042 ::mlir::OpOperand &getValueMutable() {
2043 auto range = getODSOperandIndexAndLength(index: 1);
2044 return getOperation()->getOpOperand(idx: range.first);
2045 }
2046
2047 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
2048 return {index, 1};
2049 }
2050
2051 ::mlir::Operation::result_range getODSResults(unsigned index) {
2052 auto valueRange = getODSResultIndexAndLength(index);
2053 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
2054 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
2055 }
2056
2057 ::mlir::TypedValue<::mlir::Type> getRes() {
2058 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSResults(index: 0).begin());
2059 }
2060
2061 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
2062 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
2063 static llvm::hash_code computePropertiesHash(const Properties &prop);
2064 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
2065 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
2066 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
2067 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
2068 static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state);
2069 void writeProperties(::mlir::DialectBytecodeWriter &writer);
2070 ::mlir::DenseI64ArrayAttr getPositionAttr() {
2071 return ::llvm::cast<::mlir::DenseI64ArrayAttr>(Val&: getProperties().position);
2072 }
2073
2074 ::llvm::ArrayRef<int64_t> getPosition();
2075 void setPositionAttr(::mlir::DenseI64ArrayAttr attr) {
2076 getProperties().position = attr;
2077 }
2078
2079 void setPosition(::llvm::ArrayRef<int64_t> attrValue);
2080 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position);
2081 static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position);
2082 static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position);
2083 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position);
2084 static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position);
2085 static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position);
2086 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position);
2087 static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position);
2088 static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position);
2089 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef<int64_t> position);
2090 static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef<int64_t> position);
2091 static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef<int64_t> position);
2092 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef<int64_t> position);
2093 static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef<int64_t> position);
2094 static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef<int64_t> position);
2095 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef<int64_t> position);
2096 static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef<int64_t> position);
2097 static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef<int64_t> position);
2098 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
2099 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2100 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
2101 static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2102 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
2103 static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2104 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
2105 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2106 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
2107 static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2108 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
2109 static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2110 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2111 static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2112 static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2113 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2114 static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2115 static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2116 ::llvm::LogicalResult verifyInvariantsImpl();
2117 ::llvm::LogicalResult verifyInvariants();
2118 ::llvm::LogicalResult verify();
2119 static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
2120 static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
2121 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
2122 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
2123 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
2124private:
2125 ::mlir::StringAttr getAttributeNameForIndex(unsigned index) {
2126 return getAttributeNameForIndex(name: (*this)->getName(), index);
2127 }
2128
2129 static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) {
2130 assert(index < 1 && "invalid attribute index");
2131 assert(name.getStringRef() == getOperationName() && "invalid operation name");
2132 assert(name.isRegistered() && "Operation isn't registered, missing a "
2133 "dependent dialect loading?");
2134 return name.getAttributeNames()[index];
2135 }
2136
2137 static void buildPropertiesAndDiscardableAttributes(::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes);
2138public:
2139};
2140
2141} // namespace mlir::LLVM
2142MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::InsertValueOp)
2143MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::InsertValueOpGenericAdaptorBase::Properties)
2144
2145
2146#endif // GET_OP_CLASSES
2147
2148namespace mlir::LLVM {
2149
2150void registerLLVMDialectOperations(::mlir::LLVM::LLVMDialect *dialect);
2151void registerLLVMDialectOperationsAggregate(::mlir::LLVM::LLVMDialect *dialect);
2152void registerLLVMDialectOperationsArith(::mlir::LLVM::LLVMDialect *dialect);
2153void registerLLVMDialectOperationsCall(::mlir::LLVM::LLVMDialect *dialect);
2154void registerLLVMDialectOperationsCodeGenIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
2155void registerLLVMDialectOperationsConstant(::mlir::LLVM::LLVMDialect *dialect);
2156void registerLLVMDialectOperationsConstrainedIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
2157void registerLLVMDialectOperationsConversion(::mlir::LLVM::LLVMDialect *dialect);
2158void registerLLVMDialectOperationsCoroIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
2159void registerLLVMDialectOperationsDebugIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
2160void registerLLVMDialectOperationsFloatIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
2161void registerLLVMDialectOperationsGeneralIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
2162void registerLLVMDialectOperationsIntegerIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
2163void registerLLVMDialectOperationsMemory(::mlir::LLVM::LLVMDialect *dialect);
2164void registerLLVMDialectOperationsMemoryIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
2165void registerLLVMDialectOperationsModule(::mlir::LLVM::LLVMDialect *dialect);
2166void registerLLVMDialectOperationsTerminator(::mlir::LLVM::LLVMDialect *dialect);
2167void registerLLVMDialectOperationsVPIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
2168void registerLLVMDialectOperationsVarArg(::mlir::LLVM::LLVMDialect *dialect);
2169void registerLLVMDialectOperationsVector(::mlir::LLVM::LLVMDialect *dialect);
2170void registerLLVMDialectOperationsVectorIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
2171
2172} // namespace mlir::LLVM
2173