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