Run global destructors on exit

This commit enables global destructors to run after main. Destructors that are in genericjs are not run. The new wrapper 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("LowerGlobalDestructors");
   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/include/llvm/Cheerp/LowerGlobalDestructors.h

@@ -0,0 +1,31 @@
+//===-- Cheerp/LowerGlobalDestructors.h - Cheerp helper -------------------===//
+//
+//                     Cheerp: The C++ compiler for the Web
+//
+// This file is distributed under the Apache License v2.0 with LLVM Exceptions.
+// See LICENSE.TXT for details.
+//
+// Copyright 2025 Leaning Technologies
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CHEERP_LOWER_GLOBAL_DESTRUCTORS_H
+#define CHEERP_LOWER_GLOBAL_DESTRUCTORS_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace cheerp{
+
+using namespace llvm;
+
+class LowerGlobalDestructorsPass: public PassInfoMixin<LowerGlobalDestructorsPass> {
+private:
+	void filterGenericJSDestructors(Module& M);
+public:
+	PreservedAnalyses run(Module& M, ModuleAnalysisManager& MAM);
+	static bool isRequired() { return true;}
+};
+
+}
+
+#endif

llvm/include/llvm/Cheerp/PassRegistry.h

@@ -42,6 +42,7 @@
 #include "llvm/Cheerp/CommandLine.h"
 #include "llvm/Cheerp/CheerpLowerAtomic.h"
 #include "llvm/Cheerp/ThreadLocalLowering.h"
+#include "llvm/Cheerp/LowerGlobalDestructors.h"
 
 namespace cheerp {
 

llvm/lib/CheerpUtils/CMakeLists.txt

@@ -36,6 +36,7 @@ add_llvm_component_library(LLVMCheerpUtils
   CheerpLowerAtomic.cpp
   JsExport.cpp
   ThreadLocalLowering.cpp
+  LowerGlobalDestructors.cpp
   )
 
 add_dependencies(LLVMCheerpUtils intrinsics_gen)

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/CheerpUtils/LowerGlobalDestructors.cpp

@@ -0,0 +1,92 @@
+//===-- ThreadLocalLowering.h - Cheerp helper -------------------------===//
+//
+//                     Cheerp: The C++ compiler for the Web
+//
+// This file is distributed under the Apache License v2.0 with LLVM Exceptions.
+// See LICENSE.TXT for details.
+//
+// Copyright 2025 Leaning Technologies
+//
+//===----------------------------------------------------------------------===//
+
+#include <unordered_set>
+#include "llvm/Cheerp/LowerGlobalDestructors.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Transforms/Utils/LowerGlobalDtors.h"
+
+using namespace llvm;
+
+namespace cheerp
+{
+
+void LowerGlobalDestructorsPass::filterGenericJSDestructors(Module& M)
+{
+	GlobalVariable* var = M.getGlobalVariable("llvm.global_dtors");
+	if (!var || !var->hasInitializer())
+		return;
+	ConstantArray* initList = dyn_cast<ConstantArray>(var->getInitializer());
+	if (!initList)
+		return;
+
+	GlobalValue::LinkageTypes linkageTypes = var->getLinkage();
+	SmallVector<Constant*, 8> validDestructors;
+	Type* elementType = nullptr;
+
+	// Loop over the global destructors, put all the ones tagged asmjs into a new list.
+	for (Value* O: initList->operands())
+	{
+		ConstantStruct* CS = dyn_cast<ConstantStruct>(O);
+		if (!CS)
+			continue;
+
+		Constant* destructor = CS->getOperand(1);
+		if (destructor->isNullValue())
+			break;
+
+		elementType = O->getType();
+		Function* destructorFunc = dyn_cast<Function>(destructor);
+		assert(destructorFunc);
+		if (destructorFunc->getSection() == "asmjs")
+			validDestructors.push_back(cast<Constant>(O));
+	}
+
+	var->eraseFromParent();
+	uint32_t numElements = validDestructors.size();
+	// If there are no valid destructors, don't create a new global.
+	if (numElements == 0)
+		return;
+
+	ArrayType* arrayType = ArrayType::get(elementType, numElements);
+	Constant* newInitList = ConstantArray::get(arrayType, validDestructors);
+	new GlobalVariable(M, arrayType, true, linkageTypes, newInitList, "llvm.global_dtors");
+}
+
+PreservedAnalyses LowerGlobalDestructorsPass::run(Module& M, ModuleAnalysisManager& MAM)
+{
+	ModulePassManager MPM;
+	MPM.addPass(LowerGlobalDtorsPass());
+
+	// Collect all currently existing functions in a set.
+	std::unordered_set<Function*> functionsBeforePass;
+	for (Function& F: M.getFunctionList())
+		functionsBeforePass.insert(&F);
+
+	// Remove the destructors that aren't tagged asmjs.
+	filterGenericJSDestructors(M);
+
+	// Run the LowerGlobalDtorsPass.
+	PreservedAnalyses PA = MPM.run(M, MAM);
+
+	// The functions that weren't in the list before are the new functions
+	// created by the LowerGlobalDtorsPass. Tag them asmjs.
+	for (Function& F: M.getFunctionList())
+	{
+		if (!functionsBeforePass.count(&F))
+			F.setSection("asmjs");
+	}
+
+	return PA;
+}
+
+}