[CIR][NFC] Update TypeCache file to use MLIR-style camel case #165060
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Andres-Salamanca
requested review from
AmrDeveloper,
andykaylor,
bcardosolopes and
xlauko
llvmbot
added
clang
|
@llvm/pr-subscribers-clang @llvm/pr-subscribers-clangir Author: None (Andres-Salamanca) ChangesThis PR updates the file Patch is 30.97 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/165060.diff 15 Files Affected:
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...
[truncated]
|
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/141/builds/12594 Here is the relevant piece of the build log for the reference |
aokblast
pushed a commit
to aokblast/llvm-project
that referenced
this pull request
Oct 30, 2025
…65060) This PR updates the file `CIRGenTypeCache` to use MLIR-style camel case naming.The change was inspired by the discussion here: llvm#164180 (comment)
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
5 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This PR updates the file
CIRGenTypeCacheto use MLIR-style camel case naming.The change was inspired by the discussion here:#164180 (comment)