Run global destructors on exit

This commit enables global destructors to run after main. Destructors that are in genericjs are not run. The LowerGlobalDtors pass is run to lower functions with the destructor attribute into calls to __cxa_atexit. If the libc exit function is not reachable from the code, the destructors are removed. Finally, exit is now called automatically after the main function has finished running in WASI mode, or when -pthread is passed.

Author: Maqrkk

clang/lib/CodeGen/CGClass.cpp

@@ -1728,22 +1728,13 @@ void CodeGenFunction::EmitDestructorBody(FunctionArgList &Args) {
   // possible to delegate the destructor body to the complete
   // destructor.  Do so.
   if (DtorType == Dtor_Deleting) {
-    if(getTarget().isByteAddressable() || Dtor->getParent()->hasAttr<AsmJSAttr>()) {
     RunCleanupsScope DtorEpilogue(*this);
     EnterDtorCleanups(Dtor, Dtor_Deleting);
     if (HaveInsertPoint()) {
       QualType ThisTy = Dtor->getThisObjectType();
       EmitCXXDestructorCall(Dtor, Dtor_Complete, /*ForVirtualBase=*/false,
                             /*Delegating=*/false, LoadCXXThisAddress(), ThisTy);
     }
-    } else {
-    // NOTE: Code is duplicated to avoid RAII cleanup
-    if (HaveInsertPoint()) {
-      QualType ThisTy = Dtor->getThisObjectType();
-      EmitCXXDestructorCall(Dtor, Dtor_Complete, /*ForVirtualBase=*/false,
-                            /*Delegating=*/false, LoadCXXThisAddress(), ThisTy);
-    }
-    }
     return;
   }
 

clang/lib/CodeGen/CGDeclCXX.cpp

@@ -143,8 +143,8 @@ static void EmitDeclDestroy(CodeGenFunction &CGF, const VarDecl &D,
                                   CGF.needsEHCleanup(DtorKind), &D);
     Argument = llvm::Constant::getNullValue(CGF.Int8PtrTy);
   }
-
-  if(CGM.getTarget().isByteAddressable())
+  // We do not register global destructors if they are genericjs.
+  if (CGM.getTarget().isByteAddressable() || D.hasAttr<AsmJSAttr>())
     CGM.getCXXABI().registerGlobalDtor(CGF, D, Func, Argument);
 }
 
