LLVM 19.0.0git
LowerGlobalDtors.cpp
Go to the documentation of this file.
1//===-- LowerGlobalDtors.cpp - Lower @llvm.global_dtors -------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// Lower @llvm.global_dtors.
11///
12/// Implement @llvm.global_dtors by creating wrapper functions that are
13/// registered in @llvm.global_ctors and which contain a call to
14/// `__cxa_atexit` to register their destructor functions.
15///
16//===----------------------------------------------------------------------===//
17
19
20#include "llvm/IR/Constants.h"
22#include "llvm/IR/Intrinsics.h"
24#include "llvm/Pass.h"
27#include <map>
28
29using namespace llvm;
30
31#define DEBUG_TYPE "lower-global-dtors"
32
33namespace {
34class LowerGlobalDtorsLegacyPass final : public ModulePass {
35 StringRef getPassName() const override {
36 return "Lower @llvm.global_dtors via `__cxa_atexit`";
37 }
38
39 void getAnalysisUsage(AnalysisUsage &AU) const override {
40 AU.setPreservesCFG();
42 }
43
44 bool runOnModule(Module &M) override;
45
46public:
47 static char ID;
48 LowerGlobalDtorsLegacyPass() : ModulePass(ID) {
50 }
51};
52} // End anonymous namespace
53
54char LowerGlobalDtorsLegacyPass::ID = 0;
55INITIALIZE_PASS(LowerGlobalDtorsLegacyPass, DEBUG_TYPE,
56 "Lower @llvm.global_dtors via `__cxa_atexit`", false, false)
57
59 return new LowerGlobalDtorsLegacyPass();
60}
61
62static bool runImpl(Module &M);
63bool LowerGlobalDtorsLegacyPass::runOnModule(Module &M) { return runImpl(M); }
64
67 bool Changed = runImpl(M);
68 if (!Changed)
70
73 return PA;
74}
75
76static bool runImpl(Module &M) {
77 GlobalVariable *GV = M.getGlobalVariable("llvm.global_dtors");
78 if (!GV || !GV->hasInitializer())
79 return false;
80
81 const ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
82 if (!InitList)
83 return false;
84
85 // Validate @llvm.global_dtor's type.
86 auto *ETy = dyn_cast<StructType>(InitList->getType()->getElementType());
87 if (!ETy || ETy->getNumElements() != 3 ||
88 !ETy->getTypeAtIndex(0U)->isIntegerTy() ||
89 !ETy->getTypeAtIndex(1U)->isPointerTy() ||
90 !ETy->getTypeAtIndex(2U)->isPointerTy())
91 return false; // Not (int, ptr, ptr).
92
93 // Collect the contents of @llvm.global_dtors, ordered by priority. Within a
94 // priority, sequences of destructors with the same associated object are
95 // recorded so that we can register them as a group.
96 std::map<
98 std::vector<std::pair<Constant *, std::vector<Constant *>>>
99 > DtorFuncs;
100 for (Value *O : InitList->operands()) {
101 auto *CS = dyn_cast<ConstantStruct>(O);
102 if (!CS)
103 continue; // Malformed.
104
105 auto *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
106 if (!Priority)
107 continue; // Malformed.
108 uint16_t PriorityValue = Priority->getLimitedValue(UINT16_MAX);
109
110 Constant *DtorFunc = CS->getOperand(1);
111 if (DtorFunc->isNullValue())
112 break; // Found a null terminator, skip the rest.
113
114 Constant *Associated = CS->getOperand(2);
115 Associated = cast<Constant>(Associated->stripPointerCasts());
116
117 auto &AtThisPriority = DtorFuncs[PriorityValue];
118 if (AtThisPriority.empty() || AtThisPriority.back().first != Associated) {
119 std::vector<Constant *> NewList;
120 NewList.push_back(DtorFunc);
121 AtThisPriority.push_back(std::make_pair(Associated, NewList));
122 } else {
123 AtThisPriority.back().second.push_back(DtorFunc);
124 }
125 }
126 if (DtorFuncs.empty())
127 return false;
128
129 // extern "C" int __cxa_atexit(void (*f)(void *), void *p, void *d);
130 LLVMContext &C = M.getContext();
132 Type *AtExitFuncArgs[] = {VoidStar};
133 FunctionType *AtExitFuncTy =
134 FunctionType::get(Type::getVoidTy(C), AtExitFuncArgs,
135 /*isVarArg=*/false);
136
137 FunctionCallee AtExit = M.getOrInsertFunction(
138 "__cxa_atexit",
140 {PointerType::get(AtExitFuncTy, 0), VoidStar, VoidStar},
141 /*isVarArg=*/false));
142
143 // If __cxa_atexit is defined (e.g. in the case of LTO) and arg0 is not
144 // actually used (i.e. it's dummy/stub function as used in emscripten when
145 // the program never exits) we can simply return early and clear out
146 // @llvm.global_dtors.
147 if (auto F = dyn_cast<Function>(AtExit.getCallee())) {
148 if (F && F->hasExactDefinition() && F->getArg(0)->getNumUses() == 0) {
149 GV->eraseFromParent();
150 return true;
151 }
152 }
153
154 // Declare __dso_local.
155 Type *DsoHandleTy = Type::getInt8Ty(C);
156 Constant *DsoHandle = M.getOrInsertGlobal("__dso_handle", DsoHandleTy, [&] {
157 auto *GV = new GlobalVariable(M, DsoHandleTy, /*isConstant=*/true,
159 "__dso_handle");
161 return GV;
162 });
163
164 // For each unique priority level and associated symbol, generate a function
165 // to call all the destructors at that level, and a function to register the
166 // first function with __cxa_atexit.
167 for (auto &PriorityAndMore : DtorFuncs) {
168 uint16_t Priority = PriorityAndMore.first;
169 uint64_t Id = 0;
170 auto &AtThisPriority = PriorityAndMore.second;
171 for (auto &AssociatedAndMore : AtThisPriority) {
172 Constant *Associated = AssociatedAndMore.first;
173 auto ThisId = Id++;
174
175 Function *CallDtors = Function::Create(
176 AtExitFuncTy, Function::PrivateLinkage,
177 "call_dtors" +
178 (Priority != UINT16_MAX ? (Twine(".") + Twine(Priority))
179 : Twine()) +
180 (AtThisPriority.size() > 1 ? Twine("$") + Twine(ThisId)
181 : Twine()) +
182 (!Associated->isNullValue() ? (Twine(".") + Associated->getName())
183 : Twine()),
184 &M);
185 BasicBlock *BB = BasicBlock::Create(C, "body", CallDtors);
187 /*isVarArg=*/false);
188
189 for (auto *Dtor : reverse(AssociatedAndMore.second))
190 CallInst::Create(VoidVoid, Dtor, "", BB);
192
193 Function *RegisterCallDtors = Function::Create(
194 VoidVoid, Function::PrivateLinkage,
195 "register_call_dtors" +
196 (Priority != UINT16_MAX ? (Twine(".") + Twine(Priority))
197 : Twine()) +
198 (AtThisPriority.size() > 1 ? Twine("$") + Twine(ThisId)
199 : Twine()) +
200 (!Associated->isNullValue() ? (Twine(".") + Associated->getName())
201 : Twine()),
202 &M);
203 BasicBlock *EntryBB = BasicBlock::Create(C, "entry", RegisterCallDtors);
204 BasicBlock *FailBB = BasicBlock::Create(C, "fail", RegisterCallDtors);
205 BasicBlock *RetBB = BasicBlock::Create(C, "return", RegisterCallDtors);
206
208 Value *Args[] = {CallDtors, Null, DsoHandle};
209 Value *Res = CallInst::Create(AtExit, Args, "call", EntryBB);
210 Value *Cmp = new ICmpInst(EntryBB, ICmpInst::ICMP_NE, Res,
212 BranchInst::Create(FailBB, RetBB, Cmp, EntryBB);
213
214 // If `__cxa_atexit` hits out-of-memory, trap, so that we don't misbehave.
215 // This should be very rare, because if the process is running out of
216 // memory before main has even started, something is wrong.
217 CallInst::Create(Intrinsic::getDeclaration(&M, Intrinsic::trap), "",
218 FailBB);
219 new UnreachableInst(C, FailBB);
220
221 ReturnInst::Create(C, RetBB);
222
223 // Now register the registration function with @llvm.global_ctors.
224 appendToGlobalCtors(M, RegisterCallDtors, Priority, Associated);
225 }
226 }
227
228 // Now that we've lowered everything, remove @llvm.global_dtors.
229 GV->eraseFromParent();
230
231 return true;
232}
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static bool runImpl(Function &F, const TargetLowering &TLI)
static bool runImpl(Module &M)
#define DEBUG_TYPE
#define F(x, y, z)
Definition: MD5.cpp:55
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:38
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:321
Represent the analysis usage information of a pass.
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:269
Type * getElementType() const
Definition: DerivedTypes.h:384
LLVM Basic Block Representation.
Definition: BasicBlock.h:60
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:199
static BranchInst * Create(BasicBlock *IfTrue, BasicBlock::iterator InsertBefore)
Represents analyses that only rely on functions' control flow.
Definition: Analysis.h:70
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr, BasicBlock::iterator InsertBefore)
@ ICMP_NE
not equal
Definition: InstrTypes.h:1015
ConstantArray - Constant Array Declarations.
Definition: Constants.h:424
ArrayType * getType() const
Specialize the getType() method to always return an ArrayType, which reduces the amount of casting ne...
Definition: Constants.h:443
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
Definition: Constants.cpp:1762
This is an important base class in LLVM.
Definition: Constant.h:41
const Constant * stripPointerCasts() const
Definition: Constant.h:213
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:370
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:90
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Definition: DerivedTypes.h:168
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:164
@ HiddenVisibility
The GV is hidden.
Definition: GlobalValue.h:67
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:253
@ PrivateLinkage
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:59
@ ExternalWeakLinkage
ExternalWeak linkage description.
Definition: GlobalValue.h:60
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool hasInitializer() const
Definitions have initializers, declarations don't.
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:467
This instruction compares its operands according to the predicate given to the constructor.
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:251
virtual bool runOnModule(Module &M)=0
runOnModule - Virtual method overriden by subclasses to process the module being operated on.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: Pass.cpp:98
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:81
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space.
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
Definition: DerivedTypes.h:662
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:109
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: Analysis.h:115
void preserveSet()
Mark an analysis set as preserved.
Definition: Analysis.h:144
static ReturnInst * Create(LLVMContext &C, Value *retVal, BasicBlock::iterator InsertBefore)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
static Type * getVoidTy(LLVMContext &C)
static IntegerType * getInt8Ty(LLVMContext &C)
static IntegerType * getInt32Ty(LLVMContext &C)
This function has undefined behavior.
op_range operands()
Definition: User.h:242
Value * getOperand(unsigned i) const
Definition: User.h:169
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:1474
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto reverse(ContainerTy &&C)
Definition: STLExtras.h:419
ModulePass * createLowerGlobalDtorsLegacyPass()
void initializeLowerGlobalDtorsLegacyPassPass(PassRegistry &)
void appendToGlobalCtors(Module &M, Function *F, int Priority, Constant *Data=nullptr)
Append F to the list of global ctors of module M with the given Priority.
Definition: ModuleUtils.cpp:74