[HLSL] Call global destructors from entries

[beanz]

Summary

HLSL doesn't have a C++ runtime that supports atexit registration. To
enable global destructors we instead rely on the llvm.global_dtor
mechanism.

This change disables atexit generation for HLSL and updates the HLSL
code generation to call global destructors on the exit from entry
functions.

Depends on D132977.

[aaron.ballman]

This generally LGTM, but to double-check: the behavior if the user does call atexit() or or at_quick_exit() is that we simply don't call those handlers? As opposed to something worse like we dispatch to the handler and then crash on exit or something like that?

[beanz]

In D133518#3781101, @aaron.ballman wrote:

This generally LGTM, but to double-check: the behavior if the user does call atexit() or or at_quick_exit() is that we simply don't call those handlers? As opposed to something worse like we dispatch to the handler and then crash on exit or something like that?

There should be no way to successfully compile and link a shader calling atexit() or at_quick_exit(). Neither of those functions are provided by the runtime so it should turn into a compile or linking error somewhere in the build process (either missing declaration or missing symbol resolution).

[aaron.ballman]

In D133518#3781308, @beanz wrote:

In D133518#3781101, @aaron.ballman wrote:

This generally LGTM, but to double-check: the behavior if the user does call atexit() or or at_quick_exit() is that we simply don't call those handlers? As opposed to something worse like we dispatch to the handler and then crash on exit or something like that?

There should be no way to successfully compile and link a shader calling atexit() or at_quick_exit(). Neither of those functions are provided by the runtime so it should turn into a compile or linking error somewhere in the build process (either missing declaration or missing symbol resolution).

Wonderful! Then this LGTM!

clang/docs/HLSL/EntryFunctions.rst

 entry function is annotated with the ``hlsl.shader`` function attribute
 identifying the entry's pipeline stage.
 
 The body of the unmangled entry function contains first a call to execute global
 constructors, then instantiations of the user-defined entry parameters with
 their semantic values populated, and a call to the user-defined function.
 After the call instruction the return value (if any) is saved using a
 target-appropriate intrinsic for storing outputs (for DirectX, the
-``llvm.dx.store.output``). Global destructors are not supported in HLSL.
+``llvm.dx.store.output``). Lastly, any present global destructors will be called
+immediately before the return. HLSL does not support C++ ``atexit``
+registrations, instead calls to global destructors are compile-time generated.
 
 .. note::
 
    HLSL support in Clang is currently focused on compute shaders, which do not
    support output semantics. Support for output semantics will not be
    implemented until other shader profiles are supported.
 
 Below is example IR that represents the planned implementation, subject to

clang/lib/CodeGen/CGHLSLRuntime.h

protected:
 
   llvm::Value *emitInputSemantic(llvm::IRBuilder<> &B, const ParmVarDecl &D);
 
 public:
   CGHLSLRuntime(CodeGenModule &CGM) : CGM(CGM) {}
   virtual ~CGHLSLRuntime() {}
 
   void annotateHLSLResource(const VarDecl *D, llvm::GlobalVariable *GV);
-  void generateGlobalCtorCalls();
+  void generateGlobalCtorDtorCalls();
 
   void finishCodeGen();
 
   void setHLSLEntryAttributes(const FunctionDecl *FD, llvm::Function *Fn);
 
   void emitEntryFunction(const FunctionDecl *FD, llvm::Function *Fn);
 };
 
 } // namespace CodeGen
 } // namespace clang
 
 #endif

clang/lib/CodeGen/CGHLSLRuntime.cpp

 
 void CGHLSLRuntime::finishCodeGen() {
   auto &TargetOpts = CGM.getTarget().getTargetOpts();
   llvm::Module &M = CGM.getModule();
   Triple T(M.getTargetTriple());
   if (T.getArch() == Triple::ArchType::dxil)
     addDxilValVersion(TargetOpts.DxilValidatorVersion, M);
 
-  generateGlobalCtorCalls();
+  generateGlobalCtorDtorCalls();
 }
 
 void CGHLSLRuntime::annotateHLSLResource(const VarDecl *D, GlobalVariable *GV) {
   const Type *Ty = D->getType()->getPointeeOrArrayElementType();
   if (!Ty)
     return;
   const auto *RD = Ty->getAsCXXRecordDecl();
   if (!RD)
void CGHLSLRuntime::emitEntryFunction(const FunctionDecl *FD,
   }
 
   CallInst *CI = B.CreateCall(FunctionCallee(Fn), Args);
   (void)CI;
   // FIXME: Handle codegen for return type semantics.
   B.CreateRetVoid();
 }
 
