clang 22.0.0git
CIRGenBuilder.h
Go to the documentation of this file.
1//===----------------------------------------------------------------------===//
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#ifndef LLVM_CLANG_LIB_CIR_CODEGEN_CIRGENBUILDER_H
10#define LLVM_CLANG_LIB_CIR_CODEGEN_CIRGENBUILDER_H
11
12#include "Address.h"
13#include "CIRGenRecordLayout.h"
14#include "CIRGenTypeCache.h"
15#include "mlir/IR/Attributes.h"
16#include "mlir/IR/BuiltinAttributes.h"
17#include "mlir/Support/LLVM.h"
20
23#include "llvm/ADT/APFloat.h"
24#include "llvm/ADT/STLExtras.h"
25
26namespace clang::CIRGen {
27
29 const CIRGenTypeCache &typeCache;
30 llvm::StringMap<unsigned> recordNames;
31 llvm::StringMap<unsigned> globalsVersioning;
32
33public:
34 CIRGenBuilderTy(mlir::MLIRContext &mlirContext, const CIRGenTypeCache &tc)
35 : CIRBaseBuilderTy(mlirContext), typeCache(tc) {}
36
37 /// Get a cir::ConstArrayAttr for a string literal.
38 /// Note: This is different from what is returned by
39 /// mlir::Builder::getStringAttr() which is an mlir::StringAttr.
40 mlir::Attribute getString(llvm::StringRef str, mlir::Type eltTy,
41 std::optional<size_t> size) {
42 size_t finalSize = size.value_or(str.size());
43
44 size_t lastNonZeroPos = str.find_last_not_of('\0');
45 // If the string is full of null bytes, emit a #cir.zero rather than
46 // a #cir.const_array.
47 if (lastNonZeroPos == llvm::StringRef::npos) {
48 auto arrayTy = cir::ArrayType::get(eltTy, finalSize);
49 return cir::ZeroAttr::get(arrayTy);
50 }
51 // We emit trailing zeros only if there are multiple trailing zeros.
52 size_t trailingZerosNum = 0;
53 if (finalSize > lastNonZeroPos + 2)
54 trailingZerosNum = finalSize - lastNonZeroPos - 1;
55 auto truncatedArrayTy =
56 cir::ArrayType::get(eltTy, finalSize - trailingZerosNum);
57 auto fullArrayTy = cir::ArrayType::get(eltTy, finalSize);
58 return cir::ConstArrayAttr::get(
59 fullArrayTy,
60 mlir::StringAttr::get(str.drop_back(trailingZerosNum),
61 truncatedArrayTy),
62 trailingZerosNum);
63 }
64
65 cir::ConstArrayAttr getConstArray(mlir::Attribute attrs,
66 cir::ArrayType arrayTy) const {
67 return cir::ConstArrayAttr::get(arrayTy, attrs);
68 }
69
70 mlir::Attribute getConstRecordOrZeroAttr(mlir::ArrayAttr arrayAttr,
71 bool packed = false,
72 bool padded = false,
73 mlir::Type type = {});
74
75 cir::ConstRecordAttr getAnonConstRecord(mlir::ArrayAttr arrayAttr,
76 bool packed = false,
77 bool padded = false,
78 mlir::Type ty = {}) {
80 for (auto &f : arrayAttr) {
81 auto ta = mlir::cast<mlir::TypedAttr>(f);
82 members.push_back(ta.getType());
83 }
84
85 if (!ty)
86 ty = getAnonRecordTy(members, packed, padded);
87
88 auto sTy = mlir::cast<cir::RecordType>(ty);
89 return cir::ConstRecordAttr::get(sTy, arrayAttr);
90 }
91
92 cir::TypeInfoAttr getTypeInfo(mlir::ArrayAttr fieldsAttr) {
93 cir::ConstRecordAttr anonRecord = getAnonConstRecord(fieldsAttr);
94 return cir::TypeInfoAttr::get(anonRecord.getType(), fieldsAttr);
95 }
96
97 std::string getUniqueAnonRecordName() { return getUniqueRecordName("anon"); }
98
99 std::string getUniqueRecordName(const std::string &baseName) {
100 auto it = recordNames.find(baseName);
101 if (it == recordNames.end()) {
102 recordNames[baseName] = 0;
103 return baseName;
104 }
105
106 return baseName + "." + std::to_string(recordNames[baseName]++);
107 }
108
109 cir::LongDoubleType getLongDoubleTy(const llvm::fltSemantics &format) const {
110 if (&format == &llvm::APFloat::IEEEdouble())
111 return cir::LongDoubleType::get(getContext(), typeCache.DoubleTy);
112 if (&format == &llvm::APFloat::x87DoubleExtended())
113 return cir::LongDoubleType::get(getContext(), typeCache.FP80Ty);
114 if (&format == &llvm::APFloat::IEEEquad())
115 return cir::LongDoubleType::get(getContext(), typeCache.FP128Ty);
116 if (&format == &llvm::APFloat::PPCDoubleDouble())
117 llvm_unreachable("NYI: PPC double-double format for long double");
118 llvm_unreachable("Unsupported format for long double");
119 }
120
121 mlir::Type getPtrToVPtrType() {
122 return getPointerTo(cir::VPtrType::get(getContext()));
123 }
124
125 cir::FuncType getFuncType(llvm::ArrayRef<mlir::Type> params, mlir::Type retTy,
126 bool isVarArg = false) {
127 return cir::FuncType::get(params, retTy, isVarArg);
128 }
129
130 /// Get a CIR record kind from a AST declaration tag.
131 cir::RecordType::RecordKind getRecordKind(const clang::TagTypeKind kind) {
132 switch (kind) {
134 return cir::RecordType::Class;
136 return cir::RecordType::Struct;
138 return cir::RecordType::Union;
140 llvm_unreachable("interface records are NYI");
142 llvm_unreachable("enums are not records");
143 }
144 llvm_unreachable("Unsupported record kind");
145 }
146
147 /// Get a CIR named record type.
148 ///
149 /// If a record already exists and is complete, but the client tries to fetch
150 /// it with a different set of attributes, this method will crash.
152 bool packed, bool padded,
153 llvm::StringRef name) {
154 const auto nameAttr = getStringAttr(name);
155 auto kind = cir::RecordType::RecordKind::Struct;
157
158 // Create or get the record.
159 auto type =
160 getType<cir::RecordType>(members, nameAttr, packed, padded, kind);
161
162 // If we found an existing type, verify that either it is incomplete or
163 // it matches the requested attributes.
164 assert(!type.isIncomplete() ||
165 (type.getMembers() == members && type.getPacked() == packed &&
166 type.getPadded() == padded));
167
168 // Complete an incomplete record or ensure the existing complete record
169 // matches the requested attributes.
170 type.complete(members, packed, padded);
171
172 return type;
173 }
174
175 cir::RecordType getCompleteRecordType(mlir::ArrayAttr fields,
176 bool packed = false,
177 bool padded = false,
178 llvm::StringRef name = "");
179
180 /// Get an incomplete CIR struct type. If we have a complete record
181 /// declaration, we may create an incomplete type and then add the
182 /// members, so \p rd here may be complete.
183 cir::RecordType getIncompleteRecordTy(llvm::StringRef name,
184 const clang::RecordDecl *rd) {
185 const mlir::StringAttr nameAttr = getStringAttr(name);
186 cir::RecordType::RecordKind kind = cir::RecordType::RecordKind::Struct;
187 if (rd)
188 kind = getRecordKind(rd->getTagKind());
189 return getType<cir::RecordType>(nameAttr, kind);
190 }
191
192 // Return true if the value is a null constant such as null pointer, (+0.0)
193 // for floating-point or zero initializer
194 bool isNullValue(mlir::Attribute attr) const {
195 if (mlir::isa<cir::ZeroAttr>(attr))
196 return true;
197
198 if (const auto ptrVal = mlir::dyn_cast<cir::ConstPtrAttr>(attr))
199 return ptrVal.isNullValue();
200
201 if (const auto intVal = mlir::dyn_cast<cir::IntAttr>(attr))
202 return intVal.isNullValue();
203
204 if (const auto boolVal = mlir::dyn_cast<cir::BoolAttr>(attr))
205 return !boolVal.getValue();
206
207 if (auto fpAttr = mlir::dyn_cast<cir::FPAttr>(attr)) {
208 auto fpVal = fpAttr.getValue();
209 bool ignored;
210 llvm::APFloat fv(+0.0);
211 fv.convert(fpVal.getSemantics(), llvm::APFloat::rmNearestTiesToEven,
212 &ignored);
213 return fv.bitwiseIsEqual(fpVal);
214 }
215
216 if (const auto arrayVal = mlir::dyn_cast<cir::ConstArrayAttr>(attr)) {
217 if (mlir::isa<mlir::StringAttr>(arrayVal.getElts()))
218 return false;
219
220 return llvm::all_of(
221 mlir::cast<mlir::ArrayAttr>(arrayVal.getElts()),
222 [&](const mlir::Attribute &elt) { return isNullValue(elt); });
223 }
224 return false;
225 }
226
227 //
228 // Type helpers
229 // ------------
230 //
231 cir::IntType getUIntNTy(int n) {
232 switch (n) {
233 case 8:
234 return getUInt8Ty();
235 case 16:
236 return getUInt16Ty();
237 case 32:
238 return getUInt32Ty();
239 case 64:
240 return getUInt64Ty();
241 default:
242 return cir::IntType::get(getContext(), n, false);
243 }
244 }
245
246 cir::IntType getSIntNTy(int n) {
247 switch (n) {
248 case 8:
249 return getSInt8Ty();
250 case 16:
251 return getSInt16Ty();
252 case 32:
253 return getSInt32Ty();
254 case 64:
255 return getSInt64Ty();
256 default:
257 return cir::IntType::get(getContext(), n, true);
258 }
259 }
260
261 cir::VoidType getVoidTy() { return typeCache.VoidTy; }
262
263 cir::IntType getSInt8Ty() { return typeCache.SInt8Ty; }
264 cir::IntType getSInt16Ty() { return typeCache.SInt16Ty; }
265 cir::IntType getSInt32Ty() { return typeCache.SInt32Ty; }
266 cir::IntType getSInt64Ty() { return typeCache.SInt64Ty; }
267
268 cir::IntType getUInt8Ty() { return typeCache.UInt8Ty; }
269 cir::IntType getUInt16Ty() { return typeCache.UInt16Ty; }
270 cir::IntType getUInt32Ty() { return typeCache.UInt32Ty; }
271 cir::IntType getUInt64Ty() { return typeCache.UInt64Ty; }
272
273 cir::ConstantOp getConstInt(mlir::Location loc, llvm::APSInt intVal);
274
275 cir::ConstantOp getConstInt(mlir::Location loc, llvm::APInt intVal);
276
277 cir::ConstantOp getConstInt(mlir::Location loc, mlir::Type t, uint64_t c);
278
279 cir::ConstantOp getConstFP(mlir::Location loc, mlir::Type t,
280 llvm::APFloat fpVal);
281
282 bool isInt8Ty(mlir::Type i) {
283 return i == typeCache.UInt8Ty || i == typeCache.SInt8Ty;
284 }
285 bool isInt16Ty(mlir::Type i) {
286 return i == typeCache.UInt16Ty || i == typeCache.SInt16Ty;
287 }
288 bool isInt32Ty(mlir::Type i) {
289 return i == typeCache.UInt32Ty || i == typeCache.SInt32Ty;
290 }
291 bool isInt64Ty(mlir::Type i) {
292 return i == typeCache.UInt64Ty || i == typeCache.SInt64Ty;
293 }
294 bool isInt(mlir::Type i) { return mlir::isa<cir::IntType>(i); }
295
296 // Fetch the type representing a pointer to unsigned int8 values.
297 cir::PointerType getUInt8PtrTy() { return typeCache.UInt8PtrTy; }
298
299 /// Get a CIR anonymous record type.
301 bool packed = false, bool padded = false) {
303 auto kind = cir::RecordType::RecordKind::Struct;
304 return getType<cir::RecordType>(members, packed, padded, kind);
305 }
306
307 //
308 // Constant creation helpers
309 // -------------------------
310 //
311 cir::ConstantOp getSInt32(int32_t c, mlir::Location loc) {
312 return getConstantInt(loc, getSInt32Ty(), c);
313 }
314 cir::ConstantOp getUInt32(uint32_t c, mlir::Location loc) {
315 return getConstantInt(loc, getUInt32Ty(), c);
316 }
317 cir::ConstantOp getSInt64(uint64_t c, mlir::Location loc) {
318 cir::IntType sInt64Ty = getSInt64Ty();
319 return cir::ConstantOp::create(*this, loc, cir::IntAttr::get(sInt64Ty, c));
320 }
321
322 mlir::Value createNeg(mlir::Value value) {
323
324 if (auto intTy = mlir::dyn_cast<cir::IntType>(value.getType())) {
325 // Source is a unsigned integer: first cast it to signed.
326 if (intTy.isUnsigned())
327 value = createIntCast(value, getSIntNTy(intTy.getWidth()));
328 return cir::UnaryOp::create(*this, value.getLoc(), value.getType(),
329 cir::UnaryOpKind::Minus, value);
330 }
331
332 llvm_unreachable("negation for the given type is NYI");
333 }
334
335 // TODO: split this to createFPExt/createFPTrunc when we have dedicated cast
336 // operations.
337 mlir::Value createFloatingCast(mlir::Value v, mlir::Type destType) {
339
340 return cir::CastOp::create(*this, v.getLoc(), destType,
341 cir::CastKind::floating, v);
342 }
343
344 mlir::Value createFSub(mlir::Location loc, mlir::Value lhs, mlir::Value rhs) {
348
349 return cir::BinOp::create(*this, loc, cir::BinOpKind::Sub, lhs, rhs);
350 }
351
352 mlir::Value createFAdd(mlir::Location loc, mlir::Value lhs, mlir::Value rhs) {
356
357 return cir::BinOp::create(*this, loc, cir::BinOpKind::Add, lhs, rhs);
358 }
359 mlir::Value createFMul(mlir::Location loc, mlir::Value lhs, mlir::Value rhs) {
363
364 return cir::BinOp::create(*this, loc, cir::BinOpKind::Mul, lhs, rhs);
365 }
366 mlir::Value createFDiv(mlir::Location loc, mlir::Value lhs, mlir::Value rhs) {
370
371 return cir::BinOp::create(*this, loc, cir::BinOpKind::Div, lhs, rhs);
372 }
373
374 mlir::Value createDynCast(mlir::Location loc, mlir::Value src,
375 cir::PointerType destType, bool isRefCast,
376 cir::DynamicCastInfoAttr info) {
377 auto castKind =
378 isRefCast ? cir::DynamicCastKind::Ref : cir::DynamicCastKind::Ptr;
379 return cir::DynamicCastOp::create(*this, loc, destType, castKind, src, info,
380 /*relative_layout=*/false);
381 }
382
383 mlir::Value createDynCastToVoid(mlir::Location loc, mlir::Value src,
384 bool vtableUseRelativeLayout) {
385 // TODO(cir): consider address space here.
387 cir::PointerType destTy = getVoidPtrTy();
388 return cir::DynamicCastOp::create(
389 *this, loc, destTy, cir::DynamicCastKind::Ptr, src,
390 cir::DynamicCastInfoAttr{}, vtableUseRelativeLayout);
391 }
392
393 Address createBaseClassAddr(mlir::Location loc, Address addr,
394 mlir::Type destType, unsigned offset,
395 bool assumeNotNull) {
396 if (destType == addr.getElementType())
397 return addr;
398
399 auto ptrTy = getPointerTo(destType);
400 auto baseAddr =
401 cir::BaseClassAddrOp::create(*this, loc, ptrTy, addr.getPointer(),
402 mlir::APInt(64, offset), assumeNotNull);
403 return Address(baseAddr, destType, addr.getAlignment());
404 }
405
406 mlir::Value createVTTAddrPoint(mlir::Location loc, mlir::Type retTy,
407 mlir::Value addr, uint64_t offset) {
408 return cir::VTTAddrPointOp::create(*this, loc, retTy,
409 mlir::FlatSymbolRefAttr{}, addr, offset);
410 }
411
412 mlir::Value createVTTAddrPoint(mlir::Location loc, mlir::Type retTy,
413 mlir::FlatSymbolRefAttr sym, uint64_t offset) {
414 return cir::VTTAddrPointOp::create(*this, loc, retTy, sym, mlir::Value{},
415 offset);
416 }
417
418 /// Cast the element type of the given address to a different type,
419 /// preserving information like the alignment.
420 Address createElementBitCast(mlir::Location loc, Address addr,
421 mlir::Type destType) {
422 if (destType == addr.getElementType())
423 return addr;
424
425 auto ptrTy = getPointerTo(destType);
426 return Address(createBitcast(loc, addr.getPointer(), ptrTy), destType,
427 addr.getAlignment());
428 }
429
430 cir::LoadOp createLoad(mlir::Location loc, Address addr,
431 bool isVolatile = false) {
432 mlir::IntegerAttr align = getAlignmentAttr(addr.getAlignment());
433 return cir::LoadOp::create(*this, loc, addr.getPointer(), /*isDeref=*/false,
434 isVolatile, /*alignment=*/align,
435 /*mem_order=*/cir::MemOrderAttr{});
436 }
437
438 cir::LoadOp createAlignedLoad(mlir::Location loc, mlir::Type ty,
439 mlir::Value ptr, llvm::MaybeAlign align) {
440 if (ty != mlir::cast<cir::PointerType>(ptr.getType()).getPointee())
441 ptr = createPtrBitcast(ptr, ty);
442 uint64_t alignment = align ? align->value() : 0;
443 mlir::IntegerAttr alignAttr = getAlignmentAttr(alignment);
444 return cir::LoadOp::create(*this, loc, ptr, /*isDeref=*/false,
445 /*isVolatile=*/false, alignAttr,
446 /*mem_order=*/cir::MemOrderAttr{});
447 }
448
449 cir::LoadOp
450 createAlignedLoad(mlir::Location loc, mlir::Type ty, mlir::Value ptr,
452 return createAlignedLoad(loc, ty, ptr, align.getAsAlign());
453 }
454
455 cir::StoreOp createStore(mlir::Location loc, mlir::Value val, Address dst,
456 bool isVolatile = false,
457 mlir::IntegerAttr align = {},
458 cir::MemOrderAttr order = {}) {
459 if (!align)
460 align = getAlignmentAttr(dst.getAlignment());
461 return CIRBaseBuilderTy::createStore(loc, val, dst.getPointer(), isVolatile,
462 align, order);
463 }
464
465 /// Create a cir.complex.real_ptr operation that derives a pointer to the real
466 /// part of the complex value pointed to by the specified pointer value.
467 mlir::Value createComplexRealPtr(mlir::Location loc, mlir::Value value) {
468 auto srcPtrTy = mlir::cast<cir::PointerType>(value.getType());
469 auto srcComplexTy = mlir::cast<cir::ComplexType>(srcPtrTy.getPointee());
470 return cir::ComplexRealPtrOp::create(
471 *this, loc, getPointerTo(srcComplexTy.getElementType()), value);
472 }
473
474 Address createComplexRealPtr(mlir::Location loc, Address addr) {
475 return Address{createComplexRealPtr(loc, addr.getPointer()),
476 addr.getAlignment()};
477 }
478
479 /// Create a cir.complex.imag_ptr operation that derives a pointer to the
480 /// imaginary part of the complex value pointed to by the specified pointer
481 /// value.
482 mlir::Value createComplexImagPtr(mlir::Location loc, mlir::Value value) {
483 auto srcPtrTy = mlir::cast<cir::PointerType>(value.getType());
484 auto srcComplexTy = mlir::cast<cir::ComplexType>(srcPtrTy.getPointee());
485 return cir::ComplexImagPtrOp::create(
486 *this, loc, getPointerTo(srcComplexTy.getElementType()), value);
487 }
488
489 Address createComplexImagPtr(mlir::Location loc, Address addr) {
490 return Address{createComplexImagPtr(loc, addr.getPointer()),
491 addr.getAlignment()};
492 }
493
494 /// Create a cir.ptr_stride operation to get access to an array element.
495 /// \p idx is the index of the element to access, \p shouldDecay is true if
496 /// the result should decay to a pointer to the element type.
497 mlir::Value getArrayElement(mlir::Location arrayLocBegin,
498 mlir::Location arrayLocEnd, mlir::Value arrayPtr,
499 mlir::Type eltTy, mlir::Value idx,
500 bool shouldDecay);
501
502 /// Returns a decayed pointer to the first element of the array
503 /// pointed to by \p arrayPtr.
504 mlir::Value maybeBuildArrayDecay(mlir::Location loc, mlir::Value arrayPtr,
505 mlir::Type eltTy);
506
507 // Convert byte offset to sequence of high-level indices suitable for
508 // GlobalViewAttr. Ideally we shouldn't deal with low-level offsets at all
509 // but currently some parts of Clang AST, which we don't want to touch just
510 // yet, return them.
512 int64_t offset, mlir::Type ty, cir::CIRDataLayout layout,
514
515 /// Creates a versioned global variable. If the symbol is already taken, an ID
516 /// will be appended to the symbol. The returned global must always be queried
517 /// for its name so it can be referenced correctly.
518 [[nodiscard]] cir::GlobalOp
519 createVersionedGlobal(mlir::ModuleOp module, mlir::Location loc,
520 mlir::StringRef name, mlir::Type type, bool isConstant,
521 cir::GlobalLinkageKind linkage) {
522 // Create a unique name if the given name is already taken.
523 std::string uniqueName;
524 if (unsigned version = globalsVersioning[name.str()]++)
525 uniqueName = name.str() + "." + std::to_string(version);
526 else
527 uniqueName = name.str();
528
529 return createGlobal(module, loc, uniqueName, type, isConstant, linkage);
530 }
531
532 cir::StackSaveOp createStackSave(mlir::Location loc, mlir::Type ty) {
533 return cir::StackSaveOp::create(*this, loc, ty);
534 }
535
536 cir::StackRestoreOp createStackRestore(mlir::Location loc, mlir::Value v) {
537 return cir::StackRestoreOp::create(*this, loc, v);
538 }
539
540 mlir::Value createSetBitfield(mlir::Location loc, mlir::Type resultType,
541 Address dstAddr, mlir::Type storageType,
542 mlir::Value src, const CIRGenBitFieldInfo &info,
543 bool isLvalueVolatile, bool useVolatile) {
544 unsigned offset = useVolatile ? info.volatileOffset : info.offset;
545
546 // If using AAPCS and the field is volatile, load with the size of the
547 // declared field
548 storageType =
549 useVolatile ? cir::IntType::get(storageType.getContext(),
550 info.volatileStorageSize, info.isSigned)
551 : storageType;
552 return cir::SetBitfieldOp::create(
553 *this, loc, resultType, dstAddr.getPointer(), storageType, src,
554 info.name, info.size, offset, info.isSigned, isLvalueVolatile,
555 dstAddr.getAlignment().getAsAlign().value());
556 }
557
558 mlir::Value createGetBitfield(mlir::Location loc, mlir::Type resultType,
559 Address addr, mlir::Type storageType,
560 const CIRGenBitFieldInfo &info,
561 bool isLvalueVolatile, bool useVolatile) {
562 unsigned offset = useVolatile ? info.volatileOffset : info.offset;
563
564 // If using AAPCS and the field is volatile, load with the size of the
565 // declared field
566 storageType =
567 useVolatile ? cir::IntType::get(storageType.getContext(),
568 info.volatileStorageSize, info.isSigned)
569 : storageType;
570 return cir::GetBitfieldOp::create(*this, loc, resultType, addr.getPointer(),
571 storageType, info.name, info.size, offset,
572 info.isSigned, isLvalueVolatile,
573 addr.getAlignment().getAsAlign().value());
574 }
575};
576
577} // namespace clang::CIRGen
578
579#endif
TokenType getType() const
Returns the token's type, e.g.
__device__ __2f16 float c
cir::PointerType getPointerTo(mlir::Type ty)
mlir::Value createPtrBitcast(mlir::Value src, mlir::Type newPointeeTy)
mlir::Value createIntCast(mlir::Value src, mlir::Type newTy)
mlir::Value createBitcast(mlir::Value src, mlir::Type newTy)
CIRBaseBuilderTy(mlir::MLIRContext &mlirContext)
cir::GlobalOp createGlobal(mlir::ModuleOp mlirModule, mlir::Location loc, mlir::StringRef name, mlir::Type type, bool isConstant, cir::GlobalLinkageKind linkage)
mlir::IntegerAttr getAlignmentAttr(clang::CharUnits alignment)
cir::ConstantOp getConstantInt(mlir::Location loc, mlir::Type ty, int64_t value)
cir::PointerType getVoidPtrTy(clang::LangAS langAS=clang::LangAS::Default)
mlir::Value getPointer() const
Definition Address.h:82
mlir::Type getElementType() const
Definition Address.h:109
clang::CharUnits getAlignment() const
Definition Address.h:117
cir::RecordType getCompleteNamedRecordType(llvm::ArrayRef< mlir::Type > members, bool packed, bool padded, llvm::StringRef name)
Get a CIR named record type.
cir::StackSaveOp createStackSave(mlir::Location loc, mlir::Type ty)
cir::TypeInfoAttr getTypeInfo(mlir::ArrayAttr fieldsAttr)
mlir::Value createComplexRealPtr(mlir::Location loc, mlir::Value value)
Create a cir.complex.real_ptr operation that derives a pointer to the real part of the complex value ...
cir::RecordType::RecordKind getRecordKind(const clang::TagTypeKind kind)
Get a CIR record kind from a AST declaration tag.
cir::IntType getSIntNTy(int n)
cir::ConstRecordAttr getAnonConstRecord(mlir::ArrayAttr arrayAttr, bool packed=false, bool padded=false, mlir::Type ty={})
cir::ConstantOp getSInt64(uint64_t c, mlir::Location loc)
cir::RecordType getIncompleteRecordTy(llvm::StringRef name, const clang::RecordDecl *rd)
Get an incomplete CIR struct type.
cir::ConstantOp getUInt32(uint32_t c, mlir::Location loc)
cir::GlobalOp createVersionedGlobal(mlir::ModuleOp module, mlir::Location loc, mlir::StringRef name, mlir::Type type, bool isConstant, cir::GlobalLinkageKind linkage)
Creates a versioned global variable.
cir::PointerType getUInt8PtrTy()
std::string getUniqueRecordName(const std::string &baseName)
mlir::Attribute getConstRecordOrZeroAttr(mlir::ArrayAttr arrayAttr, bool packed=false, bool padded=false, mlir::Type type={})
cir::RecordType getAnonRecordTy(llvm::ArrayRef< mlir::Type > members, bool packed=false, bool padded=false)
Get a CIR anonymous record type.
mlir::Value createVTTAddrPoint(mlir::Location loc, mlir::Type retTy, mlir::FlatSymbolRefAttr sym, uint64_t offset)
Address createBaseClassAddr(mlir::Location loc, Address addr, mlir::Type destType, unsigned offset, bool assumeNotNull)
mlir::Value createComplexImagPtr(mlir::Location loc, mlir::Value value)
Create a cir.complex.imag_ptr operation that derives a pointer to the imaginary part of the complex v...
mlir::Value maybeBuildArrayDecay(mlir::Location loc, mlir::Value arrayPtr, mlir::Type eltTy)
Returns a decayed pointer to the first element of the array pointed to by arrayPtr.
mlir::Attribute getString(llvm::StringRef str, mlir::Type eltTy, std::optional< size_t > size)
Get a cir::ConstArrayAttr for a string literal.
cir::LoadOp createAlignedLoad(mlir::Location loc, mlir::Type ty, mlir::Value ptr, llvm::MaybeAlign align)
cir::ConstantOp getConstFP(mlir::Location loc, mlir::Type t, llvm::APFloat fpVal)
mlir::Value createFloatingCast(mlir::Value v, mlir::Type destType)
cir::FuncType getFuncType(llvm::ArrayRef< mlir::Type > params, mlir::Type retTy, bool isVarArg=false)
mlir::Value createFDiv(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
Address createElementBitCast(mlir::Location loc, Address addr, mlir::Type destType)
Cast the element type of the given address to a different type, preserving information like the align...
mlir::Value createDynCastToVoid(mlir::Location loc, mlir::Value src, bool vtableUseRelativeLayout)
mlir::Value createDynCast(mlir::Location loc, mlir::Value src, cir::PointerType destType, bool isRefCast, cir::DynamicCastInfoAttr info)
mlir::Value createGetBitfield(mlir::Location loc, mlir::Type resultType, Address addr, mlir::Type storageType, const CIRGenBitFieldInfo &info, bool isLvalueVolatile, bool useVolatile)
bool isNullValue(mlir::Attribute attr) const
cir::StackRestoreOp createStackRestore(mlir::Location loc, mlir::Value v)
mlir::Value createSetBitfield(mlir::Location loc, mlir::Type resultType, Address dstAddr, mlir::Type storageType, mlir::Value src, const CIRGenBitFieldInfo &info, bool isLvalueVolatile, bool useVolatile)
Address createComplexRealPtr(mlir::Location loc, Address addr)
mlir::Value createFAdd(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
CIRGenBuilderTy(mlir::MLIRContext &mlirContext, const CIRGenTypeCache &tc)
cir::RecordType getCompleteRecordType(mlir::ArrayAttr fields, bool packed=false, bool padded=false, llvm::StringRef name="")
cir::ConstantOp getConstInt(mlir::Location loc, llvm::APSInt intVal)
void computeGlobalViewIndicesFromFlatOffset(int64_t offset, mlir::Type ty, cir::CIRDataLayout layout, llvm::SmallVectorImpl< int64_t > &indices)
Address createComplexImagPtr(mlir::Location loc, Address addr)
mlir::Value createFMul(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
cir::ConstantOp getSInt32(int32_t c, mlir::Location loc)
mlir::Value createVTTAddrPoint(mlir::Location loc, mlir::Type retTy, mlir::Value addr, uint64_t offset)
cir::LoadOp createLoad(mlir::Location loc, Address addr, bool isVolatile=false)
cir::LongDoubleType getLongDoubleTy(const llvm::fltSemantics &format) const
cir::ConstArrayAttr getConstArray(mlir::Attribute attrs, cir::ArrayType arrayTy) const
mlir::Value createFSub(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
cir::IntType getUIntNTy(int n)
mlir::Value getArrayElement(mlir::Location arrayLocBegin, mlir::Location arrayLocEnd, mlir::Value arrayPtr, mlir::Type eltTy, mlir::Value idx, bool shouldDecay)
Create a cir.ptr_stride operation to get access to an array element.
cir::StoreOp createStore(mlir::Location loc, mlir::Value val, Address dst, bool isVolatile=false, mlir::IntegerAttr align={}, cir::MemOrderAttr order={})
mlir::Value createNeg(mlir::Value value)
cir::LoadOp createAlignedLoad(mlir::Location loc, mlir::Type ty, mlir::Value ptr, clang::CharUnits align=clang::CharUnits::One())
CharUnits - This is an opaque type for sizes expressed in character units.
Definition CharUnits.h:38
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
Definition CharUnits.h:189
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition CharUnits.h:58
Represents a struct/union/class.
Definition Decl.h:4312
TagKind getTagKind() const
Definition Decl.h:3911
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
TagTypeKind
The kind of a tag type.
Definition TypeBase.h:5878
@ Interface
The "__interface" keyword.
Definition TypeBase.h:5883
@ Struct
The "struct" keyword.
Definition TypeBase.h:5880
@ Class
The "class" keyword.
Definition TypeBase.h:5889
@ Union
The "union" keyword.
Definition TypeBase.h:5886
@ Enum
The "enum" keyword.
Definition TypeBase.h:5892
static bool metaDataNode()
static bool addressSpace()
static bool fpConstraints()
static bool astRecordDeclAttr()
static bool fastMathFlags()
Record with information about how a bitfield should be accessed.
unsigned offset
The offset within a contiguous run of bitfields that are represented as a single "field" within the c...
unsigned volatileStorageSize
The storage size in bits which should be used when accessing this bitfield.
unsigned size
The total size of the bit-field, in bits.
unsigned isSigned
Whether the bit-field is signed.
unsigned volatileOffset
The offset within a contiguous run of bitfields that are represented as a single "field" within the c...
llvm::StringRef name
The name of a bitfield.
This structure provides a set of types that are commonly used during IR emission.