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