[clang] [CIR][NFC] Move createGlobalOp to be a member function (PR #197445)
via cfe-commits
cfe-commits at lists.llvm.org
Wed May 13 06:34:22 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clangir
Author: Erich Keane (erichkeane)
<details>
<summary>Changes</summary>
For some reason this was a static function with the first argument being a CIRGenModule object anyway. This is a NFC that I tried to do as a drive-by earlier but got called out on, so here it is :)
---
Full diff: https://github.com/llvm/llvm-project/pull/197445.diff
4 Files Affected:
- (modified) clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp (+2-2)
- (modified) clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp (+4-5)
- (modified) clang/lib/CIR/CodeGen/CIRGenModule.cpp (+26-28)
- (modified) clang/lib/CIR/CodeGen/CIRGenModule.h (+3-3)
``````````diff
diff --git a/clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp b/clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp
index 0466c212fe165..868e80e2a2b31 100644
--- a/clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp
@@ -334,8 +334,8 @@ mlir::Operation *CIRGenNVCUDARuntime::getKernelHandle(cir::FuncOp fn,
StringRef globalName = cgm.getMangledName(
gd.getWithKernelReferenceKind(KernelReferenceKind::Kernel));
cir::PointerType fnPtrTy = builder.getPointerTo(fn.getFunctionType());
- cir::GlobalOp globalOp = CIRGenModule::createGlobalOp(
- cgm, fn.getLoc(), globalName, fnPtrTy, /*isConstant=*/true);
+ cir::GlobalOp globalOp =
+ cgm.createGlobalOp(fn.getLoc(), globalName, fnPtrTy, /*isConstant=*/true);
globalOp->setAttr("alignment", builder.getI64IntegerAttr(
cgm.getPointerAlign().getQuantity()));
diff --git a/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp b/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp
index 750bb7b87c10d..560a4de9b9b01 100644
--- a/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp
@@ -1202,8 +1202,8 @@ CIRGenItaniumRTTIBuilder::getAddrOfExternalRTTIDescriptor(mlir::Location loc,
// From LLVM codegen => Note for the future: If we would ever like to do
// deferred emission of RTTI, check if emitting vtables opportunistically
// need any adjustment.
- gv = CIRGenModule::createGlobalOp(cgm, loc, name, builder.getUInt8PtrTy(),
- /*isConstant=*/true);
+ gv = cgm.createGlobalOp(loc, name, builder.getUInt8PtrTy(),
+ /*isConstant=*/true);
const CXXRecordDecl *rd = ty->getAsCXXRecordDecl();
cgm.setGVProperties(gv, rd);
@@ -1601,9 +1601,8 @@ mlir::Attribute CIRGenItaniumRTTIBuilder::buildTypeInfo(
// Create new global and search for an existing global.
auto oldGV = dyn_cast_or_null<cir::GlobalOp>(cgm.getGlobalValue(name));
- cir::GlobalOp gv =
- CIRGenModule::createGlobalOp(cgm, loc, name, init.getType(),
- /*isConstant=*/true);
+ cir::GlobalOp gv = cgm.createGlobalOp(loc, name, init.getType(),
+ /*isConstant=*/true);
gv.setLinkage(linkage);
// Export the typeinfo in the same circumstances as the vtable is
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
index 9ebdac56006a4..5a980a15a40c0 100644
--- a/clang/lib/CIR/CodeGen/CIRGenModule.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
@@ -683,12 +683,12 @@ mlir::Operation *CIRGenModule::getGlobalValue(StringRef name) {
}
cir::GlobalOp
-CIRGenModule::createGlobalOp(CIRGenModule &cgm, mlir::Location loc,
- StringRef name, mlir::Type t, bool isConstant,
+CIRGenModule::createGlobalOp(mlir::Location loc, StringRef name, mlir::Type t,
+ bool isConstant,
mlir::ptr::MemorySpaceAttrInterface addrSpace,
mlir::Operation *insertPoint) {
cir::GlobalOp g;
- CIRGenBuilderTy &builder = cgm.getBuilder();
+ CIRGenBuilderTy &builder = getBuilder();
{
mlir::OpBuilder::InsertionGuard guard(builder);
@@ -700,22 +700,22 @@ CIRGenModule::createGlobalOp(CIRGenModule &cgm, mlir::Location loc,
builder.setInsertionPoint(insertPoint);
} else {
// Group global operations together at the top of the module.
- if (cgm.lastGlobalOp)
- builder.setInsertionPointAfter(cgm.lastGlobalOp);
+ if (lastGlobalOp)
+ builder.setInsertionPointAfter(lastGlobalOp);
else
- builder.setInsertionPointToStart(cgm.getModule().getBody());
+ builder.setInsertionPointToStart(getModule().getBody());
}
g = cir::GlobalOp::create(builder, loc, name, t, isConstant, addrSpace);
if (!insertPoint)
- cgm.lastGlobalOp = g;
+ lastGlobalOp = g;
// Default to private until we can judge based on the initializer,
// since MLIR doesn't allow public declarations.
mlir::SymbolTable::setSymbolVisibility(
g, mlir::SymbolTable::Visibility::Private);
}
- cgm.symbolLookupCache[g.getSymNameAttr()] = g;
+ symbolLookupCache[g.getSymNameAttr()] = g;
return g;
}
@@ -1130,9 +1130,8 @@ CIRGenModule::getOrCreateCIRGlobal(StringRef mangledName, mlir::Type ty,
// mlir::SymbolTable::Visibility::Public is the default, no need to explicitly
// mark it as such.
- cir::GlobalOp gv = CIRGenModule::createGlobalOp(
- *this, loc, mangledName, ty, isConstant, declCIRAS,
- /*insertPoint=*/entry.getOperation());
+ cir::GlobalOp gv = createGlobalOp(loc, mangledName, ty, isConstant, declCIRAS,
+ /*insertPoint=*/entry.getOperation());
// If we already created a global with the same mangled name (but different
// type) before, remove it from its parent.
@@ -1298,8 +1297,8 @@ static void emitUsed(CIRGenModule &cgm, StringRef name,
cir::ConstArrayAttr initAttr = cir::ConstArrayAttr::get(
arrayTy, mlir::ArrayAttr::get(&cgm.getMLIRContext(), usedArray));
- cir::GlobalOp gv = CIRGenModule::createGlobalOp(cgm, loc, name, arrayTy,
- /*isConstant=*/false);
+ cir::GlobalOp gv = cgm.createGlobalOp(loc, name, arrayTy,
+ /*isConstant=*/false);
gv.setLinkage(cir::GlobalLinkageKind::AppendingLinkage);
gv.setInitialValueAttr(initAttr);
gv.setSectionAttr(builder.getStringAttr("llvm.metadata"));
@@ -1731,7 +1730,7 @@ cir::GlobalOp CIRGenModule::createOrReplaceCXXRuntimeVariable(
}
// Create a new variable.
- gv = createGlobalOp(*this, loc, name, ty);
+ gv = createGlobalOp(loc, name, ty);
// Set up extra information and add to the module
gv.setLinkageAttr(
@@ -2033,8 +2032,8 @@ generateStringLiteral(mlir::Location loc, mlir::TypedAttr c,
// Create a global variable for this string
// FIXME(cir): check for insertion point in module level.
- cir::GlobalOp gv = CIRGenModule::createGlobalOp(
- cgm, loc, globalName, c.getType(), !cgm.getLangOpts().WritableStrings);
+ cir::GlobalOp gv = cgm.createGlobalOp(loc, globalName, c.getType(),
+ !cgm.getLangOpts().WritableStrings);
// Set up extra information and add to the module
gv.setAlignmentAttr(cgm.getSize(alignment));
@@ -3409,7 +3408,7 @@ void CIRGenModule::release() {
cir::LangAddressSpaceAttr::get(&getMLIRContext(),
getGlobalVarAddressSpace(nullptr));
- auto gv = createGlobalOp(*this, loc, cuidName, int8Ty,
+ auto gv = createGlobalOp(loc, cuidName, int8Ty,
/*isConstant=*/false, addrSpace);
gv.setLinkage(cir::GlobalLinkageKind::ExternalLinkage);
// Initialize with zero
@@ -3492,14 +3491,13 @@ void CIRGenModule::emitAliasDefinition(GlobalDecl gd) {
// TODO(cir): Make GlobalAlias a separate op.
cir::CIRGlobalValueInterface alias =
- isFunction
- ? mlir::cast<cir::CIRGlobalValueInterface>(
- createCIRFunction(loc, mangledName,
- mlir::cast<cir::FuncType>(declTy),
- cast<FunctionDecl>(d))
- .getOperation())
- : mlir::cast<cir::CIRGlobalValueInterface>(
- createGlobalOp(*this, loc, mangledName, declTy).getOperation());
+ isFunction ? mlir::cast<cir::CIRGlobalValueInterface>(
+ createCIRFunction(loc, mangledName,
+ mlir::cast<cir::FuncType>(declTy),
+ cast<FunctionDecl>(d))
+ .getOperation())
+ : mlir::cast<cir::CIRGlobalValueInterface>(
+ createGlobalOp(loc, mangledName, declTy).getOperation());
alias.setAliasee(aa->getAliasee());
alias.setLinkage(linkage);
mlir::SymbolTable::setSymbolVisibility(alias, visibility);
@@ -3763,7 +3761,7 @@ CIRGenModule::getAddrOfGlobalTemporary(const MaterializeTemporaryExpr *mte,
}
}
mlir::Location loc = getLoc(mte->getSourceRange());
- cir::GlobalOp gv = createGlobalOp(*this, loc, name, type, isConstant);
+ cir::GlobalOp gv = createGlobalOp(loc, name, type, isConstant);
gv.setInitialValueAttr(initialValue);
if (emitter)
@@ -3829,7 +3827,7 @@ cir::GlobalOp CIRGenModule::getAddrOfUnnamedGlobalConstantDecl(
std::string name = numEntries == 0
? ".constant"
: (Twine(".constant.") + Twine(numEntries)).str();
- auto globalOp = createGlobalOp(*this, builder.getUnknownLoc(), name,
+ auto globalOp = createGlobalOp(builder.getUnknownLoc(), name,
typedInit.getType(), /*is_constant=*/true);
globalOp.setLinkage(cir::GlobalLinkageKind::PrivateLinkage);
@@ -3870,7 +3868,7 @@ CIRGenModule::getAddrOfTemplateParamObject(const TemplateParamObjectDecl *tpo) {
: cir::GlobalLinkageKind::InternalLinkage;
assert(!cir::MissingFeatures::addressSpace());
- auto globalOp = createGlobalOp(*this, builder.getUnknownLoc(), name,
+ auto globalOp = createGlobalOp(builder.getUnknownLoc(), name,
typedInit.getType(), /*is_constant=*/true);
globalOp.setLinkage(linkage);
globalOp.setAlignment(alignment.getAsAlign().value());
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.h b/clang/lib/CIR/CodeGen/CIRGenModule.h
index e2184ef8640f3..dcd185da72b75 100644
--- a/clang/lib/CIR/CodeGen/CIRGenModule.h
+++ b/clang/lib/CIR/CodeGen/CIRGenModule.h
@@ -275,9 +275,9 @@ class CIRGenModule : public CIRGenTypeCache {
cir::GlobalOp getOrCreateCIRGlobal(const VarDecl *d, mlir::Type ty,
ForDefinition_t isForDefinition);
- static cir::GlobalOp
- createGlobalOp(CIRGenModule &cgm, mlir::Location loc, llvm::StringRef name,
- mlir::Type t, bool isConstant = false,
+ cir::GlobalOp
+ createGlobalOp(mlir::Location loc, llvm::StringRef name, mlir::Type t,
+ bool isConstant = false,
mlir::ptr::MemorySpaceAttrInterface addrSpace = {},
mlir::Operation *insertPoint = nullptr);
``````````
</details>
https://github.com/llvm/llvm-project/pull/197445
More information about the cfe-commits
mailing list