[clang] 217f0e5 - [CIR][NFC] Update TypeCache file to use MLIR-style camel case (#165060)
via cfe-commits
cfe-commits at lists.llvm.org
Tue Oct 28 17:26:37 PDT 2025
Author: Andres-Salamanca
Date: 2025-10-28T19:26:33-05:00
New Revision: 217f0e54c92e0cf2fd609828363e694dc61bd2f8
URL: https://github.com/llvm/llvm-project/commit/217f0e54c92e0cf2fd609828363e694dc61bd2f8
DIFF: https://github.com/llvm/llvm-project/commit/217f0e54c92e0cf2fd609828363e694dc61bd2f8.diff
LOG: [CIR][NFC] Update TypeCache file to use MLIR-style camel case (#165060)
This PR updates the file `CIRGenTypeCache` to use MLIR-style camel case
naming.The change was inspired by the discussion here:
https://github.com/llvm/llvm-project/pull/164180#discussion_r2461444730
Added:
Modified:
clang/lib/CIR/CodeGen/CIRGenBuilder.h
clang/lib/CIR/CodeGen/CIRGenClass.cpp
clang/lib/CIR/CodeGen/CIRGenCoroutine.cpp
clang/lib/CIR/CodeGen/CIRGenDecl.cpp
clang/lib/CIR/CodeGen/CIRGenExpr.cpp
clang/lib/CIR/CodeGen/CIRGenExprAggregate.cpp
clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp
clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp
clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
clang/lib/CIR/CodeGen/CIRGenFunction.cpp
clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp
clang/lib/CIR/CodeGen/CIRGenModule.cpp
clang/lib/CIR/CodeGen/CIRGenOpenACCRecipe.cpp
clang/lib/CIR/CodeGen/CIRGenTypeCache.h
clang/lib/CIR/CodeGen/CIRGenTypes.cpp
Removed:
################################################################################
diff --git a/clang/lib/CIR/CodeGen/CIRGenBuilder.h b/clang/lib/CIR/CodeGen/CIRGenBuilder.h
index 50d585dca3b8c..e5066fac19185 100644
--- a/clang/lib/CIR/CodeGen/CIRGenBuilder.h
+++ b/clang/lib/CIR/CodeGen/CIRGenBuilder.h
@@ -108,11 +108,11 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
cir::LongDoubleType getLongDoubleTy(const llvm::fltSemantics &format) const {
if (&format == &llvm::APFloat::IEEEdouble())
- return cir::LongDoubleType::get(getContext(), typeCache.DoubleTy);
+ return cir::LongDoubleType::get(getContext(), typeCache.doubleTy);
if (&format == &llvm::APFloat::x87DoubleExtended())
- return cir::LongDoubleType::get(getContext(), typeCache.FP80Ty);
+ return cir::LongDoubleType::get(getContext(), typeCache.fP80Ty);
if (&format == &llvm::APFloat::IEEEquad())
- return cir::LongDoubleType::get(getContext(), typeCache.FP128Ty);
+ return cir::LongDoubleType::get(getContext(), typeCache.fP128Ty);
if (&format == &llvm::APFloat::PPCDoubleDouble())
llvm_unreachable("NYI: PPC double-double format for long double");
llvm_unreachable("Unsupported format for long double");
@@ -258,17 +258,17 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
}
}
- cir::VoidType getVoidTy() { return typeCache.VoidTy; }
+ cir::VoidType getVoidTy() { return typeCache.voidTy; }
- cir::IntType getSInt8Ty() { return typeCache.SInt8Ty; }
- cir::IntType getSInt16Ty() { return typeCache.SInt16Ty; }
- cir::IntType getSInt32Ty() { return typeCache.SInt32Ty; }
- cir::IntType getSInt64Ty() { return typeCache.SInt64Ty; }
+ cir::IntType getSInt8Ty() { return typeCache.sInt8Ty; }
+ cir::IntType getSInt16Ty() { return typeCache.sInt16Ty; }
+ cir::IntType getSInt32Ty() { return typeCache.sInt32Ty; }
+ cir::IntType getSInt64Ty() { return typeCache.sInt64Ty; }
- cir::IntType getUInt8Ty() { return typeCache.UInt8Ty; }
- cir::IntType getUInt16Ty() { return typeCache.UInt16Ty; }
- cir::IntType getUInt32Ty() { return typeCache.UInt32Ty; }
- cir::IntType getUInt64Ty() { return typeCache.UInt64Ty; }
+ cir::IntType getUInt8Ty() { return typeCache.uInt8Ty; }
+ cir::IntType getUInt16Ty() { return typeCache.uInt16Ty; }
+ cir::IntType getUInt32Ty() { return typeCache.uInt32Ty; }
+ cir::IntType getUInt64Ty() { return typeCache.uInt64Ty; }
cir::ConstantOp getConstInt(mlir::Location loc, llvm::APSInt intVal);
@@ -280,21 +280,21 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
llvm::APFloat fpVal);
bool isInt8Ty(mlir::Type i) {
- return i == typeCache.UInt8Ty || i == typeCache.SInt8Ty;
+ return i == typeCache.uInt8Ty || i == typeCache.sInt8Ty;
}
bool isInt16Ty(mlir::Type i) {
- return i == typeCache.UInt16Ty || i == typeCache.SInt16Ty;
+ return i == typeCache.uInt16Ty || i == typeCache.sInt16Ty;
}
bool isInt32Ty(mlir::Type i) {
- return i == typeCache.UInt32Ty || i == typeCache.SInt32Ty;
+ return i == typeCache.uInt32Ty || i == typeCache.sInt32Ty;
}
bool isInt64Ty(mlir::Type i) {
- return i == typeCache.UInt64Ty || i == typeCache.SInt64Ty;
+ return i == typeCache.uInt64Ty || i == typeCache.sInt64Ty;
}
bool isInt(mlir::Type i) { return mlir::isa<cir::IntType>(i); }
// Fetch the type representing a pointer to unsigned int8 values.
- cir::PointerType getUInt8PtrTy() { return typeCache.UInt8PtrTy; }
+ cir::PointerType getUInt8PtrTy() { return typeCache.uInt8PtrTy; }
/// Get a CIR anonymous record type.
cir::RecordType getAnonRecordTy(llvm::ArrayRef<mlir::Type> members,
diff --git a/clang/lib/CIR/CodeGen/CIRGenClass.cpp b/clang/lib/CIR/CodeGen/CIRGenClass.cpp
index 5046e0945002f..a8296782ebc40 100644
--- a/clang/lib/CIR/CodeGen/CIRGenClass.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenClass.cpp
@@ -362,7 +362,7 @@ static Address applyNonVirtualAndVirtualOffset(
// not bytes. So the pointer must be cast to a byte pointer and back.
mlir::Value ptr = addr.getPointer();
- mlir::Type charPtrType = cgf.cgm.UInt8PtrTy;
+ mlir::Type charPtrType = cgf.cgm.uInt8PtrTy;
mlir::Value charPtr = cgf.getBuilder().createBitcast(ptr, charPtrType);
mlir::Value adjusted = cir::PtrStrideOp::create(
cgf.getBuilder(), loc, charPtrType, charPtr, baseOffset);
@@ -1105,7 +1105,7 @@ mlir::Value CIRGenFunction::getVTTParameter(GlobalDecl gd, bool forVirtualBase,
// We're the complete constructor, so get the VTT by name.
cir::GlobalOp vtt = cgm.getVTables().getAddrOfVTT(rd);
return builder.createVTTAddrPoint(
- loc, builder.getPointerTo(cgm.VoidPtrTy),
+ loc, builder.getPointerTo(cgm.voidPtrTy),
mlir::FlatSymbolRefAttr::get(vtt.getSymNameAttr()), subVTTIndex);
}
}
diff --git a/clang/lib/CIR/CodeGen/CIRGenCoroutine.cpp b/clang/lib/CIR/CodeGen/CIRGenCoroutine.cpp
index 8723a6e502b38..930ae55405756 100644
--- a/clang/lib/CIR/CodeGen/CIRGenCoroutine.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenCoroutine.cpp
@@ -55,7 +55,7 @@ cir::CallOp CIRGenFunction::emitCoroIDBuiltinCall(mlir::Location loc,
if (!builtin) {
fnOp = cgm.createCIRBuiltinFunction(
loc, cgm.builtinCoroId,
- cir::FuncType::get({int32Ty, VoidPtrTy, VoidPtrTy, VoidPtrTy}, int32Ty),
+ cir::FuncType::get({int32Ty, voidPtrTy, voidPtrTy, voidPtrTy}, int32Ty),
/*FD=*/nullptr);
assert(fnOp && "should always succeed");
} else {
@@ -75,7 +75,7 @@ cir::CallOp CIRGenFunction::emitCoroAllocBuiltinCall(mlir::Location loc) {
cir::FuncOp fnOp;
if (!builtin) {
fnOp = cgm.createCIRBuiltinFunction(loc, cgm.builtinCoroAlloc,
- cir::FuncType::get({UInt32Ty}, boolTy),
+ cir::FuncType::get({uInt32Ty}, boolTy),
/*fd=*/nullptr);
assert(fnOp && "should always succeed");
} else {
@@ -95,7 +95,7 @@ CIRGenFunction::emitCoroBeginBuiltinCall(mlir::Location loc,
if (!builtin) {
fnOp = cgm.createCIRBuiltinFunction(
loc, cgm.builtinCoroBegin,
- cir::FuncType::get({UInt32Ty, VoidPtrTy}, VoidPtrTy),
+ cir::FuncType::get({uInt32Ty, voidPtrTy}, voidPtrTy),
/*fd=*/nullptr);
assert(fnOp && "should always succeed");
} else {
@@ -110,7 +110,7 @@ CIRGenFunction::emitCoroBeginBuiltinCall(mlir::Location loc,
mlir::LogicalResult
CIRGenFunction::emitCoroutineBody(const CoroutineBodyStmt &s) {
mlir::Location openCurlyLoc = getLoc(s.getBeginLoc());
- cir::ConstantOp nullPtrCst = builder.getNullPtr(VoidPtrTy, openCurlyLoc);
+ cir::ConstantOp nullPtrCst = builder.getNullPtr(voidPtrTy, openCurlyLoc);
auto fn = mlir::cast<cir::FuncOp>(curFn);
fn.setCoroutine(true);
diff --git a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp
index 5667273c00daf..aeea0efeb77c3 100644
--- a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp
@@ -80,13 +80,13 @@ CIRGenFunction::emitAutoVarAlloca(const VarDecl &d,
assert(!cir::MissingFeatures::openMP());
if (!didCallStackSave) {
// Save the stack.
- cir::PointerType defaultTy = AllocaInt8PtrTy;
+ cir::PointerType defaultTy = allocaInt8PtrTy;
CharUnits align = CharUnits::fromQuantity(
cgm.getDataLayout().getAlignment(defaultTy, false));
Address stack = createTempAlloca(defaultTy, align, loc, "saved_stack");
mlir::Value v = builder.createStackSave(loc, defaultTy);
- assert(v.getType() == AllocaInt8PtrTy);
+ assert(v.getType() == allocaInt8PtrTy);
builder.createStore(loc, v, stack);
didCallStackSave = true;
diff --git a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
index df6ee56eac30b..5ccb431e626ae 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
@@ -2529,7 +2529,7 @@ CIRGenFunction::emitConditionalBlocks(const AbstractConditionalOperator *e,
// If both arms are void, so be it.
if (!yieldTy)
- yieldTy = VoidTy;
+ yieldTy = voidTy;
// Insert required yields.
for (mlir::OpBuilder::InsertPoint &toInsert : insertPoints) {
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprAggregate.cpp b/clang/lib/CIR/CodeGen/CIRGenExprAggregate.cpp
index 8fe0d9b4a69ef..3d3030ca87e2a 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExprAggregate.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExprAggregate.cpp
@@ -490,7 +490,7 @@ void AggExprEmitter::emitArrayInit(Address destPtr, cir::ArrayType arrayTy,
for (uint64_t i = 0; i != numInitElements; ++i) {
// Advance to the next element.
if (i > 0) {
- one = builder.getConstantInt(loc, cgf.PtrDiffTy, i);
+ one = builder.getConstantInt(loc, cgf.ptrDiffTy, i);
element = builder.createPtrStride(loc, begin, one);
}
@@ -512,7 +512,7 @@ void AggExprEmitter::emitArrayInit(Address destPtr, cir::ArrayType arrayTy,
cgf.getTypes().isZeroInitializable(elementType))) {
// Advance to the start of the rest of the array.
if (numInitElements) {
- one = builder.getConstantInt(loc, cgf.PtrDiffTy, 1);
+ one = builder.getConstantInt(loc, cgf.ptrDiffTy, 1);
element = cir::PtrStrideOp::create(builder, loc, cirElementPtrType,
element, one);
}
@@ -526,7 +526,7 @@ void AggExprEmitter::emitArrayInit(Address destPtr, cir::ArrayType arrayTy,
// Compute the end of array
cir::ConstantOp numArrayElementsConst = builder.getConstInt(
- loc, mlir::cast<cir::IntType>(cgf.PtrDiffTy), numArrayElements);
+ loc, mlir::cast<cir::IntType>(cgf.ptrDiffTy), numArrayElements);
mlir::Value end = cir::PtrStrideOp::create(builder, loc, cirElementPtrType,
begin, numArrayElementsConst);
@@ -563,7 +563,7 @@ void AggExprEmitter::emitArrayInit(Address destPtr, cir::ArrayType arrayTy,
// Advance pointer and store them to temporary variable
cir::ConstantOp one = builder.getConstInt(
- loc, mlir::cast<cir::IntType>(cgf.PtrDiffTy), 1);
+ loc, mlir::cast<cir::IntType>(cgf.ptrDiffTy), 1);
auto nextElement = cir::PtrStrideOp::create(
builder, loc, cirElementPtrType, currentElement, one);
cgf.emitStoreThroughLValue(RValue::get(nextElement), tmpLV);
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp b/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp
index 7a35382e79a93..9dd9b6d550763 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp
@@ -257,12 +257,12 @@ static mlir::Value emitCXXNewAllocSize(CIRGenFunction &cgf, const CXXNewExpr *e,
if (!e->isArray()) {
CharUnits typeSize = cgf.getContext().getTypeSizeInChars(type);
sizeWithoutCookie = cgf.getBuilder().getConstant(
- loc, cir::IntAttr::get(cgf.SizeTy, typeSize.getQuantity()));
+ loc, cir::IntAttr::get(cgf.sizeTy, typeSize.getQuantity()));
return sizeWithoutCookie;
}
// The width of size_t.
- unsigned sizeWidth = cgf.cgm.getDataLayout().getTypeSizeInBits(cgf.SizeTy);
+ unsigned sizeWidth = cgf.cgm.getDataLayout().getTypeSizeInBits(cgf.sizeTy);
// The number of elements can be have an arbitrary integer type;
// essentially, we need to multiply it by a constant factor, add a
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp b/clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp
index 928e5aa821bb5..6af87a0159f0a 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp
@@ -46,7 +46,7 @@ namespace {
class ConstExprEmitter;
static mlir::TypedAttr computePadding(CIRGenModule &cgm, CharUnits size) {
- mlir::Type eltTy = cgm.UCharTy;
+ mlir::Type eltTy = cgm.uCharTy;
clang::CharUnits::QuantityType arSize = size.getQuantity();
CIRGenBuilderTy &bld = cgm.getBuilder();
if (size > CharUnits::One()) {
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
index db6878d479366..119314fe27dce 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
@@ -762,9 +762,9 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
// FIXME(cir): For now lets pretend we shouldn't use the conversion
// intrinsics and insert a cast here unconditionally.
src = builder.createCast(cgf.getLoc(loc), cir::CastKind::floating, src,
- cgf.FloatTy);
+ cgf.floatTy);
srcType = cgf.getContext().FloatTy;
- mlirSrcType = cgf.FloatTy;
+ mlirSrcType = cgf.floatTy;
}
}
@@ -1738,7 +1738,7 @@ mlir::Value ScalarExprEmitter::emitSub(const BinOpInfo &ops) {
//
// See more in `EmitSub` in CGExprScalar.cpp.
assert(!cir::MissingFeatures::llvmLoweringPtrDiffConsidersPointee());
- return cir::PtrDiffOp::create(builder, cgf.getLoc(ops.loc), cgf.PtrDiffTy,
+ return cir::PtrDiffOp::create(builder, cgf.getLoc(ops.loc), cgf.ptrDiffTy,
ops.lhs, ops.rhs);
}
@@ -2220,7 +2220,7 @@ mlir::Value ScalarExprEmitter::VisitUnaryExprOrTypeTraitExpr(
"sizeof operator for VariableArrayType",
e->getStmtClassName());
return builder.getConstant(
- loc, cir::IntAttr::get(cgf.cgm.UInt64Ty,
+ loc, cir::IntAttr::get(cgf.cgm.uInt64Ty,
llvm::APSInt(llvm::APInt(64, 1), true)));
}
} else if (e->getKind() == UETT_OpenMPRequiredSimdAlign) {
@@ -2228,12 +2228,12 @@ mlir::Value ScalarExprEmitter::VisitUnaryExprOrTypeTraitExpr(
e->getSourceRange(), "sizeof operator for OpenMpRequiredSimdAlign",
e->getStmtClassName());
return builder.getConstant(
- loc, cir::IntAttr::get(cgf.cgm.UInt64Ty,
+ loc, cir::IntAttr::get(cgf.cgm.uInt64Ty,
llvm::APSInt(llvm::APInt(64, 1), true)));
}
return builder.getConstant(
- loc, cir::IntAttr::get(cgf.cgm.UInt64Ty,
+ loc, cir::IntAttr::get(cgf.cgm.uInt64Ty,
e->EvaluateKnownConstInt(cgf.getContext())));
}
@@ -2329,14 +2329,14 @@ mlir::Value ScalarExprEmitter::VisitAbstractConditionalOperator(
mlir::Value lhs = Visit(lhsExpr);
if (!lhs) {
- lhs = builder.getNullValue(cgf.VoidTy, loc);
+ lhs = builder.getNullValue(cgf.voidTy, loc);
lhsIsVoid = true;
}
mlir::Value rhs = Visit(rhsExpr);
if (lhsIsVoid) {
assert(!rhs && "lhs and rhs types must match");
- rhs = builder.getNullValue(cgf.VoidTy, loc);
+ rhs = builder.getNullValue(cgf.voidTy, loc);
}
return builder.createSelect(loc, condV, lhs, rhs);
@@ -2381,7 +2381,7 @@ mlir::Value ScalarExprEmitter::VisitAbstractConditionalOperator(
if (!insertPoints.empty()) {
// If both arms are void, so be it.
if (!yieldTy)
- yieldTy = cgf.VoidTy;
+ yieldTy = cgf.voidTy;
// Insert required yields.
for (mlir::OpBuilder::InsertPoint &toInsert : insertPoints) {
diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
index 58feb36f78f23..71ff20a3b0e43 100644
--- a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
@@ -1008,7 +1008,7 @@ CIRGenFunction::emitArrayLength(const clang::ArrayType *origArrayType,
if (isa<VariableArrayType>(arrayType)) {
assert(cir::MissingFeatures::vlas());
cgm.errorNYI(*currSrcLoc, "VLAs");
- return builder.getConstInt(*currSrcLoc, SizeTy, 0);
+ return builder.getConstInt(*currSrcLoc, sizeTy, 0);
}
uint64_t countFromCLAs = 1;
@@ -1037,7 +1037,7 @@ CIRGenFunction::emitArrayLength(const clang::ArrayType *origArrayType,
}
baseType = eltType;
- return builder.getConstInt(*currSrcLoc, SizeTy, countFromCLAs);
+ return builder.getConstInt(*currSrcLoc, sizeTy, countFromCLAs);
}
mlir::Value CIRGenFunction::emitAlignmentAssumption(
@@ -1074,7 +1074,7 @@ CIRGenFunction::getVLASize(const VariableArrayType *type) {
elementType = type->getElementType();
mlir::Value vlaSize = vlaSizeMap[type->getSizeExpr()];
assert(vlaSize && "no size for VLA!");
- assert(vlaSize.getType() == SizeTy);
+ assert(vlaSize.getType() == sizeTy);
if (!numElements) {
numElements = vlaSize;
@@ -1188,7 +1188,7 @@ void CIRGenFunction::emitVariablyModifiedType(QualType type) {
// Always zexting here would be wrong if it weren't
// undefined behavior to have a negative bound.
// FIXME: What about when size's type is larger than size_t?
- entry = builder.createIntCast(size, SizeTy);
+ entry = builder.createIntCast(size, sizeTy);
}
}
type = vat->getElementType();
diff --git a/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp b/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp
index 88fedf1acc6a1..f603f5ec4383d 100644
--- a/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp
@@ -1846,13 +1846,13 @@ mlir::Value CIRGenItaniumCXXABI::getVirtualBaseClassOffset(
const CXXRecordDecl *classDecl, const CXXRecordDecl *baseClassDecl) {
CIRGenBuilderTy &builder = cgf.getBuilder();
mlir::Value vtablePtr = cgf.getVTablePtr(loc, thisAddr, classDecl);
- mlir::Value vtableBytePtr = builder.createBitcast(vtablePtr, cgm.UInt8PtrTy);
+ mlir::Value vtableBytePtr = builder.createBitcast(vtablePtr, cgm.uInt8PtrTy);
CharUnits vbaseOffsetOffset =
cgm.getItaniumVTableContext().getVirtualBaseOffsetOffset(classDecl,
baseClassDecl);
mlir::Value offsetVal =
builder.getSInt64(vbaseOffsetOffset.getQuantity(), loc);
- auto vbaseOffsetPtr = cir::PtrStrideOp::create(builder, loc, cgm.UInt8PtrTy,
+ auto vbaseOffsetPtr = cir::PtrStrideOp::create(builder, loc, cgm.uInt8PtrTy,
vtableBytePtr, offsetVal);
mlir::Value vbaseOffset;
@@ -1861,9 +1861,9 @@ mlir::Value CIRGenItaniumCXXABI::getVirtualBaseClassOffset(
cgm.errorNYI(loc, "getVirtualBaseClassOffset: relative layout");
} else {
mlir::Value offsetPtr = builder.createBitcast(
- vbaseOffsetPtr, builder.getPointerTo(cgm.PtrDiffTy));
+ vbaseOffsetPtr, builder.getPointerTo(cgm.ptrDiffTy));
vbaseOffset = builder.createLoad(
- loc, Address(offsetPtr, cgm.PtrDiffTy, cgf.getPointerAlign()));
+ loc, Address(offsetPtr, cgm.ptrDiffTy, cgf.getPointerAlign()));
}
return vbaseOffset;
}
@@ -2244,7 +2244,7 @@ Address CIRGenItaniumCXXABI::initializeArrayCookie(CIRGenFunction &cgf,
// Write the number of elements into the appropriate slot.
Address numElementsPtr =
- cookiePtr.withElementType(cgf.getBuilder(), cgf.SizeTy);
+ cookiePtr.withElementType(cgf.getBuilder(), cgf.sizeTy);
cgf.getBuilder().createStore(loc, numElements, numElementsPtr);
// Finally, compute a pointer to the actual data buffer by skipping
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
index 46adfe28e377a..9f9b2db4771df 100644
--- a/clang/lib/CIR/CodeGen/CIRGenModule.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
@@ -67,28 +67,28 @@ CIRGenModule::CIRGenModule(mlir::MLIRContext &mlirContext,
abi(createCXXABI(*this)), genTypes(*this), vtables(*this) {
// Initialize cached types
- VoidTy = cir::VoidType::get(&getMLIRContext());
- VoidPtrTy = cir::PointerType::get(VoidTy);
- SInt8Ty = cir::IntType::get(&getMLIRContext(), 8, /*isSigned=*/true);
- SInt16Ty = cir::IntType::get(&getMLIRContext(), 16, /*isSigned=*/true);
- SInt32Ty = cir::IntType::get(&getMLIRContext(), 32, /*isSigned=*/true);
- SInt64Ty = cir::IntType::get(&getMLIRContext(), 64, /*isSigned=*/true);
- SInt128Ty = cir::IntType::get(&getMLIRContext(), 128, /*isSigned=*/true);
- UInt8Ty = cir::IntType::get(&getMLIRContext(), 8, /*isSigned=*/false);
- UInt8PtrTy = cir::PointerType::get(UInt8Ty);
+ voidTy = cir::VoidType::get(&getMLIRContext());
+ voidPtrTy = cir::PointerType::get(voidTy);
+ sInt8Ty = cir::IntType::get(&getMLIRContext(), 8, /*isSigned=*/true);
+ sInt16Ty = cir::IntType::get(&getMLIRContext(), 16, /*isSigned=*/true);
+ sInt32Ty = cir::IntType::get(&getMLIRContext(), 32, /*isSigned=*/true);
+ sInt64Ty = cir::IntType::get(&getMLIRContext(), 64, /*isSigned=*/true);
+ sInt128Ty = cir::IntType::get(&getMLIRContext(), 128, /*isSigned=*/true);
+ uInt8Ty = cir::IntType::get(&getMLIRContext(), 8, /*isSigned=*/false);
+ uInt8PtrTy = cir::PointerType::get(uInt8Ty);
cirAllocaAddressSpace = getTargetCIRGenInfo().getCIRAllocaAddressSpace();
- UInt16Ty = cir::IntType::get(&getMLIRContext(), 16, /*isSigned=*/false);
- UInt32Ty = cir::IntType::get(&getMLIRContext(), 32, /*isSigned=*/false);
- UInt64Ty = cir::IntType::get(&getMLIRContext(), 64, /*isSigned=*/false);
- UInt128Ty = cir::IntType::get(&getMLIRContext(), 128, /*isSigned=*/false);
- FP16Ty = cir::FP16Type::get(&getMLIRContext());
- BFloat16Ty = cir::BF16Type::get(&getMLIRContext());
- FloatTy = cir::SingleType::get(&getMLIRContext());
- DoubleTy = cir::DoubleType::get(&getMLIRContext());
- FP80Ty = cir::FP80Type::get(&getMLIRContext());
- FP128Ty = cir::FP128Type::get(&getMLIRContext());
-
- AllocaInt8PtrTy = cir::PointerType::get(UInt8Ty, cirAllocaAddressSpace);
+ uInt16Ty = cir::IntType::get(&getMLIRContext(), 16, /*isSigned=*/false);
+ uInt32Ty = cir::IntType::get(&getMLIRContext(), 32, /*isSigned=*/false);
+ uInt64Ty = cir::IntType::get(&getMLIRContext(), 64, /*isSigned=*/false);
+ uInt128Ty = cir::IntType::get(&getMLIRContext(), 128, /*isSigned=*/false);
+ fP16Ty = cir::FP16Type::get(&getMLIRContext());
+ bFloat16Ty = cir::BF16Type::get(&getMLIRContext());
+ floatTy = cir::SingleType::get(&getMLIRContext());
+ doubleTy = cir::DoubleType::get(&getMLIRContext());
+ fP80Ty = cir::FP80Type::get(&getMLIRContext());
+ fP128Ty = cir::FP128Type::get(&getMLIRContext());
+
+ allocaInt8PtrTy = cir::PointerType::get(uInt8Ty, cirAllocaAddressSpace);
PointerAlignInBytes =
astContext
@@ -97,16 +97,16 @@ CIRGenModule::CIRGenModule(mlir::MLIRContext &mlirContext,
.getQuantity();
const unsigned charSize = astContext.getTargetInfo().getCharWidth();
- UCharTy = cir::IntType::get(&getMLIRContext(), charSize, /*isSigned=*/false);
+ uCharTy = cir::IntType::get(&getMLIRContext(), charSize, /*isSigned=*/false);
// TODO(CIR): Should be updated once TypeSizeInfoAttr is upstreamed
const unsigned sizeTypeSize =
astContext.getTypeSize(astContext.getSignedSizeType());
SizeSizeInBytes = astContext.toCharUnitsFromBits(sizeTypeSize).getQuantity();
// In CIRGenTypeCache, UIntPtrTy and SizeType are fields of the same union
- UIntPtrTy =
+ uIntPtrTy =
cir::IntType::get(&getMLIRContext(), sizeTypeSize, /*isSigned=*/false);
- PtrDiffTy =
+ ptrDiffTy =
cir::IntType::get(&getMLIRContext(), sizeTypeSize, /*isSigned=*/true);
std::optional<cir::SourceLanguage> sourceLanguage = getCIRSourceLanguage();
diff --git a/clang/lib/CIR/CodeGen/CIRGenOpenACCRecipe.cpp b/clang/lib/CIR/CodeGen/CIRGenOpenACCRecipe.cpp
index be063033ddcfc..890f8a6c8339d 100644
--- a/clang/lib/CIR/CodeGen/CIRGenOpenACCRecipe.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenOpenACCRecipe.cpp
@@ -617,11 +617,11 @@ void OpenACCRecipeBuilderBase::createReductionRecipeCombiner(
if (const auto *cat = cgf.getContext().getAsConstantArrayType(origType)) {
// If we're in an array, we have to emit the combiner for each element of
// the array.
- auto itrTy = mlir::cast<cir::IntType>(cgf.PtrDiffTy);
+ auto itrTy = mlir::cast<cir::IntType>(cgf.ptrDiffTy);
auto itrPtrTy = cir::PointerType::get(itrTy);
mlir::Value zero =
- builder.getConstInt(loc, mlir::cast<cir::IntType>(cgf.PtrDiffTy), 0);
+ builder.getConstInt(loc, mlir::cast<cir::IntType>(cgf.ptrDiffTy), 0);
mlir::Value itr =
cir::AllocaOp::create(builder, loc, itrPtrTy, itrTy, "itr",
cgf.cgm.getSize(cgf.getPointerAlign()));
@@ -633,7 +633,7 @@ void OpenACCRecipeBuilderBase::createReductionRecipeCombiner(
[&](mlir::OpBuilder &b, mlir::Location loc) {
auto loadItr = cir::LoadOp::create(builder, loc, {itr});
mlir::Value arraySize = builder.getConstInt(
- loc, mlir::cast<cir::IntType>(cgf.PtrDiffTy), cat->getZExtSize());
+ loc, mlir::cast<cir::IntType>(cgf.ptrDiffTy), cat->getZExtSize());
auto cmp = builder.createCompare(loc, cir::CmpOpKind::lt, loadItr,
arraySize);
builder.createCondition(cmp);
diff --git a/clang/lib/CIR/CodeGen/CIRGenTypeCache.h b/clang/lib/CIR/CodeGen/CIRGenTypeCache.h
index ff5842cd86e04..0f63e91f45564 100644
--- a/clang/lib/CIR/CodeGen/CIRGenTypeCache.h
+++ b/clang/lib/CIR/CodeGen/CIRGenTypeCache.h
@@ -26,47 +26,47 @@ struct CIRGenTypeCache {
CIRGenTypeCache() {}
// ClangIR void type
- cir::VoidType VoidTy;
+ cir::VoidType voidTy;
// ClangIR signed integral types of common sizes
- cir::IntType SInt8Ty;
- cir::IntType SInt16Ty;
- cir::IntType SInt32Ty;
- cir::IntType SInt64Ty;
- cir::IntType SInt128Ty;
+ cir::IntType sInt8Ty;
+ cir::IntType sInt16Ty;
+ cir::IntType sInt32Ty;
+ cir::IntType sInt64Ty;
+ cir::IntType sInt128Ty;
// ClangIR unsigned integral type of common sizes
- cir::IntType UInt8Ty;
- cir::IntType UInt16Ty;
- cir::IntType UInt32Ty;
- cir::IntType UInt64Ty;
- cir::IntType UInt128Ty;
+ cir::IntType uInt8Ty;
+ cir::IntType uInt16Ty;
+ cir::IntType uInt32Ty;
+ cir::IntType uInt64Ty;
+ cir::IntType uInt128Ty;
// ClangIR floating-point types with fixed formats
- cir::FP16Type FP16Ty;
- cir::BF16Type BFloat16Ty;
- cir::SingleType FloatTy;
- cir::DoubleType DoubleTy;
- cir::FP80Type FP80Ty;
- cir::FP128Type FP128Ty;
+ cir::FP16Type fP16Ty;
+ cir::BF16Type bFloat16Ty;
+ cir::SingleType floatTy;
+ cir::DoubleType doubleTy;
+ cir::FP80Type fP80Ty;
+ cir::FP128Type fP128Ty;
/// ClangIR char
- mlir::Type UCharTy;
+ mlir::Type uCharTy;
/// intptr_t, size_t, and ptr
diff _t, which we assume are the same size.
union {
- mlir::Type UIntPtrTy;
- mlir::Type SizeTy;
+ mlir::Type uIntPtrTy;
+ mlir::Type sizeTy;
};
- mlir::Type PtrDiffTy;
+ mlir::Type ptrDiffTy;
/// void* in address space 0
- cir::PointerType VoidPtrTy;
- cir::PointerType UInt8PtrTy;
+ cir::PointerType voidPtrTy;
+ cir::PointerType uInt8PtrTy;
/// void* in alloca address space
- cir::PointerType AllocaInt8PtrTy;
+ cir::PointerType allocaInt8PtrTy;
/// The size and alignment of a pointer into the generic address space.
union {
diff --git a/clang/lib/CIR/CodeGen/CIRGenTypes.cpp b/clang/lib/CIR/CodeGen/CIRGenTypes.cpp
index d1b91d0c73c04..03618d4a8a8a6 100644
--- a/clang/lib/CIR/CodeGen/CIRGenTypes.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenTypes.cpp
@@ -71,7 +71,7 @@ mlir::Type CIRGenTypes::convertFunctionTypeInternal(QualType qft) {
if (!isFuncTypeConvertible(ft)) {
cgm.errorNYI(SourceLocation(), "function type involving an incomplete type",
qft);
- return cir::FuncType::get(SmallVector<mlir::Type, 1>{}, cgm.VoidTy);
+ return cir::FuncType::get(SmallVector<mlir::Type, 1>{}, cgm.voidTy);
}
const CIRGenFunctionInfo *fi;
@@ -298,7 +298,7 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
switch (cast<BuiltinType>(ty)->getKind()) {
// void
case BuiltinType::Void:
- resultType = cgm.VoidTy;
+ resultType = cgm.voidTy;
break;
// bool
@@ -338,42 +338,42 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
// Floating-point types
case BuiltinType::Float16:
- resultType = cgm.FP16Ty;
+ resultType = cgm.fP16Ty;
break;
case BuiltinType::Half:
if (astContext.getLangOpts().NativeHalfType ||
!astContext.getTargetInfo().useFP16ConversionIntrinsics()) {
- resultType = cgm.FP16Ty;
+ resultType = cgm.fP16Ty;
} else {
cgm.errorNYI(SourceLocation(), "processing of built-in type", type);
- resultType = cgm.SInt32Ty;
+ resultType = cgm.sInt32Ty;
}
break;
case BuiltinType::BFloat16:
- resultType = cgm.BFloat16Ty;
+ resultType = cgm.bFloat16Ty;
break;
case BuiltinType::Float:
assert(&astContext.getFloatTypeSemantics(type) ==
&llvm::APFloat::IEEEsingle() &&
"ClangIR NYI: 'float' in a format other than IEEE 32-bit");
- resultType = cgm.FloatTy;
+ resultType = cgm.floatTy;
break;
case BuiltinType::Double:
assert(&astContext.getFloatTypeSemantics(type) ==
&llvm::APFloat::IEEEdouble() &&
"ClangIR NYI: 'double' in a format other than IEEE 64-bit");
- resultType = cgm.DoubleTy;
+ resultType = cgm.doubleTy;
break;
case BuiltinType::LongDouble:
resultType =
builder.getLongDoubleTy(astContext.getFloatTypeSemantics(type));
break;
case BuiltinType::Float128:
- resultType = cgm.FP128Ty;
+ resultType = cgm.fP128Ty;
break;
case BuiltinType::Ibm128:
cgm.errorNYI(SourceLocation(), "processing of built-in type", type);
- resultType = cgm.SInt32Ty;
+ resultType = cgm.sInt32Ty;
break;
case BuiltinType::NullPtr:
@@ -386,7 +386,7 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
default:
cgm.errorNYI(SourceLocation(), "processing of built-in type", type);
- resultType = cgm.SInt32Ty;
+ resultType = cgm.sInt32Ty;
break;
}
break;
@@ -439,7 +439,7 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
// int X[] -> [0 x int], unless the element type is not sized. If it is
// unsized (e.g. an incomplete record) just use [0 x i8].
if (!cir::isSized(elemTy)) {
- elemTy = cgm.SInt8Ty;
+ elemTy = cgm.sInt8Ty;
}
resultType = cir::ArrayType::get(elemTy, 0);
@@ -454,7 +454,7 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
// i8 just to have a concrete type"
if (!cir::isSized(elemTy)) {
cgm.errorNYI(SourceLocation(), "arrays of undefined struct type", type);
- resultType = cgm.UInt32Ty;
+ resultType = cgm.uInt32Ty;
break;
}
@@ -477,7 +477,7 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
// Return a placeholder 'i32' type. This can be changed later when the
// type is defined (see UpdateCompletedType), but is likely to be the
// "right" answer.
- resultType = cgm.UInt32Ty;
+ resultType = cgm.uInt32Ty;
break;
}
@@ -490,7 +490,7 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
const auto *bitIntTy = cast<BitIntType>(type);
if (bitIntTy->getNumBits() > cir::IntType::maxBitwidth()) {
cgm.errorNYI(SourceLocation(), "large _BitInt type", type);
- resultType = cgm.SInt32Ty;
+ resultType = cgm.sInt32Ty;
} else {
resultType = cir::IntType::get(&getMLIRContext(), bitIntTy->getNumBits(),
bitIntTy->isSigned());
@@ -515,7 +515,7 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
default:
cgm.errorNYI(SourceLocation(), "processing of type",
type->getTypeClassName());
- resultType = cgm.SInt32Ty;
+ resultType = cgm.sInt32Ty;
break;
}
More information about the cfe-commits
mailing list