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 AtomicCmpXchgOp;
73
74} // namespace mlir::LLVM
75namespace mlir::LLVM {
76
77class AtomicRMWOp;
78
79} // namespace mlir::LLVM
80namespace mlir::LLVM {
81
82class BitReverseOp;
83
84} // namespace mlir::LLVM
85namespace mlir::LLVM {
86
87class BitcastOp;
88
89} // namespace mlir::LLVM
90namespace mlir::LLVM {
91
92class BlockAddressOp;
93
94} // namespace mlir::LLVM
95namespace mlir::LLVM {
96
97class BlockTagOp;
98
99} // namespace mlir::LLVM
100namespace mlir::LLVM {
101
102class BrOp;
103
104} // namespace mlir::LLVM
105namespace mlir::LLVM {
106
107class ByteSwapOp;
108
109} // namespace mlir::LLVM
110namespace mlir::LLVM {
111
112class CallIntrinsicOp;
113
114} // namespace mlir::LLVM
115namespace mlir::LLVM {
116
117class CallOp;
118
119} // namespace mlir::LLVM
120namespace mlir::LLVM {
121
122class ClmulOp;
123
124} // namespace mlir::LLVM
125namespace mlir::LLVM {
126
127class ComdatOp;
128
129} // namespace mlir::LLVM
130namespace mlir::LLVM {
131
132class ComdatSelectorOp;
133
134} // namespace mlir::LLVM
135namespace mlir::LLVM {
136
137class CondBrOp;
138
139} // namespace mlir::LLVM
140namespace mlir::LLVM {
141
142class ConstantOp;
143
144} // namespace mlir::LLVM
145namespace mlir::LLVM {
146
147class ConstrainedACosIntr;
148
149} // namespace mlir::LLVM
150namespace mlir::LLVM {
151
152class ConstrainedASinIntr;
153
154} // namespace mlir::LLVM
155namespace mlir::LLVM {
156
157class ConstrainedATan2Intr;
158
159} // namespace mlir::LLVM
160namespace mlir::LLVM {
161
162class ConstrainedATanIntr;
163
164} // namespace mlir::LLVM
165namespace mlir::LLVM {
166
167class ConstrainedCeilIntr;
168
169} // namespace mlir::LLVM
170namespace mlir::LLVM {
171
172class ConstrainedCosIntr;
173
174} // namespace mlir::LLVM
175namespace mlir::LLVM {
176
177class ConstrainedCoshIntr;
178
179} // namespace mlir::LLVM
180namespace mlir::LLVM {
181
182class ConstrainedExp2Intr;
183
184} // namespace mlir::LLVM
185namespace mlir::LLVM {
186
187class ConstrainedExpIntr;
188
189} // namespace mlir::LLVM
190namespace mlir::LLVM {
191
192class ConstrainedFAddIntr;
193
194} // namespace mlir::LLVM
195namespace mlir::LLVM {
196
197class ConstrainedFCmpIntr;
198
199} // namespace mlir::LLVM
200namespace mlir::LLVM {
201
202class ConstrainedFCmpSIntr;
203
204} // namespace mlir::LLVM
205namespace mlir::LLVM {
206
207class ConstrainedFDivIntr;
208
209} // namespace mlir::LLVM
210namespace mlir::LLVM {
211
212class ConstrainedFMAIntr;
213
214} // namespace mlir::LLVM
215namespace mlir::LLVM {
216
217class ConstrainedFMulAddIntr;
218
219} // namespace mlir::LLVM
220namespace mlir::LLVM {
221
222class ConstrainedFMulIntr;
223
224} // namespace mlir::LLVM
225namespace mlir::LLVM {
226
227class ConstrainedFPExtIntr;
228
229} // namespace mlir::LLVM
230namespace mlir::LLVM {
231
232class ConstrainedFPToSIIntr;
233
234} // namespace mlir::LLVM
235namespace mlir::LLVM {
236
237class ConstrainedFPToUIIntr;
238
239} // namespace mlir::LLVM
240namespace mlir::LLVM {
241
242class ConstrainedFPTruncIntr;
243
244} // namespace mlir::LLVM
245namespace mlir::LLVM {
246
247class ConstrainedFRemIntr;
248
249} // namespace mlir::LLVM
250namespace mlir::LLVM {
251
252class ConstrainedFSubIntr;
253
254} // namespace mlir::LLVM
255namespace mlir::LLVM {
256
257class ConstrainedFloorIntr;
258
259} // namespace mlir::LLVM
260namespace mlir::LLVM {
261
262class ConstrainedLLRintIntr;
263
264} // namespace mlir::LLVM
265namespace mlir::LLVM {
266
267class ConstrainedLLRoundIntr;
268
269} // namespace mlir::LLVM
270namespace mlir::LLVM {
271
272class ConstrainedLRintIntr;
273
274} // namespace mlir::LLVM
275namespace mlir::LLVM {
276
277class ConstrainedLRoundIntr;
278
279} // namespace mlir::LLVM
280namespace mlir::LLVM {
281
282class ConstrainedLdexpIntr;
283
284} // namespace mlir::LLVM
285namespace mlir::LLVM {
286
287class ConstrainedLog10Intr;
288
289} // namespace mlir::LLVM
290namespace mlir::LLVM {
291
292class ConstrainedLog2Intr;
293
294} // namespace mlir::LLVM
295namespace mlir::LLVM {
296
297class ConstrainedLogIntr;
298
299} // namespace mlir::LLVM
300namespace mlir::LLVM {
301
302class ConstrainedMaxNumIntr;
303
304} // namespace mlir::LLVM
305namespace mlir::LLVM {
306
307class ConstrainedMaximumIntr;
308
309} // namespace mlir::LLVM
310namespace mlir::LLVM {
311
312class ConstrainedMinNumIntr;
313
314} // namespace mlir::LLVM
315namespace mlir::LLVM {
316
317class ConstrainedMinimumIntr;
318
319} // namespace mlir::LLVM
320namespace mlir::LLVM {
321
322class ConstrainedNearbyIntIntr;
323
324} // namespace mlir::LLVM
325namespace mlir::LLVM {
326
327class ConstrainedPowIIntr;
328
329} // namespace mlir::LLVM
330namespace mlir::LLVM {
331
332class ConstrainedPowIntr;
333
334} // namespace mlir::LLVM
335namespace mlir::LLVM {
336
337class ConstrainedRIntIntr;
338
339} // namespace mlir::LLVM
340namespace mlir::LLVM {
341
342class ConstrainedRoundEvenIntr;
343
344} // namespace mlir::LLVM
345namespace mlir::LLVM {
346
347class ConstrainedRoundIntr;
348
349} // namespace mlir::LLVM
350namespace mlir::LLVM {
351
352class ConstrainedSIToFP;
353
354} // namespace mlir::LLVM
355namespace mlir::LLVM {
356
357class ConstrainedSinIntr;
358
359} // namespace mlir::LLVM
360namespace mlir::LLVM {
361
362class ConstrainedSinhIntr;
363
364} // namespace mlir::LLVM
365namespace mlir::LLVM {
366
367class ConstrainedSqrtIntr;
368
369} // namespace mlir::LLVM
370namespace mlir::LLVM {
371
372class ConstrainedTanIntr;
373
374} // namespace mlir::LLVM
375namespace mlir::LLVM {
376
377class ConstrainedTanhIntr;
378
379} // namespace mlir::LLVM
380namespace mlir::LLVM {
381
382class ConstrainedTruncIntr;
383
384} // namespace mlir::LLVM
385namespace mlir::LLVM {
386
387class ConstrainedUIToFP;
388
389} // namespace mlir::LLVM
390namespace mlir::LLVM {
391
392class CopySignOp;
393
394} // namespace mlir::LLVM
395namespace mlir::LLVM {
396
397class CoroAlignOp;
398
399} // namespace mlir::LLVM
400namespace mlir::LLVM {
401
402class CoroAllocOp;
403
404} // namespace mlir::LLVM
405namespace mlir::LLVM {
406
407class CoroAwaitSuspendBoolOp;
408
409} // namespace mlir::LLVM
410namespace mlir::LLVM {
411
412class CoroAwaitSuspendHandleOp;
413
414} // namespace mlir::LLVM
415namespace mlir::LLVM {
416
417class CoroAwaitSuspendVoidOp;
418
419} // namespace mlir::LLVM
420namespace mlir::LLVM {
421
422class CoroBeginOp;
423
424} // namespace mlir::LLVM
425namespace mlir::LLVM {
426
427class CoroDeadOp;
428
429} // namespace mlir::LLVM
430namespace mlir::LLVM {
431
432class CoroDestroyOp;
433
434} // namespace mlir::LLVM
435namespace mlir::LLVM {
436
437class CoroDoneOp;
438
439} // namespace mlir::LLVM
440namespace mlir::LLVM {
441
442class CoroEndOp;
443
444} // namespace mlir::LLVM
445namespace mlir::LLVM {
446
447class CoroFrameOp;
448
449} // namespace mlir::LLVM
450namespace mlir::LLVM {
451
452class CoroFreeOp;
453
454} // namespace mlir::LLVM
455namespace mlir::LLVM {
456
457class CoroIdOp;
458
459} // namespace mlir::LLVM
460namespace mlir::LLVM {
461
462class CoroIsInRampOp;
463
464} // namespace mlir::LLVM
465namespace mlir::LLVM {
466
467class CoroNoopOp;
468
469} // namespace mlir::LLVM
470namespace mlir::LLVM {
471
472class CoroPromiseOp;
473
474} // namespace mlir::LLVM
475namespace mlir::LLVM {
476
477class CoroResumeOp;
478
479} // namespace mlir::LLVM
480namespace mlir::LLVM {
481
482class CoroSaveOp;
483
484} // namespace mlir::LLVM
485namespace mlir::LLVM {
486
487class CoroSizeOp;
488
489} // namespace mlir::LLVM
490namespace mlir::LLVM {
491
492class CoroSuspendOp;
493
494} // namespace mlir::LLVM
495namespace mlir::LLVM {
496
497class CosOp;
498
499} // namespace mlir::LLVM
500namespace mlir::LLVM {
501
502class CoshOp;
503
504} // namespace mlir::LLVM
505namespace mlir::LLVM {
506
507class CountLeadingZerosOp;
508
509} // namespace mlir::LLVM
510namespace mlir::LLVM {
511
512class CountTrailingZerosOp;
513
514} // namespace mlir::LLVM
515namespace mlir::LLVM {
516
517class CtPopOp;
518
519} // namespace mlir::LLVM
520namespace mlir::LLVM {
521
522class DSOLocalEquivalentOp;
523
524} // namespace mlir::LLVM
525namespace mlir::LLVM {
526
527class DbgDeclareOp;
528
529} // namespace mlir::LLVM
530namespace mlir::LLVM {
531
532class DbgLabelOp;
533
534} // namespace mlir::LLVM
535namespace mlir::LLVM {
536
537class DbgValueOp;
538
539} // namespace mlir::LLVM
540namespace mlir::LLVM {
541
542class Exp10Op;
543
544} // namespace mlir::LLVM
545namespace mlir::LLVM {
546
547class Exp2Op;
548
549} // namespace mlir::LLVM
550namespace mlir::LLVM {
551
552class ExpOp;
553
554} // namespace mlir::LLVM
555namespace mlir::LLVM {
556
557class ExtractElementOp;
558
559} // namespace mlir::LLVM
560namespace mlir::LLVM {
561
562class ExtractValueOp;
563
564} // namespace mlir::LLVM
565namespace mlir::LLVM {
566
567class FAbsOp;
568
569} // namespace mlir::LLVM
570namespace mlir::LLVM {
571
572class FAddOp;
573
574} // namespace mlir::LLVM
575namespace mlir::LLVM {
576
577class FCeilOp;
578
579} // namespace mlir::LLVM
580namespace mlir::LLVM {
581
582class FCmpOp;
583
584} // namespace mlir::LLVM
585namespace mlir::LLVM {
586
587class FDivOp;
588
589} // namespace mlir::LLVM
590namespace mlir::LLVM {
591
592class FFloorOp;
593
594} // namespace mlir::LLVM
595namespace mlir::LLVM {
596
597class FMAOp;
598
599} // namespace mlir::LLVM
600namespace mlir::LLVM {
601
602class FMulAddOp;
603
604} // namespace mlir::LLVM
605namespace mlir::LLVM {
606
607class FMulOp;
608
609} // namespace mlir::LLVM
610namespace mlir::LLVM {
611
612class FNegOp;
613
614} // namespace mlir::LLVM
615namespace mlir::LLVM {
616
617class FPExtOp;
618
619} // namespace mlir::LLVM
620namespace mlir::LLVM {
621
622class FPToSIOp;
623
624} // namespace mlir::LLVM
625namespace mlir::LLVM {
626
627class FPToUIOp;
628
629} // namespace mlir::LLVM
630namespace mlir::LLVM {
631
632class FPTruncOp;
633
634} // namespace mlir::LLVM
635namespace mlir::LLVM {
636
637class FRemOp;
638
639} // namespace mlir::LLVM
640namespace mlir::LLVM {
641
642class FSubOp;
643
644} // namespace mlir::LLVM
645namespace mlir::LLVM {
646
647class FTruncOp;
648
649} // namespace mlir::LLVM
650namespace mlir::LLVM {
651
652class FenceOp;
653
654} // namespace mlir::LLVM
655namespace mlir::LLVM {
656
657class FractionExpOp;
658
659} // namespace mlir::LLVM
660namespace mlir::LLVM {
661
662class FreezeOp;
663
664} // namespace mlir::LLVM
665namespace mlir::LLVM {
666
667class FshlOp;
668
669} // namespace mlir::LLVM
670namespace mlir::LLVM {
671
672class FshrOp;
673
674} // namespace mlir::LLVM
675namespace mlir::LLVM {
676
677class GEPOp;
678
679} // namespace mlir::LLVM
680namespace mlir::LLVM {
681
682class GetActiveLaneMaskOp;
683
684} // namespace mlir::LLVM
685namespace mlir::LLVM {
686
687class GlobalCtorsOp;
688
689} // namespace mlir::LLVM
690namespace mlir::LLVM {
691
692class GlobalDtorsOp;
693
694} // namespace mlir::LLVM
695namespace mlir::LLVM {
696
697class GlobalOp;
698
699} // namespace mlir::LLVM
700namespace mlir::LLVM {
701
702class ICmpOp;
703
704} // namespace mlir::LLVM
705namespace mlir::LLVM {
706
707class IFuncOp;
708
709} // namespace mlir::LLVM
710namespace mlir::LLVM {
711
712class IndirectBrOp;
713
714} // namespace mlir::LLVM
715namespace mlir::LLVM {
716
717class InlineAsmOp;
718
719} // namespace mlir::LLVM
720namespace mlir::LLVM {
721
722class InsertElementOp;
723
724} // namespace mlir::LLVM
725namespace mlir::LLVM {
726
727class InsertValueOp;
728
729} // namespace mlir::LLVM
730namespace mlir::LLVM {
731
732class IntToPtrOp;
733
734} // namespace mlir::LLVM
735namespace mlir::LLVM {
736
737class InvariantEndOp;
738
739} // namespace mlir::LLVM
740namespace mlir::LLVM {
741
742class InvariantStartOp;
743
744} // namespace mlir::LLVM
745namespace mlir::LLVM {
746
747class InvokeOp;
748
749} // namespace mlir::LLVM
750namespace mlir::LLVM {
751
752class IsFPClass;
753
754} // namespace mlir::LLVM
755namespace mlir::LLVM {
756
757class LLVMFuncOp;
758
759} // namespace mlir::LLVM
760namespace mlir::LLVM {
761
762class LShrOp;
763
764} // namespace mlir::LLVM
765namespace mlir::LLVM {
766
767class LandingpadOp;
768
769} // namespace mlir::LLVM
770namespace mlir::LLVM {
771
772class LaunderInvariantGroupOp;
773
774} // namespace mlir::LLVM
775namespace mlir::LLVM {
776
777class LifetimeEndOp;
778
779} // namespace mlir::LLVM
780namespace mlir::LLVM {
781
782class LifetimeStartOp;
783
784} // namespace mlir::LLVM
785namespace mlir::LLVM {
786
787class LinkerOptionsOp;
788
789} // namespace mlir::LLVM
790namespace mlir::LLVM {
791
792class LlrintOp;
793
794} // namespace mlir::LLVM
795namespace mlir::LLVM {
796
797class LlroundOp;
798
799} // namespace mlir::LLVM
800namespace mlir::LLVM {
801
802class LoadExpOp;
803
804} // namespace mlir::LLVM
805namespace mlir::LLVM {
806
807class LoadOp;
808
809} // namespace mlir::LLVM
810namespace mlir::LLVM {
811
812class Log10Op;
813
814} // namespace mlir::LLVM
815namespace mlir::LLVM {
816
817class Log2Op;
818
819} // namespace mlir::LLVM
820namespace mlir::LLVM {
821
822class LogOp;
823
824} // namespace mlir::LLVM
825namespace mlir::LLVM {
826
827class LrintOp;
828
829} // namespace mlir::LLVM
830namespace mlir::LLVM {
831
832class LroundOp;
833
834} // namespace mlir::LLVM
835namespace mlir::LLVM {
836
837class MaskedLoadOp;
838
839} // namespace mlir::LLVM
840namespace mlir::LLVM {
841
842class MaskedStoreOp;
843
844} // namespace mlir::LLVM
845namespace mlir::LLVM {
846
847class MatrixColumnMajorLoadOp;
848
849} // namespace mlir::LLVM
850namespace mlir::LLVM {
851
852class MatrixColumnMajorStoreOp;
853
854} // namespace mlir::LLVM
855namespace mlir::LLVM {
856
857class MatrixMultiplyOp;
858
859} // namespace mlir::LLVM
860namespace mlir::LLVM {
861
862class MatrixTransposeOp;
863
864} // namespace mlir::LLVM
865namespace mlir::LLVM {
866
867class MaxNumOp;
868
869} // namespace mlir::LLVM
870namespace mlir::LLVM {
871
872class MaximumNumOp;
873
874} // namespace mlir::LLVM
875namespace mlir::LLVM {
876
877class MaximumOp;
878
879} // namespace mlir::LLVM
880namespace mlir::LLVM {
881
882class MemcpyInlineOp;
883
884} // namespace mlir::LLVM
885namespace mlir::LLVM {
886
887class MemcpyOp;
888
889} // namespace mlir::LLVM
890namespace mlir::LLVM {
891
892class MemmoveOp;
893
894} // namespace mlir::LLVM
895namespace mlir::LLVM {
896
897class MemsetInlineOp;
898
899} // namespace mlir::LLVM
900namespace mlir::LLVM {
901
902class MemsetOp;
903
904} // namespace mlir::LLVM
905namespace mlir::LLVM {
906
907class MetadataAsValueOp;
908
909} // namespace mlir::LLVM
910namespace mlir::LLVM {
911
912class MinNumOp;
913
914} // namespace mlir::LLVM
915namespace mlir::LLVM {
916
917class MinimumNumOp;
918
919} // namespace mlir::LLVM
920namespace mlir::LLVM {
921
922class MinimumOp;
923
924} // namespace mlir::LLVM
925namespace mlir::LLVM {
926
927class ModfOp;
928
929} // namespace mlir::LLVM
930namespace mlir::LLVM {
931
932class ModuleFlagsOp;
933
934} // namespace mlir::LLVM
935namespace mlir::LLVM {
936
937class MulOp;
938
939} // namespace mlir::LLVM
940namespace mlir::LLVM {
941
942class NamedMetadataOp;
943
944} // namespace mlir::LLVM
945namespace mlir::LLVM {
946
947class NearbyintOp;
948
949} // namespace mlir::LLVM
950namespace mlir::LLVM {
951
952class NoneTokenOp;
953
954} // namespace mlir::LLVM
955namespace mlir::LLVM {
956
957class OrOp;
958
959} // namespace mlir::LLVM
960namespace mlir::LLVM {
961
962class PdepOp;
963
964} // namespace mlir::LLVM
965namespace mlir::LLVM {
966
967class PextOp;
968
969} // namespace mlir::LLVM
970namespace mlir::LLVM {
971
972class PoisonOp;
973
974} // namespace mlir::LLVM
975namespace mlir::LLVM {
976
977class PowIOp;
978
979} // namespace mlir::LLVM
980namespace mlir::LLVM {
981
982class PowOp;
983
984} // namespace mlir::LLVM
985namespace mlir::LLVM {
986
987class Prefetch;
988
989} // namespace mlir::LLVM
990namespace mlir::LLVM {
991
992class PtrToAddrOp;
993
994} // namespace mlir::LLVM
995namespace mlir::LLVM {
996
997class PtrToIntOp;
998
999} // namespace mlir::LLVM
1000namespace mlir::LLVM {
1001
1002class ResumeOp;
1003
1004} // namespace mlir::LLVM
1005namespace mlir::LLVM {
1006
1007class ReturnOp;
1008
1009} // namespace mlir::LLVM
1010namespace mlir::LLVM {
1011
1012class RintOp;
1013
1014} // namespace mlir::LLVM
1015namespace mlir::LLVM {
1016
1017class RoundEvenOp;
1018
1019} // namespace mlir::LLVM
1020namespace mlir::LLVM {
1021
1022class RoundOp;
1023
1024} // namespace mlir::LLVM
1025namespace mlir::LLVM {
1026
1027class SAddSat;
1028
1029} // namespace mlir::LLVM
1030namespace mlir::LLVM {
1031
1032class SAddWithOverflowOp;
1033
1034} // namespace mlir::LLVM
1035namespace mlir::LLVM {
1036
1037class SCmpOp;
1038
1039} // namespace mlir::LLVM
1040namespace mlir::LLVM {
1041
1042class SDivOp;
1043
1044} // namespace mlir::LLVM
1045namespace mlir::LLVM {
1046
1047class SExtOp;
1048
1049} // namespace mlir::LLVM
1050namespace mlir::LLVM {
1051
1052class SIToFPOp;
1053
1054} // namespace mlir::LLVM
1055namespace mlir::LLVM {
1056
1057class SMaxOp;
1058
1059} // namespace mlir::LLVM
1060namespace mlir::LLVM {
1061
1062class SMinOp;
1063
1064} // namespace mlir::LLVM
1065namespace mlir::LLVM {
1066
1067class SMulHOp;
1068
1069} // namespace mlir::LLVM
1070namespace mlir::LLVM {
1071
1072class SMulWithOverflowOp;
1073
1074} // namespace mlir::LLVM
1075namespace mlir::LLVM {
1076
1077class SRemOp;
1078
1079} // namespace mlir::LLVM
1080namespace mlir::LLVM {
1081
1082class SSHLSat;
1083
1084} // namespace mlir::LLVM
1085namespace mlir::LLVM {
1086
1087class SSubSat;
1088
1089} // namespace mlir::LLVM
1090namespace mlir::LLVM {
1091
1092class SSubWithOverflowOp;
1093
1094} // namespace mlir::LLVM
1095namespace mlir::LLVM {
1096
1097class SelectOp;
1098
1099} // namespace mlir::LLVM
1100namespace mlir::LLVM {
1101
1102class ShlOp;
1103
1104} // namespace mlir::LLVM
1105namespace mlir::LLVM {
1106
1107class ShuffleVectorOp;
1108
1109} // namespace mlir::LLVM
1110namespace mlir::LLVM {
1111
1112class SinOp;
1113
1114} // namespace mlir::LLVM
1115namespace mlir::LLVM {
1116
1117class SincosOp;
1118
1119} // namespace mlir::LLVM
1120namespace mlir::LLVM {
1121
1122class SinhOp;
1123
1124} // namespace mlir::LLVM
1125namespace mlir::LLVM {
1126
1127class SqrtOp;
1128
1129} // namespace mlir::LLVM
1130namespace mlir::LLVM {
1131
1132class StackRestoreOp;
1133
1134} // namespace mlir::LLVM
1135namespace mlir::LLVM {
1136
1137class StackSaveOp;
1138
1139} // namespace mlir::LLVM
1140namespace mlir::LLVM {
1141
1142class StepVectorOp;
1143
1144} // namespace mlir::LLVM
1145namespace mlir::LLVM {
1146
1147class StoreOp;
1148
1149} // namespace mlir::LLVM
1150namespace mlir::LLVM {
1151
1152class SubOp;
1153
1154} // namespace mlir::LLVM
1155namespace mlir::LLVM {
1156
1157class SwitchOp;
1158
1159} // namespace mlir::LLVM
1160namespace mlir::LLVM {
1161
1162class TanOp;
1163
1164} // namespace mlir::LLVM
1165namespace mlir::LLVM {
1166
1167class TanhOp;
1168
1169} // namespace mlir::LLVM
1170namespace mlir::LLVM {
1171
1172class TruncOp;
1173
1174} // namespace mlir::LLVM
1175namespace mlir::LLVM {
1176
1177class UAddSat;
1178
1179} // namespace mlir::LLVM
1180namespace mlir::LLVM {
1181
1182class UAddWithOverflowOp;
1183
1184} // namespace mlir::LLVM
1185namespace mlir::LLVM {
1186
1187class UCmpOp;
1188
1189} // namespace mlir::LLVM
1190namespace mlir::LLVM {
1191
1192class UDivOp;
1193
1194} // namespace mlir::LLVM
1195namespace mlir::LLVM {
1196
1197class UIToFPOp;
1198
1199} // namespace mlir::LLVM
1200namespace mlir::LLVM {
1201
1202class UMaxOp;
1203
1204} // namespace mlir::LLVM
1205namespace mlir::LLVM {
1206
1207class UMinOp;
1208
1209} // namespace mlir::LLVM
1210namespace mlir::LLVM {
1211
1212class UMulHOp;
1213
1214} // namespace mlir::LLVM
1215namespace mlir::LLVM {
1216
1217class UMulWithOverflowOp;
1218
1219} // namespace mlir::LLVM
1220namespace mlir::LLVM {
1221
1222class URemOp;
1223
1224} // namespace mlir::LLVM
1225namespace mlir::LLVM {
1226
1227class USHLSat;
1228
1229} // namespace mlir::LLVM
1230namespace mlir::LLVM {
1231
1232class USubSat;
1233
1234} // namespace mlir::LLVM
1235namespace mlir::LLVM {
1236
1237class USubWithOverflowOp;
1238
1239} // namespace mlir::LLVM
1240namespace mlir::LLVM {
1241
1242class UndefOp;
1243
1244} // namespace mlir::LLVM
1245namespace mlir::LLVM {
1246
1247class UnreachableOp;
1248
1249} // namespace mlir::LLVM
1250namespace mlir::LLVM {
1251
1252class VPLoadOp;
1253
1254} // namespace mlir::LLVM
1255namespace mlir::LLVM {
1256
1257class VPMergeMinOp;
1258
1259} // namespace mlir::LLVM
1260namespace mlir::LLVM {
1261
1262class VPReduceAddOp;
1263
1264} // namespace mlir::LLVM
1265namespace mlir::LLVM {
1266
1267class VPReduceAndOp;
1268
1269} // namespace mlir::LLVM
1270namespace mlir::LLVM {
1271
1272class VPReduceFAddOp;
1273
1274} // namespace mlir::LLVM
1275namespace mlir::LLVM {
1276
1277class VPReduceFMaxOp;
1278
1279} // namespace mlir::LLVM
1280namespace mlir::LLVM {
1281
1282class VPReduceFMaximumOp;
1283
1284} // namespace mlir::LLVM
1285namespace mlir::LLVM {
1286
1287class VPReduceFMinOp;
1288
1289} // namespace mlir::LLVM
1290namespace mlir::LLVM {
1291
1292class VPReduceFMinimumOp;
1293
1294} // namespace mlir::LLVM
1295namespace mlir::LLVM {
1296
1297class VPReduceFMulOp;
1298
1299} // namespace mlir::LLVM
1300namespace mlir::LLVM {
1301
1302class VPReduceMulOp;
1303
1304} // namespace mlir::LLVM
1305namespace mlir::LLVM {
1306
1307class VPReduceOrOp;
1308
1309} // namespace mlir::LLVM
1310namespace mlir::LLVM {
1311
1312class VPReduceSMaxOp;
1313
1314} // namespace mlir::LLVM
1315namespace mlir::LLVM {
1316
1317class VPReduceSMinOp;
1318
1319} // namespace mlir::LLVM
1320namespace mlir::LLVM {
1321
1322class VPReduceUMaxOp;
1323
1324} // namespace mlir::LLVM
1325namespace mlir::LLVM {
1326
1327class VPReduceUMinOp;
1328
1329} // namespace mlir::LLVM
1330namespace mlir::LLVM {
1331
1332class VPReduceXorOp;
1333
1334} // namespace mlir::LLVM
1335namespace mlir::LLVM {
1336
1337class VPSDivOp;
1338
1339} // namespace mlir::LLVM
1340namespace mlir::LLVM {
1341
1342class VPSRemOp;
1343
1344} // namespace mlir::LLVM
1345namespace mlir::LLVM {
1346
1347class VPStoreOp;
1348
1349} // namespace mlir::LLVM
1350namespace mlir::LLVM {
1351
1352class VPStridedLoadOp;
1353
1354} // namespace mlir::LLVM
1355namespace mlir::LLVM {
1356
1357class VPStridedStoreOp;
1358
1359} // namespace mlir::LLVM
1360namespace mlir::LLVM {
1361
1362class VPUDivOp;
1363
1364} // namespace mlir::LLVM
1365namespace mlir::LLVM {
1366
1367class VPURemOp;
1368
1369} // namespace mlir::LLVM
1370namespace mlir::LLVM {
1371
1372class VaArgOp;
1373
1374} // namespace mlir::LLVM
1375namespace mlir::LLVM {
1376
1377class VaCopyOp;
1378
1379} // namespace mlir::LLVM
1380namespace mlir::LLVM {
1381
1382class VaEndOp;
1383
1384} // namespace mlir::LLVM
1385namespace mlir::LLVM {
1386
1387class VaStartOp;
1388
1389} // namespace mlir::LLVM
1390namespace mlir::LLVM {
1391
1392class XOrOp;
1393
1394} // namespace mlir::LLVM
1395namespace mlir::LLVM {
1396
1397class ZExtOp;
1398
1399} // namespace mlir::LLVM
1400namespace mlir::LLVM {
1401
1402class ZeroOp;
1403
1404} // namespace mlir::LLVM
1405namespace mlir::LLVM {
1406
1407class masked_compressstore;
1408
1409} // namespace mlir::LLVM
1410namespace mlir::LLVM {
1411
1412class masked_expandload;
1413
1414} // namespace mlir::LLVM
1415namespace mlir::LLVM {
1416
1417class masked_gather;
1418
1419} // namespace mlir::LLVM
1420namespace mlir::LLVM {
1421
1422class masked_scatter;
1423
1424} // namespace mlir::LLVM
1425namespace mlir::LLVM {
1426
1427class vector_deinterleave2;
1428
1429} // namespace mlir::LLVM
1430namespace mlir::LLVM {
1431
1432class vector_extract;
1433
1434} // namespace mlir::LLVM
1435namespace mlir::LLVM {
1436
1437class vector_insert;
1438
1439} // namespace mlir::LLVM
1440namespace mlir::LLVM {
1441
1442class vector_interleave2;
1443
1444} // namespace mlir::LLVM
1445namespace mlir::LLVM {
1446
1447class vector_reduce_add;
1448
1449} // namespace mlir::LLVM
1450namespace mlir::LLVM {
1451
1452class vector_reduce_and;
1453
1454} // namespace mlir::LLVM
1455namespace mlir::LLVM {
1456
1457class vector_reduce_fadd;
1458
1459} // namespace mlir::LLVM
1460namespace mlir::LLVM {
1461
1462class vector_reduce_fmax;
1463
1464} // namespace mlir::LLVM
1465namespace mlir::LLVM {
1466
1467class vector_reduce_fmaximum;
1468
1469} // namespace mlir::LLVM
1470namespace mlir::LLVM {
1471
1472class vector_reduce_fmaximumnum;
1473
1474} // namespace mlir::LLVM
1475namespace mlir::LLVM {
1476
1477class vector_reduce_fmin;
1478
1479} // namespace mlir::LLVM
1480namespace mlir::LLVM {
1481
1482class vector_reduce_fminimum;
1483
1484} // namespace mlir::LLVM
1485namespace mlir::LLVM {
1486
1487class vector_reduce_fminimumnum;
1488
1489} // namespace mlir::LLVM
1490namespace mlir::LLVM {
1491
1492class vector_reduce_fmul;
1493
1494} // namespace mlir::LLVM
1495namespace mlir::LLVM {
1496
1497class vector_reduce_mul;
1498
1499} // namespace mlir::LLVM
1500namespace mlir::LLVM {
1501
1502class vector_reduce_or;
1503
1504} // namespace mlir::LLVM
1505namespace mlir::LLVM {
1506
1507class vector_reduce_smax;
1508
1509} // namespace mlir::LLVM
1510namespace mlir::LLVM {
1511
1512class vector_reduce_smin;
1513
1514} // namespace mlir::LLVM
1515namespace mlir::LLVM {
1516
1517class vector_reduce_umax;
1518
1519} // namespace mlir::LLVM
1520namespace mlir::LLVM {
1521
1522class vector_reduce_umin;
1523
1524} // namespace mlir::LLVM
1525namespace mlir::LLVM {
1526
1527class vector_reduce_xor;
1528
1529} // namespace mlir::LLVM
1530namespace mlir::LLVM {
1531
1532class vector_repeat;
1533
1534} // namespace mlir::LLVM
1535namespace mlir::LLVM {
1536
1537class Annotation;
1538
1539} // namespace mlir::LLVM
1540namespace mlir::LLVM {
1541
1542class ArithmeticFenceOp;
1543
1544} // namespace mlir::LLVM
1545namespace mlir::LLVM {
1546
1547class AssumeOp;
1548
1549} // namespace mlir::LLVM
1550namespace mlir::LLVM {
1551
1552class DebugTrap;
1553
1554} // namespace mlir::LLVM
1555namespace mlir::LLVM {
1556
1557class EhTypeidForOp;
1558
1559} // namespace mlir::LLVM
1560namespace mlir::LLVM {
1561
1562class ExpectOp;
1563
1564} // namespace mlir::LLVM
1565namespace mlir::LLVM {
1566
1567class ExpectWithProbabilityOp;
1568
1569} // namespace mlir::LLVM
1570namespace mlir::LLVM {
1571
1572class FakeUseOp;
1573
1574} // namespace mlir::LLVM
1575namespace mlir::LLVM {
1576
1577class IsConstantOp;
1578
1579} // namespace mlir::LLVM
1580namespace mlir::LLVM {
1581
1582class NoAliasScopeDeclOp;
1583
1584} // namespace mlir::LLVM
1585namespace mlir::LLVM {
1586
1587class PtrAnnotation;
1588
1589} // namespace mlir::LLVM
1590namespace mlir::LLVM {
1591
1592class PtrMaskOp;
1593
1594} // namespace mlir::LLVM
1595namespace mlir::LLVM {
1596
1597class SSACopyOp;
1598
1599} // namespace mlir::LLVM
1600namespace mlir::LLVM {
1601
1602class ThreadlocalAddressOp;
1603
1604} // namespace mlir::LLVM
1605namespace mlir::LLVM {
1606
1607class Trap;
1608
1609} // namespace mlir::LLVM
1610namespace mlir::LLVM {
1611
1612class UBSanTrap;
1613
1614} // namespace mlir::LLVM
1615namespace mlir::LLVM {
1616
1617class VarAnnotation;
1618
1619} // namespace mlir::LLVM
1620namespace mlir::LLVM {
1621
1622class vscale;
1623
1624} // namespace mlir::LLVM
1625#ifdef GET_OP_CLASSES
1626#undef GET_OP_CLASSES
1627
1628#include "mlir/Bytecode/BytecodeOpInterface.h"
1629#include "mlir/Dialect/LLVMIR/LLVMAttrs.h"
1630#include "mlir/IR/BuiltinAttributes.h"
1631#include "mlir/IR/BuiltinTypes.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::Annotation declarations
1642//===----------------------------------------------------------------------===//
1643
1644namespace detail {
1645
1646class AnnotationGenericAdaptorBase {
1647public:
1648 using Properties = ::mlir::EmptyProperties;
1649protected:
1650 ::mlir::DictionaryAttr odsAttrs;
1651 ::std::optional<::mlir::OperationName> odsOpName;
1652 Properties properties;
1653 ::mlir::RegionRange odsRegions;
1654public:
1655 AnnotationGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
1656 odsOpName.emplace(args: "llvm.intr.annotation", args: odsAttrs.getContext());
1657 }
1658
1659 AnnotationGenericAdaptorBase(Annotation op);
1660
1661 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
1662 return {index, 1};
1663 }
1664
1665 const Properties &getProperties() {
1666 return properties;
1667 }
1668
1669 ::mlir::DictionaryAttr getAttributes() {
1670 return odsAttrs;
1671 }
1672
1673};
1674
1675} // namespace detail
1676template <typename RangeT>
1677class AnnotationGenericAdaptor : public detail::AnnotationGenericAdaptorBase {
1678 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
1679 using Base = detail::AnnotationGenericAdaptorBase;
1680 static constexpr int odsIndex_integer = 0;
1681 static constexpr int odsIndex_annotation = 1;
1682 static constexpr int odsIndex_fileName = 2;
1683 static constexpr int odsIndex_line = 3;
1684public:
1685 AnnotationGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
1686
1687 AnnotationGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : AnnotationGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
1688
1689 AnnotationGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : AnnotationGenericAdaptor(values, attrs, Properties{}, {}) {}
1690
1691 AnnotationGenericAdaptor(RangeT values, const AnnotationGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
1692
1693 template <typename LateInst = Annotation, typename = std::enable_if_t<std::is_same_v<LateInst, Annotation>>>
1694 AnnotationGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
1695
1696 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
1697 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
1698 }
1699
1700 RangeT getODSOperands(unsigned index) {
1701 auto valueRange = getODSOperandIndexAndLength(index);
1702 return {std::next(odsOperands.begin(), valueRange.first),
1703 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
1704 }
1705
1706 ValueT getInteger() {
1707 return (*getODSOperands(index: 0).begin());
1708 }
1709
1710 ValueT getAnnotation() {
1711 return (*getODSOperands(index: 1).begin());
1712 }
1713
1714 ValueT getFileName() {
1715 return (*getODSOperands(index: 2).begin());
1716 }
1717
1718 ValueT getLine() {
1719 return (*getODSOperands(index: 3).begin());
1720 }
1721
1722 RangeT getOperands() {
1723 return odsOperands;
1724 }
1725
1726private:
1727 RangeT odsOperands;
1728};
1729class AnnotationAdaptor : public AnnotationGenericAdaptor<::mlir::ValueRange> {
1730public:
1731 using AnnotationGenericAdaptor::AnnotationGenericAdaptor;
1732 AnnotationAdaptor(Annotation op);
1733
1734 ::llvm::LogicalResult verify(::mlir::Location loc);
1735};
1736class Annotation : public ::mlir::Op<Annotation, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> {
1737public:
1738 using Op::Op;
1739 using Op::print;
1740 using Adaptor = AnnotationAdaptor;
1741 template <typename RangeT>
1742 using GenericAdaptor = AnnotationGenericAdaptor<RangeT>;
1743 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
1744 static constexpr int odsIndex_integer = 0;
1745 static constexpr int odsIndex_annotation = 1;
1746 static constexpr int odsIndex_fileName = 2;
1747 static constexpr int odsIndex_line = 3;
1748 static constexpr int odsIndex_res = 0;
1749 using Properties = FoldAdaptor::Properties;
1750 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
1751 return {};
1752 }
1753
1754 static constexpr ::llvm::StringLiteral getOperationName() {
1755 return ::llvm::StringLiteral("llvm.intr.annotation");
1756 }
1757
1758 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
1759 return {index, 1};
1760 }
1761
1762 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
1763 auto [start, length] = getODSOperandIndexAndLength(index);
1764 return getOperation()->getOperands().slice(n: start, m: length);
1765 }
1766
1767 ::mlir::TypedValue<::mlir::IntegerType> getInteger() {
1768 return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(Val: *getODSOperands(index: 0).begin());
1769 }
1770
1771 ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getAnnotation() {
1772 return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(Val: *getODSOperands(index: 1).begin());
1773 }
1774
1775 ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getFileName() {
1776 return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(Val: *getODSOperands(index: 2).begin());
1777 }
1778
1779 ::mlir::TypedValue<::mlir::IntegerType> getLine() {
1780 return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(Val: *getODSOperands(index: 3).begin());
1781 }
1782
1783 ::mlir::OpOperand &getIntegerMutable() {
1784 auto range = getODSOperandIndexAndLength(index: 0);
1785 return getOperation()->getOpOperand(idx: range.first);
1786 }
1787
1788 ::mlir::OpOperand &getAnnotationMutable() {
1789 auto range = getODSOperandIndexAndLength(index: 1);
1790 return getOperation()->getOpOperand(idx: range.first);
1791 }
1792
1793 ::mlir::OpOperand &getFileNameMutable() {
1794 auto range = getODSOperandIndexAndLength(index: 2);
1795 return getOperation()->getOpOperand(idx: range.first);
1796 }
1797
1798 ::mlir::OpOperand &getLineMutable() {
1799 auto range = getODSOperandIndexAndLength(index: 3);
1800 return getOperation()->getOpOperand(idx: range.first);
1801 }
1802
1803 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
1804 return {index, 1};
1805 }
1806
1807 ::mlir::Operation::result_range getODSResults(unsigned index) {
1808 auto valueRange = getODSResultIndexAndLength(index);
1809 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
1810 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
1811 }
1812
1813 ::mlir::TypedValue<::mlir::IntegerType> getRes() {
1814 return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(Val: *getODSResults(index: 0).begin());
1815 }
1816
1817 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
1818 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
1819 static llvm::hash_code computePropertiesHash(const Properties &prop);
1820 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
1821 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
1822 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
1823 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
1824 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value integer, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line);
1825 static Annotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value integer, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line);
1826 static Annotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value integer, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line);
1827 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value integer, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line);
1828 static Annotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value integer, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line);
1829 static Annotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value integer, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line);
1830 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value integer, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line);
1831 static Annotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value integer, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line);
1832 static Annotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value integer, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line);
1833 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
1834 static Annotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
1835 static Annotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
1836 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
1837 static Annotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
1838 static Annotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
1839 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
1840 static Annotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
1841 static Annotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
1842 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
1843 static Annotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
1844 static Annotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
1845 ::llvm::LogicalResult verifyInvariantsImpl();
1846 ::llvm::LogicalResult verifyInvariants();
1847 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);
1848 static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
1849public:
1850};
1851
1852} // namespace mlir::LLVM
1853MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::Annotation)
1854
1855namespace mlir::LLVM {
1856
1857
1858//===----------------------------------------------------------------------===//
1859// ::mlir::LLVM::ArithmeticFenceOp declarations
1860//===----------------------------------------------------------------------===//
1861
1862namespace detail {
1863
1864class ArithmeticFenceOpGenericAdaptorBase {
1865public:
1866 using Properties = ::mlir::EmptyProperties;
1867protected:
1868 ::mlir::DictionaryAttr odsAttrs;
1869 ::std::optional<::mlir::OperationName> odsOpName;
1870 Properties properties;
1871 ::mlir::RegionRange odsRegions;
1872public:
1873 ArithmeticFenceOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
1874 odsOpName.emplace(args: "llvm.intr.arithmetic.fence", args: odsAttrs.getContext());
1875 }
1876
1877 ArithmeticFenceOpGenericAdaptorBase(ArithmeticFenceOp op);
1878
1879 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
1880 return {index, 1};
1881 }
1882
1883 const Properties &getProperties() {
1884 return properties;
1885 }
1886
1887 ::mlir::DictionaryAttr getAttributes() {
1888 return odsAttrs;
1889 }
1890
1891};
1892
1893} // namespace detail
1894template <typename RangeT>
1895class ArithmeticFenceOpGenericAdaptor : public detail::ArithmeticFenceOpGenericAdaptorBase {
1896 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
1897 using Base = detail::ArithmeticFenceOpGenericAdaptorBase;
1898 static constexpr int odsIndex_in = 0;
1899public:
1900 ArithmeticFenceOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
1901
1902 ArithmeticFenceOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ArithmeticFenceOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
1903
1904 ArithmeticFenceOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ArithmeticFenceOpGenericAdaptor(values, attrs, Properties{}, {}) {}
1905
1906 ArithmeticFenceOpGenericAdaptor(RangeT values, const ArithmeticFenceOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
1907
1908 template <typename LateInst = ArithmeticFenceOp, typename = std::enable_if_t<std::is_same_v<LateInst, ArithmeticFenceOp>>>
1909 ArithmeticFenceOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
1910
1911 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
1912 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
1913 }
1914
1915 RangeT getODSOperands(unsigned index) {
1916 auto valueRange = getODSOperandIndexAndLength(index);
1917 return {std::next(odsOperands.begin(), valueRange.first),
1918 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
1919 }
1920
1921 ValueT getIn() {
1922 return (*getODSOperands(index: 0).begin());
1923 }
1924
1925 RangeT getOperands() {
1926 return odsOperands;
1927 }
1928
1929private:
1930 RangeT odsOperands;
1931};
1932class ArithmeticFenceOpAdaptor : public ArithmeticFenceOpGenericAdaptor<::mlir::ValueRange> {
1933public:
1934 using ArithmeticFenceOpGenericAdaptor::ArithmeticFenceOpGenericAdaptor;
1935 ArithmeticFenceOpAdaptor(ArithmeticFenceOp op);
1936
1937 ::llvm::LogicalResult verify(::mlir::Location loc);
1938};
1939class ArithmeticFenceOp : public ::mlir::Op<ArithmeticFenceOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::InferTypeOpInterface::Trait> {
1940public:
1941 using Op::Op;
1942 using Op::print;
1943 using Adaptor = ArithmeticFenceOpAdaptor;
1944 template <typename RangeT>
1945 using GenericAdaptor = ArithmeticFenceOpGenericAdaptor<RangeT>;
1946 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
1947 static constexpr int odsIndex_in = 0;
1948 static constexpr int odsIndex_res = 0;
1949 using Properties = FoldAdaptor::Properties;
1950 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
1951 return {};
1952 }
1953
1954 static constexpr ::llvm::StringLiteral getOperationName() {
1955 return ::llvm::StringLiteral("llvm.intr.arithmetic.fence");
1956 }
1957
1958 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
1959 return {index, 1};
1960 }
1961
1962 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
1963 auto [start, length] = getODSOperandIndexAndLength(index);
1964 return getOperation()->getOperands().slice(n: start, m: length);
1965 }
1966
1967 ::mlir::TypedValue<::mlir::Type> getIn() {
1968 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSOperands(index: 0).begin());
1969 }
1970
1971 ::mlir::OpOperand &getInMutable() {
1972 auto range = getODSOperandIndexAndLength(index: 0);
1973 return getOperation()->getOpOperand(idx: range.first);
1974 }
1975
1976 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
1977 return {index, 1};
1978 }
1979
1980 ::mlir::Operation::result_range getODSResults(unsigned index) {
1981 auto valueRange = getODSResultIndexAndLength(index);
1982 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
1983 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
1984 }
1985
1986 ::mlir::TypedValue<::mlir::Type> getRes() {
1987 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSResults(index: 0).begin());
1988 }
1989
1990 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
1991 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
1992 static llvm::hash_code computePropertiesHash(const Properties &prop);
1993 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
1994 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
1995 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
1996 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
1997 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value in);
1998 static ArithmeticFenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value in);
1999 static ArithmeticFenceOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value in);
2000 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value in);
2001 static ArithmeticFenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value in);
2002 static ArithmeticFenceOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value in);
2003 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value in);
2004 static ArithmeticFenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value in);
2005 static ArithmeticFenceOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value in);
2006 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2007 static ArithmeticFenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2008 static ArithmeticFenceOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2009 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2010 static ArithmeticFenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2011 static ArithmeticFenceOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2012 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2013 static ArithmeticFenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2014 static ArithmeticFenceOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2015 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2016 static ArithmeticFenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2017 static ArithmeticFenceOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2018 ::llvm::LogicalResult verifyInvariantsImpl();
2019 ::llvm::LogicalResult verifyInvariants();
2020 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);
2021 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
2022 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
2023 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
2024public:
2025};
2026
2027} // namespace mlir::LLVM
2028MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ArithmeticFenceOp)
2029
2030namespace mlir::LLVM {
2031
2032
2033//===----------------------------------------------------------------------===//
2034// ::mlir::LLVM::AssumeOp declarations
2035//===----------------------------------------------------------------------===//
2036
2037namespace detail {
2038
2039class AssumeOpGenericAdaptorBase {
2040public:
2041 struct Properties {
2042 using op_bundle_sizesTy = ::mlir::DenseI32ArrayAttr;
2043 op_bundle_sizesTy op_bundle_sizes;
2044
2045 auto getOpBundleSizes() const {
2046 auto &propStorage = this->op_bundle_sizes;
2047 return ::llvm::cast<::mlir::DenseI32ArrayAttr>(Val: propStorage);
2048 }
2049 void setOpBundleSizes(const ::mlir::DenseI32ArrayAttr &propValue) {
2050 this->op_bundle_sizes = propValue;
2051 }
2052 using op_bundle_tagsTy = ::mlir::ArrayAttr;
2053 op_bundle_tagsTy op_bundle_tags;
2054
2055 auto getOpBundleTags() const {
2056 auto &propStorage = this->op_bundle_tags;
2057 return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(Val: propStorage);
2058 }
2059 void setOpBundleTags(const ::mlir::ArrayAttr &propValue) {
2060 this->op_bundle_tags = propValue;
2061 }
2062 bool operator==(const Properties &rhs) const {
2063 return
2064 rhs.op_bundle_sizes == this->op_bundle_sizes &&
2065 rhs.op_bundle_tags == this->op_bundle_tags &&
2066 true;
2067 }
2068 bool operator!=(const Properties &rhs) const {
2069 return !(*this == rhs);
2070 }
2071 };
2072protected:
2073 ::mlir::DictionaryAttr odsAttrs;
2074 ::std::optional<::mlir::OperationName> odsOpName;
2075 Properties properties;
2076 ::mlir::RegionRange odsRegions;
2077public:
2078 AssumeOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
2079 odsOpName.emplace(args: "llvm.intr.assume", args: odsAttrs.getContext());
2080 }
2081
2082 AssumeOpGenericAdaptorBase(AssumeOp op);
2083
2084 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
2085 const Properties &getProperties() {
2086 return properties;
2087 }
2088
2089 ::mlir::DictionaryAttr getAttributes() {
2090 return odsAttrs;
2091 }
2092
2093 ::mlir::DenseI32ArrayAttr getOpBundleSizesAttr() {
2094 auto attr = ::llvm::cast<::mlir::DenseI32ArrayAttr>(Val: getProperties().op_bundle_sizes);
2095 return attr;
2096 }
2097
2098 ::llvm::ArrayRef<int32_t> getOpBundleSizes();
2099 ::mlir::ArrayAttr getOpBundleTagsAttr() {
2100 auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(Val: getProperties().op_bundle_tags);
2101 return attr;
2102 }
2103
2104 ::std::optional< ::mlir::ArrayAttr > getOpBundleTags();
2105};
2106
2107} // namespace detail
2108template <typename RangeT>
2109class AssumeOpGenericAdaptor : public detail::AssumeOpGenericAdaptorBase {
2110 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
2111 using Base = detail::AssumeOpGenericAdaptorBase;
2112 static constexpr int odsIndex_cond = 0;
2113 static constexpr int odsIndex_op_bundle_operands = 1;
2114public:
2115 AssumeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
2116
2117 AssumeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : AssumeOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
2118
2119 AssumeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : AssumeOpGenericAdaptor(values, attrs, Properties{}, {}) {}
2120
2121 AssumeOpGenericAdaptor(RangeT values, const AssumeOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
2122
2123 template <typename LateInst = AssumeOp, typename = std::enable_if_t<std::is_same_v<LateInst, AssumeOp>>>
2124 AssumeOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
2125
2126 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
2127 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
2128 }
2129
2130 RangeT getODSOperands(unsigned index) {
2131 auto valueRange = getODSOperandIndexAndLength(index);
2132 return {std::next(odsOperands.begin(), valueRange.first),
2133 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
2134 }
2135
2136 ValueT getCond() {
2137 return (*getODSOperands(index: 0).begin());
2138 }
2139
2140 ::llvm::SmallVector<RangeT> getOpBundleOperands() {
2141 auto tblgenTmpOperands = getODSOperands(index: 1);
2142 auto sizes = getOpBundleSizes();
2143
2144 ::llvm::SmallVector<RangeT> tblgenTmpOperandGroups;
2145 for (int i = 0, e = sizes.size(); i < e; ++i) {
2146 tblgenTmpOperandGroups.push_back(tblgenTmpOperands.take_front(sizes[i]));
2147 tblgenTmpOperands = tblgenTmpOperands.drop_front(sizes[i]);
2148 }
2149 return tblgenTmpOperandGroups;
2150 }
2151
2152 RangeT getOperands() {
2153 return odsOperands;
2154 }
2155
2156private:
2157 RangeT odsOperands;
2158};
2159class AssumeOpAdaptor : public AssumeOpGenericAdaptor<::mlir::ValueRange> {
2160public:
2161 using AssumeOpGenericAdaptor::AssumeOpGenericAdaptor;
2162 AssumeOpAdaptor(AssumeOp op);
2163
2164 ::llvm::LogicalResult verify(::mlir::Location loc);
2165};
2166class AssumeOp : public ::mlir::Op<AssumeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> {
2167public:
2168 using Op::Op;
2169 using Op::print;
2170 using Adaptor = AssumeOpAdaptor;
2171 template <typename RangeT>
2172 using GenericAdaptor = AssumeOpGenericAdaptor<RangeT>;
2173 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
2174 static constexpr int odsIndex_cond = 0;
2175 static constexpr int odsIndex_op_bundle_operands = 1;
2176 using Properties = FoldAdaptor::Properties;
2177 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
2178 static ::llvm::StringRef attrNames[] = {::llvm::StringRef("op_bundle_sizes"), ::llvm::StringRef("op_bundle_tags")};
2179 return ::llvm::ArrayRef(attrNames);
2180 }
2181
2182 ::mlir::StringAttr getOpBundleSizesAttrName() {
2183 return getAttributeNameForIndex(index: 0);
2184 }
2185
2186 static ::mlir::StringAttr getOpBundleSizesAttrName(::mlir::OperationName name) {
2187 return getAttributeNameForIndex(name, index: 0);
2188 }
2189
2190 ::mlir::StringAttr getOpBundleTagsAttrName() {
2191 return getAttributeNameForIndex(index: 1);
2192 }
2193
2194 static ::mlir::StringAttr getOpBundleTagsAttrName(::mlir::OperationName name) {
2195 return getAttributeNameForIndex(name, index: 1);
2196 }
2197
2198 static constexpr ::llvm::StringLiteral getOperationName() {
2199 return ::llvm::StringLiteral("llvm.intr.assume");
2200 }
2201
2202 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
2203 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
2204 auto [start, length] = getODSOperandIndexAndLength(index);
2205 return getOperation()->getOperands().slice(n: start, m: length);
2206 }
2207
2208 ::mlir::TypedValue<::mlir::IntegerType> getCond() {
2209 return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(Val: *getODSOperands(index: 0).begin());
2210 }
2211
2212 ::mlir::OperandRangeRange getOpBundleOperands() {
2213 return getODSOperands(index: 1).split(segmentSizes: getOpBundleSizesAttr());
2214 }
2215
2216 ::mlir::OpOperand &getCondMutable() {
2217 auto range = getODSOperandIndexAndLength(index: 0);
2218 return getOperation()->getOpOperand(idx: range.first);
2219 }
2220
2221 ::mlir::MutableOperandRangeRange getOpBundleOperandsMutable();
2222 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
2223 return {index, 1};
2224 }
2225
2226 ::mlir::Operation::result_range getODSResults(unsigned index) {
2227 auto valueRange = getODSResultIndexAndLength(index);
2228 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
2229 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
2230 }
2231
2232 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
2233 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
2234 static llvm::hash_code computePropertiesHash(const Properties &prop);
2235 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
2236 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
2237 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
2238 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
2239 static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state);
2240 void writeProperties(::mlir::DialectBytecodeWriter &writer);
2241 ::mlir::DenseI32ArrayAttr getOpBundleSizesAttr() {
2242 return ::llvm::cast<::mlir::DenseI32ArrayAttr>(Val&: getProperties().op_bundle_sizes);
2243 }
2244
2245 ::llvm::ArrayRef<int32_t> getOpBundleSizes();
2246 ::mlir::ArrayAttr getOpBundleTagsAttr() {
2247 return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(Val&: getProperties().op_bundle_tags);
2248 }
2249
2250 ::std::optional< ::mlir::ArrayAttr > getOpBundleTags();
2251 void setOpBundleSizesAttr(::mlir::DenseI32ArrayAttr attr) {
2252 getProperties().op_bundle_sizes = attr;
2253 }
2254
2255 void setOpBundleSizes(::llvm::ArrayRef<int32_t> attrValue);
2256 void setOpBundleTagsAttr(::mlir::ArrayAttr attr) {
2257 getProperties().op_bundle_tags = attr;
2258 }
2259
2260 ::mlir::Attribute removeOpBundleTagsAttr() {
2261 auto attr = getProperties().op_bundle_tags;
2262 getProperties().op_bundle_tags = {};
2263 return attr;
2264 }
2265
2266 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value cond);
2267 static AssumeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value cond);
2268 static AssumeOp create(::mlir::ImplicitLocOpBuilder &builder, Value cond);
2269 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value cond, llvm::StringRef tag, ValueRange args);
2270 static AssumeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value cond, llvm::StringRef tag, ValueRange args);
2271 static AssumeOp create(::mlir::ImplicitLocOpBuilder &builder, Value cond, llvm::StringRef tag, ValueRange args);
2272 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value cond, AssumeAlignTag tag, Value ptr, Value align);
2273 static AssumeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value cond, AssumeAlignTag tag, Value ptr, Value align);
2274 static AssumeOp create(::mlir::ImplicitLocOpBuilder &builder, Value cond, AssumeAlignTag tag, Value ptr, Value align);
2275 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value cond, AssumeSeparateStorageTag tag, Value ptr1, Value ptr2);
2276 static AssumeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value cond, AssumeSeparateStorageTag tag, Value ptr1, Value ptr2);
2277 static AssumeOp create(::mlir::ImplicitLocOpBuilder &builder, Value cond, AssumeSeparateStorageTag tag, Value ptr1, Value ptr2);
2278 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value cond, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags);
2279 static AssumeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value cond, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags);
2280 static AssumeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value cond, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags);
2281 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value cond, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags);
2282 static AssumeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value cond, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags);
2283 static AssumeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value cond, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags);
2284 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
2285 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2286 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
2287 static AssumeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2288 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
2289 static AssumeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2290 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2291 static AssumeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2292 static AssumeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2293 ::llvm::LogicalResult verifyInvariantsImpl();
2294 ::llvm::LogicalResult verifyInvariants();
2295 ::llvm::LogicalResult verify();
2296 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
2297 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
2298private:
2299 ::mlir::StringAttr getAttributeNameForIndex(unsigned index) {
2300 return getAttributeNameForIndex(name: (*this)->getName(), index);
2301 }
2302
2303 static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) {
2304 assert(index < 2 && "invalid attribute index");
2305 assert(name.getStringRef() == getOperationName() && "invalid operation name");
2306 assert(name.isRegistered() && "Operation isn't registered, missing a "
2307 "dependent dialect loading?");
2308 return name.getAttributeNames()[index];
2309 }
2310
2311 static void buildPropertiesAndDiscardableAttributes(::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes);
2312public:
2313};
2314
2315} // namespace mlir::LLVM
2316MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::AssumeOp)
2317MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::AssumeOpGenericAdaptorBase::Properties)
2318
2319namespace mlir::LLVM {
2320
2321
2322//===----------------------------------------------------------------------===//
2323// ::mlir::LLVM::DebugTrap declarations
2324//===----------------------------------------------------------------------===//
2325
2326namespace detail {
2327
2328class DebugTrapGenericAdaptorBase {
2329public:
2330 using Properties = ::mlir::EmptyProperties;
2331protected:
2332 ::mlir::DictionaryAttr odsAttrs;
2333 ::std::optional<::mlir::OperationName> odsOpName;
2334 Properties properties;
2335 ::mlir::RegionRange odsRegions;
2336public:
2337 DebugTrapGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
2338 odsOpName.emplace(args: "llvm.intr.debugtrap", args: odsAttrs.getContext());
2339 }
2340
2341 DebugTrapGenericAdaptorBase(DebugTrap op);
2342
2343 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
2344 return {index, 1};
2345 }
2346
2347 const Properties &getProperties() {
2348 return properties;
2349 }
2350
2351 ::mlir::DictionaryAttr getAttributes() {
2352 return odsAttrs;
2353 }
2354
2355};
2356
2357} // namespace detail
2358template <typename RangeT>
2359class DebugTrapGenericAdaptor : public detail::DebugTrapGenericAdaptorBase {
2360 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
2361 using Base = detail::DebugTrapGenericAdaptorBase;
2362public:
2363 DebugTrapGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
2364
2365 DebugTrapGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : DebugTrapGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
2366
2367 DebugTrapGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : DebugTrapGenericAdaptor(values, attrs, Properties{}, {}) {}
2368
2369 DebugTrapGenericAdaptor(RangeT values, const DebugTrapGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
2370
2371 template <typename LateInst = DebugTrap, typename = std::enable_if_t<std::is_same_v<LateInst, DebugTrap>>>
2372 DebugTrapGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
2373
2374 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
2375 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
2376 }
2377
2378 RangeT getODSOperands(unsigned index) {
2379 auto valueRange = getODSOperandIndexAndLength(index);
2380 return {std::next(odsOperands.begin(), valueRange.first),
2381 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
2382 }
2383
2384 RangeT getOperands() {
2385 return odsOperands;
2386 }
2387
2388private:
2389 RangeT odsOperands;
2390};
2391class DebugTrapAdaptor : public DebugTrapGenericAdaptor<::mlir::ValueRange> {
2392public:
2393 using DebugTrapGenericAdaptor::DebugTrapGenericAdaptor;
2394 DebugTrapAdaptor(DebugTrap op);
2395
2396 ::llvm::LogicalResult verify(::mlir::Location loc);
2397};
2398class DebugTrap : public ::mlir::Op<DebugTrap, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> {
2399public:
2400 using Op::Op;
2401 using Op::print;
2402 using Adaptor = DebugTrapAdaptor;
2403 template <typename RangeT>
2404 using GenericAdaptor = DebugTrapGenericAdaptor<RangeT>;
2405 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
2406 using Properties = FoldAdaptor::Properties;
2407 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
2408 return {};
2409 }
2410
2411 static constexpr ::llvm::StringLiteral getOperationName() {
2412 return ::llvm::StringLiteral("llvm.intr.debugtrap");
2413 }
2414
2415 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
2416 return {index, 1};
2417 }
2418
2419 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
2420 auto [start, length] = getODSOperandIndexAndLength(index);
2421 return getOperation()->getOperands().slice(n: start, m: length);
2422 }
2423
2424 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
2425 return {index, 1};
2426 }
2427
2428 ::mlir::Operation::result_range getODSResults(unsigned index) {
2429 auto valueRange = getODSResultIndexAndLength(index);
2430 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
2431 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
2432 }
2433
2434 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
2435 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
2436 static llvm::hash_code computePropertiesHash(const Properties &prop);
2437 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
2438 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
2439 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
2440 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
2441 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState);
2442 static DebugTrap create(::mlir::OpBuilder &builder, ::mlir::Location location);
2443 static DebugTrap create(::mlir::ImplicitLocOpBuilder &builder);
2444 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes);
2445 static DebugTrap create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes);
2446 static DebugTrap create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes);
2447 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2448 static DebugTrap create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2449 static DebugTrap create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2450 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2451 static DebugTrap create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2452 static DebugTrap create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2453 ::llvm::LogicalResult verifyInvariantsImpl();
2454 ::llvm::LogicalResult verifyInvariants();
2455 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
2456 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
2457public:
2458};
2459
2460} // namespace mlir::LLVM
2461MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::DebugTrap)
2462
2463namespace mlir::LLVM {
2464
2465
2466//===----------------------------------------------------------------------===//
2467// ::mlir::LLVM::EhTypeidForOp declarations
2468//===----------------------------------------------------------------------===//
2469
2470namespace detail {
2471
2472class EhTypeidForOpGenericAdaptorBase {
2473public:
2474 using Properties = ::mlir::EmptyProperties;
2475protected:
2476 ::mlir::DictionaryAttr odsAttrs;
2477 ::std::optional<::mlir::OperationName> odsOpName;
2478 Properties properties;
2479 ::mlir::RegionRange odsRegions;
2480public:
2481 EhTypeidForOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
2482 odsOpName.emplace(args: "llvm.intr.eh.typeid.for", args: odsAttrs.getContext());
2483 }
2484
2485 EhTypeidForOpGenericAdaptorBase(EhTypeidForOp op);
2486
2487 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
2488 return {index, 1};
2489 }
2490
2491 const Properties &getProperties() {
2492 return properties;
2493 }
2494
2495 ::mlir::DictionaryAttr getAttributes() {
2496 return odsAttrs;
2497 }
2498
2499};
2500
2501} // namespace detail
2502template <typename RangeT>
2503class EhTypeidForOpGenericAdaptor : public detail::EhTypeidForOpGenericAdaptorBase {
2504 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
2505 using Base = detail::EhTypeidForOpGenericAdaptorBase;
2506 static constexpr int odsIndex_type_info = 0;
2507public:
2508 EhTypeidForOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
2509
2510 EhTypeidForOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : EhTypeidForOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
2511
2512 EhTypeidForOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : EhTypeidForOpGenericAdaptor(values, attrs, Properties{}, {}) {}
2513
2514 EhTypeidForOpGenericAdaptor(RangeT values, const EhTypeidForOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
2515
2516 template <typename LateInst = EhTypeidForOp, typename = std::enable_if_t<std::is_same_v<LateInst, EhTypeidForOp>>>
2517 EhTypeidForOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
2518
2519 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
2520 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
2521 }
2522
2523 RangeT getODSOperands(unsigned index) {
2524 auto valueRange = getODSOperandIndexAndLength(index);
2525 return {std::next(odsOperands.begin(), valueRange.first),
2526 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
2527 }
2528
2529 ValueT getTypeInfo() {
2530 return (*getODSOperands(index: 0).begin());
2531 }
2532
2533 RangeT getOperands() {
2534 return odsOperands;
2535 }
2536
2537private:
2538 RangeT odsOperands;
2539};
2540class EhTypeidForOpAdaptor : public EhTypeidForOpGenericAdaptor<::mlir::ValueRange> {
2541public:
2542 using EhTypeidForOpGenericAdaptor::EhTypeidForOpGenericAdaptor;
2543 EhTypeidForOpAdaptor(EhTypeidForOp op);
2544
2545 ::llvm::LogicalResult verify(::mlir::Location loc);
2546};
2547class EhTypeidForOp : public ::mlir::Op<EhTypeidForOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> {
2548public:
2549 using Op::Op;
2550 using Op::print;
2551 using Adaptor = EhTypeidForOpAdaptor;
2552 template <typename RangeT>
2553 using GenericAdaptor = EhTypeidForOpGenericAdaptor<RangeT>;
2554 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
2555 static constexpr int odsIndex_type_info = 0;
2556 static constexpr int odsIndex_res = 0;
2557 using Properties = FoldAdaptor::Properties;
2558 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
2559 return {};
2560 }
2561
2562 static constexpr ::llvm::StringLiteral getOperationName() {
2563 return ::llvm::StringLiteral("llvm.intr.eh.typeid.for");
2564 }
2565
2566 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
2567 return {index, 1};
2568 }
2569
2570 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
2571 auto [start, length] = getODSOperandIndexAndLength(index);
2572 return getOperation()->getOperands().slice(n: start, m: length);
2573 }
2574
2575 ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getTypeInfo() {
2576 return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(Val: *getODSOperands(index: 0).begin());
2577 }
2578
2579 ::mlir::OpOperand &getTypeInfoMutable() {
2580 auto range = getODSOperandIndexAndLength(index: 0);
2581 return getOperation()->getOpOperand(idx: range.first);
2582 }
2583
2584 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
2585 return {index, 1};
2586 }
2587
2588 ::mlir::Operation::result_range getODSResults(unsigned index) {
2589 auto valueRange = getODSResultIndexAndLength(index);
2590 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
2591 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
2592 }
2593
2594 ::mlir::TypedValue<::mlir::Type> getRes() {
2595 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSResults(index: 0).begin());
2596 }
2597
2598 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
2599 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
2600 static llvm::hash_code computePropertiesHash(const Properties &prop);
2601 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
2602 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
2603 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
2604 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
2605 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value type_info);
2606 static EhTypeidForOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value type_info);
2607 static EhTypeidForOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value type_info);
2608 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value type_info);
2609 static EhTypeidForOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value type_info);
2610 static EhTypeidForOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value type_info);
2611 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2612 static EhTypeidForOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2613 static EhTypeidForOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2614 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2615 static EhTypeidForOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2616 static EhTypeidForOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2617 ::llvm::LogicalResult verifyInvariantsImpl();
2618 ::llvm::LogicalResult verifyInvariants();
2619 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
2620 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
2621public:
2622};
2623
2624} // namespace mlir::LLVM
2625MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::EhTypeidForOp)
2626
2627namespace mlir::LLVM {
2628
2629
2630//===----------------------------------------------------------------------===//
2631// ::mlir::LLVM::ExpectOp declarations
2632//===----------------------------------------------------------------------===//
2633
2634namespace detail {
2635
2636class ExpectOpGenericAdaptorBase {
2637public:
2638 using Properties = ::mlir::EmptyProperties;
2639protected:
2640 ::mlir::DictionaryAttr odsAttrs;
2641 ::std::optional<::mlir::OperationName> odsOpName;
2642 Properties properties;
2643 ::mlir::RegionRange odsRegions;
2644public:
2645 ExpectOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
2646 odsOpName.emplace(args: "llvm.intr.expect", args: odsAttrs.getContext());
2647 }
2648
2649 ExpectOpGenericAdaptorBase(ExpectOp op);
2650
2651 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
2652 return {index, 1};
2653 }
2654
2655 const Properties &getProperties() {
2656 return properties;
2657 }
2658
2659 ::mlir::DictionaryAttr getAttributes() {
2660 return odsAttrs;
2661 }
2662
2663};
2664
2665} // namespace detail
2666template <typename RangeT>
2667class ExpectOpGenericAdaptor : public detail::ExpectOpGenericAdaptorBase {
2668 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
2669 using Base = detail::ExpectOpGenericAdaptorBase;
2670 static constexpr int odsIndex_val = 0;
2671 static constexpr int odsIndex_expected = 1;
2672public:
2673 ExpectOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
2674
2675 ExpectOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ExpectOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
2676
2677 ExpectOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ExpectOpGenericAdaptor(values, attrs, Properties{}, {}) {}
2678
2679 ExpectOpGenericAdaptor(RangeT values, const ExpectOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
2680
2681 template <typename LateInst = ExpectOp, typename = std::enable_if_t<std::is_same_v<LateInst, ExpectOp>>>
2682 ExpectOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
2683
2684 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
2685 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
2686 }
2687
2688 RangeT getODSOperands(unsigned index) {
2689 auto valueRange = getODSOperandIndexAndLength(index);
2690 return {std::next(odsOperands.begin(), valueRange.first),
2691 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
2692 }
2693
2694 ValueT getVal() {
2695 return (*getODSOperands(index: 0).begin());
2696 }
2697
2698 ValueT getExpected() {
2699 return (*getODSOperands(index: 1).begin());
2700 }
2701
2702 RangeT getOperands() {
2703 return odsOperands;
2704 }
2705
2706private:
2707 RangeT odsOperands;
2708};
2709class ExpectOpAdaptor : public ExpectOpGenericAdaptor<::mlir::ValueRange> {
2710public:
2711 using ExpectOpGenericAdaptor::ExpectOpGenericAdaptor;
2712 ExpectOpAdaptor(ExpectOp op);
2713
2714 ::llvm::LogicalResult verify(::mlir::Location loc);
2715};
2716class ExpectOp : public ::mlir::Op<ExpectOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::InferTypeOpInterface::Trait> {
2717public:
2718 using Op::Op;
2719 using Op::print;
2720 using Adaptor = ExpectOpAdaptor;
2721 template <typename RangeT>
2722 using GenericAdaptor = ExpectOpGenericAdaptor<RangeT>;
2723 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
2724 static constexpr int odsIndex_val = 0;
2725 static constexpr int odsIndex_expected = 1;
2726 static constexpr int odsIndex_res = 0;
2727 using Properties = FoldAdaptor::Properties;
2728 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
2729 return {};
2730 }
2731
2732 static constexpr ::llvm::StringLiteral getOperationName() {
2733 return ::llvm::StringLiteral("llvm.intr.expect");
2734 }
2735
2736 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
2737 return {index, 1};
2738 }
2739
2740 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
2741 auto [start, length] = getODSOperandIndexAndLength(index);
2742 return getOperation()->getOperands().slice(n: start, m: length);
2743 }
2744
2745 ::mlir::TypedValue<::mlir::IntegerType> getVal() {
2746 return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(Val: *getODSOperands(index: 0).begin());
2747 }
2748
2749 ::mlir::TypedValue<::mlir::IntegerType> getExpected() {
2750 return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(Val: *getODSOperands(index: 1).begin());
2751 }
2752
2753 ::mlir::OpOperand &getValMutable() {
2754 auto range = getODSOperandIndexAndLength(index: 0);
2755 return getOperation()->getOpOperand(idx: range.first);
2756 }
2757
2758 ::mlir::OpOperand &getExpectedMutable() {
2759 auto range = getODSOperandIndexAndLength(index: 1);
2760 return getOperation()->getOpOperand(idx: range.first);
2761 }
2762
2763 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
2764 return {index, 1};
2765 }
2766
2767 ::mlir::Operation::result_range getODSResults(unsigned index) {
2768 auto valueRange = getODSResultIndexAndLength(index);
2769 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
2770 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
2771 }
2772
2773 ::mlir::TypedValue<::mlir::Type> getRes() {
2774 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSResults(index: 0).begin());
2775 }
2776
2777 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
2778 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
2779 static llvm::hash_code computePropertiesHash(const Properties &prop);
2780 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
2781 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
2782 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
2783 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
2784 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value val, ::mlir::Value expected);
2785 static ExpectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value val, ::mlir::Value expected);
2786 static ExpectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value val, ::mlir::Value expected);
2787 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value val, ::mlir::Value expected);
2788 static ExpectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value val, ::mlir::Value expected);
2789 static ExpectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value val, ::mlir::Value expected);
2790 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::Value expected);
2791 static ExpectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::Value expected);
2792 static ExpectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::Value expected);
2793 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2794 static ExpectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2795 static ExpectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2796 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2797 static ExpectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2798 static ExpectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
2799 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2800 static ExpectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2801 static ExpectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2802 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2803 static ExpectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2804 static ExpectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
2805 ::llvm::LogicalResult verifyInvariantsImpl();
2806 ::llvm::LogicalResult verifyInvariants();
2807 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);
2808 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
2809 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
2810 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
2811public:
2812};
2813
2814} // namespace mlir::LLVM
2815MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ExpectOp)
2816
2817namespace mlir::LLVM {
2818
2819
2820//===----------------------------------------------------------------------===//
2821// ::mlir::LLVM::ExpectWithProbabilityOp declarations
2822//===----------------------------------------------------------------------===//
2823
2824namespace detail {
2825
2826class ExpectWithProbabilityOpGenericAdaptorBase {
2827public:
2828 struct Properties {
2829 using probTy = ::mlir::FloatAttr;
2830 probTy prob;
2831
2832 auto getProb() const {
2833 auto &propStorage = this->prob;
2834 return ::llvm::cast<::mlir::FloatAttr>(Val: propStorage);
2835 }
2836 void setProb(const ::mlir::FloatAttr &propValue) {
2837 this->prob = propValue;
2838 }
2839 bool operator==(const Properties &rhs) const {
2840 return
2841 rhs.prob == this->prob &&
2842 true;
2843 }
2844 bool operator!=(const Properties &rhs) const {
2845 return !(*this == rhs);
2846 }
2847 };
2848protected:
2849 ::mlir::DictionaryAttr odsAttrs;
2850 ::std::optional<::mlir::OperationName> odsOpName;
2851 Properties properties;
2852 ::mlir::RegionRange odsRegions;
2853public:
2854 ExpectWithProbabilityOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
2855 odsOpName.emplace(args: "llvm.intr.expect.with.probability", args: odsAttrs.getContext());
2856 }
2857
2858 ExpectWithProbabilityOpGenericAdaptorBase(ExpectWithProbabilityOp op);
2859
2860 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
2861 return {index, 1};
2862 }
2863
2864 const Properties &getProperties() {
2865 return properties;
2866 }
2867
2868 ::mlir::DictionaryAttr getAttributes() {
2869 return odsAttrs;
2870 }
2871
2872 ::mlir::FloatAttr getProbAttr() {
2873 auto attr = ::llvm::cast<::mlir::FloatAttr>(Val: getProperties().prob);
2874 return attr;
2875 }
2876
2877 ::llvm::APFloat getProb();
2878};
2879
2880} // namespace detail
2881template <typename RangeT>
2882class ExpectWithProbabilityOpGenericAdaptor : public detail::ExpectWithProbabilityOpGenericAdaptorBase {
2883 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
2884 using Base = detail::ExpectWithProbabilityOpGenericAdaptorBase;
2885 static constexpr int odsIndex_val = 0;
2886 static constexpr int odsIndex_expected = 1;
2887public:
2888 ExpectWithProbabilityOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
2889
2890 ExpectWithProbabilityOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ExpectWithProbabilityOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
2891
2892 ExpectWithProbabilityOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ExpectWithProbabilityOpGenericAdaptor(values, attrs, Properties{}, {}) {}
2893
2894 ExpectWithProbabilityOpGenericAdaptor(RangeT values, const ExpectWithProbabilityOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
2895
2896 template <typename LateInst = ExpectWithProbabilityOp, typename = std::enable_if_t<std::is_same_v<LateInst, ExpectWithProbabilityOp>>>
2897 ExpectWithProbabilityOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
2898
2899 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
2900 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
2901 }
2902
2903 RangeT getODSOperands(unsigned index) {
2904 auto valueRange = getODSOperandIndexAndLength(index);
2905 return {std::next(odsOperands.begin(), valueRange.first),
2906 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
2907 }
2908
2909 ValueT getVal() {
2910 return (*getODSOperands(index: 0).begin());
2911 }
2912
2913 ValueT getExpected() {
2914 return (*getODSOperands(index: 1).begin());
2915 }
2916
2917 RangeT getOperands() {
2918 return odsOperands;
2919 }
2920
2921private:
2922 RangeT odsOperands;
2923};
2924class ExpectWithProbabilityOpAdaptor : public ExpectWithProbabilityOpGenericAdaptor<::mlir::ValueRange> {
2925public:
2926 using ExpectWithProbabilityOpGenericAdaptor::ExpectWithProbabilityOpGenericAdaptor;
2927 ExpectWithProbabilityOpAdaptor(ExpectWithProbabilityOp op);
2928
2929 ::llvm::LogicalResult verify(::mlir::Location loc);
2930};
2931class ExpectWithProbabilityOp : public ::mlir::Op<ExpectWithProbabilityOp, ::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> {
2932public:
2933 using Op::Op;
2934 using Op::print;
2935 using Adaptor = ExpectWithProbabilityOpAdaptor;
2936 template <typename RangeT>
2937 using GenericAdaptor = ExpectWithProbabilityOpGenericAdaptor<RangeT>;
2938 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
2939 static constexpr int odsIndex_val = 0;
2940 static constexpr int odsIndex_expected = 1;
2941 static constexpr int odsIndex_res = 0;
2942 using Properties = FoldAdaptor::Properties;
2943 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
2944 static ::llvm::StringRef attrNames[] = {::llvm::StringRef("prob")};
2945 return ::llvm::ArrayRef(attrNames);
2946 }
2947
2948 ::mlir::StringAttr getProbAttrName() {
2949 return getAttributeNameForIndex(index: 0);
2950 }
2951
2952 static ::mlir::StringAttr getProbAttrName(::mlir::OperationName name) {
2953 return getAttributeNameForIndex(name, index: 0);
2954 }
2955
2956 static constexpr ::llvm::StringLiteral getOperationName() {
2957 return ::llvm::StringLiteral("llvm.intr.expect.with.probability");
2958 }
2959
2960 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
2961 return {index, 1};
2962 }
2963
2964 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
2965 auto [start, length] = getODSOperandIndexAndLength(index);
2966 return getOperation()->getOperands().slice(n: start, m: length);
2967 }
2968
2969 ::mlir::TypedValue<::mlir::IntegerType> getVal() {
2970 return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(Val: *getODSOperands(index: 0).begin());
2971 }
2972
2973 ::mlir::TypedValue<::mlir::IntegerType> getExpected() {
2974 return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(Val: *getODSOperands(index: 1).begin());
2975 }
2976
2977 ::mlir::OpOperand &getValMutable() {
2978 auto range = getODSOperandIndexAndLength(index: 0);
2979 return getOperation()->getOpOperand(idx: range.first);
2980 }
2981
2982 ::mlir::OpOperand &getExpectedMutable() {
2983 auto range = getODSOperandIndexAndLength(index: 1);
2984 return getOperation()->getOpOperand(idx: range.first);
2985 }
2986
2987 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
2988 return {index, 1};
2989 }
2990
2991 ::mlir::Operation::result_range getODSResults(unsigned index) {
2992 auto valueRange = getODSResultIndexAndLength(index);
2993 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
2994 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
2995 }
2996
2997 ::mlir::TypedValue<::mlir::Type> getRes() {
2998 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSResults(index: 0).begin());
2999 }
3000
3001 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
3002 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
3003 static llvm::hash_code computePropertiesHash(const Properties &prop);
3004 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
3005 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
3006 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
3007 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
3008 static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state);
3009 void writeProperties(::mlir::DialectBytecodeWriter &writer);
3010 ::mlir::FloatAttr getProbAttr() {
3011 return ::llvm::cast<::mlir::FloatAttr>(Val&: getProperties().prob);
3012 }
3013
3014 ::llvm::APFloat getProb();
3015 void setProbAttr(::mlir::FloatAttr attr) {
3016 getProperties().prob = attr;
3017 }
3018
3019 void setProb(::llvm::APFloat attrValue);
3020 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value val, ::mlir::Value expected, ::mlir::FloatAttr prob);
3021 static ExpectWithProbabilityOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value val, ::mlir::Value expected, ::mlir::FloatAttr prob);
3022 static ExpectWithProbabilityOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value val, ::mlir::Value expected, ::mlir::FloatAttr prob);
3023 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value val, ::mlir::Value expected, ::mlir::FloatAttr prob);
3024 static ExpectWithProbabilityOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value val, ::mlir::Value expected, ::mlir::FloatAttr prob);
3025 static ExpectWithProbabilityOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value val, ::mlir::Value expected, ::mlir::FloatAttr prob);
3026 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::Value expected, ::mlir::FloatAttr prob);
3027 static ExpectWithProbabilityOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::Value expected, ::mlir::FloatAttr prob);
3028 static ExpectWithProbabilityOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::Value expected, ::mlir::FloatAttr prob);
3029 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value val, ::mlir::Value expected, ::llvm::APFloat prob);
3030 static ExpectWithProbabilityOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value val, ::mlir::Value expected, ::llvm::APFloat prob);
3031 static ExpectWithProbabilityOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value val, ::mlir::Value expected, ::llvm::APFloat prob);
3032 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value val, ::mlir::Value expected, ::llvm::APFloat prob);
3033 static ExpectWithProbabilityOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value val, ::mlir::Value expected, ::llvm::APFloat prob);
3034 static ExpectWithProbabilityOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value val, ::mlir::Value expected, ::llvm::APFloat prob);
3035 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::Value expected, ::llvm::APFloat prob);
3036 static ExpectWithProbabilityOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::Value expected, ::llvm::APFloat prob);
3037 static ExpectWithProbabilityOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::Value expected, ::llvm::APFloat prob);
3038 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
3039 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3040 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
3041 static ExpectWithProbabilityOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3042 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
3043 static ExpectWithProbabilityOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3044 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
3045 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3046 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
3047 static ExpectWithProbabilityOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3048 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
3049 static ExpectWithProbabilityOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3050 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3051 static ExpectWithProbabilityOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3052 static ExpectWithProbabilityOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3053 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3054 static ExpectWithProbabilityOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3055 static ExpectWithProbabilityOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3056 ::llvm::LogicalResult verifyInvariantsImpl();
3057 ::llvm::LogicalResult verifyInvariants();
3058 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);
3059 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
3060 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
3061 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
3062private:
3063 ::mlir::StringAttr getAttributeNameForIndex(unsigned index) {
3064 return getAttributeNameForIndex(name: (*this)->getName(), index);
3065 }
3066
3067 static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) {
3068 assert(index < 1 && "invalid attribute index");
3069 assert(name.getStringRef() == getOperationName() && "invalid operation name");
3070 assert(name.isRegistered() && "Operation isn't registered, missing a "
3071 "dependent dialect loading?");
3072 return name.getAttributeNames()[index];
3073 }
3074
3075 static void buildPropertiesAndDiscardableAttributes(::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes);
3076public:
3077};
3078
3079} // namespace mlir::LLVM
3080MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ExpectWithProbabilityOp)
3081MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::ExpectWithProbabilityOpGenericAdaptorBase::Properties)
3082
3083namespace mlir::LLVM {
3084
3085
3086//===----------------------------------------------------------------------===//
3087// ::mlir::LLVM::FakeUseOp declarations
3088//===----------------------------------------------------------------------===//
3089
3090namespace detail {
3091
3092class FakeUseOpGenericAdaptorBase {
3093public:
3094 using Properties = ::mlir::EmptyProperties;
3095protected:
3096 ::mlir::DictionaryAttr odsAttrs;
3097 ::std::optional<::mlir::OperationName> odsOpName;
3098 Properties properties;
3099 ::mlir::RegionRange odsRegions;
3100public:
3101 FakeUseOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
3102 odsOpName.emplace(args: "llvm.intr.fake.use", args: odsAttrs.getContext());
3103 }
3104
3105 FakeUseOpGenericAdaptorBase(FakeUseOp op);
3106
3107 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
3108 const Properties &getProperties() {
3109 return properties;
3110 }
3111
3112 ::mlir::DictionaryAttr getAttributes() {
3113 return odsAttrs;
3114 }
3115
3116};
3117
3118} // namespace detail
3119template <typename RangeT>
3120class FakeUseOpGenericAdaptor : public detail::FakeUseOpGenericAdaptorBase {
3121 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
3122 using Base = detail::FakeUseOpGenericAdaptorBase;
3123 static constexpr int odsIndex_args = 0;
3124public:
3125 FakeUseOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
3126
3127 FakeUseOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FakeUseOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
3128
3129 FakeUseOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FakeUseOpGenericAdaptor(values, attrs, Properties{}, {}) {}
3130
3131 FakeUseOpGenericAdaptor(RangeT values, const FakeUseOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
3132
3133 template <typename LateInst = FakeUseOp, typename = std::enable_if_t<std::is_same_v<LateInst, FakeUseOp>>>
3134 FakeUseOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
3135
3136 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
3137 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
3138 }
3139
3140 RangeT getODSOperands(unsigned index) {
3141 auto valueRange = getODSOperandIndexAndLength(index);
3142 return {std::next(odsOperands.begin(), valueRange.first),
3143 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
3144 }
3145
3146 RangeT getArgs() {
3147 return getODSOperands(index: 0);
3148 }
3149
3150 RangeT getOperands() {
3151 return odsOperands;
3152 }
3153
3154private:
3155 RangeT odsOperands;
3156};
3157class FakeUseOpAdaptor : public FakeUseOpGenericAdaptor<::mlir::ValueRange> {
3158public:
3159 using FakeUseOpGenericAdaptor::FakeUseOpGenericAdaptor;
3160 FakeUseOpAdaptor(FakeUseOp op);
3161
3162 ::llvm::LogicalResult verify(::mlir::Location loc);
3163};
3164class FakeUseOp : public ::mlir::Op<FakeUseOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants> {
3165public:
3166 using Op::Op;
3167 using Op::print;
3168 using Adaptor = FakeUseOpAdaptor;
3169 template <typename RangeT>
3170 using GenericAdaptor = FakeUseOpGenericAdaptor<RangeT>;
3171 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
3172 static constexpr int odsIndex_args = 0;
3173 using Properties = FoldAdaptor::Properties;
3174 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
3175 return {};
3176 }
3177
3178 static constexpr ::llvm::StringLiteral getOperationName() {
3179 return ::llvm::StringLiteral("llvm.intr.fake.use");
3180 }
3181
3182 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
3183 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
3184 auto [start, length] = getODSOperandIndexAndLength(index);
3185 return getOperation()->getOperands().slice(n: start, m: length);
3186 }
3187
3188 ::mlir::Operation::operand_range getArgs() {
3189 return getODSOperands(index: 0);
3190 }
3191
3192 ::mlir::MutableOperandRange getArgsMutable();
3193 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
3194 return {index, 1};
3195 }
3196
3197 ::mlir::Operation::result_range getODSResults(unsigned index) {
3198 auto valueRange = getODSResultIndexAndLength(index);
3199 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
3200 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
3201 }
3202
3203 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
3204 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
3205 static llvm::hash_code computePropertiesHash(const Properties &prop);
3206 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
3207 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
3208 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
3209 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
3210 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange args);
3211 static FakeUseOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange args);
3212 static FakeUseOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange args);
3213 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3214 static FakeUseOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3215 static FakeUseOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3216 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3217 static FakeUseOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3218 static FakeUseOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3219 ::llvm::LogicalResult verifyInvariantsImpl();
3220 ::llvm::LogicalResult verifyInvariants();
3221 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
3222 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
3223public:
3224};
3225
3226} // namespace mlir::LLVM
3227MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FakeUseOp)
3228
3229namespace mlir::LLVM {
3230
3231
3232//===----------------------------------------------------------------------===//
3233// ::mlir::LLVM::IsConstantOp declarations
3234//===----------------------------------------------------------------------===//
3235
3236namespace detail {
3237
3238class IsConstantOpGenericAdaptorBase {
3239public:
3240 using Properties = ::mlir::EmptyProperties;
3241protected:
3242 ::mlir::DictionaryAttr odsAttrs;
3243 ::std::optional<::mlir::OperationName> odsOpName;
3244 Properties properties;
3245 ::mlir::RegionRange odsRegions;
3246public:
3247 IsConstantOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
3248 odsOpName.emplace(args: "llvm.intr.is.constant", args: odsAttrs.getContext());
3249 }
3250
3251 IsConstantOpGenericAdaptorBase(IsConstantOp op);
3252
3253 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
3254 return {index, 1};
3255 }
3256
3257 const Properties &getProperties() {
3258 return properties;
3259 }
3260
3261 ::mlir::DictionaryAttr getAttributes() {
3262 return odsAttrs;
3263 }
3264
3265};
3266
3267} // namespace detail
3268template <typename RangeT>
3269class IsConstantOpGenericAdaptor : public detail::IsConstantOpGenericAdaptorBase {
3270 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
3271 using Base = detail::IsConstantOpGenericAdaptorBase;
3272 static constexpr int odsIndex_val = 0;
3273public:
3274 IsConstantOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
3275
3276 IsConstantOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : IsConstantOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
3277
3278 IsConstantOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : IsConstantOpGenericAdaptor(values, attrs, Properties{}, {}) {}
3279
3280 IsConstantOpGenericAdaptor(RangeT values, const IsConstantOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
3281
3282 template <typename LateInst = IsConstantOp, typename = std::enable_if_t<std::is_same_v<LateInst, IsConstantOp>>>
3283 IsConstantOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
3284
3285 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
3286 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
3287 }
3288
3289 RangeT getODSOperands(unsigned index) {
3290 auto valueRange = getODSOperandIndexAndLength(index);
3291 return {std::next(odsOperands.begin(), valueRange.first),
3292 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
3293 }
3294
3295 ValueT getVal() {
3296 return (*getODSOperands(index: 0).begin());
3297 }
3298
3299 RangeT getOperands() {
3300 return odsOperands;
3301 }
3302
3303private:
3304 RangeT odsOperands;
3305};
3306class IsConstantOpAdaptor : public IsConstantOpGenericAdaptor<::mlir::ValueRange> {
3307public:
3308 using IsConstantOpGenericAdaptor::IsConstantOpGenericAdaptor;
3309 IsConstantOpAdaptor(IsConstantOp op);
3310
3311 ::llvm::LogicalResult verify(::mlir::Location loc);
3312};
3313class IsConstantOp : public ::mlir::Op<IsConstantOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> {
3314public:
3315 using Op::Op;
3316 using Op::print;
3317 using Adaptor = IsConstantOpAdaptor;
3318 template <typename RangeT>
3319 using GenericAdaptor = IsConstantOpGenericAdaptor<RangeT>;
3320 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
3321 static constexpr int odsIndex_val = 0;
3322 static constexpr int odsIndex_res = 0;
3323 using Properties = FoldAdaptor::Properties;
3324 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
3325 return {};
3326 }
3327
3328 static constexpr ::llvm::StringLiteral getOperationName() {
3329 return ::llvm::StringLiteral("llvm.intr.is.constant");
3330 }
3331
3332 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
3333 return {index, 1};
3334 }
3335
3336 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
3337 auto [start, length] = getODSOperandIndexAndLength(index);
3338 return getOperation()->getOperands().slice(n: start, m: length);
3339 }
3340
3341 ::mlir::TypedValue<::mlir::Type> getVal() {
3342 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSOperands(index: 0).begin());
3343 }
3344
3345 ::mlir::OpOperand &getValMutable() {
3346 auto range = getODSOperandIndexAndLength(index: 0);
3347 return getOperation()->getOpOperand(idx: range.first);
3348 }
3349
3350 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
3351 return {index, 1};
3352 }
3353
3354 ::mlir::Operation::result_range getODSResults(unsigned index) {
3355 auto valueRange = getODSResultIndexAndLength(index);
3356 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
3357 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
3358 }
3359
3360 ::mlir::TypedValue<::mlir::IntegerType> getRes() {
3361 return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(Val: *getODSResults(index: 0).begin());
3362 }
3363
3364 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
3365 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
3366 static llvm::hash_code computePropertiesHash(const Properties &prop);
3367 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
3368 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
3369 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
3370 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
3371 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value val);
3372 static IsConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value val);
3373 static IsConstantOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value val);
3374 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value val);
3375 static IsConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value val);
3376 static IsConstantOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value val);
3377 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value val);
3378 static IsConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value val);
3379 static IsConstantOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value val);
3380 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3381 static IsConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3382 static IsConstantOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3383 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3384 static IsConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3385 static IsConstantOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3386 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3387 static IsConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3388 static IsConstantOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3389 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3390 static IsConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3391 static IsConstantOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3392 ::llvm::LogicalResult verifyInvariantsImpl();
3393 ::llvm::LogicalResult verifyInvariants();
3394 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);
3395 static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
3396 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
3397public:
3398};
3399
3400} // namespace mlir::LLVM
3401MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::IsConstantOp)
3402
3403namespace mlir::LLVM {
3404
3405
3406//===----------------------------------------------------------------------===//
3407// ::mlir::LLVM::NoAliasScopeDeclOp declarations
3408//===----------------------------------------------------------------------===//
3409
3410namespace detail {
3411
3412class NoAliasScopeDeclOpGenericAdaptorBase {
3413public:
3414 struct Properties {
3415 using scopeTy = ::mlir::LLVM::AliasScopeAttr;
3416 scopeTy scope;
3417
3418 auto getScope() const {
3419 auto &propStorage = this->scope;
3420 return ::llvm::cast<::mlir::LLVM::AliasScopeAttr>(Val: propStorage);
3421 }
3422 void setScope(const ::mlir::LLVM::AliasScopeAttr &propValue) {
3423 this->scope = propValue;
3424 }
3425 bool operator==(const Properties &rhs) const {
3426 return
3427 rhs.scope == this->scope &&
3428 true;
3429 }
3430 bool operator!=(const Properties &rhs) const {
3431 return !(*this == rhs);
3432 }
3433 };
3434protected:
3435 ::mlir::DictionaryAttr odsAttrs;
3436 ::std::optional<::mlir::OperationName> odsOpName;
3437 Properties properties;
3438 ::mlir::RegionRange odsRegions;
3439public:
3440 NoAliasScopeDeclOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
3441 odsOpName.emplace(args: "llvm.intr.experimental.noalias.scope.decl", args: odsAttrs.getContext());
3442 }
3443
3444 NoAliasScopeDeclOpGenericAdaptorBase(NoAliasScopeDeclOp op);
3445
3446 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
3447 return {index, 1};
3448 }
3449
3450 const Properties &getProperties() {
3451 return properties;
3452 }
3453
3454 ::mlir::DictionaryAttr getAttributes() {
3455 return odsAttrs;
3456 }
3457
3458 ::mlir::LLVM::AliasScopeAttr getScopeAttr() {
3459 auto attr = ::llvm::cast<::mlir::LLVM::AliasScopeAttr>(Val: getProperties().scope);
3460 return attr;
3461 }
3462
3463 ::mlir::LLVM::AliasScopeAttr getScope();
3464};
3465
3466} // namespace detail
3467template <typename RangeT>
3468class NoAliasScopeDeclOpGenericAdaptor : public detail::NoAliasScopeDeclOpGenericAdaptorBase {
3469 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
3470 using Base = detail::NoAliasScopeDeclOpGenericAdaptorBase;
3471public:
3472 NoAliasScopeDeclOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
3473
3474 NoAliasScopeDeclOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : NoAliasScopeDeclOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
3475
3476 NoAliasScopeDeclOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : NoAliasScopeDeclOpGenericAdaptor(values, attrs, Properties{}, {}) {}
3477
3478 NoAliasScopeDeclOpGenericAdaptor(RangeT values, const NoAliasScopeDeclOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
3479
3480 template <typename LateInst = NoAliasScopeDeclOp, typename = std::enable_if_t<std::is_same_v<LateInst, NoAliasScopeDeclOp>>>
3481 NoAliasScopeDeclOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
3482
3483 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
3484 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
3485 }
3486
3487 RangeT getODSOperands(unsigned index) {
3488 auto valueRange = getODSOperandIndexAndLength(index);
3489 return {std::next(odsOperands.begin(), valueRange.first),
3490 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
3491 }
3492
3493 RangeT getOperands() {
3494 return odsOperands;
3495 }
3496
3497private:
3498 RangeT odsOperands;
3499};
3500class NoAliasScopeDeclOpAdaptor : public NoAliasScopeDeclOpGenericAdaptor<::mlir::ValueRange> {
3501public:
3502 using NoAliasScopeDeclOpGenericAdaptor::NoAliasScopeDeclOpGenericAdaptor;
3503 NoAliasScopeDeclOpAdaptor(NoAliasScopeDeclOp op);
3504
3505 ::llvm::LogicalResult verify(::mlir::Location loc);
3506};
3507class NoAliasScopeDeclOp : public ::mlir::Op<NoAliasScopeDeclOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> {
3508public:
3509 using Op::Op;
3510 using Op::print;
3511 using Adaptor = NoAliasScopeDeclOpAdaptor;
3512 template <typename RangeT>
3513 using GenericAdaptor = NoAliasScopeDeclOpGenericAdaptor<RangeT>;
3514 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
3515 using Properties = FoldAdaptor::Properties;
3516 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
3517 static ::llvm::StringRef attrNames[] = {::llvm::StringRef("scope")};
3518 return ::llvm::ArrayRef(attrNames);
3519 }
3520
3521 ::mlir::StringAttr getScopeAttrName() {
3522 return getAttributeNameForIndex(index: 0);
3523 }
3524
3525 static ::mlir::StringAttr getScopeAttrName(::mlir::OperationName name) {
3526 return getAttributeNameForIndex(name, index: 0);
3527 }
3528
3529 static constexpr ::llvm::StringLiteral getOperationName() {
3530 return ::llvm::StringLiteral("llvm.intr.experimental.noalias.scope.decl");
3531 }
3532
3533 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
3534 return {index, 1};
3535 }
3536
3537 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
3538 auto [start, length] = getODSOperandIndexAndLength(index);
3539 return getOperation()->getOperands().slice(n: start, m: length);
3540 }
3541
3542 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
3543 return {index, 1};
3544 }
3545
3546 ::mlir::Operation::result_range getODSResults(unsigned index) {
3547 auto valueRange = getODSResultIndexAndLength(index);
3548 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
3549 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
3550 }
3551
3552 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
3553 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
3554 static llvm::hash_code computePropertiesHash(const Properties &prop);
3555 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
3556 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
3557 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
3558 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
3559 static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state);
3560 void writeProperties(::mlir::DialectBytecodeWriter &writer);
3561 ::mlir::LLVM::AliasScopeAttr getScopeAttr() {
3562 return ::llvm::cast<::mlir::LLVM::AliasScopeAttr>(Val&: getProperties().scope);
3563 }
3564
3565 ::mlir::LLVM::AliasScopeAttr getScope();
3566 void setScopeAttr(::mlir::LLVM::AliasScopeAttr attr) {
3567 getProperties().scope = attr;
3568 }
3569
3570 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::LLVM::AliasScopeAttr scope);
3571 static NoAliasScopeDeclOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::LLVM::AliasScopeAttr scope);
3572 static NoAliasScopeDeclOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::LLVM::AliasScopeAttr scope);
3573 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AliasScopeAttr scope);
3574 static NoAliasScopeDeclOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AliasScopeAttr scope);
3575 static NoAliasScopeDeclOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AliasScopeAttr scope);
3576 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
3577 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3578 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
3579 static NoAliasScopeDeclOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3580 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
3581 static NoAliasScopeDeclOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3582 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3583 static NoAliasScopeDeclOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3584 static NoAliasScopeDeclOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3585 ::llvm::LogicalResult verifyInvariantsImpl();
3586 ::llvm::LogicalResult verifyInvariants();
3587 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
3588 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
3589private:
3590 ::mlir::StringAttr getAttributeNameForIndex(unsigned index) {
3591 return getAttributeNameForIndex(name: (*this)->getName(), index);
3592 }
3593
3594 static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) {
3595 assert(index < 1 && "invalid attribute index");
3596 assert(name.getStringRef() == getOperationName() && "invalid operation name");
3597 assert(name.isRegistered() && "Operation isn't registered, missing a "
3598 "dependent dialect loading?");
3599 return name.getAttributeNames()[index];
3600 }
3601
3602 static void buildPropertiesAndDiscardableAttributes(::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes);
3603public:
3604};
3605
3606} // namespace mlir::LLVM
3607MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::NoAliasScopeDeclOp)
3608MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::NoAliasScopeDeclOpGenericAdaptorBase::Properties)
3609
3610namespace mlir::LLVM {
3611
3612
3613//===----------------------------------------------------------------------===//
3614// ::mlir::LLVM::PtrAnnotation declarations
3615//===----------------------------------------------------------------------===//
3616
3617namespace detail {
3618
3619class PtrAnnotationGenericAdaptorBase {
3620public:
3621 using Properties = ::mlir::EmptyProperties;
3622protected:
3623 ::mlir::DictionaryAttr odsAttrs;
3624 ::std::optional<::mlir::OperationName> odsOpName;
3625 Properties properties;
3626 ::mlir::RegionRange odsRegions;
3627public:
3628 PtrAnnotationGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
3629 odsOpName.emplace(args: "llvm.intr.ptr.annotation", args: odsAttrs.getContext());
3630 }
3631
3632 PtrAnnotationGenericAdaptorBase(PtrAnnotation op);
3633
3634 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
3635 return {index, 1};
3636 }
3637
3638 const Properties &getProperties() {
3639 return properties;
3640 }
3641
3642 ::mlir::DictionaryAttr getAttributes() {
3643 return odsAttrs;
3644 }
3645
3646};
3647
3648} // namespace detail
3649template <typename RangeT>
3650class PtrAnnotationGenericAdaptor : public detail::PtrAnnotationGenericAdaptorBase {
3651 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
3652 using Base = detail::PtrAnnotationGenericAdaptorBase;
3653 static constexpr int odsIndex_ptr = 0;
3654 static constexpr int odsIndex_annotation = 1;
3655 static constexpr int odsIndex_fileName = 2;
3656 static constexpr int odsIndex_line = 3;
3657 static constexpr int odsIndex_attr = 4;
3658public:
3659 PtrAnnotationGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
3660
3661 PtrAnnotationGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : PtrAnnotationGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
3662
3663 PtrAnnotationGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : PtrAnnotationGenericAdaptor(values, attrs, Properties{}, {}) {}
3664
3665 PtrAnnotationGenericAdaptor(RangeT values, const PtrAnnotationGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
3666
3667 template <typename LateInst = PtrAnnotation, typename = std::enable_if_t<std::is_same_v<LateInst, PtrAnnotation>>>
3668 PtrAnnotationGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
3669
3670 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
3671 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
3672 }
3673
3674 RangeT getODSOperands(unsigned index) {
3675 auto valueRange = getODSOperandIndexAndLength(index);
3676 return {std::next(odsOperands.begin(), valueRange.first),
3677 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
3678 }
3679
3680 ValueT getPtr() {
3681 return (*getODSOperands(index: 0).begin());
3682 }
3683
3684 ValueT getAnnotation() {
3685 return (*getODSOperands(index: 1).begin());
3686 }
3687
3688 ValueT getFileName() {
3689 return (*getODSOperands(index: 2).begin());
3690 }
3691
3692 ValueT getLine() {
3693 return (*getODSOperands(index: 3).begin());
3694 }
3695
3696 ValueT getAttr() {
3697 return (*getODSOperands(index: 4).begin());
3698 }
3699
3700 RangeT getOperands() {
3701 return odsOperands;
3702 }
3703
3704private:
3705 RangeT odsOperands;
3706};
3707class PtrAnnotationAdaptor : public PtrAnnotationGenericAdaptor<::mlir::ValueRange> {
3708public:
3709 using PtrAnnotationGenericAdaptor::PtrAnnotationGenericAdaptor;
3710 PtrAnnotationAdaptor(PtrAnnotation op);
3711
3712 ::llvm::LogicalResult verify(::mlir::Location loc);
3713};
3714class PtrAnnotation : public ::mlir::Op<PtrAnnotation, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::LLVM::LLVMPointerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<5>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> {
3715public:
3716 using Op::Op;
3717 using Op::print;
3718 using Adaptor = PtrAnnotationAdaptor;
3719 template <typename RangeT>
3720 using GenericAdaptor = PtrAnnotationGenericAdaptor<RangeT>;
3721 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
3722 static constexpr int odsIndex_ptr = 0;
3723 static constexpr int odsIndex_annotation = 1;
3724 static constexpr int odsIndex_fileName = 2;
3725 static constexpr int odsIndex_line = 3;
3726 static constexpr int odsIndex_attr = 4;
3727 static constexpr int odsIndex_res = 0;
3728 using Properties = FoldAdaptor::Properties;
3729 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
3730 return {};
3731 }
3732
3733 static constexpr ::llvm::StringLiteral getOperationName() {
3734 return ::llvm::StringLiteral("llvm.intr.ptr.annotation");
3735 }
3736
3737 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
3738 return {index, 1};
3739 }
3740
3741 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
3742 auto [start, length] = getODSOperandIndexAndLength(index);
3743 return getOperation()->getOperands().slice(n: start, m: length);
3744 }
3745
3746 ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getPtr() {
3747 return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(Val: *getODSOperands(index: 0).begin());
3748 }
3749
3750 ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getAnnotation() {
3751 return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(Val: *getODSOperands(index: 1).begin());
3752 }
3753
3754 ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getFileName() {
3755 return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(Val: *getODSOperands(index: 2).begin());
3756 }
3757
3758 ::mlir::TypedValue<::mlir::IntegerType> getLine() {
3759 return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(Val: *getODSOperands(index: 3).begin());
3760 }
3761
3762 ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getAttr() {
3763 return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(Val: *getODSOperands(index: 4).begin());
3764 }
3765
3766 ::mlir::OpOperand &getPtrMutable() {
3767 auto range = getODSOperandIndexAndLength(index: 0);
3768 return getOperation()->getOpOperand(idx: range.first);
3769 }
3770
3771 ::mlir::OpOperand &getAnnotationMutable() {
3772 auto range = getODSOperandIndexAndLength(index: 1);
3773 return getOperation()->getOpOperand(idx: range.first);
3774 }
3775
3776 ::mlir::OpOperand &getFileNameMutable() {
3777 auto range = getODSOperandIndexAndLength(index: 2);
3778 return getOperation()->getOpOperand(idx: range.first);
3779 }
3780
3781 ::mlir::OpOperand &getLineMutable() {
3782 auto range = getODSOperandIndexAndLength(index: 3);
3783 return getOperation()->getOpOperand(idx: range.first);
3784 }
3785
3786 ::mlir::OpOperand &getAttrMutable() {
3787 auto range = getODSOperandIndexAndLength(index: 4);
3788 return getOperation()->getOpOperand(idx: range.first);
3789 }
3790
3791 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
3792 return {index, 1};
3793 }
3794
3795 ::mlir::Operation::result_range getODSResults(unsigned index) {
3796 auto valueRange = getODSResultIndexAndLength(index);
3797 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
3798 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
3799 }
3800
3801 ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getRes() {
3802 return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(Val: *getODSResults(index: 0).begin());
3803 }
3804
3805 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
3806 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
3807 static llvm::hash_code computePropertiesHash(const Properties &prop);
3808 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
3809 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
3810 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
3811 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
3812 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value ptr, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
3813 static PtrAnnotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value ptr, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
3814 static PtrAnnotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value ptr, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
3815 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value ptr, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
3816 static PtrAnnotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value ptr, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
3817 static PtrAnnotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value ptr, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
3818 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value ptr, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
3819 static PtrAnnotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value ptr, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
3820 static PtrAnnotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value ptr, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
3821 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3822 static PtrAnnotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3823 static PtrAnnotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3824 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3825 static PtrAnnotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3826 static PtrAnnotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
3827 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3828 static PtrAnnotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3829 static PtrAnnotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3830 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3831 static PtrAnnotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3832 static PtrAnnotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
3833 ::llvm::LogicalResult verifyInvariantsImpl();
3834 ::llvm::LogicalResult verifyInvariants();
3835 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);
3836 static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
3837public:
3838};
3839
3840} // namespace mlir::LLVM
3841MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::PtrAnnotation)
3842
3843namespace mlir::LLVM {
3844
3845
3846//===----------------------------------------------------------------------===//
3847// ::mlir::LLVM::PtrMaskOp declarations
3848//===----------------------------------------------------------------------===//
3849
3850namespace detail {
3851
3852class PtrMaskOpGenericAdaptorBase {
3853public:
3854 using Properties = ::mlir::EmptyProperties;
3855protected:
3856 ::mlir::DictionaryAttr odsAttrs;
3857 ::std::optional<::mlir::OperationName> odsOpName;
3858 Properties properties;
3859 ::mlir::RegionRange odsRegions;
3860public:
3861 PtrMaskOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
3862 odsOpName.emplace(args: "llvm.intr.ptrmask", args: odsAttrs.getContext());
3863 }
3864
3865 PtrMaskOpGenericAdaptorBase(PtrMaskOp op);
3866
3867 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
3868 return {index, 1};
3869 }
3870
3871 const Properties &getProperties() {
3872 return properties;
3873 }
3874
3875 ::mlir::DictionaryAttr getAttributes() {
3876 return odsAttrs;
3877 }
3878
3879};
3880
3881} // namespace detail
3882template <typename RangeT>
3883class PtrMaskOpGenericAdaptor : public detail::PtrMaskOpGenericAdaptorBase {
3884 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
3885 using Base = detail::PtrMaskOpGenericAdaptorBase;
3886 static constexpr int odsIndex_ptr = 0;
3887 static constexpr int odsIndex_mask = 1;
3888public:
3889 PtrMaskOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
3890
3891 PtrMaskOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : PtrMaskOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
3892
3893 PtrMaskOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : PtrMaskOpGenericAdaptor(values, attrs, Properties{}, {}) {}
3894
3895 PtrMaskOpGenericAdaptor(RangeT values, const PtrMaskOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
3896
3897 template <typename LateInst = PtrMaskOp, typename = std::enable_if_t<std::is_same_v<LateInst, PtrMaskOp>>>
3898 PtrMaskOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
3899
3900 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
3901 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
3902 }
3903
3904 RangeT getODSOperands(unsigned index) {
3905 auto valueRange = getODSOperandIndexAndLength(index);
3906 return {std::next(odsOperands.begin(), valueRange.first),
3907 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
3908 }
3909
3910 ValueT getPtr() {
3911 return (*getODSOperands(index: 0).begin());
3912 }
3913
3914 ValueT getMask() {
3915 return (*getODSOperands(index: 1).begin());
3916 }
3917
3918 RangeT getOperands() {
3919 return odsOperands;
3920 }
3921
3922private:
3923 RangeT odsOperands;
3924};
3925class PtrMaskOpAdaptor : public PtrMaskOpGenericAdaptor<::mlir::ValueRange> {
3926public:
3927 using PtrMaskOpGenericAdaptor::PtrMaskOpGenericAdaptor;
3928 PtrMaskOpAdaptor(PtrMaskOp op);
3929
3930 ::llvm::LogicalResult verify(::mlir::Location loc);
3931};
3932class PtrMaskOp : public ::mlir::Op<PtrMaskOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> {
3933public:
3934 using Op::Op;
3935 using Op::print;
3936 using Adaptor = PtrMaskOpAdaptor;
3937 template <typename RangeT>
3938 using GenericAdaptor = PtrMaskOpGenericAdaptor<RangeT>;
3939 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
3940 static constexpr int odsIndex_ptr = 0;
3941 static constexpr int odsIndex_mask = 1;
3942 static constexpr int odsIndex_res = 0;
3943 using Properties = FoldAdaptor::Properties;
3944 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
3945 return {};
3946 }
3947
3948 static constexpr ::llvm::StringLiteral getOperationName() {
3949 return ::llvm::StringLiteral("llvm.intr.ptrmask");
3950 }
3951
3952 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
3953 return {index, 1};
3954 }
3955
3956 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
3957 auto [start, length] = getODSOperandIndexAndLength(index);
3958 return getOperation()->getOperands().slice(n: start, m: length);
3959 }
3960
3961 ::mlir::TypedValue<::mlir::Type> getPtr() {
3962 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSOperands(index: 0).begin());
3963 }
3964
3965 ::mlir::TypedValue<::mlir::Type> getMask() {
3966 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSOperands(index: 1).begin());
3967 }
3968
3969 ::mlir::OpOperand &getPtrMutable() {
3970 auto range = getODSOperandIndexAndLength(index: 0);
3971 return getOperation()->getOpOperand(idx: range.first);
3972 }
3973
3974 ::mlir::OpOperand &getMaskMutable() {
3975 auto range = getODSOperandIndexAndLength(index: 1);
3976 return getOperation()->getOpOperand(idx: range.first);
3977 }
3978
3979 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
3980 return {index, 1};
3981 }
3982
3983 ::mlir::Operation::result_range getODSResults(unsigned index) {
3984 auto valueRange = getODSResultIndexAndLength(index);
3985 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
3986 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
3987 }
3988
3989 ::mlir::TypedValue<::mlir::Type> getRes() {
3990 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSResults(index: 0).begin());
3991 }
3992
3993 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
3994 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
3995 static llvm::hash_code computePropertiesHash(const Properties &prop);
3996 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
3997 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
3998 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
3999 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
4000 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value ptr, ::mlir::Value mask);
4001 static PtrMaskOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value ptr, ::mlir::Value mask);
4002 static PtrMaskOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value ptr, ::mlir::Value mask);
4003 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value ptr, ::mlir::Value mask);
4004 static PtrMaskOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value ptr, ::mlir::Value mask);
4005 static PtrMaskOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value ptr, ::mlir::Value mask);
4006 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value ptr, ::mlir::Value mask);
4007 static PtrMaskOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value ptr, ::mlir::Value mask);
4008 static PtrMaskOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value ptr, ::mlir::Value mask);
4009 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4010 static PtrMaskOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4011 static PtrMaskOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4012 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4013 static PtrMaskOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4014 static PtrMaskOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4015 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4016 static PtrMaskOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4017 static PtrMaskOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4018 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4019 static PtrMaskOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4020 static PtrMaskOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4021 ::llvm::LogicalResult verifyInvariantsImpl();
4022 ::llvm::LogicalResult verifyInvariants();
4023 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);
4024 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
4025 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
4026 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
4027public:
4028};
4029
4030} // namespace mlir::LLVM
4031MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::PtrMaskOp)
4032
4033namespace mlir::LLVM {
4034
4035
4036//===----------------------------------------------------------------------===//
4037// ::mlir::LLVM::SSACopyOp declarations
4038//===----------------------------------------------------------------------===//
4039
4040namespace detail {
4041
4042class SSACopyOpGenericAdaptorBase {
4043public:
4044 using Properties = ::mlir::EmptyProperties;
4045protected:
4046 ::mlir::DictionaryAttr odsAttrs;
4047 ::std::optional<::mlir::OperationName> odsOpName;
4048 Properties properties;
4049 ::mlir::RegionRange odsRegions;
4050public:
4051 SSACopyOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
4052 odsOpName.emplace(args: "llvm.intr.ssa.copy", args: odsAttrs.getContext());
4053 }
4054
4055 SSACopyOpGenericAdaptorBase(SSACopyOp op);
4056
4057 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
4058 return {index, 1};
4059 }
4060
4061 const Properties &getProperties() {
4062 return properties;
4063 }
4064
4065 ::mlir::DictionaryAttr getAttributes() {
4066 return odsAttrs;
4067 }
4068
4069};
4070
4071} // namespace detail
4072template <typename RangeT>
4073class SSACopyOpGenericAdaptor : public detail::SSACopyOpGenericAdaptorBase {
4074 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
4075 using Base = detail::SSACopyOpGenericAdaptorBase;
4076 static constexpr int odsIndex_operand = 0;
4077public:
4078 SSACopyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
4079
4080 SSACopyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : SSACopyOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
4081
4082 SSACopyOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : SSACopyOpGenericAdaptor(values, attrs, Properties{}, {}) {}
4083
4084 SSACopyOpGenericAdaptor(RangeT values, const SSACopyOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
4085
4086 template <typename LateInst = SSACopyOp, typename = std::enable_if_t<std::is_same_v<LateInst, SSACopyOp>>>
4087 SSACopyOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
4088
4089 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
4090 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
4091 }
4092
4093 RangeT getODSOperands(unsigned index) {
4094 auto valueRange = getODSOperandIndexAndLength(index);
4095 return {std::next(odsOperands.begin(), valueRange.first),
4096 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
4097 }
4098
4099 ValueT getOperand() {
4100 return (*getODSOperands(index: 0).begin());
4101 }
4102
4103 RangeT getOperands() {
4104 return odsOperands;
4105 }
4106
4107private:
4108 RangeT odsOperands;
4109};
4110class SSACopyOpAdaptor : public SSACopyOpGenericAdaptor<::mlir::ValueRange> {
4111public:
4112 using SSACopyOpGenericAdaptor::SSACopyOpGenericAdaptor;
4113 SSACopyOpAdaptor(SSACopyOp op);
4114
4115 ::llvm::LogicalResult verify(::mlir::Location loc);
4116};
4117class SSACopyOp : public ::mlir::Op<SSACopyOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::InferTypeOpInterface::Trait> {
4118public:
4119 using Op::Op;
4120 using Op::print;
4121 using Adaptor = SSACopyOpAdaptor;
4122 template <typename RangeT>
4123 using GenericAdaptor = SSACopyOpGenericAdaptor<RangeT>;
4124 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
4125 static constexpr int odsIndex_operand = 0;
4126 static constexpr int odsIndex_res = 0;
4127 using Properties = FoldAdaptor::Properties;
4128 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
4129 return {};
4130 }
4131
4132 static constexpr ::llvm::StringLiteral getOperationName() {
4133 return ::llvm::StringLiteral("llvm.intr.ssa.copy");
4134 }
4135
4136 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
4137 return {index, 1};
4138 }
4139
4140 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
4141 auto [start, length] = getODSOperandIndexAndLength(index);
4142 return getOperation()->getOperands().slice(n: start, m: length);
4143 }
4144
4145 ::mlir::TypedValue<::mlir::Type> getOperand() {
4146 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSOperands(index: 0).begin());
4147 }
4148
4149 ::mlir::OpOperand &getOperandMutable() {
4150 auto range = getODSOperandIndexAndLength(index: 0);
4151 return getOperation()->getOpOperand(idx: range.first);
4152 }
4153
4154 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
4155 return {index, 1};
4156 }
4157
4158 ::mlir::Operation::result_range getODSResults(unsigned index) {
4159 auto valueRange = getODSResultIndexAndLength(index);
4160 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
4161 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
4162 }
4163
4164 ::mlir::TypedValue<::mlir::Type> getRes() {
4165 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSResults(index: 0).begin());
4166 }
4167
4168 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
4169 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
4170 static llvm::hash_code computePropertiesHash(const Properties &prop);
4171 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
4172 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
4173 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
4174 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
4175 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value operand);
4176 static SSACopyOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value operand);
4177 static SSACopyOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value operand);
4178 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand);
4179 static SSACopyOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value operand);
4180 static SSACopyOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value operand);
4181 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand);
4182 static SSACopyOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value operand);
4183 static SSACopyOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value operand);
4184 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4185 static SSACopyOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4186 static SSACopyOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4187 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4188 static SSACopyOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4189 static SSACopyOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4190 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4191 static SSACopyOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4192 static SSACopyOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4193 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4194 static SSACopyOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4195 static SSACopyOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4196 ::llvm::LogicalResult verifyInvariantsImpl();
4197 ::llvm::LogicalResult verifyInvariants();
4198 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);
4199 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
4200 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
4201 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
4202public:
4203};
4204
4205} // namespace mlir::LLVM
4206MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::SSACopyOp)
4207
4208namespace mlir::LLVM {
4209
4210
4211//===----------------------------------------------------------------------===//
4212// ::mlir::LLVM::ThreadlocalAddressOp declarations
4213//===----------------------------------------------------------------------===//
4214
4215namespace detail {
4216
4217class ThreadlocalAddressOpGenericAdaptorBase {
4218public:
4219 using Properties = ::mlir::EmptyProperties;
4220protected:
4221 ::mlir::DictionaryAttr odsAttrs;
4222 ::std::optional<::mlir::OperationName> odsOpName;
4223 Properties properties;
4224 ::mlir::RegionRange odsRegions;
4225public:
4226 ThreadlocalAddressOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
4227 odsOpName.emplace(args: "llvm.intr.threadlocal.address", args: odsAttrs.getContext());
4228 }
4229
4230 ThreadlocalAddressOpGenericAdaptorBase(ThreadlocalAddressOp op);
4231
4232 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
4233 return {index, 1};
4234 }
4235
4236 const Properties &getProperties() {
4237 return properties;
4238 }
4239
4240 ::mlir::DictionaryAttr getAttributes() {
4241 return odsAttrs;
4242 }
4243
4244};
4245
4246} // namespace detail
4247template <typename RangeT>
4248class ThreadlocalAddressOpGenericAdaptor : public detail::ThreadlocalAddressOpGenericAdaptorBase {
4249 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
4250 using Base = detail::ThreadlocalAddressOpGenericAdaptorBase;
4251 static constexpr int odsIndex_global = 0;
4252public:
4253 ThreadlocalAddressOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
4254
4255 ThreadlocalAddressOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ThreadlocalAddressOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
4256
4257 ThreadlocalAddressOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ThreadlocalAddressOpGenericAdaptor(values, attrs, Properties{}, {}) {}
4258
4259 ThreadlocalAddressOpGenericAdaptor(RangeT values, const ThreadlocalAddressOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
4260
4261 template <typename LateInst = ThreadlocalAddressOp, typename = std::enable_if_t<std::is_same_v<LateInst, ThreadlocalAddressOp>>>
4262 ThreadlocalAddressOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
4263
4264 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
4265 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
4266 }
4267
4268 RangeT getODSOperands(unsigned index) {
4269 auto valueRange = getODSOperandIndexAndLength(index);
4270 return {std::next(odsOperands.begin(), valueRange.first),
4271 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
4272 }
4273
4274 ValueT getGlobal() {
4275 return (*getODSOperands(index: 0).begin());
4276 }
4277
4278 RangeT getOperands() {
4279 return odsOperands;
4280 }
4281
4282private:
4283 RangeT odsOperands;
4284};
4285class ThreadlocalAddressOpAdaptor : public ThreadlocalAddressOpGenericAdaptor<::mlir::ValueRange> {
4286public:
4287 using ThreadlocalAddressOpGenericAdaptor::ThreadlocalAddressOpGenericAdaptor;
4288 ThreadlocalAddressOpAdaptor(ThreadlocalAddressOp op);
4289
4290 ::llvm::LogicalResult verify(::mlir::Location loc);
4291};
4292class ThreadlocalAddressOp : public ::mlir::Op<ThreadlocalAddressOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> {
4293public:
4294 using Op::Op;
4295 using Op::print;
4296 using Adaptor = ThreadlocalAddressOpAdaptor;
4297 template <typename RangeT>
4298 using GenericAdaptor = ThreadlocalAddressOpGenericAdaptor<RangeT>;
4299 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
4300 static constexpr int odsIndex_global = 0;
4301 static constexpr int odsIndex_res = 0;
4302 using Properties = FoldAdaptor::Properties;
4303 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
4304 return {};
4305 }
4306
4307 static constexpr ::llvm::StringLiteral getOperationName() {
4308 return ::llvm::StringLiteral("llvm.intr.threadlocal.address");
4309 }
4310
4311 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
4312 return {index, 1};
4313 }
4314
4315 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
4316 auto [start, length] = getODSOperandIndexAndLength(index);
4317 return getOperation()->getOperands().slice(n: start, m: length);
4318 }
4319
4320 ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getGlobal() {
4321 return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(Val: *getODSOperands(index: 0).begin());
4322 }
4323
4324 ::mlir::OpOperand &getGlobalMutable() {
4325 auto range = getODSOperandIndexAndLength(index: 0);
4326 return getOperation()->getOpOperand(idx: range.first);
4327 }
4328
4329 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
4330 return {index, 1};
4331 }
4332
4333 ::mlir::Operation::result_range getODSResults(unsigned index) {
4334 auto valueRange = getODSResultIndexAndLength(index);
4335 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
4336 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
4337 }
4338
4339 ::mlir::TypedValue<::mlir::Type> getRes() {
4340 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSResults(index: 0).begin());
4341 }
4342
4343 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
4344 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
4345 static llvm::hash_code computePropertiesHash(const Properties &prop);
4346 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
4347 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
4348 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
4349 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
4350 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value global);
4351 static ThreadlocalAddressOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value global);
4352 static ThreadlocalAddressOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value global);
4353 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value global);
4354 static ThreadlocalAddressOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value global);
4355 static ThreadlocalAddressOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value global);
4356 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4357 static ThreadlocalAddressOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4358 static ThreadlocalAddressOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4359 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4360 static ThreadlocalAddressOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4361 static ThreadlocalAddressOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4362 ::llvm::LogicalResult verifyInvariantsImpl();
4363 ::llvm::LogicalResult verifyInvariants();
4364 static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
4365 void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
4366public:
4367};
4368
4369} // namespace mlir::LLVM
4370MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ThreadlocalAddressOp)
4371
4372namespace mlir::LLVM {
4373
4374
4375//===----------------------------------------------------------------------===//
4376// ::mlir::LLVM::Trap declarations
4377//===----------------------------------------------------------------------===//
4378
4379namespace detail {
4380
4381class TrapGenericAdaptorBase {
4382public:
4383 using Properties = ::mlir::EmptyProperties;
4384protected:
4385 ::mlir::DictionaryAttr odsAttrs;
4386 ::std::optional<::mlir::OperationName> odsOpName;
4387 Properties properties;
4388 ::mlir::RegionRange odsRegions;
4389public:
4390 TrapGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
4391 odsOpName.emplace(args: "llvm.intr.trap", args: odsAttrs.getContext());
4392 }
4393
4394 TrapGenericAdaptorBase(Trap op);
4395
4396 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
4397 return {index, 1};
4398 }
4399
4400 const Properties &getProperties() {
4401 return properties;
4402 }
4403
4404 ::mlir::DictionaryAttr getAttributes() {
4405 return odsAttrs;
4406 }
4407
4408};
4409
4410} // namespace detail
4411template <typename RangeT>
4412class TrapGenericAdaptor : public detail::TrapGenericAdaptorBase {
4413 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
4414 using Base = detail::TrapGenericAdaptorBase;
4415public:
4416 TrapGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
4417
4418 TrapGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : TrapGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
4419
4420 TrapGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : TrapGenericAdaptor(values, attrs, Properties{}, {}) {}
4421
4422 TrapGenericAdaptor(RangeT values, const TrapGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
4423
4424 template <typename LateInst = Trap, typename = std::enable_if_t<std::is_same_v<LateInst, Trap>>>
4425 TrapGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
4426
4427 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
4428 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
4429 }
4430
4431 RangeT getODSOperands(unsigned index) {
4432 auto valueRange = getODSOperandIndexAndLength(index);
4433 return {std::next(odsOperands.begin(), valueRange.first),
4434 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
4435 }
4436
4437 RangeT getOperands() {
4438 return odsOperands;
4439 }
4440
4441private:
4442 RangeT odsOperands;
4443};
4444class TrapAdaptor : public TrapGenericAdaptor<::mlir::ValueRange> {
4445public:
4446 using TrapGenericAdaptor::TrapGenericAdaptor;
4447 TrapAdaptor(Trap op);
4448
4449 ::llvm::LogicalResult verify(::mlir::Location loc);
4450};
4451class Trap : public ::mlir::Op<Trap, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> {
4452public:
4453 using Op::Op;
4454 using Op::print;
4455 using Adaptor = TrapAdaptor;
4456 template <typename RangeT>
4457 using GenericAdaptor = TrapGenericAdaptor<RangeT>;
4458 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
4459 using Properties = FoldAdaptor::Properties;
4460 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
4461 return {};
4462 }
4463
4464 static constexpr ::llvm::StringLiteral getOperationName() {
4465 return ::llvm::StringLiteral("llvm.intr.trap");
4466 }
4467
4468 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
4469 return {index, 1};
4470 }
4471
4472 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
4473 auto [start, length] = getODSOperandIndexAndLength(index);
4474 return getOperation()->getOperands().slice(n: start, m: length);
4475 }
4476
4477 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
4478 return {index, 1};
4479 }
4480
4481 ::mlir::Operation::result_range getODSResults(unsigned index) {
4482 auto valueRange = getODSResultIndexAndLength(index);
4483 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
4484 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
4485 }
4486
4487 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
4488 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
4489 static llvm::hash_code computePropertiesHash(const Properties &prop);
4490 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
4491 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
4492 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
4493 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
4494 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState);
4495 static Trap create(::mlir::OpBuilder &builder, ::mlir::Location location);
4496 static Trap create(::mlir::ImplicitLocOpBuilder &builder);
4497 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes);
4498 static Trap create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes);
4499 static Trap create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes);
4500 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4501 static Trap create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4502 static Trap create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4503 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4504 static Trap create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4505 static Trap create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4506 ::llvm::LogicalResult verifyInvariantsImpl();
4507 ::llvm::LogicalResult verifyInvariants();
4508 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
4509 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
4510public:
4511};
4512
4513} // namespace mlir::LLVM
4514MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::Trap)
4515
4516namespace mlir::LLVM {
4517
4518
4519//===----------------------------------------------------------------------===//
4520// ::mlir::LLVM::UBSanTrap declarations
4521//===----------------------------------------------------------------------===//
4522
4523namespace detail {
4524
4525class UBSanTrapGenericAdaptorBase {
4526public:
4527 struct Properties {
4528 using failureKindTy = ::mlir::IntegerAttr;
4529 failureKindTy failureKind;
4530
4531 auto getFailureKind() const {
4532 auto &propStorage = this->failureKind;
4533 return ::llvm::cast<::mlir::IntegerAttr>(Val: propStorage);
4534 }
4535 void setFailureKind(const ::mlir::IntegerAttr &propValue) {
4536 this->failureKind = propValue;
4537 }
4538 bool operator==(const Properties &rhs) const {
4539 return
4540 rhs.failureKind == this->failureKind &&
4541 true;
4542 }
4543 bool operator!=(const Properties &rhs) const {
4544 return !(*this == rhs);
4545 }
4546 };
4547protected:
4548 ::mlir::DictionaryAttr odsAttrs;
4549 ::std::optional<::mlir::OperationName> odsOpName;
4550 Properties properties;
4551 ::mlir::RegionRange odsRegions;
4552public:
4553 UBSanTrapGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
4554 odsOpName.emplace(args: "llvm.intr.ubsantrap", args: odsAttrs.getContext());
4555 }
4556
4557 UBSanTrapGenericAdaptorBase(UBSanTrap op);
4558
4559 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
4560 return {index, 1};
4561 }
4562
4563 const Properties &getProperties() {
4564 return properties;
4565 }
4566
4567 ::mlir::DictionaryAttr getAttributes() {
4568 return odsAttrs;
4569 }
4570
4571 ::mlir::IntegerAttr getFailureKindAttr() {
4572 auto attr = ::llvm::cast<::mlir::IntegerAttr>(Val: getProperties().failureKind);
4573 return attr;
4574 }
4575
4576 uint8_t getFailureKind();
4577};
4578
4579} // namespace detail
4580template <typename RangeT>
4581class UBSanTrapGenericAdaptor : public detail::UBSanTrapGenericAdaptorBase {
4582 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
4583 using Base = detail::UBSanTrapGenericAdaptorBase;
4584public:
4585 UBSanTrapGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
4586
4587 UBSanTrapGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : UBSanTrapGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
4588
4589 UBSanTrapGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : UBSanTrapGenericAdaptor(values, attrs, Properties{}, {}) {}
4590
4591 UBSanTrapGenericAdaptor(RangeT values, const UBSanTrapGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
4592
4593 template <typename LateInst = UBSanTrap, typename = std::enable_if_t<std::is_same_v<LateInst, UBSanTrap>>>
4594 UBSanTrapGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
4595
4596 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
4597 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
4598 }
4599
4600 RangeT getODSOperands(unsigned index) {
4601 auto valueRange = getODSOperandIndexAndLength(index);
4602 return {std::next(odsOperands.begin(), valueRange.first),
4603 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
4604 }
4605
4606 RangeT getOperands() {
4607 return odsOperands;
4608 }
4609
4610private:
4611 RangeT odsOperands;
4612};
4613class UBSanTrapAdaptor : public UBSanTrapGenericAdaptor<::mlir::ValueRange> {
4614public:
4615 using UBSanTrapGenericAdaptor::UBSanTrapGenericAdaptor;
4616 UBSanTrapAdaptor(UBSanTrap op);
4617
4618 ::llvm::LogicalResult verify(::mlir::Location loc);
4619};
4620class UBSanTrap : public ::mlir::Op<UBSanTrap, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> {
4621public:
4622 using Op::Op;
4623 using Op::print;
4624 using Adaptor = UBSanTrapAdaptor;
4625 template <typename RangeT>
4626 using GenericAdaptor = UBSanTrapGenericAdaptor<RangeT>;
4627 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
4628 using Properties = FoldAdaptor::Properties;
4629 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
4630 static ::llvm::StringRef attrNames[] = {::llvm::StringRef("failureKind")};
4631 return ::llvm::ArrayRef(attrNames);
4632 }
4633
4634 ::mlir::StringAttr getFailureKindAttrName() {
4635 return getAttributeNameForIndex(index: 0);
4636 }
4637
4638 static ::mlir::StringAttr getFailureKindAttrName(::mlir::OperationName name) {
4639 return getAttributeNameForIndex(name, index: 0);
4640 }
4641
4642 static constexpr ::llvm::StringLiteral getOperationName() {
4643 return ::llvm::StringLiteral("llvm.intr.ubsantrap");
4644 }
4645
4646 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
4647 return {index, 1};
4648 }
4649
4650 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
4651 auto [start, length] = getODSOperandIndexAndLength(index);
4652 return getOperation()->getOperands().slice(n: start, m: length);
4653 }
4654
4655 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
4656 return {index, 1};
4657 }
4658
4659 ::mlir::Operation::result_range getODSResults(unsigned index) {
4660 auto valueRange = getODSResultIndexAndLength(index);
4661 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
4662 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
4663 }
4664
4665 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
4666 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
4667 static llvm::hash_code computePropertiesHash(const Properties &prop);
4668 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
4669 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
4670 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
4671 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
4672 static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state);
4673 void writeProperties(::mlir::DialectBytecodeWriter &writer);
4674 ::mlir::IntegerAttr getFailureKindAttr() {
4675 return ::llvm::cast<::mlir::IntegerAttr>(Val&: getProperties().failureKind);
4676 }
4677
4678 uint8_t getFailureKind();
4679 void setFailureKindAttr(::mlir::IntegerAttr attr) {
4680 getProperties().failureKind = attr;
4681 }
4682
4683 void setFailureKind(uint8_t attrValue);
4684 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr failureKind);
4685 static UBSanTrap create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::IntegerAttr failureKind);
4686 static UBSanTrap create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::IntegerAttr failureKind);
4687 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr failureKind);
4688 static UBSanTrap create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr failureKind);
4689 static UBSanTrap create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr failureKind);
4690 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, uint8_t failureKind);
4691 static UBSanTrap create(::mlir::OpBuilder &builder, ::mlir::Location location, uint8_t failureKind);
4692 static UBSanTrap create(::mlir::ImplicitLocOpBuilder &builder, uint8_t failureKind);
4693 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, uint8_t failureKind);
4694 static UBSanTrap create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, uint8_t failureKind);
4695 static UBSanTrap create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, uint8_t failureKind);
4696 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
4697 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4698 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
4699 static UBSanTrap create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4700 [[deprecated("use the overload taking Properties and discardableAttributes instead")]]
4701 static UBSanTrap create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4702 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4703 static UBSanTrap create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4704 static UBSanTrap create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4705 ::llvm::LogicalResult verifyInvariantsImpl();
4706 ::llvm::LogicalResult verifyInvariants();
4707 static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
4708 LLVM_ATTRIBUTE_MINSIZE void print(::mlir::OpAsmPrinter &_odsPrinter);
4709private:
4710 ::mlir::StringAttr getAttributeNameForIndex(unsigned index) {
4711 return getAttributeNameForIndex(name: (*this)->getName(), index);
4712 }
4713
4714 static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) {
4715 assert(index < 1 && "invalid attribute index");
4716 assert(name.getStringRef() == getOperationName() && "invalid operation name");
4717 assert(name.isRegistered() && "Operation isn't registered, missing a "
4718 "dependent dialect loading?");
4719 return name.getAttributeNames()[index];
4720 }
4721
4722 static void buildPropertiesAndDiscardableAttributes(::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes);
4723public:
4724};
4725
4726} // namespace mlir::LLVM
4727MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::UBSanTrap)
4728MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::UBSanTrapGenericAdaptorBase::Properties)
4729
4730namespace mlir::LLVM {
4731
4732
4733//===----------------------------------------------------------------------===//
4734// ::mlir::LLVM::VarAnnotation declarations
4735//===----------------------------------------------------------------------===//
4736
4737namespace detail {
4738
4739class VarAnnotationGenericAdaptorBase {
4740public:
4741 using Properties = ::mlir::EmptyProperties;
4742protected:
4743 ::mlir::DictionaryAttr odsAttrs;
4744 ::std::optional<::mlir::OperationName> odsOpName;
4745 Properties properties;
4746 ::mlir::RegionRange odsRegions;
4747public:
4748 VarAnnotationGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
4749 odsOpName.emplace(args: "llvm.intr.var.annotation", args: odsAttrs.getContext());
4750 }
4751
4752 VarAnnotationGenericAdaptorBase(VarAnnotation op);
4753
4754 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
4755 return {index, 1};
4756 }
4757
4758 const Properties &getProperties() {
4759 return properties;
4760 }
4761
4762 ::mlir::DictionaryAttr getAttributes() {
4763 return odsAttrs;
4764 }
4765
4766};
4767
4768} // namespace detail
4769template <typename RangeT>
4770class VarAnnotationGenericAdaptor : public detail::VarAnnotationGenericAdaptorBase {
4771 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
4772 using Base = detail::VarAnnotationGenericAdaptorBase;
4773 static constexpr int odsIndex_val = 0;
4774 static constexpr int odsIndex_annotation = 1;
4775 static constexpr int odsIndex_fileName = 2;
4776 static constexpr int odsIndex_line = 3;
4777 static constexpr int odsIndex_attr = 4;
4778public:
4779 VarAnnotationGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
4780
4781 VarAnnotationGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : VarAnnotationGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
4782
4783 VarAnnotationGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : VarAnnotationGenericAdaptor(values, attrs, Properties{}, {}) {}
4784
4785 VarAnnotationGenericAdaptor(RangeT values, const VarAnnotationGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
4786
4787 template <typename LateInst = VarAnnotation, typename = std::enable_if_t<std::is_same_v<LateInst, VarAnnotation>>>
4788 VarAnnotationGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
4789
4790 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
4791 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
4792 }
4793
4794 RangeT getODSOperands(unsigned index) {
4795 auto valueRange = getODSOperandIndexAndLength(index);
4796 return {std::next(odsOperands.begin(), valueRange.first),
4797 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
4798 }
4799
4800 ValueT getVal() {
4801 return (*getODSOperands(index: 0).begin());
4802 }
4803
4804 ValueT getAnnotation() {
4805 return (*getODSOperands(index: 1).begin());
4806 }
4807
4808 ValueT getFileName() {
4809 return (*getODSOperands(index: 2).begin());
4810 }
4811
4812 ValueT getLine() {
4813 return (*getODSOperands(index: 3).begin());
4814 }
4815
4816 ValueT getAttr() {
4817 return (*getODSOperands(index: 4).begin());
4818 }
4819
4820 RangeT getOperands() {
4821 return odsOperands;
4822 }
4823
4824private:
4825 RangeT odsOperands;
4826};
4827class VarAnnotationAdaptor : public VarAnnotationGenericAdaptor<::mlir::ValueRange> {
4828public:
4829 using VarAnnotationGenericAdaptor::VarAnnotationGenericAdaptor;
4830 VarAnnotationAdaptor(VarAnnotation op);
4831
4832 ::llvm::LogicalResult verify(::mlir::Location loc);
4833};
4834class VarAnnotation : public ::mlir::Op<VarAnnotation, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<5>::Impl, ::mlir::OpTrait::OpInvariants> {
4835public:
4836 using Op::Op;
4837 using Op::print;
4838 using Adaptor = VarAnnotationAdaptor;
4839 template <typename RangeT>
4840 using GenericAdaptor = VarAnnotationGenericAdaptor<RangeT>;
4841 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
4842 static constexpr int odsIndex_val = 0;
4843 static constexpr int odsIndex_annotation = 1;
4844 static constexpr int odsIndex_fileName = 2;
4845 static constexpr int odsIndex_line = 3;
4846 static constexpr int odsIndex_attr = 4;
4847 using Properties = FoldAdaptor::Properties;
4848 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
4849 return {};
4850 }
4851
4852 static constexpr ::llvm::StringLiteral getOperationName() {
4853 return ::llvm::StringLiteral("llvm.intr.var.annotation");
4854 }
4855
4856 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
4857 return {index, 1};
4858 }
4859
4860 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
4861 auto [start, length] = getODSOperandIndexAndLength(index);
4862 return getOperation()->getOperands().slice(n: start, m: length);
4863 }
4864
4865 ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getVal() {
4866 return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(Val: *getODSOperands(index: 0).begin());
4867 }
4868
4869 ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getAnnotation() {
4870 return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(Val: *getODSOperands(index: 1).begin());
4871 }
4872
4873 ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getFileName() {
4874 return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(Val: *getODSOperands(index: 2).begin());
4875 }
4876
4877 ::mlir::TypedValue<::mlir::IntegerType> getLine() {
4878 return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(Val: *getODSOperands(index: 3).begin());
4879 }
4880
4881 ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getAttr() {
4882 return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(Val: *getODSOperands(index: 4).begin());
4883 }
4884
4885 ::mlir::OpOperand &getValMutable() {
4886 auto range = getODSOperandIndexAndLength(index: 0);
4887 return getOperation()->getOpOperand(idx: range.first);
4888 }
4889
4890 ::mlir::OpOperand &getAnnotationMutable() {
4891 auto range = getODSOperandIndexAndLength(index: 1);
4892 return getOperation()->getOpOperand(idx: range.first);
4893 }
4894
4895 ::mlir::OpOperand &getFileNameMutable() {
4896 auto range = getODSOperandIndexAndLength(index: 2);
4897 return getOperation()->getOpOperand(idx: range.first);
4898 }
4899
4900 ::mlir::OpOperand &getLineMutable() {
4901 auto range = getODSOperandIndexAndLength(index: 3);
4902 return getOperation()->getOpOperand(idx: range.first);
4903 }
4904
4905 ::mlir::OpOperand &getAttrMutable() {
4906 auto range = getODSOperandIndexAndLength(index: 4);
4907 return getOperation()->getOpOperand(idx: range.first);
4908 }
4909
4910 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
4911 return {index, 1};
4912 }
4913
4914 ::mlir::Operation::result_range getODSResults(unsigned index) {
4915 auto valueRange = getODSResultIndexAndLength(index);
4916 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
4917 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
4918 }
4919
4920 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
4921 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
4922 static llvm::hash_code computePropertiesHash(const Properties &prop);
4923 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
4924 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
4925 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
4926 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
4927 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value val, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
4928 static VarAnnotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value val, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
4929 static VarAnnotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value val, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
4930 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
4931 static VarAnnotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
4932 static VarAnnotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value val, ::mlir::Value annotation, ::mlir::Value fileName, ::mlir::Value line, ::mlir::Value attr);
4933 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4934 static VarAnnotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4935 static VarAnnotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
4936 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4937 static VarAnnotation create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4938 static VarAnnotation create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
4939 ::llvm::LogicalResult verifyInvariantsImpl();
4940 ::llvm::LogicalResult verifyInvariants();
4941 static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
4942public:
4943};
4944
4945} // namespace mlir::LLVM
4946MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::VarAnnotation)
4947
4948namespace mlir::LLVM {
4949
4950
4951//===----------------------------------------------------------------------===//
4952// ::mlir::LLVM::vscale declarations
4953//===----------------------------------------------------------------------===//
4954
4955namespace detail {
4956
4957class vscaleGenericAdaptorBase {
4958public:
4959 using Properties = ::mlir::EmptyProperties;
4960protected:
4961 ::mlir::DictionaryAttr odsAttrs;
4962 ::std::optional<::mlir::OperationName> odsOpName;
4963 Properties properties;
4964 ::mlir::RegionRange odsRegions;
4965public:
4966 vscaleGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs)
4967 odsOpName.emplace(args: "llvm.intr.vscale", args: odsAttrs.getContext());
4968 }
4969
4970 vscaleGenericAdaptorBase(vscale op);
4971
4972 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) {
4973 return {index, 1};
4974 }
4975
4976 const Properties &getProperties() {
4977 return properties;
4978 }
4979
4980 ::mlir::DictionaryAttr getAttributes() {
4981 return odsAttrs;
4982 }
4983
4984};
4985
4986} // namespace detail
4987template <typename RangeT>
4988class vscaleGenericAdaptor : public detail::vscaleGenericAdaptorBase {
4989 using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
4990 using Base = detail::vscaleGenericAdaptorBase;
4991public:
4992 vscaleGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
4993
4994 vscaleGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : vscaleGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
4995
4996 vscaleGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : vscaleGenericAdaptor(values, attrs, Properties{}, {}) {}
4997
4998 vscaleGenericAdaptor(RangeT values, const vscaleGenericAdaptorBase &base) : Base(base), odsOperands(values) {}
4999
5000 template <typename LateInst = vscale, typename = std::enable_if_t<std::is_same_v<LateInst, vscale>>>
5001 vscaleGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
5002
5003 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
5004 return Base::getODSOperandIndexAndLength(index, odsOperandsSize: odsOperands.size());
5005 }
5006
5007 RangeT getODSOperands(unsigned index) {
5008 auto valueRange = getODSOperandIndexAndLength(index);
5009 return {std::next(odsOperands.begin(), valueRange.first),
5010 std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
5011 }
5012
5013 RangeT getOperands() {
5014 return odsOperands;
5015 }
5016
5017private:
5018 RangeT odsOperands;
5019};
5020class vscaleAdaptor : public vscaleGenericAdaptor<::mlir::ValueRange> {
5021public:
5022 using vscaleGenericAdaptor::vscaleGenericAdaptor;
5023 vscaleAdaptor(vscale op);
5024
5025 ::llvm::LogicalResult verify(::mlir::Location loc);
5026};
5027class vscale : public ::mlir::Op<vscale, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> {
5028public:
5029 using Op::Op;
5030 using Op::print;
5031 using Adaptor = vscaleAdaptor;
5032 template <typename RangeT>
5033 using GenericAdaptor = vscaleGenericAdaptor<RangeT>;
5034 using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
5035 static constexpr int odsIndex_res = 0;
5036 using Properties = FoldAdaptor::Properties;
5037 static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
5038 return {};
5039 }
5040
5041 static constexpr ::llvm::StringLiteral getOperationName() {
5042 return ::llvm::StringLiteral("llvm.intr.vscale");
5043 }
5044
5045 std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
5046 return {index, 1};
5047 }
5048
5049 ::mlir::Operation::operand_range getODSOperands(unsigned index) {
5050 auto [start, length] = getODSOperandIndexAndLength(index);
5051 return getOperation()->getOperands().slice(n: start, m: length);
5052 }
5053
5054 std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index) {
5055 return {index, 1};
5056 }
5057
5058 ::mlir::Operation::result_range getODSResults(unsigned index) {
5059 auto valueRange = getODSResultIndexAndLength(index);
5060 return {std::next(x: getOperation()->result_begin(), n: valueRange.first),
5061 std::next(x: getOperation()->result_begin(), n: valueRange.first + valueRange.second)};
5062 }
5063
5064 ::mlir::TypedValue<::mlir::Type> getRes() {
5065 return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(Val: *getODSResults(index: 0).begin());
5066 }
5067
5068 static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
5069 static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
5070 static llvm::hash_code computePropertiesHash(const Properties &prop);
5071 static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
5072 static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
5073 static void walkInherentAttrs(::mlir::MLIRContext *ctx, Properties &prop, ::llvm::function_ref<void(::llvm::StringRef, ::mlir::Attribute &)> visitor);
5074 static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
5075 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res);
5076 static vscale create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res);
5077 static vscale create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res);
5078 static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes);
5079 static vscale create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes);
5080 static vscale create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes);
5081 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
5082 static vscale create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
5083 static vscale create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
5084 static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
5085 static vscale create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
5086 static vscale create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {});
5087 ::llvm::LogicalResult verifyInvariantsImpl();
5088 ::llvm::LogicalResult verifyInvariants();
5089 static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
5090public:
5091};
5092
5093} // namespace mlir::LLVM
5094MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::vscale)
5095
5096
5097#endif // GET_OP_CLASSES
5098
5099namespace mlir::LLVM {
5100
5101void registerLLVMDialectOperations(::mlir::LLVM::LLVMDialect *dialect);
5102void registerLLVMDialectOperationsAggregate(::mlir::LLVM::LLVMDialect *dialect);
5103void registerLLVMDialectOperationsArith(::mlir::LLVM::LLVMDialect *dialect);
5104void registerLLVMDialectOperationsCall(::mlir::LLVM::LLVMDialect *dialect);
5105void registerLLVMDialectOperationsCodeGenIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
5106void registerLLVMDialectOperationsConstant(::mlir::LLVM::LLVMDialect *dialect);
5107void registerLLVMDialectOperationsConstrainedIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
5108void registerLLVMDialectOperationsConversion(::mlir::LLVM::LLVMDialect *dialect);
5109void registerLLVMDialectOperationsCoroIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
5110void registerLLVMDialectOperationsDebugIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
5111void registerLLVMDialectOperationsFloatIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
5112void registerLLVMDialectOperationsGeneralIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
5113void registerLLVMDialectOperationsIntegerIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
5114void registerLLVMDialectOperationsMemory(::mlir::LLVM::LLVMDialect *dialect);
5115void registerLLVMDialectOperationsMemoryIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
5116void registerLLVMDialectOperationsModule(::mlir::LLVM::LLVMDialect *dialect);
5117void registerLLVMDialectOperationsTerminator(::mlir::LLVM::LLVMDialect *dialect);
5118void registerLLVMDialectOperationsVPIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
5119void registerLLVMDialectOperationsVarArg(::mlir::LLVM::LLVMDialect *dialect);
5120void registerLLVMDialectOperationsVector(::mlir::LLVM::LLVMDialect *dialect);
5121void registerLLVMDialectOperationsVectorIntrinsic(::mlir::LLVM::LLVMDialect *dialect);
5122
5123} // namespace mlir::LLVM
5124