[clang] [CIR] Add support for global linkage and visibility (PR #141973)
via cfe-commits
cfe-commits at lists.llvm.org
Thu May 29 09:18:11 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clangir
Author: Andy Kaylor (andykaylor)
<details>
<summary>Changes</summary>
This change adds support for the CIRGlobalValueInterface and attributes for visibility and comdat to GlobalOp.
The comdat attribute isn't correctly calculated yet, but it was required for the CIRGlobalValueInterface interface. There are also some cases where dso_local isn't set correctly, but it is better than it was before this change. Those issues will be addressed in a future patch.
---
Patch is 58.01 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/141973.diff
26 Files Affected:
- (modified) clang/include/clang/CIR/Dialect/IR/CIRAttrs.h (+1)
- (modified) clang/include/clang/CIR/Dialect/IR/CIRAttrs.td (+43)
- (modified) clang/include/clang/CIR/Dialect/IR/CIROps.td (+16-1)
- (modified) clang/include/clang/CIR/Dialect/IR/CMakeLists.txt (+2-2)
- (modified) clang/include/clang/CIR/MissingFeatures.h (+2-4)
- (modified) clang/lib/CIR/CodeGen/CIRGenModule.cpp (+205-13)
- (modified) clang/lib/CIR/CodeGen/CIRGenModule.h (+24-1)
- (modified) clang/lib/CIR/Dialect/IR/CIRDialect.cpp (+3)
- (modified) clang/lib/CIR/Interfaces/CIROpInterfaces.cpp (+14-3)
- (modified) clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp (+2-4)
- (modified) clang/test/CIR/CodeGen/array.cpp (+13-11)
- (modified) clang/test/CIR/CodeGen/namespace.cpp (+1-1)
- (modified) clang/test/CIR/CodeGen/string-literals.c (+6-6)
- (modified) clang/test/CIR/CodeGen/struct.c (+11-11)
- (modified) clang/test/CIR/CodeGen/struct.cpp (+2-2)
- (modified) clang/test/CIR/CodeGen/union.c (+1-1)
- (modified) clang/test/CIR/CodeGen/vector-ext.cpp (+5-5)
- (modified) clang/test/CIR/CodeGen/vector.cpp (+4-4)
- (modified) clang/test/CIR/IR/array.cir (+8-8)
- (modified) clang/test/CIR/IR/global-var-linkage.cir (+8-8)
- (modified) clang/test/CIR/IR/global.cir (+54-54)
- (modified) clang/test/CIR/Lowering/array.cpp (+9-9)
- (modified) clang/test/CIR/Lowering/global-var-simple.cpp (+33-33)
- (modified) clang/test/CIR/Lowering/hello.c (+2-5)
- (modified) clang/test/CIR/global-var-linkage.cpp (+7-7)
- (modified) clang/test/CIR/global-var-simple.cpp (+1-1)
``````````diff
diff --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.h b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.h
index 1451ea47c50c8..64556bcb92baa 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.h
+++ b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.h
@@ -13,6 +13,7 @@
#ifndef LLVM_CLANG_CIR_DIALECT_IR_CIRATTRS_H
#define LLVM_CLANG_CIR_DIALECT_IR_CIRATTRS_H
+#include "clang/CIR/Dialect/IR/CIROpsEnums.h"
#include "clang/CIR/Dialect/IR/CIRTypes.h"
#include "mlir/IR/Attributes.h"
diff --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
index 8152535930095..bddd7a825c505 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
@@ -276,4 +276,47 @@ def ConstPtrAttr : CIR_Attr<"ConstPtr", "ptr", [TypedAttrInterface]> {
}];
}
+//===----------------------------------------------------------------------===//
+// VisibilityAttr
+//===----------------------------------------------------------------------===//
+
+def VK_Default : I32EnumAttrCase<"Default", 1, "default">;
+def VK_Hidden : I32EnumAttrCase<"Hidden", 2, "hidden">;
+def VK_Protected : I32EnumAttrCase<"Protected", 3, "protected">;
+
+def VisibilityKind : I32EnumAttr<"VisibilityKind", "C/C++ visibility", [
+ VK_Default, VK_Hidden, VK_Protected
+]> {
+ let cppNamespace = "::cir";
+}
+
+def VisibilityAttr : CIR_Attr<"Visibility", "visibility"> {
+ let summary = "Visibility attribute";
+ let description = [{
+ Visibility attributes.
+ }];
+ let parameters = (ins "VisibilityKind":$value);
+
+ let assemblyFormat = [{
+ $value
+ }];
+
+ let builders = [
+ AttrBuilder<(ins CArg<"VisibilityKind", "cir::VisibilityKind::Default">:$value), [{
+ return $_get($_ctxt, value);
+ }]>
+ ];
+
+ let skipDefaultBuilders = 1;
+
+ // Make DefaultValuedAttr accept VisibilityKind as default value ($0).
+ let constBuilderCall = "cir::VisibilityAttr::get($_builder.getContext(), $0)";
+
+ let extraClassDeclaration = [{
+ bool isDefault() const { return getValue() == VisibilityKind::Default; };
+ bool isHidden() const { return getValue() == VisibilityKind::Hidden; };
+ bool isProtected() const { return getValue() == VisibilityKind::Protected; };
+ }];
+}
+
#endif // LLVM_CLANG_CIR_DIALECT_IR_CIRATTRS_TD
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index 5ce03c19369cb..6637ad14091cc 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -1634,7 +1634,8 @@ def GlobalLinkageKind : I32EnumAttr<
// properties of a global variable will be added over time as more of ClangIR
// is upstreamed.
-def GlobalOp : CIR_Op<"global"> {
+def GlobalOp : CIR_Op<"global",
+ [DeclareOpInterfaceMethods<CIRGlobalValueInterface>]> {
let summary = "Declare or define a global variable";
let description = [{
The `cir.global` operation declares or defines a named global variable.
@@ -1643,17 +1644,31 @@ def GlobalOp : CIR_Op<"global"> {
described by the type of the variable.
The `linkage` tracks C/C++ linkage types, currently very similar to LLVM's.
+ Symbol visibility in `sym_visibility` is defined in terms of MLIR's visibility
+ and verified to be in accordance to `linkage`.
}];
+ // Note that both sym_name and sym_visibility are tied to Symbol trait.
+ // TODO: sym_visibility can possibly be represented by implementing the
+ // necessary Symbol's interface in terms of linkage instead.
let arguments = (ins SymbolNameAttr:$sym_name,
+ DefaultValuedAttr<
+ VisibilityAttr,
+ "VisibilityKind::Default"
+ >:$global_visibility,
+ OptionalAttr<StrAttr>:$sym_visibility,
TypeAttr:$sym_type,
Arg<GlobalLinkageKind, "linkage type">:$linkage,
OptionalAttr<AnyAttr>:$initial_value,
+ UnitAttr:$comdat,
UnitAttr:$dsolocal,
OptionalAttr<I64Attr>:$alignment);
let assemblyFormat = [{
+ ($sym_visibility^)?
+ (`` $global_visibility^)?
$linkage
+ (`comdat` $comdat^)?
(`dsolocal` $dsolocal^)?
$sym_name
custom<GlobalOpTypeAndInitialValue>($sym_type, $initial_value)
diff --git a/clang/include/clang/CIR/Dialect/IR/CMakeLists.txt b/clang/include/clang/CIR/Dialect/IR/CMakeLists.txt
index 6e6d59ea5dadb..6e7f3da4add3e 100644
--- a/clang/include/clang/CIR/Dialect/IR/CMakeLists.txt
+++ b/clang/include/clang/CIR/Dialect/IR/CMakeLists.txt
@@ -14,10 +14,10 @@ mlir_tablegen(CIROpsDialect.cpp.inc -gen-dialect-defs)
add_public_tablegen_target(MLIRCIROpsIncGen)
add_dependencies(mlir-headers MLIRCIROpsIncGen)
-mlir_tablegen(CIROpsAttributes.h.inc -gen-attrdef-decls)
-mlir_tablegen(CIROpsAttributes.cpp.inc -gen-attrdef-defs)
mlir_tablegen(CIROpsEnums.h.inc -gen-enum-decls)
mlir_tablegen(CIROpsEnums.cpp.inc -gen-enum-defs)
+mlir_tablegen(CIROpsAttributes.h.inc -gen-attrdef-decls)
+mlir_tablegen(CIROpsAttributes.cpp.inc -gen-attrdef-defs)
add_public_tablegen_target(MLIRCIREnumsGen)
set(LLVM_TARGET_DEFINITIONS CIRTypeConstraints.td)
diff --git a/clang/include/clang/CIR/MissingFeatures.h b/clang/include/clang/CIR/MissingFeatures.h
index 56bf9b1130f12..11250be483edc 100644
--- a/clang/include/clang/CIR/MissingFeatures.h
+++ b/clang/include/clang/CIR/MissingFeatures.h
@@ -31,7 +31,6 @@ struct MissingFeatures {
static bool cgfSymbolTable() { return false; }
// Unhandled global/linkage information.
- static bool opGlobalDSOLocal() { return false; }
static bool opGlobalThreadLocal() { return false; }
static bool opGlobalConstant() { return false; }
static bool opGlobalWeakRef() { return false; }
@@ -41,11 +40,11 @@ struct MissingFeatures {
static bool opGlobalVisibility() { return false; }
static bool opGlobalDLLImportExport() { return false; }
static bool opGlobalPartition() { return false; }
- static bool opGlobalCIRGlobalValueInterface() { return false; }
static bool supportIFuncAttr() { return false; }
static bool supportVisibility() { return false; }
- static bool supportComdat() { return false; }
+ static bool hiddenVisibility() { return false; }
+ static bool protectedVisibility() { return false; }
// Load/store attributes
static bool opLoadStoreThreadLocal() { return false; }
@@ -188,7 +187,6 @@ struct MissingFeatures {
static bool updateCompletedType() { return false; }
static bool targetSpecificCXXABI() { return false; }
static bool moduleNameHash() { return false; }
- static bool setDSOLocal() { return false; }
static bool constantFoldSwitchStatement() { return false; }
static bool cudaSupport() { return false; }
static bool maybeHandleStaticInExternC() { return false; }
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
index b31b2b33d7d86..0d315aa277140 100644
--- a/clang/lib/CIR/CodeGen/CIRGenModule.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
@@ -21,6 +21,7 @@
#include "clang/AST/GlobalDecl.h"
#include "clang/Basic/SourceManager.h"
#include "clang/CIR/Dialect/IR/CIRDialect.h"
+#include "clang/CIR/Interfaces/CIROpInterfaces.h"
#include "clang/CIR/MissingFeatures.h"
#include "CIRGenFunctionInfo.h"
@@ -391,9 +392,7 @@ CIRGenModule::getOrCreateCIRGlobal(StringRef mangledName, mlir::Type ty,
if (d->getTLSKind())
errorNYI(d->getSourceRange(), "thread local global variable");
- assert(!cir::MissingFeatures::opGlobalDLLImportExport());
- assert(!cir::MissingFeatures::opGlobalPartition());
- assert(!cir::MissingFeatures::setDSOLocal());
+ setGVProperties(gv, d);
// If required by the ABI, treat declarations of static data members with
// inline initializers as definitions.
@@ -401,15 +400,20 @@ CIRGenModule::getOrCreateCIRGlobal(StringRef mangledName, mlir::Type ty,
errorNYI(d->getSourceRange(), "MS static data member inline definition");
assert(!cir::MissingFeatures::opGlobalSection());
- assert(!cir::MissingFeatures::opGlobalVisibility());
+ gv.setGlobalVisibilityAttr(getGlobalVisibilityAttrFromDecl(d));
// Handle XCore specific ABI requirements.
if (getTriple().getArch() == llvm::Triple::xcore)
errorNYI(d->getSourceRange(), "XCore specific ABI requirements");
- // We need to check for external const declarations with initializers here,
- // but the 'isPublic()' part of the check uses the CIRGlobalValueInterface.
- assert(!cir::MissingFeatures::opGlobalCIRGlobalValueInterface());
+ // Check if we a have a const declaration with an initializer, we may be
+ // able to emit it as available_externally to expose it's value to the
+ // optimizer.
+ if (getLangOpts().CPlusPlus && gv.isPublic() &&
+ d->getType().isConstQualified() && gv.isDeclaration() &&
+ !d->hasDefinition() && d->hasInit() && !d->hasAttr<DLLImportAttr>())
+ errorNYI(d->getSourceRange(),
+ "external const declaration with initializer");
}
return gv;
@@ -568,7 +572,9 @@ void CIRGenModule::emitGlobalVarDefinition(const clang::VarDecl *vd,
// Set CIR linkage and DLL storage class.
gv.setLinkage(linkage);
-
+ // FIXME(cir): setLinkage should likely set MLIR's visibility automatically.
+ gv.setVisibility(getMLIRVisibilityFromCIRLinkage(linkage));
+ assert(!cir::MissingFeatures::opGlobalDLLImportExport());
if (linkage == cir::GlobalLinkageKind::CommonLinkage)
errorNYI(initExpr->getSourceRange(), "common linkage");
}
@@ -632,8 +638,13 @@ CIRGenModule::getConstantArrayFromStringLiteral(const StringLiteral *e) {
return mlir::Attribute();
}
+bool CIRGenModule::supportsCOMDAT() const {
+ return getTriple().supportsCOMDAT();
+}
+
static bool shouldBeInCOMDAT(CIRGenModule &cgm, const Decl &d) {
- assert(!cir::MissingFeatures::supportComdat());
+ if (!cgm.supportsCOMDAT())
+ return false;
if (d.hasAttr<SelectAnyAttr>())
return true;
@@ -836,8 +847,11 @@ static cir::GlobalOp generateStringLiteral(mlir::Location loc,
assert(!cir::MissingFeatures::opGlobalThreadLocal());
assert(!cir::MissingFeatures::opGlobalUnnamedAddr());
CIRGenModule::setInitializer(gv, c);
- assert(!cir::MissingFeatures::supportComdat());
- assert(!cir::MissingFeatures::opGlobalDSOLocal());
+ if (gv.isWeakForLinker()) {
+ assert(cgm.supportsCOMDAT() && "Only COFF uses weak string literals");
+ gv.setComdat(true);
+ }
+ cgm.setDSOLocal(static_cast<mlir::Operation *>(gv));
return gv;
}
@@ -894,7 +908,7 @@ cir::GlobalOp CIRGenModule::getGlobalForStringLiteral(const StringLiteral *s,
auto typedC = llvm::cast<mlir::TypedAttr>(c);
cir::GlobalOp gv =
generateStringLiteral(loc, typedC, *this, uniqueName, alignment);
- assert(!cir::MissingFeatures::opGlobalDSOLocal());
+ setDSOLocal(static_cast<mlir::Operation *>(gv));
assert(!cir::MissingFeatures::sanitizers());
@@ -1075,6 +1089,135 @@ void CIRGenModule::emitTentativeDefinition(const VarDecl *d) {
emitGlobalVarDefinition(d);
}
+static bool shouldAssumeDSOLocal(const CIRGenModule &cgm,
+ cir::CIRGlobalValueInterface gv) {
+ if (gv.hasLocalLinkage())
+ return true;
+
+ if (!gv.hasDefaultVisibility() && !gv.hasExternalWeakLinkage())
+ return true;
+
+ // DLLImport explicitly marks the GV as external.
+ // so it shouldn't be dso_local
+ // But we don't have the info set now
+ assert(!cir::MissingFeatures::opGlobalDLLImportExport());
+
+ const llvm::Triple &tt = cgm.getTriple();
+ const auto &cgOpts = cgm.getCodeGenOpts();
+ if (tt.isWindowsGNUEnvironment()) {
+ // In MinGW, variables without DLLImport can still be automatically
+ // imported from a DLL by the linker; don't mark variables that
+ // potentially could come from another DLL as DSO local.
+
+ // With EmulatedTLS, TLS variables can be autoimported from other DLLs
+ // (and this actually happens in the public interface of libstdc++), so
+ // such variables can't be marked as DSO local. (Native TLS variables
+ // can't be dllimported at all, though.)
+ cgm.errorNYI("shouldAssumeDSOLocal: MinGW");
+ }
+
+ // On COFF, don't mark 'extern_weak' symbols as DSO local. If these symbols
+ // remain unresolved in the link, they can be resolved to zero, which is
+ // outside the current DSO.
+ if (tt.isOSBinFormatCOFF() && gv.hasExternalWeakLinkage())
+ return false;
+
+ // Every other GV is local on COFF.
+ // Make an exception for windows OS in the triple: Some firmware builds use
+ // *-win32-macho triples. This (accidentally?) produced windows relocations
+ // without GOT tables in older clang versions; Keep this behaviour.
+ // FIXME: even thread local variables?
+ if (tt.isOSBinFormatCOFF() || (tt.isOSWindows() && tt.isOSBinFormatMachO()))
+ return true;
+
+ // Only handle COFF and ELF for now.
+ if (!tt.isOSBinFormatELF())
+ return false;
+
+ llvm::Reloc::Model rm = cgOpts.RelocationModel;
+ const auto &lOpts = cgm.getLangOpts();
+ if (rm != llvm::Reloc::Static && !lOpts.PIE) {
+ // On ELF, if -fno-semantic-interposition is specified and the target
+ // supports local aliases, there will be neither CC1
+ // -fsemantic-interposition nor -fhalf-no-semantic-interposition. Set
+ // dso_local on the function if using a local alias is preferable (can avoid
+ // PLT indirection).
+ if (!(isa<cir::FuncOp>(gv) && gv.canBenefitFromLocalAlias()))
+ return false;
+ return !(cgm.getLangOpts().SemanticInterposition ||
+ cgm.getLangOpts().HalfNoSemanticInterposition);
+ }
+
+ // A definition cannot be preempted from an executable.
+ if (!gv.isDeclarationForLinker())
+ return true;
+
+ // Most PIC code sequences that assume that a symbol is local cannot produce a
+ // 0 if it turns out the symbol is undefined. While this is ABI and relocation
+ // depended, it seems worth it to handle it here.
+ if (rm == llvm::Reloc::PIC_ && gv.hasExternalWeakLinkage())
+ return false;
+
+ // PowerPC64 prefers TOC indirection to avoid copy relocations.
+ if (tt.isPPC64())
+ return false;
+
+ if (cgOpts.DirectAccessExternalData) {
+ // If -fdirect-access-external-data (default for -fno-pic), set dso_local
+ // for non-thread-local variables. If the symbol is not defined in the
+ // executable, a copy relocation will be needed at link time. dso_local is
+ // excluded for thread-local variables because they generally don't support
+ // copy relocations.
+ if (auto globalOp = dyn_cast<cir::GlobalOp>(gv.getOperation())) {
+ // Assume variables are not thread-local until that support is added.
+ assert(!cir::MissingFeatures::opGlobalThreadLocal());
+ return true;
+ }
+
+ // -fno-pic sets dso_local on a function declaration to allow direct
+ // accesses when taking its address (similar to a data symbol). If the
+ // function is not defined in the executable, a canonical PLT entry will be
+ // needed at link time. -fno-direct-access-external-data can avoid the
+ // canonical PLT entry. We don't generalize this condition to -fpie/-fpic as
+ // it could just cause trouble without providing perceptible benefits.
+ if (isa<cir::FuncOp>(gv) && !cgOpts.NoPLT && rm == llvm::Reloc::Static)
+ return true;
+ }
+
+ // If we can use copy relocations we can assume it is local.
+
+ // Otherwise don't assume it is local.
+
+ return false;
+}
+
+void CIRGenModule::setGlobalVisibility(mlir::Operation *gv,
+ const NamedDecl *d) const {
+ assert(!cir::MissingFeatures::opGlobalVisibility());
+}
+
+void CIRGenModule::setDSOLocal(cir::CIRGlobalValueInterface gv) const {
+ gv.setDSOLocal(shouldAssumeDSOLocal(*this, gv));
+}
+
+void CIRGenModule::setDSOLocal(mlir::Operation *op) const {
+ if (auto globalValue = dyn_cast<cir::CIRGlobalValueInterface>(op))
+ setDSOLocal(globalValue);
+}
+
+void CIRGenModule::setGVProperties(mlir::Operation *op,
+ const NamedDecl *d) const {
+ assert(!cir::MissingFeatures::opGlobalDLLImportExport());
+ setGVPropertiesAux(op, d);
+}
+
+void CIRGenModule::setGVPropertiesAux(mlir::Operation *op,
+ const NamedDecl *d) const {
+ setGlobalVisibility(op, d);
+ setDSOLocal(op);
+ assert(!cir::MissingFeatures::opGlobalPartition());
+}
+
cir::FuncOp CIRGenModule::getOrCreateCIRFunction(
StringRef mangledName, mlir::Type funcType, GlobalDecl gd, bool forVTable,
bool dontDefer, bool isThunk, ForDefinition_t isForDefinition,
@@ -1111,7 +1254,7 @@ cir::FuncOp CIRGenModule::getOrCreateCIRFunction(
// Handle dropped DLL attributes.
if (d && !d->hasAttr<DLLImportAttr>() && !d->hasAttr<DLLExportAttr>()) {
assert(!cir::MissingFeatures::setDLLStorageClass());
- assert(!cir::MissingFeatures::setDSOLocal());
+ setDSOLocal(entry);
}
// If there are two attempts to define the same mangled name, issue an
@@ -1165,6 +1308,55 @@ CIRGenModule::createCIRFunction(mlir::Location loc, StringRef name,
return func;
}
+mlir::SymbolTable::Visibility
+CIRGenModule::getMLIRVisibilityFromCIRLinkage(cir::GlobalLinkageKind glk) {
+ switch (glk) {
+ case cir::GlobalLinkageKind::InternalLinkage:
+ case cir::GlobalLinkageKind::PrivateLinkage:
+ return mlir::SymbolTable::Visibility::Private;
+ case cir::GlobalLinkageKind::ExternalLinkage:
+ case cir::GlobalLinkageKind::ExternalWeakLinkage:
+ case cir::GlobalLinkageKind::LinkOnceODRLinkage:
+ case cir::GlobalLinkageKind::AvailableExternallyLinkage:
+ case cir::GlobalLinkageKind::CommonLinkage:
+ case cir::GlobalLinkageKind::WeakAnyLinkage:
+ case cir::GlobalLinkageKind::WeakODRLinkage:
+ return mlir::SymbolTable::Visibility::Public;
+ default: {
+ llvm::errs() << "visibility not implemented for '"
+ << stringifyGlobalLinkageKind(glk) << "'\n";
+ assert(0 && "not implemented");
+ }
+ }
+ llvm_unreachable("linkage should be handled above!");
+}
+
+cir::VisibilityKind CIRGenModule::getGlobalVisibilityKindFromClangVisibility(
+ clang::VisibilityAttr::VisibilityType visibility) {
+ switch (visibility) {
+ case clang::VisibilityAttr::VisibilityType::Default:
+ return cir::VisibilityKind::Default;
+ case clang::VisibilityAttr::VisibilityType::Hidden:
+ return cir::VisibilityKind::Hidden;
+ case clang::VisibilityAttr::VisibilityType::Protected:
+ return cir::VisibilityKind::Protected;
+ }
+ llvm_unreachable("unexpected visibility value");
+}
+
+cir::VisibilityAttr
+CIRGenModule::getGlobalVisibilityAttrFromDecl(const Decl *decl) {
+ const clang::VisibilityAttr *va = decl->getAttr<clang::VisibilityAttr>();
+ cir::VisibilityAttr cirVisibility =
+ cir::VisibilityAttr::get(&getMLIRContext());
+ if (va) {
+ cirVisibility = cir::VisibilityAttr::get(
+ &getMLIRContext(),
+ getGlobalVisibilityKindFromClangVisibility(va->getVisibility()));
+ }
+ return cirVisibility;
+}
+
mlir::Type CIRGenModule::convertType(QualType type) {
return genTypes.convertType(type);
}
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.h b/clang/lib/CIR/CodeGen/CIRGenModule.h
index aac8fe72b1890..19cb5eda3507c 100644
--- a/clang/lib/CIR/CodeGen/CIRGenModule.h
+++ b/clang/lib/CIR/CodeGen/CIRGenModule.h
@@ -179,6 +179,16 @@ class CIRGenModule : public CIRGenTypeCache {
mlir::Type convertType(clang::QualType type);
+ /// Set the visibility for the given global.
+ void setGlobalVisibility(mlir::Operation *op, const NamedDecl *d) const;
+ void setDSOLocal(mlir::Operation *op) const;
+ void setDSOLocal(cir::CIRGlobalValueInterface gv) const;
+
+ /// Set visibility, dllimport/dllexport and dso_local.
+ /// This must be called after dllimport/dllexport is set.
+ void setGVProperties(mlir::Operation *op, const NamedDecl *d) const;
+ void setGVPropertiesAux(mlir::Operation *op, const NamedDecl *d) const;
+
void emitGlobalDefinition(clang::GlobalDecl gd,
mlir::Operation *op = nullptr);
void emitGlobalFunctionDefinition(clang::GlobalDecl gd, mlir::Operation *op);
@@ -198,6 +208,8 @@ class CIRGenModule : public CIRGenTypeCache {
void emitTentativeDefinition(const VarDecl *d);
+ bool supportsC...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/141973
More information about the cfe-commits
mailing list