[llvm] Remove GlobalObject::getAlign/setAlignment (PR #143188)
Eli Friedman via llvm-commits
llvm-commits at lists.llvm.org
Fri Jun 6 11:23:39 PDT 2025
https://github.com/efriedma-quic created https://github.com/llvm/llvm-project/pull/143188
Currently, GlobalObject has an "alignment" property... but it's basically nonsense: alignment doesn't mean the same thing for variables and functions, and it's completely meaningless for ifuncs.
This "removes" (actually marking protected) the methods from GlobalObject, adds the relevant methods to Function and GlobalVariable, and adjusts the code appropriately.
This should make future alignment-related cleanups easier.
>From 6ba8c9d180656ad4e60595f33509ff18b100517a Mon Sep 17 00:00:00 2001
From: Eli Friedman <efriedma at quicinc.com>
Date: Fri, 6 Jun 2025 10:43:18 -0700
Subject: [PATCH] Remove GlobalObject::getAlign/setAlignment
Currently, GlobalObject has an "alignment" property... but it's
basically nonsense: alignment doesn't mean the same thing for variables
and functions, and it's completely meaningless for ifuncs.
This "removes" (actually marking protected) the methods from
GlobalObject, adds the relevant methods to Function and GlobalVariable,
and adjusts the code appropriately.
This should make future alignment-related cleanups easier.
---
llvm/include/llvm/IR/Function.h | 21 ++++++++++
llvm/include/llvm/IR/GlobalObject.h | 8 +---
llvm/include/llvm/IR/GlobalVariable.h | 23 +++++++++++
llvm/include/llvm/SandboxIR/Constant.h | 38 ++++++------------
llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp | 6 ++-
llvm/lib/IR/Core.cpp | 8 +++-
llvm/lib/IR/IRBuilder.cpp | 6 +--
llvm/lib/IR/Value.cpp | 41 +++++++++-----------
llvm/lib/IR/Verifier.cpp | 16 +++++---
llvm/lib/LTO/LTOModule.cpp | 7 +++-
llvm/lib/SandboxIR/Constant.cpp | 14 ++-----
llvm/lib/Target/PowerPC/PPCMIPeephole.cpp | 7 ++--
llvm/lib/Target/SystemZ/SystemZSubtarget.cpp | 8 ++--
llvm/lib/Transforms/Utils/Local.cpp | 12 +++---
14 files changed, 123 insertions(+), 92 deletions(-)
diff --git a/llvm/include/llvm/IR/Function.h b/llvm/include/llvm/IR/Function.h
index b37c6c6f94a07..47c7bec1a03c8 100644
--- a/llvm/include/llvm/IR/Function.h
+++ b/llvm/include/llvm/IR/Function.h
@@ -1038,6 +1038,27 @@ class LLVM_ABI Function : public GlobalObject, public ilist_node<Function> {
/// Return value: true => null pointer dereference is not undefined.
bool nullPointerIsDefined() const;
+ /// Returns the alignment of the given function.
+ ///
+ /// Note that this is the alignment of the code, not the alignment of a
+ /// function pointer.
+ MaybeAlign getAlign() const {
+ return GlobalObject::getAlign();
+ }
+
+ /// Sets the alignment attribute of the Function.
+ void setAlignment(Align Align) {
+ GlobalObject::setAlignment(Align);
+ }
+
+ /// Sets the alignment attribute of the Function.
+ ///
+ /// This method will be deprecated as the alignment property should always be
+ /// defined.
+ void setAlignment(MaybeAlign Align) {
+ GlobalObject::setAlignment(Align);
+ }
+
private:
void allocHungoffUselist();
template<int Idx> void setHungoffOperand(Constant *C);
diff --git a/llvm/include/llvm/IR/GlobalObject.h b/llvm/include/llvm/IR/GlobalObject.h
index 557add940f452..08a02b42bdc14 100644
--- a/llvm/include/llvm/IR/GlobalObject.h
+++ b/llvm/include/llvm/IR/GlobalObject.h
@@ -67,12 +67,7 @@ class GlobalObject : public GlobalValue {
public:
GlobalObject(const GlobalObject &) = delete;
- /// FIXME: Remove this function once transition to Align is over.
- uint64_t getAlignment() const {
- MaybeAlign Align = getAlign();
- return Align ? Align->value() : 0;
- }
-
+protected:
/// Returns the alignment of the given variable or function.
///
/// Note that for functions this is the alignment of the code, not the
@@ -103,6 +98,7 @@ class GlobalObject : public GlobalValue {
assert(getGlobalObjectSubClassData() == Val && "representation error");
}
+public:
/// Check if this global has a custom object file section.
///
/// This is more efficient than calling getSection() and checking for an empty
diff --git a/llvm/include/llvm/IR/GlobalVariable.h b/llvm/include/llvm/IR/GlobalVariable.h
index a411897f5490e..3b64758dfe7ce 100644
--- a/llvm/include/llvm/IR/GlobalVariable.h
+++ b/llvm/include/llvm/IR/GlobalVariable.h
@@ -298,6 +298,29 @@ class GlobalVariable : public GlobalObject, public ilist_node<GlobalVariable> {
///
LLVM_ABI void clearCodeModel();
+ /// FIXME: Remove this function once transition to Align is over.
+ uint64_t getAlignment() const {
+ MaybeAlign Align = getAlign();
+ return Align ? Align->value() : 0;
+ }
+
+ /// Returns the alignment of the given variable.
+ MaybeAlign getAlign() const {
+ return GlobalObject::getAlign();
+ }
+
+ /// Sets the alignment attribute of the GlobalVariable.
+ void setAlignment(Align Align) {
+ GlobalObject::setAlignment(Align);
+ }
+
+ /// Sets the alignment attribute of the GlobalVariable.
+ /// This method will be deprecated as the alignment property should always be
+ /// defined.
+ void setAlignment(MaybeAlign Align) {
+ GlobalObject::setAlignment(Align);
+ }
+
// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Value *V) {
return V->getValueID() == Value::GlobalVariableVal;
diff --git a/llvm/include/llvm/SandboxIR/Constant.h b/llvm/include/llvm/SandboxIR/Constant.h
index 2012cf8a8ed3e..e7b18a442d330 100644
--- a/llvm/include/llvm/SandboxIR/Constant.h
+++ b/llvm/include/llvm/SandboxIR/Constant.h
@@ -976,32 +976,6 @@ class GlobalObject : public GlobalValue {
}
}
- /// FIXME: Remove this function once transition to Align is over.
- uint64_t getAlignment() const {
- return cast<llvm::GlobalObject>(Val)->getAlignment();
- }
-
- /// Returns the alignment of the given variable or function.
- ///
- /// Note that for functions this is the alignment of the code, not the
- /// alignment of a function pointer.
- MaybeAlign getAlign() const {
- return cast<llvm::GlobalObject>(Val)->getAlign();
- }
-
- // TODO: Add missing: setAlignment(Align)
-
- /// Sets the alignment attribute of the GlobalObject.
- /// This method will be deprecated as the alignment property should always be
- /// defined.
- void setAlignment(MaybeAlign Align);
-
- unsigned getGlobalObjectSubClassData() const {
- return cast<llvm::GlobalObject>(Val)->getGlobalObjectSubClassData();
- }
-
- void setGlobalObjectSubClassData(unsigned V);
-
/// Check if this global has a custom object file section.
///
/// This is more efficient than calling getSection() and checking for an empty
@@ -1294,6 +1268,18 @@ class GlobalVariable final
return cast<llvm::GlobalVariable>(Val)->getCodeModel();
}
+ /// Returns the alignment of the given variable.
+ MaybeAlign getAlign() const {
+ return cast<llvm::GlobalVariable>(Val)->getAlign();
+ }
+
+ // TODO: Add missing: setAligment(Align)
+
+ /// Sets the alignment attribute of the GlobalVariable.
+ /// This method will be deprecated as the alignment property should always be
+ /// defined.
+ void setAlignment(MaybeAlign Align);
+
// TODO: Missing setCodeModel(). Requires custom tracker.
#ifndef NDEBUG
diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
index bcfc64c6f36bb..e13e92378d4aa 100644
--- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
@@ -369,7 +369,11 @@ Align AsmPrinter::getGVAlignment(const GlobalObject *GV, const DataLayout &DL,
Alignment = InAlign;
// If the GV has a specified alignment, take it into account.
- const MaybeAlign GVAlign(GV->getAlign());
+ MaybeAlign GVAlign;
+ if (auto *GVar = dyn_cast<GlobalVariable>(GV))
+ GVAlign = GVar->getAlign();
+ else if (auto *F = dyn_cast<Function>(GV))
+ GVAlign = F->getAlign();
if (!GVAlign)
return Alignment;
diff --git a/llvm/lib/IR/Core.cpp b/llvm/lib/IR/Core.cpp
index 1954b44af22ad..a7c3a56dcc22a 100644
--- a/llvm/lib/IR/Core.cpp
+++ b/llvm/lib/IR/Core.cpp
@@ -2108,8 +2108,10 @@ LLVMTypeRef LLVMGlobalGetValueType(LLVMValueRef Global) {
unsigned LLVMGetAlignment(LLVMValueRef V) {
Value *P = unwrap(V);
- if (GlobalObject *GV = dyn_cast<GlobalObject>(P))
+ if (GlobalVariable *GV = dyn_cast<GlobalVariable>(P))
return GV->getAlign() ? GV->getAlign()->value() : 0;
+ if (Function *F = dyn_cast<Function>(P))
+ return F->getAlign() ? F->getAlign()->value() : 0;
if (AllocaInst *AI = dyn_cast<AllocaInst>(P))
return AI->getAlign().value();
if (LoadInst *LI = dyn_cast<LoadInst>(P))
@@ -2128,8 +2130,10 @@ unsigned LLVMGetAlignment(LLVMValueRef V) {
void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes) {
Value *P = unwrap(V);
- if (GlobalObject *GV = dyn_cast<GlobalObject>(P))
+ if (GlobalVariable *GV = dyn_cast<GlobalVariable>(P))
GV->setAlignment(MaybeAlign(Bytes));
+ else if (Function *F = dyn_cast<Function>(P))
+ F->setAlignment(MaybeAlign(Bytes));
else if (AllocaInst *AI = dyn_cast<AllocaInst>(P))
AI->setAlignment(Align(Bytes));
else if (LoadInst *LI = dyn_cast<LoadInst>(P))
diff --git a/llvm/lib/IR/IRBuilder.cpp b/llvm/lib/IR/IRBuilder.cpp
index 580b0af709337..90ec6626b3a70 100644
--- a/llvm/lib/IR/IRBuilder.cpp
+++ b/llvm/lib/IR/IRBuilder.cpp
@@ -457,10 +457,10 @@ CallInst *IRBuilderBase::CreateInvariantStart(Value *Ptr, ConstantInt *Size) {
}
static MaybeAlign getAlign(Value *Ptr) {
- if (auto *O = dyn_cast<GlobalObject>(Ptr))
- return O->getAlign();
+ if (auto *V = dyn_cast<GlobalVariable>(Ptr))
+ return V->getAlign();
if (auto *A = dyn_cast<GlobalAlias>(Ptr))
- return A->getAliaseeObject()->getAlign();
+ return getAlign(A->getAliaseeObject());
return {};
}
diff --git a/llvm/lib/IR/Value.cpp b/llvm/lib/IR/Value.cpp
index d6cb65d94a11d..02c16e201abe2 100644
--- a/llvm/lib/IR/Value.cpp
+++ b/llvm/lib/IR/Value.cpp
@@ -957,30 +957,27 @@ uint64_t Value::getPointerDereferenceableBytes(const DataLayout &DL,
Align Value::getPointerAlignment(const DataLayout &DL) const {
assert(getType()->isPointerTy() && "must be pointer");
- if (auto *GO = dyn_cast<GlobalObject>(this)) {
- if (isa<Function>(GO)) {
- Align FunctionPtrAlign = DL.getFunctionPtrAlign().valueOrOne();
- switch (DL.getFunctionPtrAlignType()) {
- case DataLayout::FunctionPtrAlignType::Independent:
- return FunctionPtrAlign;
- case DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign:
- return std::max(FunctionPtrAlign, GO->getAlign().valueOrOne());
- }
- llvm_unreachable("Unhandled FunctionPtrAlignType");
+ if (const Function *F = dyn_cast<Function>(this)) {
+ Align FunctionPtrAlign = DL.getFunctionPtrAlign().valueOrOne();
+ switch (DL.getFunctionPtrAlignType()) {
+ case DataLayout::FunctionPtrAlignType::Independent:
+ return FunctionPtrAlign;
+ case DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign:
+ return std::max(FunctionPtrAlign, F->getAlign().valueOrOne());
}
- const MaybeAlign Alignment(GO->getAlign());
+ llvm_unreachable("Unhandled FunctionPtrAlignType");
+ } else if (auto *GVar = dyn_cast<GlobalVariable>(this)) {
+ const MaybeAlign Alignment(GVar->getAlign());
if (!Alignment) {
- if (auto *GVar = dyn_cast<GlobalVariable>(GO)) {
- Type *ObjectType = GVar->getValueType();
- if (ObjectType->isSized()) {
- // If the object is defined in the current Module, we'll be giving
- // it the preferred alignment. Otherwise, we have to assume that it
- // may only have the minimum ABI alignment.
- if (GVar->isStrongDefinitionForLinker())
- return DL.getPreferredAlign(GVar);
- else
- return DL.getABITypeAlign(ObjectType);
- }
+ Type *ObjectType = GVar->getValueType();
+ if (ObjectType->isSized()) {
+ // If the object is defined in the current Module, we'll be giving
+ // it the preferred alignment. Otherwise, we have to assume that it
+ // may only have the minimum ABI alignment.
+ if (GVar->isStrongDefinitionForLinker())
+ return DL.getPreferredAlign(GVar);
+ else
+ return DL.getABITypeAlign(ObjectType);
}
}
return Alignment.valueOrOne();
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
index 2d03a7a261b5b..592bb6aa90613 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -735,12 +735,6 @@ void Verifier::visitGlobalValue(const GlobalValue &GV) {
"Global is external, but doesn't have external or weak linkage!", &GV);
if (const GlobalObject *GO = dyn_cast<GlobalObject>(&GV)) {
-
- if (MaybeAlign A = GO->getAlign()) {
- Check(A->value() <= Value::MaximumAlignment,
- "huge alignment values are unsupported", GO);
- }
-
if (const MDNode *Associated =
GO->getMetadata(LLVMContext::MD_associated)) {
Check(Associated->getNumOperands() == 1,
@@ -830,6 +824,11 @@ void Verifier::visitGlobalValue(const GlobalValue &GV) {
void Verifier::visitGlobalVariable(const GlobalVariable &GV) {
Type *GVType = GV.getValueType();
+ if (MaybeAlign A = GV.getAlign()) {
+ Check(A->value() <= Value::MaximumAlignment,
+ "huge alignment values are unsupported", &GV);
+ }
+
if (GV.hasInitializer()) {
Check(GV.getInitializer()->getType() == GVType,
"Global variable initializer type does not match global "
@@ -2869,6 +2868,11 @@ void Verifier::visitFunction(const Function &F) {
Check(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(),
"Invalid struct return type!", &F);
+ if (MaybeAlign A = F.getAlign()) {
+ Check(A->value() <= Value::MaximumAlignment,
+ "huge alignment values are unsupported", &F);
+ }
+
AttributeList Attrs = F.getAttributes();
Check(verifyAttributeCount(Attrs, FT->getNumParams()),
diff --git a/llvm/lib/LTO/LTOModule.cpp b/llvm/lib/LTO/LTOModule.cpp
index 749ae635e610c..e0a975806a31d 100644
--- a/llvm/lib/LTO/LTOModule.cpp
+++ b/llvm/lib/LTO/LTOModule.cpp
@@ -414,8 +414,11 @@ void LTOModule::addDefinedFunctionSymbol(StringRef Name, const GlobalValue *F) {
void LTOModule::addDefinedSymbol(StringRef Name, const GlobalValue *def,
bool isFunction) {
- const GlobalObject *go = dyn_cast<GlobalObject>(def);
- uint32_t attr = go ? Log2(go->getAlign().valueOrOne()) : 0;
+ uint32_t attr = 0;
+ if (auto *gv = dyn_cast<GlobalVariable>(def))
+ attr = Log2(gv->getAlign().valueOrOne());
+ else if (auto *f = dyn_cast<Function>(def))
+ attr = Log2(f->getAlign().valueOrOne());
// set permissions part
if (isFunction) {
diff --git a/llvm/lib/SandboxIR/Constant.cpp b/llvm/lib/SandboxIR/Constant.cpp
index fa79a01c7f345..5779a1c7738fb 100644
--- a/llvm/lib/SandboxIR/Constant.cpp
+++ b/llvm/lib/SandboxIR/Constant.cpp
@@ -282,20 +282,12 @@ PoisonValue *PoisonValue::getElementValue(unsigned Idx) const {
cast<llvm::PoisonValue>(Val)->getElementValue(Idx)));
}
-void GlobalObject::setAlignment(MaybeAlign Align) {
+void GlobalVariable::setAlignment(MaybeAlign Align) {
Ctx.getTracker()
.emplaceIfTracking<
- GenericSetter<&GlobalObject::getAlign, &GlobalObject::setAlignment>>(
+ GenericSetter<&GlobalVariable::getAlign, &GlobalVariable::setAlignment>>(
this);
- cast<llvm::GlobalObject>(Val)->setAlignment(Align);
-}
-
-void GlobalObject::setGlobalObjectSubClassData(unsigned V) {
- Ctx.getTracker()
- .emplaceIfTracking<
- GenericSetter<&GlobalObject::getGlobalObjectSubClassData,
- &GlobalObject::setGlobalObjectSubClassData>>(this);
- cast<llvm::GlobalObject>(Val)->setGlobalObjectSubClassData(V);
+ cast<llvm::GlobalVariable>(Val)->setAlignment(Align);
}
void GlobalObject::setSection(StringRef S) {
diff --git a/llvm/lib/Target/PowerPC/PPCMIPeephole.cpp b/llvm/lib/Target/PowerPC/PPCMIPeephole.cpp
index 1c53b740b3f81..18350650bfe2d 100644
--- a/llvm/lib/Target/PowerPC/PPCMIPeephole.cpp
+++ b/llvm/lib/Target/PowerPC/PPCMIPeephole.cpp
@@ -42,6 +42,7 @@
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachinePostDominators.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/IR/GlobalVariable.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/DebugCounter.h"
@@ -997,9 +998,9 @@ bool PPCMIPeephole::simplifyCode() {
// the transformation.
bool IsWordAligned = false;
if (SrcMI->getOperand(1).isGlobal()) {
- const GlobalObject *GO =
- dyn_cast<GlobalObject>(SrcMI->getOperand(1).getGlobal());
- if (GO && GO->getAlign() && *GO->getAlign() >= 4 &&
+ const GlobalVariable *GV =
+ dyn_cast<GlobalVariable>(SrcMI->getOperand(1).getGlobal());
+ if (GV && GV->getAlign() && *GV->getAlign() >= 4 &&
(SrcMI->getOperand(1).getOffset() % 4 == 0))
IsWordAligned = true;
} else if (SrcMI->getOperand(1).isImm()) {
diff --git a/llvm/lib/Target/SystemZ/SystemZSubtarget.cpp b/llvm/lib/Target/SystemZ/SystemZSubtarget.cpp
index 6c376e4bf622c..942ef88385620 100644
--- a/llvm/lib/Target/SystemZ/SystemZSubtarget.cpp
+++ b/llvm/lib/Target/SystemZ/SystemZSubtarget.cpp
@@ -8,7 +8,7 @@
#include "SystemZSubtarget.h"
#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
-#include "llvm/IR/GlobalValue.h"
+#include "llvm/IR/GlobalVariable.h"
#include "llvm/Target/TargetMachine.h"
using namespace llvm;
@@ -83,9 +83,9 @@ bool SystemZSubtarget::isAddressedViaADA(const GlobalValue *GV) const {
// least two byte alignment, then generated code can use relative
// instructions to address the variable. Otherwise, use the ADA to address
// the variable.
- if (GO->getAlignment() & 0x1) {
- return true;
- }
+ if (auto *GV = dyn_cast<GlobalVariable>(GO))
+ if (GV->getAlign() && (*GV->getAlign()).value() & 0x1)
+ return true;
// getKindForGlobal only works with definitions
if (GO->isDeclaration()) {
diff --git a/llvm/lib/Transforms/Utils/Local.cpp b/llvm/lib/Transforms/Utils/Local.cpp
index be71cb69ad8cc..cf6a6055afbb6 100644
--- a/llvm/lib/Transforms/Utils/Local.cpp
+++ b/llvm/lib/Transforms/Utils/Local.cpp
@@ -1548,9 +1548,9 @@ Align llvm::tryEnforceAlignment(Value *V, Align PrefAlign,
return PrefAlign;
}
- if (auto *GO = dyn_cast<GlobalObject>(V)) {
+ if (auto *GV = dyn_cast<GlobalVariable>(V)) {
// TODO: as above, this shouldn't be necessary.
- Align CurrentAlign = GO->getPointerAlignment(DL);
+ Align CurrentAlign = GV->getPointerAlignment(DL);
if (PrefAlign <= CurrentAlign)
return CurrentAlign;
@@ -1558,16 +1558,16 @@ Align llvm::tryEnforceAlignment(Value *V, Align PrefAlign,
// of the global. If the memory we set aside for the global may not be the
// memory used by the final program then it is impossible for us to reliably
// enforce the preferred alignment.
- if (!GO->canIncreaseAlignment())
+ if (!GV->canIncreaseAlignment())
return CurrentAlign;
- if (GO->isThreadLocal()) {
- unsigned MaxTLSAlign = GO->getParent()->getMaxTLSAlignment() / CHAR_BIT;
+ if (GV->isThreadLocal()) {
+ unsigned MaxTLSAlign = GV->getParent()->getMaxTLSAlignment() / CHAR_BIT;
if (MaxTLSAlign && PrefAlign > Align(MaxTLSAlign))
PrefAlign = Align(MaxTLSAlign);
}
- GO->setAlignment(PrefAlign);
+ GV->setAlignment(PrefAlign);
return PrefAlign;
}
More information about the llvm-commits
mailing list