1//===-- WebAssemblyLowerGlobalDtors.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/// WebAssembly doesn't have a builtin way to invoke static destructors. 13/// Implement @llvm.global_dtors by creating wrapper functions that are 14/// registered in @llvm.global_ctors and which contain a call to 15/// `__cxa_atexit` to register their destructor functions. 16/// 17//===----------------------------------------------------------------------===// 18 19#include "WebAssembly.h" 20#include "llvm/ADT/MapVector.h" 21#include "llvm/IR/Constants.h" 22#include "llvm/IR/Instructions.h" 23#include "llvm/IR/Intrinsics.h" 24#include "llvm/IR/Module.h" 25#include "llvm/Pass.h" 26#include "llvm/Support/Debug.h" 27#include "llvm/Support/raw_ostream.h" 28#include "llvm/Transforms/Utils/ModuleUtils.h" 29using namespace llvm; 30 31#define DEBUG_TYPE "wasm-lower-global-dtors" 32 33namespace { 34class LowerGlobalDtors final : public ModulePass { 35 StringRef getPassName() const override { 36 return "WebAssembly Lower @llvm.global_dtors"; 37 } 38 39 void getAnalysisUsage(AnalysisUsage &AU) const override { 40 AU.setPreservesCFG(); 41 ModulePass::getAnalysisUsage(AU); 42 } 43 44 bool runOnModule(Module &M) override; 45 46public: 47 static char ID; 48 LowerGlobalDtors() : ModulePass(ID) {} 49}; 50} // End anonymous namespace 51 52char LowerGlobalDtors::ID = 0; 53INITIALIZE_PASS(LowerGlobalDtors, DEBUG_TYPE, 54 "Lower @llvm.global_dtors for WebAssembly", false, false) 55 56ModulePass *llvm::createWebAssemblyLowerGlobalDtors() { 57 return new LowerGlobalDtors(); 58} 59 60bool LowerGlobalDtors::runOnModule(Module &M) { 61 LLVM_DEBUG(dbgs() << "********** Lower Global Destructors **********\n"); 62 63 GlobalVariable *GV = M.getGlobalVariable("llvm.global_dtors"); 64 if (!GV || !GV->hasInitializer()) 65 return false; 66 67 const ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer()); 68 if (!InitList) 69 return false; 70 71 // Sanity-check @llvm.global_dtor's type. 72 auto *ETy = dyn_cast<StructType>(InitList->getType()->getElementType()); 73 if (!ETy || ETy->getNumElements() != 3 || 74 !ETy->getTypeAtIndex(0U)->isIntegerTy() || 75 !ETy->getTypeAtIndex(1U)->isPointerTy() || 76 !ETy->getTypeAtIndex(2U)->isPointerTy()) 77 return false; // Not (int, ptr, ptr). 78 79 // Collect the contents of @llvm.global_dtors, collated by priority and 80 // associated symbol. 81 std::map<uint16_t, MapVector<Constant *, std::vector<Constant *>>> DtorFuncs; 82 for (Value *O : InitList->operands()) { 83 auto *CS = dyn_cast<ConstantStruct>(O); 84 if (!CS) 85 continue; // Malformed. 86 87 auto *Priority = dyn_cast<ConstantInt>(CS->getOperand(0)); 88 if (!Priority) 89 continue; // Malformed. 90 uint16_t PriorityValue = Priority->getLimitedValue(UINT16_MAX); 91 92 Constant *DtorFunc = CS->getOperand(1); 93 if (DtorFunc->isNullValue()) 94 break; // Found a null terminator, skip the rest. 95 96 Constant *Associated = CS->getOperand(2); 97 Associated = cast<Constant>(Associated->stripPointerCasts()); 98 99 DtorFuncs[PriorityValue][Associated].push_back(DtorFunc); 100 } 101 if (DtorFuncs.empty()) 102 return false; 103 104 // extern "C" int __cxa_atexit(void (*f)(void *), void *p, void *d); 105 LLVMContext &C = M.getContext(); 106 PointerType *VoidStar = Type::getInt8PtrTy(C); 107 Type *AtExitFuncArgs[] = {VoidStar}; 108 FunctionType *AtExitFuncTy = 109 FunctionType::get(Type::getVoidTy(C), AtExitFuncArgs, 110 /*isVarArg=*/false); 111 112 FunctionCallee AtExit = M.getOrInsertFunction( 113 "__cxa_atexit", 114 FunctionType::get(Type::getInt32Ty(C), 115 {PointerType::get(AtExitFuncTy, 0), VoidStar, VoidStar}, 116 /*isVarArg=*/false)); 117 118 // Declare __dso_local. 119 Constant *DsoHandle = M.getNamedValue("__dso_handle"); 120 if (!DsoHandle) { 121 Type *DsoHandleTy = Type::getInt8Ty(C); 122 GlobalVariable *Handle = new GlobalVariable( 123 M, DsoHandleTy, /*isConstant=*/true, 124 GlobalVariable::ExternalWeakLinkage, nullptr, "__dso_handle"); 125 Handle->setVisibility(GlobalVariable::HiddenVisibility); 126 DsoHandle = Handle; 127 } 128 129 // For each unique priority level and associated symbol, generate a function 130 // to call all the destructors at that level, and a function to register the 131 // first function with __cxa_atexit. 132 for (auto &PriorityAndMore : DtorFuncs) { 133 uint16_t Priority = PriorityAndMore.first; 134 for (auto &AssociatedAndMore : PriorityAndMore.second) { 135 Constant *Associated = AssociatedAndMore.first; 136 137 Function *CallDtors = Function::Create( 138 AtExitFuncTy, Function::PrivateLinkage, 139 "call_dtors" + 140 (Priority != UINT16_MAX ? (Twine(".") + Twine(Priority)) 141 : Twine()) + 142 (!Associated->isNullValue() ? (Twine(".") + Associated->getName()) 143 : Twine()), 144 &M); 145 BasicBlock *BB = BasicBlock::Create(C, "body", CallDtors); 146 FunctionType *VoidVoid = FunctionType::get(Type::getVoidTy(C), 147 /*isVarArg=*/false); 148 149 for (auto Dtor : AssociatedAndMore.second) 150 CallInst::Create(VoidVoid, Dtor, "", BB); 151 ReturnInst::Create(C, BB); 152 153 Function *RegisterCallDtors = Function::Create( 154 VoidVoid, Function::PrivateLinkage, 155 "register_call_dtors" + 156 (Priority != UINT16_MAX ? (Twine(".") + Twine(Priority)) 157 : Twine()) + 158 (!Associated->isNullValue() ? (Twine(".") + Associated->getName()) 159 : Twine()), 160 &M); 161 BasicBlock *EntryBB = BasicBlock::Create(C, "entry", RegisterCallDtors); 162 BasicBlock *FailBB = BasicBlock::Create(C, "fail", RegisterCallDtors); 163 BasicBlock *RetBB = BasicBlock::Create(C, "return", RegisterCallDtors); 164 165 Value *Null = ConstantPointerNull::get(VoidStar); 166 Value *Args[] = {CallDtors, Null, DsoHandle}; 167 Value *Res = CallInst::Create(AtExit, Args, "call", EntryBB); 168 Value *Cmp = new ICmpInst(*EntryBB, ICmpInst::ICMP_NE, Res, 169 Constant::getNullValue(Res->getType())); 170 BranchInst::Create(FailBB, RetBB, Cmp, EntryBB); 171 172 // If `__cxa_atexit` hits out-of-memory, trap, so that we don't misbehave. 173 // This should be very rare, because if the process is running out of 174 // memory before main has even started, something is wrong. 175 CallInst::Create(Intrinsic::getDeclaration(&M, Intrinsic::trap), "", 176 FailBB); 177 new UnreachableInst(C, FailBB); 178 179 ReturnInst::Create(C, RetBB); 180 181 // Now register the registration function with @llvm.global_ctors. 182 appendToGlobalCtors(M, RegisterCallDtors, Priority, Associated); 183 } 184 } 185 186 // Now that we've lowered everything, remove @llvm.global_dtors. 187 GV->eraseFromParent(); 188 189 return true; 190} 191