@@ -1154,6 +1154,8 @@ llvm::Function *CodeGenFunction::generateDestroyHelper(
   llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
   llvm::Function *fn = CGM.CreateGlobalInitOrCleanUpFunction(
       FTy, "__cxx_global_array_dtor", FI, VD->getLocation());
+  if (getContext().getTargetInfo().getTriple().isCheerpWasm())
+    fn->setSection("asmjs");
 
   CurEHLocation = VD->getBeginLoc();
 

clang/lib/Driver/ToolChains/WebAssembly.cpp

@@ -762,6 +762,7 @@ void cheerp::CheerpOptimizer::ConstructJob(Compilation &C, const JobAction &JA,
     CmdArgs.push_back("-cheerp-keep-invokes");
   addPass("function(simplifycfg)");
 
+  addPass("lower-global-dtors");
   addPass("CallConstructors");
   addPass("GlobalDepsAnalyzer");
   addPass("TypeOptimizer");

llvm/include/llvm/Cheerp/GlobalDepsAnalyzer.h

@@ -219,6 +219,8 @@ class GlobalDepsAnalyzer
 	 * \warning Even if this returns 0, it does *not* mean that the module has 
 	 * not been modified. This function also *reorders* the variables inside the module.
 	 */
+	void removeGlobalDestructors(llvm::Module& M);
+
 	int filterModule( const llvm::DenseSet<const llvm::Function*>&, llvm::Module & );
 
 	static bool isMathIntrinsic(const llvm::Function* F);

llvm/lib/CheerpUtils/CallConstructors.cpp

@@ -138,9 +138,11 @@ PreservedAnalyses CallConstructorsPass::run(llvm::Module &M, llvm::ModuleAnalysi
 		{
 			ExitCode = Builder.CreateCall(Main->getFunctionType(), Main);
 		}
-		if (Wasi)
+		if (!LowerAtomics || Wasi)
 		{
-			Function* Exit = M.getFunction("__syscall_exit");
+			// In WASI mode, or if -pthread has been passed, we call exit after main, which will run global destructors
+			Function* Exit = M.getFunction("exit");
+			assert(Exit != nullptr);
 			if (ExitCode->getType() != Builder.getInt32Ty())
 				ExitCode = ConstantInt::get(Builder.getInt32Ty(), 0);
 			Builder.CreateCall(Exit->getFunctionType(), Exit, ExitCode);

llvm/lib/CheerpUtils/GlobalDepsAnalyzer.cpp

@@ -796,6 +796,11 @@ bool GlobalDepsAnalyzer::runOnModule( llvm::Module & module )
 		markAsReachableIfPresent(module.getFunction("__udivti3"));
 	}
 
+	// If libc exit isn't called, remove global destructors.
+	Function* exitFunction = module.getFunction("exit");
+	if (!llcPass && (exitFunction == nullptr || !isReachable(module.getFunction("exit"))))
+		removeGlobalDestructors(module);
+
 	NumRemovedGlobals = filterModule(droppedMathBuiltins, module);
 
 	if(hasUndefinedSymbolErrors)
@@ -1566,6 +1571,23 @@ bool GlobalDepsAnalyzer::isMathIntrinsic(const llvm::Function* F)
 		(builtinID == BuiltinInstr::MOD_F);
 }
 
+void GlobalDepsAnalyzer::removeGlobalDestructors(llvm::Module& M)
+{
+	// The goal is to empty the function cxa_atexit, and let optimization do the rest.
+	Function* cxaAtexit = M.getFunction("__cxa_atexit");
+	if (cxaAtexit == nullptr)
+		return;
+
+	GlobalValue::LinkageTypes linkage = cxaAtexit->getLinkage();
+	cxaAtexit->deleteBody();
+	BasicBlock* block = BasicBlock::Create(M.getContext(), "entry", cxaAtexit);
+	ConstantInt* ret = ConstantInt::get(Type::getInt32Ty(M.getContext()), 0);
+	IRBuilder<> Builder(M.getContext());
+	Builder.SetInsertPoint(block);
+	Builder.CreateRet(ret);
+	cxaAtexit->setLinkage(linkage);
+}
+
 int GlobalDepsAnalyzer::filterModule( const DenseSet<const Function*>& droppedMathBuiltins, Module & module )
 {
 	std::vector< llvm::GlobalValue * > eraseQueue;

llvm/lib/Transforms/Utils/LowerGlobalDtors.cpp

@@ -17,6 +17,7 @@
 
 #include "llvm/Transforms/Utils/LowerGlobalDtors.h"
 
+#include "llvm/ADT/Triple.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
@@ -111,6 +112,11 @@ static bool runImpl(Module &M) {
     if (DtorFunc->isNullValue())
       break; // Found a null terminator, skip the rest.
 
+    // We do not add global destructors that are genericjs.
+    Function* F = cast<Function>(DtorFunc);
+    if (F->getSection() != "asmjs")
+      continue;
+
     Constant *Associated = CS->getOperand(2);
     Associated = cast<Constant>(Associated->stripPointerCastsSafe());
 
@@ -150,6 +156,8 @@ static bool runImpl(Module &M) {
     return GV;
   });
 
+  bool asmjs = Triple(M.getTargetTriple()).isCheerpWasm();
+
   // For each unique priority level and associated symbol, generate a function
   // to call all the destructors at that level, and a function to register the
   // first function with __cxa_atexit.
@@ -171,6 +179,8 @@ static bool runImpl(Module &M) {
               (!Associated->isNullValue() ? (Twine(".") + Associated->getName())
                                           : Twine()),
           &M);
+      if (asmjs)
+        CallDtors->setSection("asmjs");
       BasicBlock *BB = BasicBlock::Create(C, "body", CallDtors);
       FunctionType *VoidVoid = FunctionType::get(Type::getVoidTy(C),
                                                  /*isVarArg=*/false);
@@ -189,6 +199,8 @@ static bool runImpl(Module &M) {
               (!Associated->isNullValue() ? (Twine(".") + Associated->getName())
                                           : Twine()),
           &M);
+      if (asmjs)
+        RegisterCallDtors->setSection("asmjs");
       BasicBlock *EntryBB = BasicBlock::Create(C, "entry", RegisterCallDtors);
       BasicBlock *FailBB = BasicBlock::Create(C, "fail", RegisterCallDtors);
       BasicBlock *RetBB = BasicBlock::Create(C, "return", RegisterCallDtors);