Lower `@llvm.global_dtors` using `__cxa_atexit` on MachO

[yln]

Summary

For MachO, lower .llvm.global_dtors into .llvm_global_ctors with
__cxa_atexit calls to avoid emitting the deprecated __mod_term_func.

Reuse the existing WebAssemblyLowerGlobalDtors.cpp to accomplish this.

[yln]

I wanted to check in to get your feedback on the overall approach while I am working on adding tests for the behavior change.

On Darwin (MachO really) we want to transition away from the deprecated __mod_term_funcs section (relevant: D45578). However, currently @llvm.global_dtors, i.e., llvm::appendToGlobalDtors callers, are lowered to it.
Here I am trying to reuse an existing lowering pass for WebAssembly (which doesn't have a destructor section, D41211) to transform @llvm.global_dtors into functions registered as constructors (@llvm.global_ctors) that then call __cxa_atexit to register the destructor.

[sunfish]

The overall approach here makes sense to me. The tests test/CodeGen/WebAssembly/global_dtors.ll and test/CodeGen/WebAssembly/lower-global-dtors.ll cover the main interesting corner cases that we've hit with this pass; they currently have wasm targets and wasm-specific CHECK lines, but could likely be ported to other targets.

[delcypher]

@yln I like the approach here as it solves problem for all of LLVM, not just ASan specifically :). This is better than what I was going to do originally. I think the only missing there here are some tests.

[yln]

Make pass compatible with new pass manager to ease testing with opt. Add and adapt tests. Add documentation. Make clang-format happy.

[yln]

llvm/lib/CodeGen/TargetPassConfig.cpp

898–902

Is TargetPassConfig::addIRPasses() the right place to hook this pass?

[yln]

llvm/include/llvm/Transforms/Utils/LowerGlobalDtors.h

2

Copypasta Eliminate Invoke instructions is fixed.

[yln]

Declare preserved analyses in new pass format.

[delcypher]

llvm/lib/CodeGen/TargetPassConfig.cpp

900

Random thought. Do we want to support the legacy way of calling destructors, rather than removing it entirely? If we were to do such a thing I'd suspect we'd guard using the legacy way on the OS deployment target.

Just to be clear. I'm happy with the patch the way it is. I'm just wondering if we should consider allowing the legacy way as well. I can't see an obvious use case for it because the new way should work on older OSs too but maybe there's a use case I haven't thought about?

[yln]

llvm/lib/CodeGen/TargetPassConfig.cpp

900

Having a way to explicitly request the old behavior sounds like a good idea. I will look into it.

[yln]

Add support for an escape hatch to fallback to the old behavior: via Clang driver flag
(-fregister-global-dtors-with-atexit) or llc / code generation flag
(-lower-global-dtors-via-cxa-atexit). This escape hatch will be
removed in the future.

[yln]

llvm/lib/CodeGen/TargetPassConfig.cpp

900

I added an escape hatch to fallback to the old behavior:

• via Clang driver flag -fregister-global-dtors-with-atexit
• llc / code generation flag -lower-global-dtors-via-cxa-atexit.

This escape hatch will be removed in the future.

[yln]

@sunfish
Hi Dan, I hope you are still happy with this change. I didn't change any WebAssembly tests, but rather added a new IR-level test, so all existing WebAssembly behavior should stay the same. Let me know if you have any concerns.

[delcypher]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1181

If you have access to Options.LowerGlobalDtorsViaCxaAtExit then you could do something like

if (Options.LowerGlobalDtorsViaCxaAtExit)
  report_fatal_error("@llvm.global_dtors should have been lowered already");

so that we error when appropriate.

I'm not sure if you have easy access to the option from this class, so if it's difficult then we can ignore this problem.

llvm/lib/CodeGen/TargetPassConfig.cpp

900

@yln I don't see any modifications to the driver. How is -fregister-global-dtors-with-atexit added as a driver flag?

[yln]

Report fatal error when we can, instead of never.

[sunfish]

In D121327#3381123, @yln wrote:

@sunfish
Hi Dan, I hope you are still happy with this change. I didn't change any WebAssembly tests, but rather added a new IR-level test, so all existing WebAssembly behavior should stay the same. Let me know if you have any concerns.

Yes, the change looks good to me!

[yln]

llvm/lib/CodeGen/TargetPassConfig.cpp

900

This is an existing flag in the frontend added as part of this change: D45578

Add a command line option `fregister_global_dtors_with_atexit` to register destructor functions annotated with __attribute__((destructor)) using __cxa_atexit or atexit.

It's on by default on Darwin:

if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
                 options::OPT_fno_register_global_dtors_with_atexit,
                 RawTriple.isOSDarwin() && !KernelOrKext))
  CmdArgs.push_back("-fregister-global-dtors-with-atexit");

Essentially we switched over the frontend to avoid emitting the deprecated __mod_term_func section a long time ago and now I am using the same technique to lower .llvm.global_dtors in the backend. So we could say the flag is exactly what we wanted to express (it makes sense to key off it), but now it applies more fully.

