1//====- LowerToLLVM.h- Lowering from CIR to LLVM --------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file declares an interface for converting CIR modules to LLVM IR.
10//
11//===----------------------------------------------------------------------===//
12#ifndef CLANG_CIR_LOWERTOLLVM_H
13#define CLANG_CIR_LOWERTOLLVM_H
14
15#include "mlir/Dialect/LLVMIR/LLVMAttrs.h"
16#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
17#include "mlir/Transforms/DialectConversion.h"
18#include "clang/CIR/Dialect/IR/CIRDialect.h"
19
20namespace cir {
21
22namespace direct {
23
24/// Convert a CIR attribute to an LLVM attribute. May use the datalayout for
25/// lowering attributes to-be-stored in memory.
26mlir::Value lowerCirAttrAsValue(mlir::Operation *parentOp, mlir::Attribute attr,
27 mlir::ConversionPatternRewriter &rewriter,
28 const mlir::TypeConverter *converter);
29
30mlir::LLVM::Linkage convertLinkage(cir::GlobalLinkageKind linkage);
31
32void convertSideEffectForCall(mlir::Operation *callOp, bool isNothrow,
33 cir::SideEffect sideEffect,
34 mlir::LLVM::MemoryEffectsAttr &memoryEffect,
35 bool &noUnwind, bool &willReturn);
36
37class CIRToLLVMAssumeOpLowering
38 : public mlir::OpConversionPattern<cir::AssumeOp> {
39public:
40 using mlir::OpConversionPattern<cir::AssumeOp>::OpConversionPattern;
41
42 mlir::LogicalResult
43 matchAndRewrite(cir::AssumeOp op, OpAdaptor,
44 mlir::ConversionPatternRewriter &) const override;
45};
46
47class CIRToLLVMBitClrsbOpLowering
48 : public mlir::OpConversionPattern<cir::BitClrsbOp> {
49public:
50 using mlir::OpConversionPattern<cir::BitClrsbOp>::OpConversionPattern;
51
52 mlir::LogicalResult
53 matchAndRewrite(cir::BitClrsbOp op, OpAdaptor,
54 mlir::ConversionPatternRewriter &) const override;
55};
56
57class CIRToLLVMBitClzOpLowering
58 : public mlir::OpConversionPattern<cir::BitClzOp> {
59public:
60 using mlir::OpConversionPattern<cir::BitClzOp>::OpConversionPattern;
61
62 mlir::LogicalResult
63 matchAndRewrite(cir::BitClzOp op, OpAdaptor,
64 mlir::ConversionPatternRewriter &) const override;
65};
66
67class CIRToLLVMBitCtzOpLowering
68 : public mlir::OpConversionPattern<cir::BitCtzOp> {
69public:
70 using mlir::OpConversionPattern<cir::BitCtzOp>::OpConversionPattern;
71
72 mlir::LogicalResult
73 matchAndRewrite(cir::BitCtzOp op, OpAdaptor,
74 mlir::ConversionPatternRewriter &) const override;
75};
76
77class CIRToLLVMBitParityOpLowering
78 : public mlir::OpConversionPattern<cir::BitParityOp> {
79public:
80 using mlir::OpConversionPattern<cir::BitParityOp>::OpConversionPattern;
81
82 mlir::LogicalResult
83 matchAndRewrite(cir::BitParityOp op, OpAdaptor,
84 mlir::ConversionPatternRewriter &) const override;
85};
86
87class CIRToLLVMBitPopcountOpLowering
88 : public mlir::OpConversionPattern<cir::BitPopcountOp> {
89public:
90 using mlir::OpConversionPattern<cir::BitPopcountOp>::OpConversionPattern;
91
92 mlir::LogicalResult
93 matchAndRewrite(cir::BitPopcountOp op, OpAdaptor,
94 mlir::ConversionPatternRewriter &) const override;
95};
96
97class CIRToLLVMBitReverseOpLowering
98 : public mlir::OpConversionPattern<cir::BitReverseOp> {
99public:
100 using mlir::OpConversionPattern<cir::BitReverseOp>::OpConversionPattern;
101
102 mlir::LogicalResult
103 matchAndRewrite(cir::BitReverseOp op, OpAdaptor,
104 mlir::ConversionPatternRewriter &) const override;
105};
106
107class CIRToLLVMBrCondOpLowering
108 : public mlir::OpConversionPattern<cir::BrCondOp> {
109public:
110 using mlir::OpConversionPattern<cir::BrCondOp>::OpConversionPattern;
111
112 mlir::LogicalResult
113 matchAndRewrite(cir::BrCondOp op, OpAdaptor,
114 mlir::ConversionPatternRewriter &) const override;
115};
116
117class CIRToLLVMByteSwapOpLowering
118 : public mlir::OpConversionPattern<cir::ByteSwapOp> {
119public:
120 using mlir::OpConversionPattern<cir::ByteSwapOp>::OpConversionPattern;
121
122 mlir::LogicalResult
123 matchAndRewrite(cir::ByteSwapOp op, OpAdaptor,
124 mlir::ConversionPatternRewriter &) const override;
125};
126
127class CIRToLLVMCastOpLowering : public mlir::OpConversionPattern<cir::CastOp> {
128 mlir::DataLayout const &dataLayout;
129
130 mlir::Type convertTy(mlir::Type ty) const;
131
132public:
133 CIRToLLVMCastOpLowering(const mlir::TypeConverter &typeConverter,
134 mlir::MLIRContext *context,
135 mlir::DataLayout const &dataLayout)
136 : OpConversionPattern(typeConverter, context), dataLayout(dataLayout) {}
137
138 mlir::LogicalResult
139 matchAndRewrite(cir::CastOp op, OpAdaptor,
140 mlir::ConversionPatternRewriter &) const override;
141};
142
143class CIRToLLVMExpectOpLowering
144 : public mlir::OpConversionPattern<cir::ExpectOp> {
145public:
146 using mlir::OpConversionPattern<cir::ExpectOp>::OpConversionPattern;
147
148 mlir::LogicalResult
149 matchAndRewrite(cir::ExpectOp op, OpAdaptor,
150 mlir::ConversionPatternRewriter &) const override;
151};
152
153class CIRToLLVMReturnOpLowering
154 : public mlir::OpConversionPattern<cir::ReturnOp> {
155public:
156 using mlir::OpConversionPattern<cir::ReturnOp>::OpConversionPattern;
157
158 mlir::LogicalResult
159 matchAndRewrite(cir::ReturnOp op, OpAdaptor,
160 mlir::ConversionPatternRewriter &) const override;
161};
162
163class CIRToLLVMCallOpLowering : public mlir::OpConversionPattern<cir::CallOp> {
164public:
165 using mlir::OpConversionPattern<cir::CallOp>::OpConversionPattern;
166
167 mlir::LogicalResult
168 matchAndRewrite(cir::CallOp op, OpAdaptor adaptor,
169 mlir::ConversionPatternRewriter &rewriter) const override;
170};
171
172class CIRToLLVMAllocaOpLowering
173 : public mlir::OpConversionPattern<cir::AllocaOp> {
174 mlir::DataLayout const &dataLayout;
175
176public:
177 CIRToLLVMAllocaOpLowering(mlir::TypeConverter const &typeConverter,
178 mlir::MLIRContext *context,
179 mlir::DataLayout const &dataLayout)
180 : OpConversionPattern<cir::AllocaOp>(typeConverter, context),
181 dataLayout(dataLayout) {}
182
183 using mlir::OpConversionPattern<cir::AllocaOp>::OpConversionPattern;
184
185 mlir::LogicalResult
186 matchAndRewrite(cir::AllocaOp op, OpAdaptor,
187 mlir::ConversionPatternRewriter &) const override;
188};
189
190class CIRToLLVMLoadOpLowering : public mlir::OpConversionPattern<cir::LoadOp> {
191 mlir::DataLayout const &dataLayout;
192
193public:
194 CIRToLLVMLoadOpLowering(const mlir::TypeConverter &typeConverter,
195 mlir::MLIRContext *context,
196 mlir::DataLayout const &dataLayout)
197 : OpConversionPattern(typeConverter, context), dataLayout(dataLayout) {}
198
199 mlir::LogicalResult
200 matchAndRewrite(cir::LoadOp op, OpAdaptor,
201 mlir::ConversionPatternRewriter &) const override;
202};
203
204class CIRToLLVMStoreOpLowering
205 : public mlir::OpConversionPattern<cir::StoreOp> {
206 mlir::DataLayout const &dataLayout;
207
208public:
209 CIRToLLVMStoreOpLowering(const mlir::TypeConverter &typeConverter,
210 mlir::MLIRContext *context,
211 mlir::DataLayout const &dataLayout)
212 : OpConversionPattern(typeConverter, context), dataLayout(dataLayout) {}
213
214 mlir::LogicalResult
215 matchAndRewrite(cir::StoreOp op, OpAdaptor,
216 mlir::ConversionPatternRewriter &) const override;
217};
218
219class CIRToLLVMConstantOpLowering
220 : public mlir::OpConversionPattern<cir::ConstantOp> {
221public:
222 CIRToLLVMConstantOpLowering(const mlir::TypeConverter &typeConverter,
223 mlir::MLIRContext *context)
224 : OpConversionPattern(typeConverter, context) {
225 setHasBoundedRewriteRecursion();
226 }
227
228 mlir::LogicalResult
229 matchAndRewrite(cir::ConstantOp op, OpAdaptor,
230 mlir::ConversionPatternRewriter &) const override;
231};
232
233class CIRToLLVMFuncOpLowering : public mlir::OpConversionPattern<cir::FuncOp> {
234 static mlir::StringRef getLinkageAttrNameString() { return "linkage"; }
235
236 void lowerFuncAttributes(
237 cir::FuncOp func, bool filterArgAndResAttrs,
238 mlir::SmallVectorImpl<mlir::NamedAttribute> &result) const;
239
240public:
241 using mlir::OpConversionPattern<cir::FuncOp>::OpConversionPattern;
242
243 mlir::LogicalResult
244 matchAndRewrite(cir::FuncOp op, OpAdaptor,
245 mlir::ConversionPatternRewriter &) const override;
246};
247
248class CIRToLLVMSwitchFlatOpLowering
249 : public mlir::OpConversionPattern<cir::SwitchFlatOp> {
250public:
251 using mlir::OpConversionPattern<cir::SwitchFlatOp>::OpConversionPattern;
252
253 mlir::LogicalResult
254 matchAndRewrite(cir::SwitchFlatOp op, OpAdaptor,
255 mlir::ConversionPatternRewriter &) const override;
256};
257
258class CIRToLLVMGetGlobalOpLowering
259 : public mlir::OpConversionPattern<cir::GetGlobalOp> {
260public:
261 using mlir::OpConversionPattern<cir::GetGlobalOp>::OpConversionPattern;
262
263 mlir::LogicalResult
264 matchAndRewrite(cir::GetGlobalOp op, OpAdaptor,
265 mlir::ConversionPatternRewriter &) const override;
266};
267
268class CIRToLLVMGlobalOpLowering
269 : public mlir::OpConversionPattern<cir::GlobalOp> {
270 const mlir::DataLayout &dataLayout;
271
272public:
273 CIRToLLVMGlobalOpLowering(const mlir::TypeConverter &typeConverter,
274 mlir::MLIRContext *context,
275 const mlir::DataLayout &dataLayout)
276 : OpConversionPattern(typeConverter, context), dataLayout(dataLayout) {
277 setHasBoundedRewriteRecursion();
278 }
279
280 mlir::LogicalResult
281 matchAndRewrite(cir::GlobalOp op, OpAdaptor adaptor,
282 mlir::ConversionPatternRewriter &rewriter) const override;
283
284private:
285 mlir::LogicalResult matchAndRewriteRegionInitializedGlobal(
286 cir::GlobalOp op, mlir::Attribute init,
287 mlir::ConversionPatternRewriter &rewriter) const;
288
289 void setupRegionInitializedLLVMGlobalOp(
290 cir::GlobalOp op, mlir::ConversionPatternRewriter &rewriter) const;
291
292 mutable mlir::LLVM::ComdatOp comdatOp = nullptr;
293 mlir::SymbolRefAttr getComdatAttr(cir::GlobalOp &op,
294 mlir::OpBuilder &builder) const;
295};
296
297class CIRToLLVMUnaryOpLowering
298 : public mlir::OpConversionPattern<cir::UnaryOp> {
299public:
300 using mlir::OpConversionPattern<cir::UnaryOp>::OpConversionPattern;
301
302 mlir::LogicalResult
303 matchAndRewrite(cir::UnaryOp op, OpAdaptor,
304 mlir::ConversionPatternRewriter &) const override;
305};
306
307class CIRToLLVMBinOpLowering : public mlir::OpConversionPattern<cir::BinOp> {
308 mlir::LLVM::IntegerOverflowFlags getIntOverflowFlag(cir::BinOp op) const;
309
310public:
311 using mlir::OpConversionPattern<cir::BinOp>::OpConversionPattern;
312
313 mlir::LogicalResult
314 matchAndRewrite(cir::BinOp op, OpAdaptor,
315 mlir::ConversionPatternRewriter &) const override;
316};
317
318class CIRToLLVMCmpOpLowering : public mlir::OpConversionPattern<cir::CmpOp> {
319public:
320 CIRToLLVMCmpOpLowering(const mlir::TypeConverter &typeConverter,
321 mlir::MLIRContext *context)
322 : OpConversionPattern(typeConverter, context) {
323 setHasBoundedRewriteRecursion();
324 }
325
326 mlir::LogicalResult
327 matchAndRewrite(cir::CmpOp op, OpAdaptor,
328 mlir::ConversionPatternRewriter &) const override;
329};
330
331class CIRToLLVMShiftOpLowering
332 : public mlir::OpConversionPattern<cir::ShiftOp> {
333public:
334 using mlir::OpConversionPattern<cir::ShiftOp>::OpConversionPattern;
335
336 mlir::LogicalResult
337 matchAndRewrite(cir::ShiftOp op, OpAdaptor,
338 mlir::ConversionPatternRewriter &) const override;
339};
340
341class CIRToLLVMSelectOpLowering
342 : public mlir::OpConversionPattern<cir::SelectOp> {
343public:
344 using mlir::OpConversionPattern<cir::SelectOp>::OpConversionPattern;
345
346 mlir::LogicalResult
347 matchAndRewrite(cir::SelectOp op, OpAdaptor,
348 mlir::ConversionPatternRewriter &) const override;
349};
350
351class CIRToLLVMBrOpLowering : public mlir::OpConversionPattern<cir::BrOp> {
352public:
353 using mlir::OpConversionPattern<cir::BrOp>::OpConversionPattern;
354
355 mlir::LogicalResult
356 matchAndRewrite(cir::BrOp op, OpAdaptor,
357 mlir::ConversionPatternRewriter &) const override;
358};
359
360class CIRToLLVMGetMemberOpLowering
361 : public mlir::OpConversionPattern<cir::GetMemberOp> {
362public:
363 using mlir::OpConversionPattern<cir::GetMemberOp>::OpConversionPattern;
364
365 mlir::LogicalResult
366 matchAndRewrite(cir::GetMemberOp op, OpAdaptor,
367 mlir::ConversionPatternRewriter &) const override;
368};
369
370class CIRToLLVMTrapOpLowering : public mlir::OpConversionPattern<cir::TrapOp> {
371public:
372 using mlir::OpConversionPattern<cir::TrapOp>::OpConversionPattern;
373
374 mlir::LogicalResult
375 matchAndRewrite(cir::TrapOp op, OpAdaptor,
376 mlir::ConversionPatternRewriter &) const override;
377};
378
379class CIRToLLVMPtrStrideOpLowering
380 : public mlir::OpConversionPattern<cir::PtrStrideOp> {
381 mlir::DataLayout const &dataLayout;
382
383public:
384 CIRToLLVMPtrStrideOpLowering(const mlir::TypeConverter &typeConverter,
385 mlir::MLIRContext *context,
386 mlir::DataLayout const &dataLayout)
387 : OpConversionPattern(typeConverter, context), dataLayout(dataLayout) {}
388 using mlir::OpConversionPattern<cir::PtrStrideOp>::OpConversionPattern;
389
390 mlir::LogicalResult
391 matchAndRewrite(cir::PtrStrideOp op, OpAdaptor,
392 mlir::ConversionPatternRewriter &) const override;
393};
394
395class CIRToLLVMBaseClassAddrOpLowering
396 : public mlir::OpConversionPattern<cir::BaseClassAddrOp> {
397public:
398 using mlir::OpConversionPattern<cir::BaseClassAddrOp>::OpConversionPattern;
399
400 mlir::LogicalResult
401 matchAndRewrite(cir::BaseClassAddrOp op, OpAdaptor,
402 mlir::ConversionPatternRewriter &) const override;
403};
404
405class CIRToLLVMStackSaveOpLowering
406 : public mlir::OpConversionPattern<cir::StackSaveOp> {
407public:
408 using mlir::OpConversionPattern<cir::StackSaveOp>::OpConversionPattern;
409
410 mlir::LogicalResult
411 matchAndRewrite(cir::StackSaveOp op, OpAdaptor,
412 mlir::ConversionPatternRewriter &) const override;
413};
414
415class CIRToLLVMStackRestoreOpLowering
416 : public mlir::OpConversionPattern<cir::StackRestoreOp> {
417public:
418 using OpConversionPattern<cir::StackRestoreOp>::OpConversionPattern;
419
420 mlir::LogicalResult
421 matchAndRewrite(cir::StackRestoreOp op, OpAdaptor adaptor,
422 mlir::ConversionPatternRewriter &rewriter) const override;
423};
424
425class CIRToLLVMVecCreateOpLowering
426 : public mlir::OpConversionPattern<cir::VecCreateOp> {
427public:
428 using mlir::OpConversionPattern<cir::VecCreateOp>::OpConversionPattern;
429
430 mlir::LogicalResult
431 matchAndRewrite(cir::VecCreateOp op, OpAdaptor,
432 mlir::ConversionPatternRewriter &) const override;
433};
434
435class CIRToLLVMVecExtractOpLowering
436 : public mlir::OpConversionPattern<cir::VecExtractOp> {
437public:
438 using mlir::OpConversionPattern<cir::VecExtractOp>::OpConversionPattern;
439
440 mlir::LogicalResult
441 matchAndRewrite(cir::VecExtractOp op, OpAdaptor,
442 mlir::ConversionPatternRewriter &) const override;
443};
444
445class CIRToLLVMVecInsertOpLowering
446 : public mlir::OpConversionPattern<cir::VecInsertOp> {
447public:
448 using mlir::OpConversionPattern<cir::VecInsertOp>::OpConversionPattern;
449
450 mlir::LogicalResult
451 matchAndRewrite(cir::VecInsertOp op, OpAdaptor,
452 mlir::ConversionPatternRewriter &) const override;
453};
454
455class CIRToLLVMVecCmpOpLowering
456 : public mlir::OpConversionPattern<cir::VecCmpOp> {
457public:
458 using mlir::OpConversionPattern<cir::VecCmpOp>::OpConversionPattern;
459
460 mlir::LogicalResult
461 matchAndRewrite(cir::VecCmpOp op, OpAdaptor,
462 mlir::ConversionPatternRewriter &) const override;
463};
464
465class CIRToLLVMVecSplatOpLowering
466 : public mlir::OpConversionPattern<cir::VecSplatOp> {
467public:
468 using mlir::OpConversionPattern<cir::VecSplatOp>::OpConversionPattern;
469
470 mlir::LogicalResult
471 matchAndRewrite(cir::VecSplatOp op, OpAdaptor,
472 mlir::ConversionPatternRewriter &) const override;
473};
474
475class CIRToLLVMVecShuffleOpLowering
476 : public mlir::OpConversionPattern<cir::VecShuffleOp> {
477public:
478 using mlir::OpConversionPattern<cir::VecShuffleOp>::OpConversionPattern;
479
480 mlir::LogicalResult
481 matchAndRewrite(cir::VecShuffleOp op, OpAdaptor,
482 mlir::ConversionPatternRewriter &) const override;
483};
484
485class CIRToLLVMVecShuffleDynamicOpLowering
486 : public mlir::OpConversionPattern<cir::VecShuffleDynamicOp> {
487public:
488 using mlir::OpConversionPattern<
489 cir::VecShuffleDynamicOp>::OpConversionPattern;
490
491 mlir::LogicalResult
492 matchAndRewrite(cir::VecShuffleDynamicOp op, OpAdaptor,
493 mlir::ConversionPatternRewriter &) const override;
494};
495
496class CIRToLLVMVecTernaryOpLowering
497 : public mlir::OpConversionPattern<cir::VecTernaryOp> {
498public:
499 using mlir::OpConversionPattern<cir::VecTernaryOp>::OpConversionPattern;
500
501 mlir::LogicalResult
502 matchAndRewrite(cir::VecTernaryOp op, OpAdaptor,
503 mlir::ConversionPatternRewriter &) const override;
504};
505
506class CIRToLLVMComplexCreateOpLowering
507 : public mlir::OpConversionPattern<cir::ComplexCreateOp> {
508public:
509 using mlir::OpConversionPattern<cir::ComplexCreateOp>::OpConversionPattern;
510
511 mlir::LogicalResult
512 matchAndRewrite(cir::ComplexCreateOp op, OpAdaptor,
513 mlir::ConversionPatternRewriter &) const override;
514};
515
516class CIRToLLVMComplexRealOpLowering
517 : public mlir::OpConversionPattern<cir::ComplexRealOp> {
518public:
519 using mlir::OpConversionPattern<cir::ComplexRealOp>::OpConversionPattern;
520
521 mlir::LogicalResult
522 matchAndRewrite(cir::ComplexRealOp op, OpAdaptor,
523 mlir::ConversionPatternRewriter &) const override;
524};
525
526class CIRToLLVMComplexImagOpLowering
527 : public mlir::OpConversionPattern<cir::ComplexImagOp> {
528public:
529 using mlir::OpConversionPattern<cir::ComplexImagOp>::OpConversionPattern;
530
531 mlir::LogicalResult
532 matchAndRewrite(cir::ComplexImagOp op, OpAdaptor,
533 mlir::ConversionPatternRewriter &) const override;
534};
535
536class CIRToLLVMComplexImagPtrOpLowering
537 : public mlir::OpConversionPattern<cir::ComplexImagPtrOp> {
538public:
539 using mlir::OpConversionPattern<cir::ComplexImagPtrOp>::OpConversionPattern;
540
541 mlir::LogicalResult
542 matchAndRewrite(cir::ComplexImagPtrOp op, OpAdaptor,
543 mlir::ConversionPatternRewriter &) const override;
544};
545
546class CIRToLLVMComplexRealPtrOpLowering
547 : public mlir::OpConversionPattern<cir::ComplexRealPtrOp> {
548public:
549 using mlir::OpConversionPattern<cir::ComplexRealPtrOp>::OpConversionPattern;
550
551 mlir::LogicalResult
552 matchAndRewrite(cir::ComplexRealPtrOp op, OpAdaptor,
553 mlir::ConversionPatternRewriter &) const override;
554};
555
556class CIRToLLVMComplexAddOpLowering
557 : public mlir::OpConversionPattern<cir::ComplexAddOp> {
558public:
559 using mlir::OpConversionPattern<cir::ComplexAddOp>::OpConversionPattern;
560
561 mlir::LogicalResult
562 matchAndRewrite(cir::ComplexAddOp op, OpAdaptor,
563 mlir::ConversionPatternRewriter &) const override;
564};
565
566class CIRToLLVMComplexSubOpLowering
567 : public mlir::OpConversionPattern<cir::ComplexSubOp> {
568public:
569 using mlir::OpConversionPattern<cir::ComplexSubOp>::OpConversionPattern;
570
571 mlir::LogicalResult
572 matchAndRewrite(cir::ComplexSubOp op, OpAdaptor,
573 mlir::ConversionPatternRewriter &) const override;
574};
575
576class CIRToLLVMSetBitfieldOpLowering
577 : public mlir::OpConversionPattern<cir::SetBitfieldOp> {
578public:
579 using mlir::OpConversionPattern<cir::SetBitfieldOp>::OpConversionPattern;
580
581 mlir::LogicalResult
582 matchAndRewrite(cir::SetBitfieldOp op, OpAdaptor,
583 mlir::ConversionPatternRewriter &) const override;
584};
585
586class CIRToLLVMGetBitfieldOpLowering
587 : public mlir::OpConversionPattern<cir::GetBitfieldOp> {
588public:
589 using mlir::OpConversionPattern<cir::GetBitfieldOp>::OpConversionPattern;
590
591 mlir::LogicalResult
592 matchAndRewrite(cir::GetBitfieldOp op, OpAdaptor,
593 mlir::ConversionPatternRewriter &) const override;
594};
595
596} // namespace direct
597} // namespace cir
598
599#endif // CLANG_CIR_LOWERTOLLVM_H
600

source code of clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.h