Thanks to visit codestin.com
Credit goes to clang.llvm.org

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 /// Get a CIR record kind from a AST declaration tag.
126 cir::RecordType::RecordKind getRecordKind(const clang::TagTypeKind kind) {
127 switch (kind) {
129 return cir::RecordType::Class;
131 return cir::RecordType::Struct;
133 return cir::RecordType::Union;
135 llvm_unreachable("interface records are NYI");
137 llvm_unreachable("enums are not records");
138 }
139 llvm_unreachable("Unsupported record kind");
140 }
141
142 /// Get a CIR named record type.
143 ///
144 /// If a record already exists and is complete, but the client tries to fetch
145 /// it with a different set of attributes, this method will crash.
147 bool packed, bool padded,
148 llvm::StringRef name) {
149 const auto nameAttr = getStringAttr(name);
150 auto kind = cir::RecordType::RecordKind::Struct;
152
153 // Create or get the record.
154 auto type =
155 getType<cir::RecordType>(members, nameAttr, packed, padded, kind);
156
157 // If we found an existing type, verify that either it is incomplete or
158 // it matches the requested attributes.
159 assert(!type.isIncomplete() ||
160 (type.getMembers() == members && type.getPacked() == packed &&
161 type.getPadded() == padded));
162
163 // Complete an incomplete record or ensure the existing complete record
164 // matches the requested attributes.
165 type.complete(members, packed, padded);
166
167 return type;
168 }
169
170 cir::RecordType getCompleteRecordType(mlir::ArrayAttr fields,
171 bool packed = false,
172 bool padded = false,
173 llvm::StringRef name = "");
174
175 /// Get an incomplete CIR struct type. If we have a complete record
176 /// declaration, we may create an incomplete type and then add the
177 /// members, so \p rd here may be complete.
178 cir::RecordType getIncompleteRecordTy(llvm::StringRef name,
179 const clang::RecordDecl *rd) {
180 const mlir::StringAttr nameAttr = getStringAttr(name);
181 cir::RecordType::RecordKind kind = cir::RecordType::RecordKind::Struct;
182 if (rd)
183 kind = getRecordKind(rd->getTagKind());
184 return getType<cir::RecordType>(nameAttr, kind);
185 }
186
187 // Return true if the value is a null constant such as null pointer, (+0.0)
188 // for floating-point or zero initializer
189 bool isNullValue(mlir::Attribute attr) const {
190 if (mlir::isa<cir::ZeroAttr>(attr))
191 return true;
192
193 if (const auto ptrVal = mlir::dyn_cast<cir::ConstPtrAttr>(attr))
194 return ptrVal.isNullValue();
195
196 if (const auto intVal = mlir::dyn_cast<cir::IntAttr>(attr))
197 return intVal.isNullValue();
198
199 if (const auto boolVal = mlir::dyn_cast<cir::BoolAttr>(attr))
200 return !boolVal.getValue();
201
202 if (auto fpAttr = mlir::dyn_cast<cir::FPAttr>(attr)) {
203 auto fpVal = fpAttr.getValue();
204 bool ignored;
205 llvm::APFloat fv(+0.0);
206 fv.convert(fpVal.getSemantics(), llvm::APFloat::rmNearestTiesToEven,
207 &ignored);
208 return fv.bitwiseIsEqual(fpVal);
209 }
210
211 if (const auto arrayVal = mlir::dyn_cast<cir::ConstArrayAttr>(attr)) {
212 if (mlir::isa<mlir::StringAttr>(arrayVal.getElts()))
213 return false;
214
215 return llvm::all_of(
216 mlir::cast<mlir::ArrayAttr>(arrayVal.getElts()),
217 [&](const mlir::Attribute &elt) { return isNullValue(elt); });
218 }
219 return false;
220 }
221
222 //
223 // Type helpers
224 // ------------
225 //
226 cir::IntType getUIntNTy(int n) {
227 switch (n) {
228 case 8:
229 return getUInt8Ty();
230 case 16:
231 return getUInt16Ty();
232 case 32:
233 return getUInt32Ty();
234 case 64:
235 return getUInt64Ty();
236 default:
237 return cir::IntType::get(getContext(), n, false);
238 }
239 }
240
241 cir::IntType getSIntNTy(int n) {
242 switch (n) {
243 case 8:
244 return getSInt8Ty();
245 case 16:
246 return getSInt16Ty();
247 case 32:
248 return getSInt32Ty();
249 case 64:
250 return getSInt64Ty();
251 default:
252 return cir::IntType::get(getContext(), n, true);
253 }
254 }
255
256 cir::VoidType getVoidTy() { return typeCache.VoidTy; }
257
258 cir::IntType getSInt8Ty() { return typeCache.SInt8Ty; }
259 cir::IntType getSInt16Ty() { return typeCache.SInt16Ty; }
260 cir::IntType getSInt32Ty() { return typeCache.SInt32Ty; }
261 cir::IntType getSInt64Ty() { return typeCache.SInt64Ty; }
262
263 cir::IntType getUInt8Ty() { return typeCache.UInt8Ty; }
264 cir::IntType getUInt16Ty() { return typeCache.UInt16Ty; }
265 cir::IntType getUInt32Ty() { return typeCache.UInt32Ty; }
266 cir::IntType getUInt64Ty() { return typeCache.UInt64Ty; }
267
268 cir::ConstantOp getConstInt(mlir::Location loc, llvm::APSInt intVal);
269
270 cir::ConstantOp getConstInt(mlir::Location loc, llvm::APInt intVal);
271
272 cir::ConstantOp getConstInt(mlir::Location loc, mlir::Type t, uint64_t c);
273
274 cir::ConstantOp getConstFP(mlir::Location loc, mlir::Type t,
275 llvm::APFloat fpVal);
276
277 bool isInt8Ty(mlir::Type i) {
278 return i == typeCache.UInt8Ty || i == typeCache.SInt8Ty;
279 }
280 bool isInt16Ty(mlir::Type i) {
281 return i == typeCache.UInt16Ty || i == typeCache.SInt16Ty;
282 }
283 bool isInt32Ty(mlir::Type i) {
284 return i == typeCache.UInt32Ty || i == typeCache.SInt32Ty;
285 }
286 bool isInt64Ty(mlir::Type i) {
287 return i == typeCache.UInt64Ty || i == typeCache.SInt64Ty;
288 }
289 bool isInt(mlir::Type i) { return mlir::isa<cir::IntType>(i); }
290
291 // Fetch the type representing a pointer to unsigned int8 values.
292 cir::PointerType getUInt8PtrTy() { return typeCache.UInt8PtrTy; }
293
294 /// Get a CIR anonymous record type.
296 bool packed = false, bool padded = false) {
298 auto kind = cir::RecordType::RecordKind::Struct;
299 return getType<cir::RecordType>(members, packed, padded, kind);
300 }
301
302 //
303 // Constant creation helpers
304 // -------------------------
305 //
306 cir::ConstantOp getSInt32(int32_t c, mlir::Location loc) {
307 return getConstantInt(loc, getSInt32Ty(), c);
308 }
309 cir::ConstantOp getUInt32(uint32_t c, mlir::Location loc) {
310 return getConstantInt(loc, getUInt32Ty(), c);
311 }
312 cir::ConstantOp getSInt64(uint64_t c, mlir::Location loc) {
313 cir::IntType sInt64Ty = getSInt64Ty();
314 return cir::ConstantOp::create(*this, loc, cir::IntAttr::get(sInt64Ty, c));
315 }
316
317 // Creates constant nullptr for pointer type ty.
318 cir::ConstantOp getNullPtr(mlir::Type ty, mlir::Location loc) {
320 return cir::ConstantOp::create(*this, loc, getConstPtrAttr(ty, 0));
321 }
322
323 mlir::Value createNeg(mlir::Value value) {
324
325 if (auto intTy = mlir::dyn_cast<cir::IntType>(value.getType())) {
326 // Source is a unsigned integer: first cast it to signed.
327 if (intTy.isUnsigned())
328 value = createIntCast(value, getSIntNTy(intTy.getWidth()));
329 return cir::UnaryOp::create(*this, value.getLoc(), value.getType(),
330 cir::UnaryOpKind::Minus, value);
331 }
332
333 llvm_unreachable("negation for the given type is NYI");
334 }
335
336 // TODO: split this to createFPExt/createFPTrunc when we have dedicated cast
337 // operations.
338 mlir::Value createFloatingCast(mlir::Value v, mlir::Type destType) {
340
341 return cir::CastOp::create(*this, v.getLoc(), destType,
342 cir::CastKind::floating, v);
343 }
344
345 mlir::Value createFSub(mlir::Location loc, mlir::Value lhs, mlir::Value rhs) {
349
350 return cir::BinOp::create(*this, loc, cir::BinOpKind::Sub, lhs, rhs);
351 }
352
353 mlir::Value createFAdd(mlir::Location loc, mlir::Value lhs, mlir::Value rhs) {
357
358 return cir::BinOp::create(*this, loc, cir::BinOpKind::Add, lhs, rhs);
359 }
360 mlir::Value createFMul(mlir::Location loc, mlir::Value lhs, mlir::Value rhs) {
364
365 return cir::BinOp::create(*this, loc, cir::BinOpKind::Mul, lhs, rhs);
366 }
367 mlir::Value createFDiv(mlir::Location loc, mlir::Value lhs, mlir::Value rhs) {
371
372 return cir::BinOp::create(*this, loc, cir::BinOpKind::Div, lhs, rhs);
373 }
374
375 Address createBaseClassAddr(mlir::Location loc, Address addr,
376 mlir::Type destType, unsigned offset,
377 bool assumeNotNull) {
378 if (destType == addr.getElementType())
379 return addr;
380
381 auto ptrTy = getPointerTo(destType);
382 auto baseAddr =
383 cir::BaseClassAddrOp::create(*this, loc, ptrTy, addr.getPointer(),
384 mlir::APInt(64, offset), assumeNotNull);
385 return Address(baseAddr, destType, addr.getAlignment());
386 }
387
388 mlir::Value createVTTAddrPoint(mlir::Location loc, mlir::Type retTy,
389 mlir::Value addr, uint64_t offset) {
390 return cir::VTTAddrPointOp::create(*this, loc, retTy,
391 mlir::FlatSymbolRefAttr{}, addr, offset);
392 }
393
394 mlir::Value createVTTAddrPoint(mlir::Location loc, mlir::Type retTy,
395 mlir::FlatSymbolRefAttr sym, uint64_t offset) {
396 return cir::VTTAddrPointOp::create(*this, loc, retTy, sym, mlir::Value{},
397 offset);
398 }
399
400 /// Cast the element type of the given address to a different type,
401 /// preserving information like the alignment.
402 Address createElementBitCast(mlir::Location loc, Address addr,
403 mlir::Type destType) {
404 if (destType == addr.getElementType())
405 return addr;
406
407 auto ptrTy = getPointerTo(destType);
408 return Address(createBitcast(loc, addr.getPointer(), ptrTy), destType,
409 addr.getAlignment());
410 }
411
412 cir::LoadOp createLoad(mlir::Location loc, Address addr,
413 bool isVolatile = false) {
414 mlir::IntegerAttr align = getAlignmentAttr(addr.getAlignment());
415 return cir::LoadOp::create(*this, loc, addr.getPointer(), /*isDeref=*/false,
416 isVolatile, /*alignment=*/align,
417 /*mem_order=*/cir::MemOrderAttr{});
418 }
419
420 cir::LoadOp createAlignedLoad(mlir::Location loc, mlir::Type ty,
421 mlir::Value ptr, llvm::MaybeAlign align) {
422 if (ty != mlir::cast<cir::PointerType>(ptr.getType()).getPointee())
423 ptr = createPtrBitcast(ptr, ty);
424 uint64_t alignment = align ? align->value() : 0;
425 mlir::IntegerAttr alignAttr = getAlignmentAttr(alignment);
426 return cir::LoadOp::create(*this, loc, ptr, /*isDeref=*/false,
427 /*isVolatile=*/false, alignAttr,
428 /*mem_order=*/cir::MemOrderAttr{});
429 }
430
431 cir::LoadOp
432 createAlignedLoad(mlir::Location loc, mlir::Type ty, mlir::Value ptr,
434 return createAlignedLoad(loc, ty, ptr, align.getAsAlign());
435 }
436
437 cir::StoreOp createStore(mlir::Location loc, mlir::Value val, Address dst,
438 bool isVolatile = false,
439 mlir::IntegerAttr align = {},
440 cir::MemOrderAttr order = {}) {
441 if (!align)
442 align = getAlignmentAttr(dst.getAlignment());
443 return CIRBaseBuilderTy::createStore(loc, val, dst.getPointer(), isVolatile,
444 align, order);
445 }
446
447 /// Create a cir.complex.real_ptr operation that derives a pointer to the real
448 /// part of the complex value pointed to by the specified pointer value.
449 mlir::Value createComplexRealPtr(mlir::Location loc, mlir::Value value) {
450 auto srcPtrTy = mlir::cast<cir::PointerType>(value.getType());
451 auto srcComplexTy = mlir::cast<cir::ComplexType>(srcPtrTy.getPointee());
452 return cir::ComplexRealPtrOp::create(
453 *this, loc, getPointerTo(srcComplexTy.getElementType()), value);
454 }
455
456 Address createComplexRealPtr(mlir::Location loc, Address addr) {
457 return Address{createComplexRealPtr(loc, addr.getPointer()),
458 addr.getAlignment()};
459 }
460
461 /// Create a cir.complex.imag_ptr operation that derives a pointer to the
462 /// imaginary part of the complex value pointed to by the specified pointer
463 /// value.
464 mlir::Value createComplexImagPtr(mlir::Location loc, mlir::Value value) {
465 auto srcPtrTy = mlir::cast<cir::PointerType>(value.getType());
466 auto srcComplexTy = mlir::cast<cir::ComplexType>(srcPtrTy.getPointee());
467 return cir::ComplexImagPtrOp::create(
468 *this, loc, getPointerTo(srcComplexTy.getElementType()), value);
469 }
470
471 Address createComplexImagPtr(mlir::Location loc, Address addr) {
472 return Address{createComplexImagPtr(loc, addr.getPointer()),
473 addr.getAlignment()};
474 }
475
476 /// Create a cir.ptr_stride operation to get access to an array element.
477 /// \p idx is the index of the element to access, \p shouldDecay is true if
478 /// the result should decay to a pointer to the element type.
479 mlir::Value getArrayElement(mlir::Location arrayLocBegin,
480 mlir::Location arrayLocEnd, mlir::Value arrayPtr,
481 mlir::Type eltTy, mlir::Value idx,
482 bool shouldDecay);
483
484 /// Returns a decayed pointer to the first element of the array
485 /// pointed to by \p arrayPtr.
486 mlir::Value maybeBuildArrayDecay(mlir::Location loc, mlir::Value arrayPtr,
487 mlir::Type eltTy);
488
489 // Convert byte offset to sequence of high-level indices suitable for
490 // GlobalViewAttr. Ideally we shouldn't deal with low-level offsets at all
491 // but currently some parts of Clang AST, which we don't want to touch just
492 // yet, return them.
494 int64_t offset, mlir::Type ty, cir::CIRDataLayout layout,
496
497 /// Creates a versioned global variable. If the symbol is already taken, an ID
498 /// will be appended to the symbol. The returned global must always be queried
499 /// for its name so it can be referenced correctly.
500 [[nodiscard]] cir::GlobalOp
501 createVersionedGlobal(mlir::ModuleOp module, mlir::Location loc,
502 mlir::StringRef name, mlir::Type type, bool isConstant,
503 cir::GlobalLinkageKind linkage) {
504 // Create a unique name if the given name is already taken.
505 std::string uniqueName;
506 if (unsigned version = globalsVersioning[name.str()]++)
507 uniqueName = name.str() + "." + std::to_string(version);
508 else
509 uniqueName = name.str();
510
511 return createGlobal(module, loc, uniqueName, type, isConstant, linkage);
512 }
513
514 mlir::Value createSetBitfield(mlir::Location loc, mlir::Type resultType,
515 Address dstAddr, mlir::Type storageType,
516 mlir::Value src, const CIRGenBitFieldInfo &info,
517 bool isLvalueVolatile, bool useVolatile) {
518 unsigned offset = useVolatile ? info.volatileOffset : info.offset;
519
520 // If using AAPCS and the field is volatile, load with the size of the
521 // declared field
522 storageType =
523 useVolatile ? cir::IntType::get(storageType.getContext(),
524 info.volatileStorageSize, info.isSigned)
525 : storageType;
526 return cir::SetBitfieldOp::create(
527 *this, loc, resultType, dstAddr.getPointer(), storageType, src,
528 info.name, info.size, offset, info.isSigned, isLvalueVolatile,
529 dstAddr.getAlignment().getAsAlign().value());
530 }
531
532 mlir::Value createGetBitfield(mlir::Location loc, mlir::Type resultType,
533 Address addr, mlir::Type storageType,
534 const CIRGenBitFieldInfo &info,
535 bool isLvalueVolatile, bool useVolatile) {
536 unsigned offset = useVolatile ? info.volatileOffset : info.offset;
537
538 // If using AAPCS and the field is volatile, load with the size of the
539 // declared field
540 storageType =
541 useVolatile ? cir::IntType::get(storageType.getContext(),
542 info.volatileStorageSize, info.isSigned)
543 : storageType;
544 return cir::GetBitfieldOp::create(*this, loc, resultType, addr.getPointer(),
545 storageType, info.name, info.size, offset,
546 info.isSigned, isLvalueVolatile,
547 addr.getAlignment().getAsAlign().value());
548 }
549};
550
551} // namespace clang::CIRGen
552
553#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)
mlir::TypedAttr getConstPtrAttr(mlir::Type type, int64_t value)
mlir::Value getPointer() const
Definition Address.h:81
mlir::Type getElementType() const
Definition Address.h:101
clang::CharUnits getAlignment() const
Definition Address.h:109
cir::RecordType getCompleteNamedRecordType(llvm::ArrayRef< mlir::Type > members, bool packed, bool padded, llvm::StringRef name)
Get a CIR named record type.
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 getNullPtr(mlir::Type ty, mlir::Location loc)
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)
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 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
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:4309
TagKind getTagKind() const
Definition Decl.h:3908
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
TagTypeKind
The kind of a tag type.
Definition TypeBase.h:5890
@ Interface
The "__interface" keyword.
Definition TypeBase.h:5895
@ Struct
The "struct" keyword.
Definition TypeBase.h:5892
@ Class
The "class" keyword.
Definition TypeBase.h:5901
@ Union
The "union" keyword.
Definition TypeBase.h:5898
@ Enum
The "enum" keyword.
Definition TypeBase.h:5904
static bool metaDataNode()
static bool targetCodeGenInfoGetNullPointer()
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.