Before D45578, destructor functions annotated with __attribute__((destructor)) were added to .llvm.global_dtor. I do not know why we decided to lower them in the frontend (where it didn't apply to .llvm.global_dtors) instead of the backend (this change).

There is certainly an opportunity here to refactor this and make the frontend use llvm.global_dtor again to reduce code duplication (after making sure we cover all the necessary cases). That's a big and wide-reaching change and I am not intending to do this as part of this change.

[Orlando]

Hi @yln, the test you added llvm/test/Transforms/LowerGlobalDestructors/lower-global-dtors.ll is failing on some bots, e.g. https://lab.llvm.org/buildbot/#/builders/139/builds/18527 (builder llvm-clang-x86_64-sie-ubuntu-fast). Please can you take a look?

[RKSimon]

@yln I've reverted your commit at rG7262eacd41997d7ca262d83367e28998662c1b21 to try and get the buildbots green again

[yln]

Hi @Orlando and @RKSimon!

Thanks for pointing out the test failure and reverting the change. I see this failure:

: 'RUN: at line 1';   /home/buildbot/buildbot-root/llvm-clang-x86_64-sie-ubuntu-fast/build/bin/opt        -lower-global-dtors -S < /home/buildbot/buildbot-root/llvm-project/llvm/test/Transforms/LowerGlobalDestructors/lower-global-dtors.ll | /home/buildbot/buildbot-root/llvm-clang-x86_64-sie-ubuntu-fast/build/bin/FileCheck /home/buildbot/buildbot-root/llvm-project/llvm/test/Transforms/LowerGlobalDestructors/lower-global-dtors.ll --implicit-check-not=llvm.global_dtors
: 'RUN: at line 2';   /home/buildbot/buildbot-root/llvm-clang-x86_64-sie-ubuntu-fast/build/bin/opt -passes=lower-global-dtors -S < /home/buildbot/buildbot-root/llvm-project/llvm/test/Transforms/LowerGlobalDestructors/lower-global-dtors.ll | /home/buildbot/buildbot-root/llvm-clang-x86_64-sie-ubuntu-fast/build/bin/FileCheck /home/buildbot/buildbot-root/llvm-project/llvm/test/Transforms/LowerGlobalDestructors/lower-global-dtors.ll --implicit-check-not=llvm.global_dtors
--
Exit Code: 2
Command Output (stderr):
--
opt: Unknown command line argument '-lower-global-dtors'.  Try: '/home/buildbot/buildbot-root/llvm-clang-x86_64-sie-ubuntu-fast/build/bin/opt --help'
opt: Did you mean '--join-globalcopies'?

This looks like my changes are not sufficiently registering the pass for opt on every platform, but so far I haven't found anything that is obviously wrong/missing. Do you know who I can reach out to help me with "pass registration"?

[yln]

New revision here: D121736

[RKSimon]

In D121327#3383733, @yln wrote:

New revision here: D121736

FYI - you could have continued to use this phab for review, it makes it easier to compare the changes you've made

clang/lib/CodeGen/BackendUtil.cpp

static bool initTargetOptions(DiagnosticsEngine &Diags,
   case LangOptions::FPM_Fast:
     Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
     break;
   }
 
   Options.BinutilsVersion =
       llvm::TargetMachine::parseBinutilsVersion(CodeGenOpts.BinutilsVersion);
   Options.UseInitArray = CodeGenOpts.UseInitArray;
+  Options.LowerGlobalDtorsViaCxaAtExit =
+      CodeGenOpts.RegisterGlobalDtorsWithAtExit;
   Options.DisableIntegratedAS = CodeGenOpts.DisableIntegratedAS;
   Options.CompressDebugSections = CodeGenOpts.getCompressDebugSections();
   Options.RelaxELFRelocations = CodeGenOpts.RelaxELFRelocations;
 
   // Set EABI version.
   Options.EABIVersion = TargetOpts.EABIVersion;
 
   if (LangOpts.hasSjLjExceptions())

llvm/docs/Passes.rst

 This can increase the size of the code exponentially (doubling it every time a
 loop is unswitched) so we only unswitch if the resultant code will be smaller
 than a threshold.
 
 This pass expects :ref:`LICM <passes-licm>` to be run before it to hoist
 invariant conditions out of the loop, to make the unswitching opportunity
 obvious.
 
+``-lower-global-dtors``: Lower global destructors
+------------------------------------------------------------
+
+This pass lowers global module destructors (``llvm.global_dtors``) by creating
+wrapper functions that are registered as global constructors in
+``llvm.global_ctors`` and which contain a call to ``__cxa_atexit`` to register
+their destructor functions.
+
 ``-loweratomic``: Lower atomic intrinsics to non-atomic form
 ------------------------------------------------------------
 
 This pass lowers atomic intrinsics to non-atomic form for use in a known
 non-preemptible environment.
 
 The pass does not verify that the environment is non-preemptible (in general
 this would require knowledge of the entire call graph of the program including

llvm/include/llvm/CodeGen/CommandFlags.h

 unsigned getOverrideStackAlignment();
 
 bool getStackRealign();
 
 std::string getTrapFuncName();
 
 bool getUseCtors();
 
+bool getLowerGlobalDtorsViaCxaAtExit();
+
 bool getRelaxELFRelocations();
 
 bool getDataSections();
 Optional<bool> getExplicitDataSections();
 
 bool getFunctionSections();
 Optional<bool> getExplicitFunctionSections();
 

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

 
 class TargetLoweringObjectFileMachO : public TargetLoweringObjectFile {
 public:
   TargetLoweringObjectFileMachO();
   ~TargetLoweringObjectFileMachO() override = default;
 
   void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
 
+  MCSection *getStaticDtorSection(unsigned Priority,
+                                  const MCSymbol *KeySym) const override;
+
   /// Emit the module flags that specify the garbage collection information.
   void emitModuleMetadata(MCStreamer &Streamer, Module &M) const override;
 
   MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                                     const TargetMachine &TM) const override;
 
   MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override;

llvm/include/llvm/InitializePasses.h

 void initializeLoopUnswitchPass(PassRegistry&);
 void initializeLoopVectorizePass(PassRegistry&);
 void initializeLoopVersioningLICMLegacyPassPass(PassRegistry &);
 void initializeLoopVersioningLegacyPassPass(PassRegistry &);
 void initializeLowerAtomicLegacyPassPass(PassRegistry&);
 void initializeLowerConstantIntrinsicsPass(PassRegistry&);
 void initializeLowerEmuTLSPass(PassRegistry&);
 void initializeLowerExpectIntrinsicPass(PassRegistry&);
+void initializeLowerGlobalDtorsLegacyPassPass(PassRegistry &);
 void initializeLowerGuardIntrinsicLegacyPassPass(PassRegistry&);
 void initializeLowerWidenableConditionLegacyPassPass(PassRegistry&);
 void initializeLowerIntrinsicsPass(PassRegistry&);
 void initializeLowerInvokeLegacyPassPass(PassRegistry&);
 void initializeLowerSwitchLegacyPassPass(PassRegistry &);
 void initializeLowerTypeTestsPass(PassRegistry&);
 void initializeLowerMatrixIntrinsicsLegacyPassPass(PassRegistry &);
 void initializeLowerMatrixIntrinsicsMinimalLegacyPassPass(PassRegistry &);

llvm/include/llvm/LinkAllPasses.h

ForcePassLinking() {
       (void) llvm::createLoopUnrollPass();
       (void) llvm::createLoopUnrollAndJamPass();
       (void) llvm::createLoopUnswitchPass();
       (void) llvm::createLoopVersioningLICMPass();
       (void) llvm::createLoopIdiomPass();
       (void) llvm::createLoopRotatePass();
       (void) llvm::createLowerConstantIntrinsicsPass();
       (void) llvm::createLowerExpectIntrinsicPass();
+      (void) llvm::createLowerGlobalDtorsLegacyPass();
       (void) llvm::createLowerInvokePass();
       (void) llvm::createLowerSwitchPass();
       (void) llvm::createNaryReassociatePass();
       (void) llvm::createObjCARCAAWrapperPass();
       (void) llvm::createObjCARCAPElimPass();
       (void) llvm::createObjCARCExpandPass();
       (void) llvm::createObjCARCContractPass();
       (void) llvm::createObjCARCOptPass();

llvm/include/llvm/Target/TargetOptions.h

namespace llvm {
   public:
     TargetOptions()
         : UnsafeFPMath(false), NoInfsFPMath(false), NoNaNsFPMath(false),
           NoTrappingFPMath(true), NoSignedZerosFPMath(false),
           ApproxFuncFPMath(false), EnableAIXExtendedAltivecABI(false),
           HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
           GuaranteedTailCallOpt(false), StackSymbolOrdering(true),
           EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false),
-          DisableIntegratedAS(false), RelaxELFRelocations(false),
-          FunctionSections(false), DataSections(false),
-          IgnoreXCOFFVisibility(false), XCOFFTracebackTable(true),
-          UniqueSectionNames(true), UniqueBasicBlockSectionNames(false),
-          TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0),
-          EmulatedTLS(false), ExplicitEmulatedTLS(false), EnableIPRA(false),
+          LowerGlobalDtorsViaCxaAtExit(false), DisableIntegratedAS(false),
+          RelaxELFRelocations(false), FunctionSections(false),
+          DataSections(false), IgnoreXCOFFVisibility(false),
+          XCOFFTracebackTable(true), UniqueSectionNames(true),
+          UniqueBasicBlockSectionNames(false), TrapUnreachable(false),
+          NoTrapAfterNoreturn(false), TLSSize(0), EmulatedTLS(false),
+          ExplicitEmulatedTLS(false), EnableIPRA(false),
           EmitStackSizeSection(false), EnableMachineOutliner(false),
           EnableMachineFunctionSplitter(false), SupportsDefaultOutlining(false),
           EmitAddrsig(false), EmitCallSiteInfo(false),
           SupportsDebugEntryValues(false), EnableDebugEntryValues(false),
           ValueTrackingVariableLocations(false), ForceDwarfFrameSection(false),
           XRayOmitFunctionIndex(false), DebugStrictDwarf(false),
           Hotpatch(false), PPCGenScalarMASSEntries(false), JMCInstrument(false),
           FPDenormalMode(DenormalMode::IEEE, DenormalMode::IEEE) {}
public:
     /// be set.
     SwiftAsyncFramePointerMode SwiftAsyncFramePointer =
         SwiftAsyncFramePointerMode::Always;
 
     /// UseInitArray - Use .init_array instead of .ctors for static
     /// constructors.
     unsigned UseInitArray : 1;
 
+    /// Use __cxa_atexit to register global destructors; determines how
+    /// llvm.global_dtors is lowered.
+    unsigned LowerGlobalDtorsViaCxaAtExit : 1;
+
     /// Disable the integrated assembler.
     unsigned DisableIntegratedAS : 1;
 
     /// Compress DWARF debug sections.
     DebugCompressionType CompressDebugSections = DebugCompressionType::None;
 
     unsigned RelaxELFRelocations : 1;
 

llvm/include/llvm/Transforms/Instrumentation/AddressSanitizerOptions.h

 
 namespace llvm {
 
 /// Types of ASan module destructors supported
 enum class AsanDtorKind {
   None,    ///< Do not emit any destructors for ASan
   Global,  ///< Append to llvm.global_dtors
   Invalid, ///< Not a valid destructor Kind.
-  // TODO(dliew): Add more more kinds.
 };
 
 /// Mode of ASan detect stack use after return
 enum class AsanDetectStackUseAfterReturnMode {
   Never,   ///< Never detect stack use after return.
   Runtime, ///< Detect stack use after return if runtime flag is enabled
            ///< (ASAN_OPTIONS=detect_stack_use_after_return=1)
   Always,  ///< Always detect stack use after return.
   Invalid, ///< Not a valid detect mode.
 };
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Transforms/Utils.h

 FunctionPass *createAssumeSimplifyPass();
 
 //===----------------------------------------------------------------------===//
 //
 // CanonicalizeFreezeInLoops - Canonicalize freeze instructions in loops so they
 // don't block SCEV.
 //
 Pass *createCanonicalizeFreezeInLoopsPass();
+
+//===----------------------------------------------------------------------===//
+// LowerGlobalDtorsLegacy - Lower @llvm.global_dtors by creating wrapper
+// functions that are registered in @llvm.global_ctors and which contain a call
+// to `__cxa_atexit` to register their destructor functions.
+ModulePass *createLowerGlobalDtorsLegacyPass();
 } // namespace llvm
 
 #endif

llvm/include/llvm/Transforms/Utils/LowerGlobalDtors.h

+//===- LowerGlobalDtors.h - Lower @llvm.global_dtors ----------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass lowers @llvm.global_dtors by creating wrapper functions that are
+// registered in @llvm.global_ctors and which contain a call to `__cxa_atexit`
+// to register their destructor functions.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_TRANSFORMS_UTILS_LOWERGLOBALDTORS_H
+#define LLVM_TRANSFORMS_UTILS_LOWERGLOBALDTORS_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class LowerGlobalDtorsPass : public PassInfoMixin<LowerGlobalDtorsPass> {
+public:
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_LOWERGLOBALDTORS_H

llvm/lib/CodeGen/CodeGen.cpp

void llvm::initializeCodeGen(PassRegistry &Registry) {
   initializeJMCInstrumenterPass(Registry);
   initializeLiveDebugValuesPass(Registry);
   initializeLiveDebugVariablesPass(Registry);
   initializeLiveIntervalsPass(Registry);
   initializeLiveRangeShrinkPass(Registry);
   initializeLiveStacksPass(Registry);
   initializeLiveVariablesPass(Registry);
   initializeLocalStackSlotPassPass(Registry);
+  initializeLowerGlobalDtorsLegacyPassPass(Registry);
   initializeLowerIntrinsicsPass(Registry);
   initializeMIRAddFSDiscriminatorsPass(Registry);
   initializeMIRCanonicalizerPass(Registry);
   initializeMIRNamerPass(Registry);
   initializeMIRProfileLoaderPassPass(Registry);
   initializeMachineBlockFrequencyInfoPass(Registry);
   initializeMachineBlockPlacementPass(Registry);
   initializeMachineBlockPlacementStatsPass(Registry);

llvm/lib/CodeGen/CommandFlags.cpp

 CGOPT(SwiftAsyncFramePointerMode, SwiftAsyncFramePointer)
 CGOPT(bool, DontPlaceZerosInBSS)
 CGOPT(bool, EnableGuaranteedTailCallOpt)
 CGOPT(bool, DisableTailCalls)
 CGOPT(bool, StackSymbolOrdering)
 CGOPT(bool, StackRealign)
 CGOPT(std::string, TrapFuncName)
 CGOPT(bool, UseCtors)
+CGOPT(bool, LowerGlobalDtorsViaCxaAtExit)
 CGOPT(bool, RelaxELFRelocations)
 CGOPT_EXP(bool, DataSections)
 CGOPT_EXP(bool, FunctionSections)
 CGOPT(bool, IgnoreXCOFFVisibility)
 CGOPT(bool, XCOFFTracebackTable)
 CGOPT(std::string, BBSections)
 CGOPT(unsigned, TLSSize)
 CGOPT(bool, EmulatedTLS)
static cl::opt<std::string> TrapFuncName(
       cl::init(""));
   CGBINDOPT(TrapFuncName);
 
   static cl::opt<bool> UseCtors("use-ctors",
                                 cl::desc("Use .ctors instead of .init_array."),
                                 cl::init(false));
   CGBINDOPT(UseCtors);
 
+  static cl::opt<bool> LowerGlobalDtorsViaCxaAtExit(
+      "lower-global-dtors-via-cxa-atexit",
+      cl::desc("Lower llvm.global_dtors (global destructors) via __cxa_atexit"),
+      cl::init(true));
+  CGBINDOPT(LowerGlobalDtorsViaCxaAtExit);
+
   static cl::opt<bool> RelaxELFRelocations(
       "relax-elf-relocations",
       cl::desc(
           "Emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL on x86-64 ELF"),
       cl::init(false));
   CGBINDOPT(RelaxELFRelocations);
 
   static cl::opt<bool> DataSections(
Options.HonorSignDependentRoundingFPMathOption =
       getEnableHonorSignDependentRoundingFPMath();
   if (getFloatABIForCalls() != FloatABI::Default)
     Options.FloatABIType = getFloatABIForCalls();
   Options.EnableAIXExtendedAltivecABI = getEnableAIXExtendedAltivecABI();
   Options.NoZerosInBSS = getDontPlaceZerosInBSS();
   Options.GuaranteedTailCallOpt = getEnableGuaranteedTailCallOpt();
   Options.StackSymbolOrdering = getStackSymbolOrdering();
   Options.UseInitArray = !getUseCtors();
+  Options.LowerGlobalDtorsViaCxaAtExit = getLowerGlobalDtorsViaCxaAtExit();
   Options.RelaxELFRelocations = getRelaxELFRelocations();
   Options.DataSections =
       getExplicitDataSections().getValueOr(TheTriple.hasDefaultDataSections());
   Options.FunctionSections = getFunctionSections();
   Options.IgnoreXCOFFVisibility = getIgnoreXCOFFVisibility();
   Options.XCOFFTracebackTable = getXCOFFTracebackTable();
   Options.BBSections = getBBSectionsMode(Options);
   Options.UniqueSectionNames = getUniqueSectionNames();

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
 
   PersonalityEncoding =
       dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
   LSDAEncoding = dwarf::DW_EH_PE_pcrel;
   TTypeEncoding =
       dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
 }
 
+MCSection *TargetLoweringObjectFileMachO::getStaticDtorSection(
+    unsigned Priority, const MCSymbol *KeySym) const {
+  // TODO(yln): Remove -lower-global-dtors-via-cxa-atexit fallback flag
+  // (LowerGlobalDtorsViaCxaAtExit) and always issue a fatal error here.
+  if (TM->Options.LowerGlobalDtorsViaCxaAtExit)
+    report_fatal_error("@llvm.global_dtors should have been lowered already");
+  return StaticDtorSection;
+}
+
 void TargetLoweringObjectFileMachO::emitModuleMetadata(MCStreamer &Streamer,
                                                        Module &M) const {
   // Emit the linker options if present.
   if (auto *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
     for (const auto *Option : LinkerOptions->operands()) {
       SmallVector<std::string, 4> StrOptions;
       for (const auto &Piece : cast<MDNode>(Option)->operands())
         StrOptions.push_back(std::string(cast<MDString>(Piece)->getString()));
MCSection *TargetLoweringObjectFileWasm::getStaticCtorSection(
   return Priority == UINT16_MAX ?
          StaticCtorSection :
          getContext().getWasmSection(".init_array." + utostr(Priority),
                                      SectionKind::getData());
 }
 
 MCSection *TargetLoweringObjectFileWasm::getStaticDtorSection(
     unsigned Priority, const MCSymbol *KeySym) const {
-  llvm_unreachable("@llvm.global_dtors should have been lowered already");
-  return nullptr;
+  report_fatal_error("@llvm.global_dtors should have been lowered already");
 }
 
 //===----------------------------------------------------------------------===//
 //                                  XCOFF
 //===----------------------------------------------------------------------===//
 bool TargetLoweringObjectFileXCOFF::ShouldEmitEHBlock(
     const MachineFunction *MF) {
   if (!MF->getLandingPads().empty())

llvm/lib/CodeGen/TargetPassConfig.cpp

void TargetPassConfig::addIRPasses() {
   }
 
   // Run GC lowering passes for builtin collectors
   // TODO: add a pass insertion point here
   addPass(&GCLoweringID);
   addPass(&ShadowStackGCLoweringID);
   addPass(createLowerConstantIntrinsicsPass());
 
+  // For MachO, lower @llvm.global_dtors into @llvm_global_ctors with
+  // __cxa_atexit() calls to avoid emitting the deprecated __mod_term_func.
+  if (TM->getTargetTriple().isOSBinFormatMachO() &&
+      TM->Options.LowerGlobalDtorsViaCxaAtExit)
+    addPass(createLowerGlobalDtorsLegacyPass());
+
   // Make sure that no unreachable blocks are instruction selected.
   addPass(createUnreachableBlockEliminationPass());
 
   // Prepare expensive constants for SelectionDAG.
   if (getOptLevel() != CodeGenOpt::None && !DisableConstantHoisting)
     addPass(createConstantHoistingPass());
 
   if (getOptLevel() != CodeGenOpt::None)

llvm/lib/Passes/PassBuilder.cpp

 #include "llvm/Transforms/Utils/FixIrreducible.h"
 #include "llvm/Transforms/Utils/HelloWorld.h"
 #include "llvm/Transforms/Utils/InjectTLIMappings.h"
 #include "llvm/Transforms/Utils/InstructionNamer.h"
 #include "llvm/Transforms/Utils/LCSSA.h"
 #include "llvm/Transforms/Utils/LibCallsShrinkWrap.h"
 #include "llvm/Transforms/Utils/LoopSimplify.h"
 #include "llvm/Transforms/Utils/LoopVersioning.h"
+#include "llvm/Transforms/Utils/LowerGlobalDtors.h"
 #include "llvm/Transforms/Utils/LowerInvoke.h"
 #include "llvm/Transforms/Utils/LowerSwitch.h"
 #include "llvm/Transforms/Utils/Mem2Reg.h"
 #include "llvm/Transforms/Utils/MetaRenamer.h"
 #include "llvm/Transforms/Utils/NameAnonGlobals.h"
 #include "llvm/Transforms/Utils/PredicateInfo.h"
 #include "llvm/Transforms/Utils/RelLookupTableConverter.h"
 #include "llvm/Transforms/Utils/StripGCRelocates.h"

llvm/lib/Passes/PassRegistry.def

 MODULE_PASS("insert-gcov-profiling", GCOVProfilerPass())
 MODULE_PASS("instrorderfile", InstrOrderFilePass())
 MODULE_PASS("instrprof", InstrProfiling())
 MODULE_PASS("internalize", InternalizePass())
 MODULE_PASS("invalidate<all>", InvalidateAllAnalysesPass())
 MODULE_PASS("ipsccp", IPSCCPPass())
 MODULE_PASS("iroutliner", IROutlinerPass())
 MODULE_PASS("print-ir-similarity", IRSimilarityAnalysisPrinterPass(dbgs()))
+MODULE_PASS("lower-global-dtors", LowerGlobalDtorsPass())
 MODULE_PASS("lowertypetests", LowerTypeTestsPass())
 MODULE_PASS("metarenamer", MetaRenamerPass())
 MODULE_PASS("mergefunc", MergeFunctionsPass())
 MODULE_PASS("name-anon-globals", NameAnonGlobalPass())
 MODULE_PASS("no-op-module", NoOpModulePass())
 MODULE_PASS("objc-arc-apelim", ObjCARCAPElimPass())
 MODULE_PASS("partial-inliner", PartialInlinerPass())
 MODULE_PASS("pgo-icall-prom", PGOIndirectCallPromotion())

llvm/lib/Target/WebAssembly/CMakeLists.txt

add_llvm_target(WebAssemblyCodeGen
   WebAssemblyFixIrreducibleControlFlow.cpp
   WebAssemblyFixFunctionBitcasts.cpp
   WebAssemblyFrameLowering.cpp
   WebAssemblyISelDAGToDAG.cpp
   WebAssemblyISelLowering.cpp
   WebAssemblyInstrInfo.cpp
   WebAssemblyLowerBrUnless.cpp
   WebAssemblyLowerEmscriptenEHSjLj.cpp
-  WebAssemblyLowerGlobalDtors.cpp
   WebAssemblyLowerRefTypesIntPtrConv.cpp
   WebAssemblyMachineFunctionInfo.cpp
   WebAssemblyMCInstLower.cpp
   WebAssemblyMCLowerPrePass.cpp
   WebAssemblyNullifyDebugValueLists.cpp
   WebAssemblyOptimizeLiveIntervals.cpp
   WebAssemblyOptimizeReturned.cpp
   WebAssemblyPeephole.cpp

llvm/lib/Target/WebAssembly/WebAssembly.h

 namespace llvm {
 
 class WebAssemblyTargetMachine;
 class ModulePass;
 class FunctionPass;
 
 // LLVM IR passes.
 ModulePass *createWebAssemblyLowerEmscriptenEHSjLj();
-ModulePass *createWebAssemblyLowerGlobalDtors();
 ModulePass *createWebAssemblyAddMissingPrototypes();
 ModulePass *createWebAssemblyFixFunctionBitcasts();
 FunctionPass *createWebAssemblyOptimizeReturned();
 FunctionPass *createWebAssemblyLowerRefTypesIntPtrConv();
 
 // ISel and immediate followup passes.
 FunctionPass *createWebAssemblyISelDag(WebAssemblyTargetMachine &TM,
                                        CodeGenOpt::Level OptLevel);

 FunctionPass *createWebAssemblyRegNumbering();
 FunctionPass *createWebAssemblyDebugFixup();
 FunctionPass *createWebAssemblyPeephole();
 ModulePass *createWebAssemblyMCLowerPrePass();
 
 // PassRegistry initialization declarations.
 void initializeWebAssemblyAddMissingPrototypesPass(PassRegistry &);
 void initializeWebAssemblyLowerEmscriptenEHSjLjPass(PassRegistry &);
-void initializeLowerGlobalDtorsPass(PassRegistry &);
 void initializeFixFunctionBitcastsPass(PassRegistry &);
 void initializeOptimizeReturnedPass(PassRegistry &);
 void initializeWebAssemblyArgumentMovePass(PassRegistry &);
 void initializeWebAssemblySetP2AlignOperandsPass(PassRegistry &);
 void initializeWebAssemblyReplacePhysRegsPass(PassRegistry &);
 void initializeWebAssemblyNullifyDebugValueListsPass(PassRegistry &);
 void initializeWebAssemblyPrepareForLiveIntervalsPass(PassRegistry &);
 void initializeWebAssemblyOptimizeLiveIntervalsPass(PassRegistry &);

llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp

 #include "WebAssemblyTargetObjectFile.h"
 #include "WebAssemblyTargetTransformInfo.h"
 #include "llvm/CodeGen/MIRParser/MIParser.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/RegAllocRegistry.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/IR/Function.h"
+#include "llvm/InitializePasses.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Scalar/LowerAtomic.h"
 #include "llvm/Transforms/Utils.h"
 using namespace llvm;
 
RegisterTargetMachine<WebAssemblyTargetMachine> X(
       getTheWebAssemblyTarget32());
   RegisterTargetMachine<WebAssemblyTargetMachine> Y(
       getTheWebAssemblyTarget64());
 
   // Register backend passes
   auto &PR = *PassRegistry::getPassRegistry();
   initializeWebAssemblyAddMissingPrototypesPass(PR);
   initializeWebAssemblyLowerEmscriptenEHSjLjPass(PR);
-  initializeLowerGlobalDtorsPass(PR);
+  initializeLowerGlobalDtorsLegacyPassPass(PR);
   initializeFixFunctionBitcastsPass(PR);
   initializeOptimizeReturnedPass(PR);
   initializeWebAssemblyArgumentMovePass(PR);
   initializeWebAssemblySetP2AlignOperandsPass(PR);
   initializeWebAssemblyReplacePhysRegsPass(PR);
   initializeWebAssemblyPrepareForLiveIntervalsPass(PR);
   initializeWebAssemblyOptimizeLiveIntervalsPass(PR);
   initializeWebAssemblyMemIntrinsicResultsPass(PR);

 // the CodeGen pass sequence.
 //===----------------------------------------------------------------------===//
 
 void WebAssemblyPassConfig::addIRPasses() {
   // Add signatures to prototype-less function declarations
   addPass(createWebAssemblyAddMissingPrototypes());
 
   // Lower .llvm.global_dtors into .llvm_global_ctors with __cxa_atexit calls.
-  addPass(createWebAssemblyLowerGlobalDtors());
+  addPass(createLowerGlobalDtorsLegacyPass());
 
   // Fix function bitcasts, as WebAssembly requires caller and callee signatures
   // to match.
   addPass(createWebAssemblyFixFunctionBitcasts());
 
   // Optimize "returned" function attributes.
   if (getOptLevel() != CodeGenOpt::None)
     addPass(createWebAssemblyOptimizeReturned());

llvm/lib/Transforms/Utils/CMakeLists.txt

add_llvm_component_library(LLVMTransformUtils
   LoopPeel.cpp
   LoopRotationUtils.cpp
   LoopSimplify.cpp
   LoopUnroll.cpp
   LoopUnrollAndJam.cpp
   LoopUnrollRuntime.cpp
   LoopUtils.cpp
   LoopVersioning.cpp
+  LowerGlobalDtors.cpp
   LowerInvoke.cpp
   LowerMemIntrinsics.cpp
   LowerSwitch.cpp
   MatrixUtils.cpp
   MemoryOpRemark.cpp
   MemoryTaggingSupport.cpp
   Mem2Reg.cpp
   MetaRenamer.cpp

llvm/lib/Transforms/Utils/LowerGlobalDtors.cpp

-//===-- WebAssemblyLowerGlobalDtors.cpp - Lower @llvm.global_dtors --------===//
+//===-- LowerGlobalDtors.cpp - Lower @llvm.global_dtors -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Lower @llvm.global_dtors.
 ///
-/// WebAssembly doesn't have a builtin way to invoke static destructors.
 /// Implement @llvm.global_dtors by creating wrapper functions that are
 /// registered in @llvm.global_ctors and which contain a call to
 /// `__cxa_atexit` to register their destructor functions.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "WebAssembly.h"
-#include "llvm/ADT/MapVector.h"
+#include "llvm/Transforms/Utils/LowerGlobalDtors.h"
+
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
-#include "llvm/IR/Module.h"
+#include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/raw_ostream.h"
+#include "llvm/Transforms/Utils.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 #include <map>
 
 using namespace llvm;
 
-#define DEBUG_TYPE "wasm-lower-global-dtors"
+#define DEBUG_TYPE "lower-global-dtors"
 
 namespace {
-class LowerGlobalDtors final : public ModulePass {
+class LowerGlobalDtorsLegacyPass final : public ModulePass {
   StringRef getPassName() const override {
-    return "WebAssembly Lower @llvm.global_dtors";
+    return "Lower @llvm.global_dtors via `__cxa_atexit`";
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesCFG();
     ModulePass::getAnalysisUsage(AU);
   }
 
   bool runOnModule(Module &M) override;
 
 public:
   static char ID;
-  LowerGlobalDtors() : ModulePass(ID) {}
+  LowerGlobalDtorsLegacyPass() : ModulePass(ID) {}
 };
 } // End anonymous namespace
 
-char LowerGlobalDtors::ID = 0;
-INITIALIZE_PASS(LowerGlobalDtors, DEBUG_TYPE,
-                "Lower @llvm.global_dtors for WebAssembly", false, false)
+char LowerGlobalDtorsLegacyPass::ID = 0;
+INITIALIZE_PASS(LowerGlobalDtorsLegacyPass, DEBUG_TYPE,
+                "Lower @llvm.global_dtors via `__cxa_atexit`", false, false)
 
-ModulePass *llvm::createWebAssemblyLowerGlobalDtors() {
-  return new LowerGlobalDtors();
+ModulePass *llvm::createLowerGlobalDtorsLegacyPass() {
+  return new LowerGlobalDtorsLegacyPass();
 }
 
-bool LowerGlobalDtors::runOnModule(Module &M) {
-  LLVM_DEBUG(dbgs() << "********** Lower Global Destructors **********\n");
+static bool runImpl(Module &M);
+bool LowerGlobalDtorsLegacyPass::runOnModule(Module &M) { return runImpl(M); }
+
+PreservedAnalyses LowerGlobalDtorsPass::run(Module &M,
+                                            ModuleAnalysisManager &AM) {
+  bool Changed = runImpl(M);
+  if (!Changed)
+    return PreservedAnalyses::all();
+
+  PreservedAnalyses PA;
+  PA.preserveSet<CFGAnalyses>();
+  return PA;
+}
 
+static bool runImpl(Module &M) {
   GlobalVariable *GV = M.getGlobalVariable("llvm.global_dtors");
   if (!GV || !GV->hasInitializer())
     return false;
 
   const ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
   if (!InitList)
     return false;
 

llvm/test/CodeGen/ARM/ctors_dtors.ll

 ; RUN: llc < %s -mtriple=arm-apple-darwin  | FileCheck %s -check-prefix=DARWIN
+; RUN: llc < %s -mtriple=arm-apple-darwin -lower-global-dtors-via-cxa-atexit=false  | FileCheck %s -check-prefix=DARWIN-OLD
 ; RUN: llc < %s -mtriple=arm-linux-gnu -target-abi=apcs  | FileCheck %s -check-prefix=ELF
 ; RUN: llc < %s -mtriple=arm-linux-gnueabi | FileCheck %s -check-prefix=GNUEABI
 
+; DARWIN: l_register_call_dtors:
+; DARWIN: bl  ___cxa_atexit
 ; DARWIN: .section  __DATA,__mod_init_func,mod_init_funcs
-; DARWIN: .section  __DATA,__mod_term_func,mod_term_funcs
+; DARWIN-NOT: __mod_term_func
+
+; DARWIN-OLD: .section  __DATA,__mod_init_func,mod_init_funcs
+; DARWIN-OLD: .section  __DATA,__mod_term_func,mod_term_funcs
 
 ; ELF: .section .ctors,"aw",%progbits
 ; ELF: .section .dtors,"aw",%progbits
 
 ; GNUEABI: .section .init_array,"aw",%init_array
 ; GNUEABI: .section .fini_array,"aw",%fini_array
 
 @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [ { i32, void ()*, i8* } { i32 65535, void ()* @__mf_init, i8* null } ]                ; <[1 x { i32, void ()*, i8* }]*> [#uses=0]

llvm/test/CodeGen/X86/2011-08-29-InitOrder.ll

 ; RUN: llc < %s -mtriple=i386-linux-gnu -use-ctors | FileCheck %s --check-prefix=CHECK-DEFAULT
 ; RUN: llc < %s -mtriple=i386-apple-darwin | FileCheck %s --check-prefix=CHECK-DARWIN
 ; PR5329
 
 @llvm.global_ctors = appending global [3 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 2000, void ()* @construct_2, i8* null }, { i32, void ()*, i8* } { i32 3000, void ()* @construct_3, i8* null }, { i32, void ()*, i8* } { i32 1000, void ()* @construct_1, i8* null }]
 ; CHECK-DEFAULT: .section        .ctors.62535,"aw",@progbits
 ; CHECK-DEFAULT: .long construct_3
 ; CHECK-DEFAULT: .section        .ctors.63535,"aw",@progbits
 ; CHECK-DEFAULT: .long construct_2
 ; CHECK-DEFAULT: .section        .ctors.64535,"aw",@progbits
 ; CHECK-DEFAULT: .long construct_1
 
-; CHECK-DARWIN: .long _construct_1
+; CHECK-DARWIN-LABEL: .section  __DATA,__mod_init_func,mod_init_funcs
+; CHECK-DARWIN:      .long _construct_1
+; CHECK-DARWIN-NEXT: .long l_register_call_dtors.1000
 ; CHECK-DARWIN-NEXT: .long _construct_2
+; CHECK-DARWIN-NEXT: .long l_register_call_dtors.2000
 ; CHECK-DARWIN-NEXT: .long _construct_3
+; CHECK-DARWIN-NEXT: .long l_register_call_dtors.3000
 
 @llvm.global_dtors = appending global [3 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 2000, void ()* @destruct_2, i8* null }, { i32, void ()*, i8* } { i32 1000, void ()* @destruct_1, i8* null }, { i32, void ()*, i8* } { i32 3000, void ()* @destruct_3, i8* null }]
 ; CHECK-DEFAULT: .section        .dtors.62535,"aw",@progbits
 ; CHECK-DEFAULT: .long destruct_3
 ; CHECK-DEFAULT: .section        .dtors.63535,"aw",@progbits
 ; CHECK-DEFAULT: .long destruct_2
 ; CHECK-DEFAULT: .section        .dtors.64535,"aw",@progbits
 ; CHECK-DEFAULT: .long destruct_1
 
-; CHECK-DARWIN:      .long _destruct_1
-; CHECK-DARWIN-NEXT: .long _destruct_2
-; CHECK-DARWIN-NEXT: .long _destruct_3
+; CHECK-DARWIN-NOT: mod_term_func
 
 declare void @construct_1()
 declare void @construct_2()
 declare void @construct_3()
 declare void @destruct_1()
 declare void @destruct_2()
 declare void @destruct_3()

llvm/test/Transforms/LowerGlobalDestructors/lower-global-dtors.ll

+; RUN: opt        -lower-global-dtors -S < %s | FileCheck %s --implicit-check-not=llvm.global_dtors
+; RUN: opt -passes=lower-global-dtors -S < %s | FileCheck %s --implicit-check-not=llvm.global_dtors
+
+; Test that @llvm.global_dtors is properly lowered into @llvm.global_ctors,
+; grouping dtor calls by priority and associated symbol.
+
+declare void @orig_ctor()
+declare void @orig_dtor0()
+declare void @orig_dtor1a()
+declare void @orig_dtor1b()
+declare void @orig_dtor1c0()
+declare void @orig_dtor1c1a()
+declare void @orig_dtor1c1b()
+declare void @orig_dtor1c2a()
+declare void @orig_dtor1c2b()
+declare void @orig_dtor1c3()
+declare void @orig_dtor1d()
+declare void @orig_dtor65535()
+declare void @orig_dtor65535c0()
+declare void @after_the_null()
+
+@associatedc0 = external global i8
+@associatedc1 = external global i8
+@associatedc2 = global i8 42
+@associatedc3 = global i8 84
+
[e-mail]_ctors = appending global
+[1 x { i32, void ()*, i8* }]
+[
+  { i32, void ()*, i8* } { i32 200, void ()* @orig_ctor, i8* null }
+]
+
[e-mail]_dtors = appending global
+[14 x { i32, void ()*, i8* }]
+[
+  { i32, void ()*, i8* } { i32 0, void ()* @orig_dtor0, i8* null },
+  { i32, void ()*, i8* } { i32 1, void ()* @orig_dtor1a, i8* null },
+  { i32, void ()*, i8* } { i32 1, void ()* @orig_dtor1b, i8* null },
+  { i32, void ()*, i8* } { i32 1, void ()* @orig_dtor1c0, i8* @associatedc0 },
+  { i32, void ()*, i8* } { i32 1, void ()* @orig_dtor1c1a, i8* @associatedc1 },
+  { i32, void ()*, i8* } { i32 1, void ()* @orig_dtor1c1b, i8* @associatedc1 },
+  { i32, void ()*, i8* } { i32 1, void ()* @orig_dtor1c2a, i8* @associatedc2 },
+  { i32, void ()*, i8* } { i32 1, void ()* @orig_dtor1c2b, i8* @associatedc2 },
+  { i32, void ()*, i8* } { i32 1, void ()* @orig_dtor1c3, i8* @associatedc3 },
+  { i32, void ()*, i8* } { i32 1, void ()* @orig_dtor1d, i8* null },
+  { i32, void ()*, i8* } { i32 65535, void ()* @orig_dtor65535c0, i8* @associatedc0 },
+  { i32, void ()*, i8* } { i32 65535, void ()* @orig_dtor65535, i8* null },
+  { i32, void ()*, i8* } { i32 65535, void ()* null, i8* null },
+  { i32, void ()*, i8* } { i32 65535, void ()* @after_the_null, i8* null }
+]
+
+; CHECK: @associatedc0 = external global i8
+; CHECK: @associatedc1 = external global i8
+; CHECK: @associatedc2 = global i8 42
+; CHECK: @associatedc3 = global i8 84
+; CHECK: @__dso_handle = extern_weak hidden constant i8
+
+; CHECK-LABEL: @llvm.global_ctors = appending global [10 x { i32, void ()*, i8* }] [
+; CHECK-SAME:  { i32, void ()*, i8* } { i32 200, void ()* @orig_ctor, i8* null },
+; CHECK-SAME:  { i32, void ()*, i8* } { i32 0, void ()* @register_call_dtors.0, i8* null },
+; CHECK-SAME:  { i32, void ()*, i8* } { i32 1, void ()* @"register_call_dtors.1$0", i8* null },
+; CHECK-SAME:  { i32, void ()*, i8* } { i32 1, void ()* @"register_call_dtors.1$1.associatedc0", i8* @associatedc0 },
+; CHECK-SAME:  { i32, void ()*, i8* } { i32 1, void ()* @"register_call_dtors.1$2.associatedc1", i8* @associatedc1 },
+; CHECK-SAME:  { i32, void ()*, i8* } { i32 1, void ()* @"register_call_dtors.1$3.associatedc2", i8* @associatedc2 },
+; CHECK-SAME:  { i32, void ()*, i8* } { i32 1, void ()* @"register_call_dtors.1$4.associatedc3", i8* @associatedc3 },
+; CHECK-SAME:  { i32, void ()*, i8* } { i32 1, void ()* @"register_call_dtors.1$5", i8* null },
+; CHECK-SAME:  { i32, void ()*, i8* } { i32 65535, void ()* @"register_call_dtors$0.associatedc0", i8* @associatedc0 },
+; CHECK-SAME:  { i32, void ()*, i8* } { i32 65535, void ()* @"register_call_dtors$1", i8* null }]
+
+; CHECK: declare void @orig_ctor()
+; CHECK: declare void @orig_dtor0()
+; --- other dtors here ---
+; CHECK: declare void @after_the_null()
+
+; CHECK: declare i32 @__cxa_atexit(void (i8*)*, i8*, i8*)
+
+; CHECK-LABEL: define private void @call_dtors.0(i8* %0)
+; CHECK:       call void @orig_dtor0()
+; CHECK-NEXT:  ret void
+
+; CHECK-LABEL: define private void @register_call_dtors.0()
+; CHECK:       %call = call i32 @__cxa_atexit(void (i8*)* @call_dtors.0, i8* null, i8* @__dso_handle)
+; CHECK-NEXT:  %0 = icmp ne i32 %call, 0
+; CHECK-NEXT:  br i1 %0, label %fail, label %return
+; CHECK-EMPTY:
+; CHECK-NEXT:  fail:
+; CHECK-NEXT:    call void @llvm.trap()
+; CHECK-NEXT:    unreachable
+; CHECK-EMPTY:
+; CHECK-NEXT:  return:
+; CHECK-NEXT:    ret void
+
+; CHECK-LABEL: define private void @"call_dtors.1$0"(i8* %0)
+; CHECK:       call void @orig_dtor1b()
+; CHECK-NEXT:  call void @orig_dtor1a()
+; CHECK-NEXT:  ret void
+
+; CHECK-LABEL: define private void @"register_call_dtors.1$0"()
+; CHECK:       %call = call i32 @__cxa_atexit(void (i8*)* @"call_dtors.1$0", i8* null, i8* @__dso_handle)
+
+; CHECK-LABEL: define private void @"call_dtors.1$1.associatedc0"(i8* %0)
+; CHECK:       call void @orig_dtor1c0()
+; CHECK-NEXT:  ret void
+
+; CHECK-LABEL: define private void @"register_call_dtors.1$1.associatedc0"()
+; CHECK:       %call = call i32 @__cxa_atexit(void (i8*)* @"call_dtors.1$1.associatedc0", i8* null, i8* @__dso_handle)
+
+; CHECK-LABEL: define private void @"call_dtors.1$2.associatedc1"(i8* %0)
+; CHECK:       call void @orig_dtor1c1b()
+; CHECK-NEXT:  call void @orig_dtor1c1a()
+; CHECK-NEXT:  ret void
+
+; CHECK-LABEL: define private void @"register_call_dtors.1$2.associatedc1"()
+; CHECK:       %call = call i32 @__cxa_atexit(void (i8*)* @"call_dtors.1$2.associatedc1", i8* null, i8* @__dso_handle)
+
+; CHECK-LABEL: define private void @"call_dtors.1$3.associatedc2"(i8* %0)
+; CHECK:       call void @orig_dtor1c2b()
+; CHECK-NEXT:  call void @orig_dtor1c2a()
+; CHECK-NEXT:  ret void
+
+; CHECK-LABEL: define private void @"register_call_dtors.1$3.associatedc2"()
+; CHECK:       %call = call i32 @__cxa_atexit(void (i8*)* @"call_dtors.1$3.associatedc2", i8* null, i8* @__dso_handle)
+
+; CHECK-LABEL: define private void @"call_dtors.1$4.associatedc3"(i8* %0)
+; CHECK:       call void @orig_dtor1c3()
+; CHECK-NEXT:  ret void
+
+; CHECK-LABEL: define private void @"register_call_dtors.1$4.associatedc3"()
+; CHECK:       %call = call i32 @__cxa_atexit(void (i8*)* @"call_dtors.1$4.associatedc3", i8* null, i8* @__dso_handle)
+
+; CHECK-LABEL: define private void @"call_dtors.1$5"(i8* %0)
+; CHECK:       call void @orig_dtor1d()
+; CHECK-NEXT:  ret void
+
+; CHECK-LABEL: define private void @"register_call_dtors.1$5"()
+; CHECK:       %call = call i32 @__cxa_atexit(void (i8*)* @"call_dtors.1$5", i8* null, i8* @__dso_handle)
+
+; CHECK-LABEL: define private void @"call_dtors$0.associatedc0"(i8* %0)
+; CHECK:       call void @orig_dtor65535c0()
+; CHECK-NEXT:  ret void
+
+; CHECK-LABEL: define private void @"register_call_dtors$0.associatedc0"()
+; CHECK:       %call = call i32 @__cxa_atexit(void (i8*)* @"call_dtors$0.associatedc0", i8* null, i8* @__dso_handle)
+
+; CHECK-LABEL: define private void @"call_dtors$1"(i8* %0)
+; CHECK:       call void @orig_dtor65535()
+; CHECK-NEXT:  ret void
+
+; CHECK-LABEL: define private void @"register_call_dtors$1"()
+; CHECK:       %call = call i32 @__cxa_atexit(void (i8*)* @"call_dtors$1", i8* null, i8* @__dso_handle)
+
+
+; This function is listed after the null terminator, so it should
+; be excluded.
+
+; CHECK-NOT: after_the_null