-void CGHLSLRuntime::generateGlobalCtorCalls() {
-  llvm::Module &M = CGM.getModule();
-  const auto *GlobalCtors = M.getNamedGlobal("llvm.global_ctors");
-  if (!GlobalCtors)
+static void gatherFunctions(SmallVectorImpl<Function *> &Fns, llvm::Module &M,
+                            bool CtorOrDtor) {
+  const auto *GV =
+      M.getNamedGlobal(CtorOrDtor ? "llvm.global_ctors" : "llvm.global_dtors");
+  if (!GV)
     return;
-  const auto *CA = dyn_cast<ConstantArray>(GlobalCtors->getInitializer());
+  const auto *CA = dyn_cast<ConstantArray>(GV->getInitializer());
   if (!CA)
     return;
   // The global_ctor array elements are a struct [Priority, Fn *, COMDat].
   // HLSL neither supports priorities or COMDat values, so we will check those
   // in an assert but not handle them.
 
   llvm::SmallVector<Function *> CtorFns;
   for (const auto &Ctor : CA->operands()) {
     if (isa<ConstantAggregateZero>(Ctor))
       continue;
     ConstantStruct *CS = cast<ConstantStruct>(Ctor);
 
     assert(cast<ConstantInt>(CS->getOperand(0))->getValue() == 65535 &&
            "HLSL doesn't support setting priority for global ctors.");
     assert(isa<ConstantPointerNull>(CS->getOperand(2)) &&
            "HLSL doesn't support COMDat for global ctors.");
-    CtorFns.push_back(cast<Function>(CS->getOperand(1)));
-  }
+    Fns.push_back(cast<Function>(CS->getOperand(1)));
+  }
 
+void CGHLSLRuntime::generateGlobalCtorDtorCalls() {
+  llvm::Module &M = CGM.getModule();
+  SmallVector<Function *> CtorFns;
+  SmallVector<Function *> DtorFns;
+  gatherFunctions(CtorFns, M, true);
+  gatherFunctions(DtorFns, M, false);
+
   // Insert a call to the global constructor at the beginning of the entry block
   // to externally exported functions. This is a bit of a hack, but HLSL allows
   // global constructors, but doesn't support driver initialization of globals.
   for (auto &F : M.functions()) {
     if (!F.hasFnAttribute("hlsl.shader"))
       continue;
     IRBuilder<> B(&F.getEntryBlock(), F.getEntryBlock().begin());
     for (auto *Fn : CtorFns)
       B.CreateCall(FunctionCallee(Fn));
+
+    // Insert global dtors before the terminator of the last instruction
+    B.SetInsertPoint(F.back().getTerminator());
+    for (auto *Fn : DtorFns)
+      B.CreateCall(FunctionCallee(Fn));
   }
 }

clang/lib/CodeGen/MicrosoftCXXABI.cpp

void MicrosoftCXXABI::registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
                                          llvm::FunctionCallee Dtor,
                                          llvm::Constant *Addr) {
   if (D.isNoDestroy(CGM.getContext()))
     return;
 
   if (D.getTLSKind())
     return emitGlobalDtorWithTLRegDtor(CGF, D, Dtor, Addr);
 
+  // HLSL doesn't support atexit.
+  if (CGM.getLangOpts().HLSL)
+    return CGM.AddCXXDtorEntry(Dtor, Addr);
+
   // The default behavior is to use atexit.
   CGF.registerGlobalDtorWithAtExit(D, Dtor, Addr);
 }
 
 void MicrosoftCXXABI::EmitThreadLocalInitFuncs(
     CodeGenModule &CGM, ArrayRef<const VarDecl *> CXXThreadLocals,
     ArrayRef<llvm::Function *> CXXThreadLocalInits,
     ArrayRef<const VarDecl *> CXXThreadLocalInitVars) {

clang/test/CodeGenHLSL/GlobalConstructorFunction.hlsl

 // RUN: %clang_cc1 -triple dxil-pc-shadermodel6.0-compute -S -emit-llvm -disable-llvm-passes %s -o - | FileCheck %s
 
 int i;
 
 __attribute__((constructor)) void call_me_first(void) {
   i = 12;
 }
 
 __attribute__((constructor)) void then_call_me(void) {
   i = 12;
 }
 
+__attribute__((destructor)) void call_me_last(void) {
+  i = 0;
+}
+
 [numthreads(1,1,1)]
 void main(unsigned GI : SV_GroupIndex) {}
 
 //CHECK: define void @main()
 //CHECK-NEXT: entry:
 //CHECK-NEXT:   call void @"?call_me_first@@YAXXZ"()
 //CHECK-NEXT:   call void @"?then_call_me@@YAXXZ"()
 //CHECK-NEXT:   %0 = call i32 @llvm.dx.flattened.thread.id.in.group()
 //CHECK-NEXT:   call void @"?main@@YAXI@Z"(i32 %0)
+//CHECK-NEXT:   call void @"?call_me_last@@YAXXZ"(
 //CHECK-NEXT:   ret void

clang/test/CodeGenHLSL/GlobalDestructors.hlsl

+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.0-compute -std=hlsl202x -S -emit-llvm -disable-llvm-passes %s -o - | FileCheck %s
+
+struct Tail {
+  Tail() {
+    add(1);
+  }
+
+  ~Tail() {
+    add(-1);
+  }
+
+  void add(int V) {
+    static int Count = 0;
+    Count += V;
+  }
+};
+
+struct Pupper {
+  static int Count;
+
+  Pupper() {
+    Count += 1; // :)
+  }
+
+  ~Pupper() {
+    Count -= 1; // :(
+  }
+} GlobalPup;
+
+void Wag() {
+  static Tail T;
+  T.add(0);
+}
+
+int Pupper::Count = 0;
+
+[numthreads(1,1,1)]
+void main(unsigned GI : SV_GroupIndex) {
+  Wag();
+}
+
+//CHECK:      define void @main()
+//CHECK-NEXT: entry:
+//CHECK-NEXT:   call void @_GLOBAL__sub_I_GlobalDestructors.hlsl()
+//CHECK-NEXT:   %0 = call i32 @llvm.dx.flattened.thread.id.in.group()
+//CHECK-NEXT:   call void @"?main@@YAXI@Z"(i32 %0)
+//CHECK-NEXT:   call void @_GLOBAL__D_a()
+//CHECK-NEXT:   ret void
+
+// This is really just a sanity check I needed for myself to verify that
+// function scope static variables also get destroyed properly.
+
+//CHECK: define internal void @_GLOBAL__D_a()
+//CHECK-NEXT: entry:
+//CHECK-NEXT:   call void @"??1Tail@@QAA@XZ"(ptr @"?T@?1??Wag@@YAXXZ@4UTail@@A")
+//CHECK-NEXT:   call void @"??1Pupper@@QAA@XZ"(ptr @"?GlobalPup@@3UPupper@@A")
+//CHECK-NEXT:   ret void