[AIX][Frontend] Static init implementation for AIX considering no priority

[Xiangling_L]

Summary

• • Provides no piroirity supoort && disables three priority related attributes: init_priority, ctor attr, dtor attr;
• '-qunique' in XL compiler equivalent behavior of emitting sinit and sterm functions name using getUniqueModuleId() function in LLVM (currently no support for InternalLinkage and WeakODRLinkage symbols);
• Add testcases to emit IR sample with sinit80000000, dtor, and __sterm80000000
• Temporarily side-steps the need to implement the functionality of llvm.global_ctors and llvm.global_dtors arrays. The uses of that functionality in this patch (with respect to the name of the functions involved) are not representative of how the functionality will be used once implemented.

[aaron.ballman]

clang/lib/Sema/SemaDeclAttr.cpp

6942–6946

This change (and the others like it) should be done within Attr.td and not exposed here. You should make these attributes target-specific.

You should also update AttrDocs.td for these attributes to document that they're not supported on AIX.

clang/test/CodeGen/aix-priority-attribute.cpp

1–4 ↗

(On Diff #261602)

I think this test file should live in SemaCXX instead, as this is not testing the codegen behavior, but testing the semantic checking behavior.

[ZarkoCA]

clang/lib/CodeGen/CGDeclCXX.cpp

720

I may be missing something but why do we need this now, as opposed to not needing it before? Why didn't we need to clear the CXXGlobalDtors after emitting the function function before?

clang/lib/CodeGen/ItaniumCXXABI.cpp

4526

Style guide now says no capitalization and no punctuation at the end for report_fatal_error messages.

[Xiangling_L]

clang/lib/CodeGen/CGDeclCXX.cpp

720

No, you didn't miss anything here. I just followed what EmitCXXGlobalInitFunc() does, which is to clear the std::vecotr once we are certain it's useless.

clang/lib/Sema/SemaDeclAttr.cpp

6942–6946

Thanks for your comments. As I mentioned in the below testcase, those three attributes actually will be supported by the follow-up patches for AIX. I will update them to report_fatal_error instead.

clang/test/CodeGen/aix-priority-attribute.cpp

1–4 ↗

(On Diff #261602)

Actually we will support those three attributes in the future, so the warning are placeholders waiting for the future upgrade where we do want to check the codegen results.

I agree the warnings here are confusing, I will update them with report_fatal_error.

[Xiangling_L]

Updated the warnings to report_fatal_error;
Update the testcases;

[Xiangling_L]

Fix a minor issue in the testcase

[Xiangling_L]

Clean clang-tidy warnings and clang-format errors

[hubert.reinterpretcast]

clang/test/CodeGen/static-init.cpp

2

Shouldn't this be internal?

[Xiangling_L]

Fix the linkage types;
Adjust the formatting;
Update the testcase;

[Xiangling_L]

Adjust mangleDynamicDestructor;
Add assertion and FIXME for getUniqueModuleId

[jasonliu]

clang/lib/AST/ItaniumMangle.cpp

5243

If I understand correctly, this function will come in pair with __cxx_global_var_init.
__cxx_global_var_init use number as suffix in the end to avoid duplication when there is more than one of those, but we are using the variable name as suffix here instead.
Do we want to use number as suffix here to match what __cxx_global_var_init does? It would help people to recognize the pairs and make them more symmetric.

clang/lib/CodeGen/CGCXXABI.h

113

Do we need this isCXXGlobalInitAndDtorFuncInternal? Looks like it's always going to return ! useSinitAndSterm() result.

clang/lib/CodeGen/CGDeclCXX.cpp

591

const for UseSinitAndSterm variable?

643

flip this for an early return?

696

We might want to avoid this string copy construction if possible.

clang/lib/CodeGen/CodeGenModule.h

20

Is this Attr.h needed somewhere in this file?

401

nit: UserSinitAndSterm -> UseSinitAndSterm?
and we do not have that property here.
Suggestion:
when getCXXABI().useSinitAndSterm() return true.

clang/lib/CodeGen/ItaniumCXXABI.cpp

4528

In this implementation we do not seem to have __srterm functions. I think we should refer to __dtor instead.

4561

Srterm is not used in this implementation.
Suggestion:
guard.hasDtorCalled

4563

I think we need a better naming for this and make it consistent with the end block below.
As it is for now, destruct.check is confusing, as we are not checking anything here and we are just going to call destructor directly in this block.

clang/test/CodeGen/static-init.cpp

0

Would it be better to test static init for at least two global variable?
Testing only one global variable does not show the whole picture of AIX static init.

[jasonliu]

clang/lib/CodeGen/CGDeclCXX.cpp

304

Is there a valid case that unatexit.getCallee() returns a type which could not be cast to llvm::Function?
i.e. Could we use cast instead of dyn_cast?

[jasonliu]

-fregister_global_dtors_with_atexit does not seem to work properly in current implementation.
We should consider somehow disabling/report_fatal_error it instead of letting it generate invalid code on AIX.

clang/lib/CodeGen/CGDeclCXX.cpp

599

I think report_fatal_error is more appropriate here? Since we know some case will trigger this, and we do not want those case to silently pass in non-assertion mode?

clang/lib/CodeGen/ItaniumCXXABI.cpp

4534

This comment is confusing.
This is not emitting __sterm function, this is emitting __cxx_global_var_destruct functions. And again, we do not have __srterm function in this implementation.

4550

nit: this is not sterm function.

[Xiangling_L]

Address the comments

clang/lib/AST/ItaniumMangle.cpp

5243

This is somewhere I am kinda on the fence. Personally, I think embed decl name in the cxx_global_var_destruct_ / cxx_global_vat_init_ as mangleDynamicAtExitDestructor does is more helpful for the user to debug the static init.
I am not sure if we want to give up that benefit and be consistent with current __cxx_global_vat_init_ using number suffix or do we want to replace number suffix by decl name for __cxx_global_vat_init_ as well.

clang/lib/CodeGen/CGCXXABI.h

113

AFAIK, not all platforms which use sinit and sterm have external linkage sinit/sterm functions. And also since for 7.2 AIX we are considering change sinit/sterm to internal linkage symbols, I seperate this query out.

clang/lib/CodeGen/CGDeclCXX.cpp

304

I used cast instead of dyn_cast before Diff 9 actually, and then I noticed that clang-tidy gave error and asked me to use dyn_cast instead. Cannot recall what the error says though...

clang/lib/CodeGen/CodeGenModule.h

20

Oops..this is something I forgot to remove. Good catch!

clang/lib/CodeGen/ItaniumCXXABI.cpp

4563

Thanks, I will try destruct.call instead.

[jasonliu]

clang/lib/CodeGen/CGCXXABI.h

113

I would prefer to create the query in the patch when we actually need it. With what we have right now, it seems redundant.

clang/lib/CodeGen/CGDeclCXX.cpp

643

It looks like one of the UseSinitAndSterm is redundant. We could have something like:

UseSinitAndSterm ? llvm::twine("__sinit80000000_clang_") + GlobalUniqueModuleId : llvm::twine("_GLOBAL__sub_I_") + getTransformedFileName(getModule())

which minimize the use of std::string?
If this is too long, then we could separate them into if statement just like what we have in EmitCXXGlobalDtorFunc, or use a lambda.

696

Could we assert !GlobalUniqueModuleId.empty() here?
Right now, it solely relies on EmitCXXGlobalInitFunc to run before EmitCXXGlobalDtorFunc to get GlobalUniqueModuleId initialized properly. I think it makes sense to put an assert here to make sure it stays in that case in the future.

703

This could go inside of the if (UseSinitAndSterm).

clang/lib/CodeGen/ItaniumCXXABI.cpp

4561

"guard.hasDtor" does not reflect what the meaning. Maybe matching with the variable name would make sense: "guard.needsDestruct" or just "needsDestruct"?

clang/test/CodeGen/static-init.cpp

3

#0 could be removed.

[hubert.reinterpretcast]

clang/lib/CodeGen/ItaniumCXXABI.cpp

4528

We should probably report_fatal_error if CXAAtExit (the option) is true before this line. This would imply driver changes to default AIX to using -fno-use-cxa-atexit. An associated test file is https://github.com/llvm/llvm-project/blame/master/clang/test/Driver/cxa-atexit.cpp.

[hubert.reinterpretcast]

clang/lib/CodeGen/CGDeclCXX.cpp

567

Consider having the SmallString<128> buffer passed in and returning a StringRef backed by that buffer.

clang/lib/CodeGen/CodeGenModule.h

1066

What is "the C++ global destructor function"? Based on the comment on CXXGlobalDtors it has something to do with termination of the program. The existing usage is limited and consistent: This is a facility used when even atexit is not available.

1068

The description of CXXGlobalDtors is

Global destructor functions and arguments that need to run on termination.

clang/lib/CodeGen/ItaniumCXXABI.cpp

4582

The purpose of the specific interface does not appear to match its usage here (see my other comment). This function is meant to be called on unloading a shared library. The usual termination path calls destructors via atexit.

[hubert.reinterpretcast]

clang/include/clang/AST/Mangle.h

178

I am not sure "destructor" is the right term here. This seems to be an analogue to the functions named using mangleDynamicAtExitDestructor, except that those rather directly perform destruction and are registered with atexit during initialization whereas these perform finalization and are "registered" by being called from an "sterm" function. What are the thoughts on mangleDynamicStermFinalizer?

clang/lib/AST/ItaniumMangle.cpp

5243

Not every dynamically initialized non-local variable of static storage duration requires non-trivial destruction. These don't actually pair with __cxx_global_var_init; rather, they pair with the calls to atexit and the functions whose addresses are passed to atexit.

[hubert.reinterpretcast]

clang/lib/CodeGen/CGDeclCXX.cpp

304

If we expect cast to be okay, then we should use it without the if.

In Diff 8, an if is used with cast (thus a clang-tidy error make sense):

if (llvm::Function *unatexitFn = cast<llvm::Function>(unatexit.getCallee()))

[Xiangling_L]

Address another round of reviews;

clang/include/clang/AST/Mangle.h

178

mangleDynamicDestructor is an analogue to mangleDynamicInitializer actually.

From this perspective, I think mangleDynamicStermFinalizer is good.

clang/lib/CodeGen/CodeGenModule.h

1068

Currently, only Apple Kernal extension will use AddCXXDtorEntry to add variable destructor to CXXGlobalDtors.
An example is:

$cat test.cpp
class test {
   int a;
public:
    test(int c) {a = c;}
    ~test() {a = 0;}
} t(1);


$clang --driver-mode=g++ -target x86_64-apple-darwin10 -fapple-kext -flto -S -o - test.cpp

...
define internal void @_GLOBAL__D_a() #0 {
entry:
  call void @_ZN4testD1Ev(%class.test* @t)       #~test() {a = 0;}
  ret void
}

Since the usage as you said below does not match with our sterm finalizer function __cxx_global_var_destruct, I am thinking we can either modify the name and the description of CXXGlobalDtors to make it also fit AIX or we can define a brand new CXXStermFinalizers vector and also related facility to GenerateCXXStermFinalizerFunc instead.

An example of modification I have in mind is:
CXXGlobalDtorsOrStermFinalizers

Global destructor functions and arguments that need to run on termination;
When UseSinitAndSterm is set, it contains sterm finalizer functions instead that need to run on unloading a shared library.

I would prefer the modification way to save a lot effort. Any thoughts on it?

clang/lib/CodeGen/ItaniumCXXABI.cpp

4528

Maybe we should add -fno-use-cxa-atexit to driver in a follow-up patch?

clang/test/CodeGen/static-init.cpp

3

Why I chose to keep this #0 is because to remove it, we would either remove the following { which I kinda feel makes the function look not nice or we need to match #0 with regex which I think is redundant.

[hubert.reinterpretcast]

clang/lib/CodeGen/CGDeclCXX.cpp

292

Please add a comment explaining the meaning of the zero and non-zero return values.

609

I don't think we should capitalize "sinit" and "sterm" in comments. Indeed, there's a comment below where they are not capitalized.

642–643

The first sentence does not apply unconditionally in the status quo of this patch. Perhaps keep the original comment completely with something like:

// When not using sinit and sterm functions:
// ...

644

Can this part be committed in a separate patch? It does not appear to have dependencies on other parts of this patch and has the appearance of being a possible change for other platforms.

689–690

Following from my previous comments on CXXGlobalDtors, I am not convinced that __sterm functions match the role.

720

If this is another drive-by fix, can we put it in a separate patch?

832–842

This change would not belong in this function if its scope remains the generation of a "GlobalDtorsFunc" (based on my understanding of the latter).

clang/lib/CodeGen/ItaniumCXXABI.cpp

4526

s/unimplemented on AIX yet/not yet implemented on AIX/;

4548

Suggestion:
Create the finalization action associated with a variable.

4561

I don't think this is a real "guard variable". I think the comments need to explain this (including scare quotes for "guard variable".

[hubert.reinterpretcast]

clang/lib/AST/ItaniumMangle.cpp

5239

I believe these are actually paired with the __dtor_ functions. The prefix can be __finalize_.

clang/lib/CodeGen/CGDeclCXX.cpp

567

FileName should be a reference?

643

The binding of the second sentence in relation to "not using sinit and sterm" is not clear in this new version. I still recommend introducing a "block" with a colon.

645

Use a SmallString for FuncName.

646

Move Storage into the else block and use it only for calling getTransformedFileName.

[hubert.reinterpretcast]

clang/lib/CodeGen/CGDeclCXX.cpp

832–842

Please assert that Arg == nullptr iff we're dealing with sinit/sterm.

clang/lib/CodeGen/CodeGenModule.h

1068

I'm fine with renaming but it should include renaming the associated fuctions.

clang/lib/CodeGen/ItaniumCXXABI.cpp

4528

I'm okay with that.

[hubert.reinterpretcast]

clang/lib/CodeGen/CGDeclCXX.cpp

689–690

This function is to be renamed.

699

The called function is to be renamed.

clang/lib/CodeGen/CodeGenModule.h

1067

This function is to be renamed.

clang/lib/CodeGen/ItaniumCXXABI.cpp

4541

This function is to be renamed.

4553

Term, being a short form for "termination", the variable name does not match the purpose based on the terminology within the Clang context.

4570

This comment is not helpful. It does not say which action is associated with which state.

clang/test/CodeGen/aix-constructor-attribute.cpp

3

Please split on the | with the new line beginning with FileCheck indented two spaces in relation to the previous line. Apply throughout.

[jasonliu]

clang/test/CodeGen/static-init.cpp

0

Looks like the non-inline comments are easier to get ignored and missed, so I will copy paste the non-inlined comment I previously had:

-fregister_global_dtors_with_atexit does not seem to work properly in current implementation.
We should consider somehow disabling/report_fatal_error it instead of letting it generate invalid code on AIX.

[hubert.reinterpretcast]

clang/test/CodeGen/static-init.cpp

0

I suggest adding also one each of the following:

• a dynamic initialization of a non-local variable of type int
• a constinit initialization of a non-local variable with non-constant destruction

[hubert.reinterpretcast]

clang/lib/CodeGen/CGDeclCXX.cpp

816

This function is to be renamed.

clang/lib/CodeGen/CodeGenModule.h

401

Minor nit: s/set/is set/;

[Xiangling_L]

Address another round of reviews;

clang/lib/CodeGen/CGDeclCXX.cpp

644

Sure. I will create a NFC patch for this part and try to commit it first. But so far, I think I can keep this part in this patch just for review purpose to make the patch look nicer?

699

Any suggestions here about how to represent the functionality of __sterm and _GLOBAL__D_a into one word? Cannot think of a good name...

Actually I am wondering do we need to rename the Destruct part? The __sterm and _GLOBAL__D_a do destruct the object by calling sterm finalizers and object destructors?

720

Sure, I will put it in the above mentioned clean-up NFC patch as well.

816

I will try GenerateCXXGlobalDestructFunc based on the thoughts as I also mentioned elsewhere that the __sterm and _GLOBAL__D_ function do destruct the object by calling sterm finalizers and object destructors.

Any suggestions or concerns about this renaming? Or do we really need to rename this one?

clang/lib/CodeGen/ItaniumCXXABI.cpp

4548

I don't get your point, can you elaborate on this a little bit?

clang/test/CodeGen/static-init.cpp

0

Thanks for doing so!

The semantic of global_dtors here on AIX is __sterm function, which we are never gonna register with __atexit. I am thinking we can disable it in a follow-up driver patch with the handling of -fno-use-cxa-atexit.

[hubert.reinterpretcast]

clang/lib/CodeGen/CGDeclCXX.cpp

644

Sure; you'd need the new patch to exist before rebasing on it anyway. We can leave the rebasing to the commit or later in the review.

699

Being clear in the naming of the function helps to signal its purpose to future maintainers. The sterm finalizers are unlikely to be understood from Destruct (it implies plain destruction a bit too much). Maybe "cleanup"?

816

I think "cleanup" works here too.

clang/lib/CodeGen/ItaniumCXXABI.cpp

4548

This is my suggestion for the comment (to replace "Create a variable destruction function").

[hubert.reinterpretcast]

clang/test/CodeGen/static-init.cpp

15

Okay, the restricted scope of this patch seems to landed in a place where how the llvm.global_dtors array will be handled is not indicated...

The backend should implement the semantics of the IR construct. When handling said array in the IR, it seems the method to handle the requisite semantics would be to generate an alias (with the appropriate linkage for the linker to pick it up) that is named using the __sinit/__sterm convention. Which is to say that at least some part of the naming should eventually move into the LLVM side and out of Clang.

Please update the description of this patch to indicate that:

• The llvm.global_ctors and llvm.global_dtors functionality has not yet been implemented on AIX.
• This patch temporarily side-steps the need to implement that functionality.
• The apparent uses of that functionality in this patch (with respect to the name of the functions involved) are not representative of how the functionality will be used once implemented.

[hubert.reinterpretcast]

clang/test/CodeGen/static-init.cpp

0

The semantic of global_dtors is not limited to the __sterm functions associated with C++ cleanup actions. With respect to user-declared __attribute__((__destructor__)) functions, the option could improve the interleaving of those cleanup actions with cleanup actions registered by user-declared __attribute__((__constructor__)) functions.

This provides that rationale for separating the __sterm functions associated with the C++ cleanup actions from the other "destructor" functions.

[hubert.reinterpretcast]

clang/lib/CodeGen/CGDeclCXX.cpp

276

s/atexit has wrong parameter type/Argument to atexit has a wrong type/;

301

s/unatexit has wrong parameter type/Argument to unatexit has a wrong type/;

645

Replace the call to toNullTerminatedStringRef and the assignment with a call to toVector.

646

CreateGlobalInitOrDestructFunction currently calls Create with llvm::GlobalValue::InternalLinkage and also calls SetInternalFunctionAttributes. Setting ExternalLinkage after-the-fact seems brittle.

653

Replace the call to toNullTerminatedStringRef and the assignment with a call to toVector.

689–690

I think "cleanup" works here too.

693–695

s/Create our global destructor function/Create our global cleanup function/;

826–827

s/dtors/cleanups/;

clang/lib/CodeGen/CodeGenModule.h

472

Near duplicate comment line.

473

s/finalizers/finalizer/;
s/it contains/it instead contains/;

474

s/instead that need to run/, which also run/;

1060

s/a destructor/an sterm finalizer/;
s/global destructor/global cleanup/;

1061

s/Dtor/StermFinalizer/;

1463–1464

s/destructs/performs cleanup associated with/;

clang/lib/CodeGen/ItaniumCXXABI.cpp

4532

There should not be period at the end of a report_fatal_error message.

4536

s/and/and (as appropriate)/;

4561

The "and the related [ ... ]" part is ambiguous in terms of describing unatexit versus the actions generated here.

Suggestion:
[ ... ] returns a value of 0, meaning that the cleanup is still pending (and we should call the __dtor function).

4562

Remove the "Otherwise [ ... ]".

4565

Does this fit on one line?

4573

Please add a test for a static local. Note the branch_weights. I do not believe the branch_weights associated with guarded initialization for a static local (what the called function is meant to deal with) is necessarily appropriate for a branch associated with finalization-on-unload.

clang/lib/Sema/SemaDeclAttr.cpp

6944

s/unsupported on AIX yet/is not yet supported on AIX/;

6953

s/unsupported on AIX yet/is not yet supported on AIX/;

7151

s/unsupported on AIX yet/is not yet supported on AIX/;

[hubert.reinterpretcast]

clang/lib/CodeGen/ItaniumCXXABI.cpp

4566

There are uses of CreateIsNull with snake_case; this is the only camelCase instance.

clang/test/CodeGen/static-init.cpp

5

Minor nit: Don't use a semicolon after a namespace definition. Apply throughout.

[hubert.reinterpretcast]

clang/test/CodeGen/static-init.cpp

15

I think the llvm.global_ctors usage is also more extensive here (and not symmetric on the finalization side):

struct C {
  C(int) {}
  ~C() {}
};

C c0 = 42;
template <typename T> C c = 42;
inline C c1 = 42;

int main(void) {
  (void) &c<int>;
}

[Xiangling_L]

Renamed some functions;
Add one more test;
etc.

clang/lib/CodeGen/ItaniumCXXABI.cpp

4573

Thank you for pointing this out. I will adjust the function name to EmitCXXGuardedInitOrDestructBranch later to match our usage.

In terms of branch_weights, this is something I am not familiar with. So please correct me if I am wrong. Some of my superficial thoughts would be are we able to apply branch_weights on a branch associated with finalization-on-unload? Should it be set as nullptr, because we would not know how many times we will call __sterm(and each sterm finalizer contained)?

BTW, I will add a testcase for a static local and we can update the branch_weights part later along with the reviews.

clang/test/CodeGen/static-init.cpp

0

Yeah, I agree that the semantic of global_dtors should contain both __sterm and __attribute__((__destructor__)) dtors. And we do need some rationale to separate __sterm and those other destructor functions out for AIX.

However, I doubt the -fregister_global_dtors_with_atexit option is something we should use. Cuz dtors with __attribute__((__destructor__)) actually are equivalent to __dtor functions in AIX's semantic which need to be registered with __atexit. However, we shouldn't register __sterm with __atexit. So it seems this option does not work well for AIX either we set it to true or false, and we need to figure something else out when we start supporting __attribute__((__destructor__)) and __attribute__((__constructor__))?

15

Yes, we should definitely test template variable(and other WeakODR linkage symbols) and inline variable. However, this patch hasn't covered these aspects yet. My plan was to set the basic frame using this patch, and have some small follow-up patches to clean up the implementation. Do you think we should cover these in this patch as well? I kinda feel it's already a bit big one..

[hubert.reinterpretcast]

clang/lib/CodeGen/ItaniumCXXABI.cpp

4573

I don't think we want to generate branch_weights. We already expect __sterm to be called rarely. Just changing the function name is not going to help though. A caller would need to indicate which of "init" or "destruct" is intended.

clang/test/CodeGen/static-init.cpp

0

Yes, we should look further into this when __attribute__((__destructor__)) is supported.

The difference between atexit-registered functions and __sterm functions is in whether or not they are run when unloading a module (which termination also does).

Thanks for your observation re: the similarity between __attribute__((__destructor__)) functions and the __dtor functions. Thinking about it a bit, the level of similarity is rather tied to the option in question. If we choose to register using atexit, we need to consider introducing the corresponding unatexit. This means that even when the option in question is active, we will produce entries into the global_dtors array at the IR level.

15

The patch is already limited in scope in such a way that covering the WeakODR linkage cases would not fit well. I'm fine with handling them later. There may be work specific for these with respect to the symmetry between the initialization and the finalization.

[jasonliu]

clang/lib/CodeGen/CGDeclCXX.cpp

707

Correct me if I'm wrong...
GlobalUniqueModuleId will always get “initialized" in EmitCXXGlobalInitFunc. And EmitCXXGlobalInitFunc will always run before EmitCXXGlobalCleanUpFunc in CodeGenModule::Release(). So in theory, we do not need to initialize it again in here.
If we could not assert (!GlobalUniqueModuleId.empty()) here, that tells me in EmitCXXGlobalInitFunc we effectively get an empty string after GlobalUniqueModuleId = GlobalUniqueModuleId.substr(1);. So something is not right?

clang/lib/CodeGen/CodeGenModule.h

471–473

Word after ; should not be Capitalize. We should use small case, or change this to ..
I would prefer changing it to ..

clang/test/CodeGen/static-init.cpp

126

Is checking this Attrs necessary?

141

I think we used to have dso_local marked on sinit and sterm function in previous diff. Now they are gone. What's the reason for removing them?

[jasonliu]

clang/lib/CodeGen/CGDeclCXX.cpp

834

nit: trailing whitespace

clang/test/CodeGen/static-init.cpp

15

nit: trailing whitespace in this line.
struct Test4 {

[Xiangling_L]

Remove trailing spaces;
Update the testcase;
Adjust the EmitGuardedInitBranch function;

[Xiangling_L]

clang/lib/CodeGen/CGDeclCXX.cpp

707

Actually GlobalUniqueModuleId will not always get “initialized" in EmitCXXGlobalInitFunc. In some cases, only __sterm will be generated for the var decl.
e.g.
The static local variable won't be inited before main() but when called at the first time.

struct Test4 {
  Test4();
    ~Test4();
  };

  void f() {
    static Test4 staticLocal;
  }

clang/test/CodeGen/static-init.cpp

126

I missed to delete this line. Thanks for pointing it out.

141

dso_local affects calls to the function in terms of how the compiler will do the optimization on the call. Since we won't be generating any calls to the function (the linker arranges for the calls to happen indirectly), marking them dso_local does not help any. So I think it doesn't really matter if we put dso_local here.

[Xiangling_L]

Adjust the patch corresponding to D81972;

[Xiangling_L]

Fix the previous bad version;

[jasonliu]

clang/lib/CodeGen/CGDeclCXX.cpp

345

Do we need to change/complicate the interface for this function, just to do a call to Builder.CreateCondBr()?
Could we call that function directly from where it's needed?

642–643

This comment does not apply well on top of this early return for some platform. I think you could move it to current line 665?

[Xiangling_L]

Removed a redundant header file;
Addressed comments;

clang/lib/CodeGen/CGDeclCXX.cpp

345

Sure, we can. Thank you for your suggestion. I was hoping to use one function to synthesize the guarded init or destruct branch. But I think it seems better if we wait for further more usage of guarded destruct branch to do so and not complicate stuff in this patch.

[jasonliu]

LGTM. But I suggest to wait for @hubert.reinterpretcast to have another scan at this before landing.

[hubert.reinterpretcast]

Thanks; LGTM with minor nit.

clang/lib/CodeGen/CodeGenModule.h

1060

Minor nit: "a sterm" should be "an sterm" if "sterm" is pronounced like "es-term".

clang/test/CodeGenCXX/aix-static-init.cpp

189

Just a comment: The finalization order of static locals in relation to non-locals cannot (using the mechanisms available) be guaranteed to be consistent with the reverse order of initialization. I don't think that there is a clearly "correct" order, so "whatever falls out" is probably okay.

[plotfi]

@rjmccall

FYI this diff appears to be breaking a ptrauth test on apple/swift/master-next (clang/test/CodeGenCXX/ptrauth-static-destructors.cpp).

Investigating this further.

[plotfi]

In D74166#2107831, @plotfi wrote:

@rjmccall

FYI this diff appears to be breaking a ptrauth test on apple/swift/master-next (clang/test/CodeGenCXX/ptrauth-static-destructors.cpp).

Investigating this further.

Looks like this was addressed in:

https://github.com/apple/llvm-project/commit/8e8176c0bee7215b397d78cfff6e617cfc50e248

and
https://github.com/apple/llvm-project/commit/4292b7edfcf0672da076a0b4e3d4fde8b2672359#diff-75a7118d42116297f6a0b1a0fd020604

clang/include/clang/AST/Mangle.h

public:
 
   virtual void mangleCXXCtorComdat(const CXXConstructorDecl *D,
                                    raw_ostream &) = 0;
   virtual void mangleCXXDtorComdat(const CXXDestructorDecl *D,
                                    raw_ostream &) = 0;
 
   virtual void mangleLambdaSig(const CXXRecordDecl *Lambda, raw_ostream &) = 0;
 
+  virtual void mangleDynamicStermFinalizer(const VarDecl *D, raw_ostream &) = 0;
+
   bool isUniqueNameMangler() { return IsUniqueNameMangler; }
 
   static bool classof(const MangleContext *C) {
     return C->getKind() == MK_Itanium;
   }
 
   static ItaniumMangleContext *create(ASTContext &Context,
                                       DiagnosticsEngine &Diags,

clang/lib/AST/ItaniumMangle.cpp

public:
   void mangleTypeName(QualType T, raw_ostream &) override;
 
   void mangleCXXCtorComdat(const CXXConstructorDecl *D, raw_ostream &) override;
   void mangleCXXDtorComdat(const CXXDestructorDecl *D, raw_ostream &) override;
   void mangleStaticGuardVariable(const VarDecl *D, raw_ostream &) override;
   void mangleDynamicInitializer(const VarDecl *D, raw_ostream &Out) override;
   void mangleDynamicAtExitDestructor(const VarDecl *D,
                                      raw_ostream &Out) override;
+  void mangleDynamicStermFinalizer(const VarDecl *D, raw_ostream &Out) override;
   void mangleSEHFilterExpression(const NamedDecl *EnclosingDecl,
                                  raw_ostream &Out) override;
   void mangleSEHFinallyBlock(const NamedDecl *EnclosingDecl,
                              raw_ostream &Out) override;
   void mangleItaniumThreadLocalInit(const VarDecl *D, raw_ostream &) override;
   void mangleItaniumThreadLocalWrapper(const VarDecl *D,
                                        raw_ostream &) override;
 
void ItaniumMangleContextImpl::mangleDynamicAtExitDestructor(const VarDecl *D,
   CXXNameMangler Mangler(*this, Out);
   Mangler.getStream() << "__dtor_";
   if (shouldMangleDeclName(D))
     Mangler.mangle(D);
   else
     Mangler.getStream() << D->getName();
 }
 
+void ItaniumMangleContextImpl::mangleDynamicStermFinalizer(const VarDecl *D,
+                                                           raw_ostream &Out) {
+  // Clang generates these internal-linkage functions as part of its
+  // implementation of the XL ABI.
+  CXXNameMangler Mangler(*this, Out);
+  Mangler.getStream() << "__finalize_";
+  if (shouldMangleDeclName(D))
+    Mangler.mangle(D);
+  else
+    Mangler.getStream() << D->getName();
+}
+
 void ItaniumMangleContextImpl::mangleSEHFilterExpression(
     const NamedDecl *EnclosingDecl, raw_ostream &Out) {
   CXXNameMangler Mangler(*this, Out);
   Mangler.getStream() << "__filt_";
   if (shouldMangleDeclName(EnclosingDecl))
     Mangler.mangle(EnclosingDecl);
   else
     Mangler.getStream() << EnclosingDecl->getName();

clang/lib/CodeGen/CGCXXABI.h

public:
   /// non-virtually for destructors).
   ///
   /// There currently is no way to indicate if a destructor returns 'this'
   /// when called virtually, and code generation does not support the case.
   virtual bool HasThisReturn(GlobalDecl GD) const { return false; }
 
   virtual bool hasMostDerivedReturn(GlobalDecl GD) const { return false; }
 
+  virtual bool useSinitAndSterm() const { return false; }
+
   /// Returns true if the target allows calling a function through a pointer
   /// with a different signature than the actual function (or equivalently,
   /// bitcasting a function or function pointer to a different function type).
   /// In principle in the most general case this could depend on the target, the
   /// calling convention, and the actual types of the arguments and return
   /// value. Here it just means whether the signature mismatch could *ever* be
   /// allowed; in other words, does the target do strict checking of signatures
   /// for all calls.
   virtual bool canCallMismatchedFunctionType() const { return true; }

clang/lib/CodeGen/CGDeclCXX.cpp

 #include "CodeGenFunction.h"
 #include "TargetInfo.h"
 #include "clang/AST/Attr.h"
 #include "clang/Basic/LangOptions.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Transforms/Utils/ModuleUtils.h"
 
 using namespace clang;
 using namespace CodeGen;
 
 static void EmitDeclInit(CodeGenFunction &CGF, const VarDecl &D,
                          ConstantAddress DeclPtr) {
   assert(
       (D.hasGlobalStorage() ||
llvm::Function *CodeGenFunction::createAtExitStub(const VarDecl &VD,
   llvm::FunctionType *ty = llvm::FunctionType::get(CGM.VoidTy, false);
   SmallString<256> FnName;
   {
     llvm::raw_svector_ostream Out(FnName);
     CGM.getCXXABI().getMangleContext().mangleDynamicAtExitDestructor(&VD, Out);
   }
 
   const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
-  llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction(
+  llvm::Function *fn = CGM.CreateGlobalInitOrCleanUpFunction(
       ty, FnName.str(), FI, VD.getLocation());
 
   CodeGenFunction CGF(CGM);
 
   CGF.StartFunction(GlobalDecl(&VD, DynamicInitKind::AtExit),
                     CGM.getContext().VoidTy, fn, FI, FunctionArgList());
 
   llvm::CallInst *call = CGF.Builder.CreateCall(dtor, addr);
 
   // Make sure the call and the callee agree on calling convention.
   if (auto *dtorFn = dyn_cast<llvm::Function>(
           dtor.getCallee()->stripPointerCastsAndAliases()))
     call->setCallingConv(dtorFn->getCallingConv());
 
   CGF.FinishFunction();
 
   return fn;
 }
 
 /// Register a global destructor using the C atexit runtime function.
 void CodeGenFunction::registerGlobalDtorWithAtExit(const VarDecl &VD,
                                                    llvm::FunctionCallee dtor,
                                                    llvm::Constant *addr) {
   // Create a function which calls the destructor.
   llvm::Constant *dtorStub = createAtExitStub(VD, dtor, addr);
   registerGlobalDtorWithAtExit(dtorStub);
 }
 
 void CodeGenFunction::registerGlobalDtorWithAtExit(llvm::Constant *dtorStub) {
   // extern "C" int atexit(void (*f)(void));
+  assert(cast<llvm::Function>(dtorStub)->getFunctionType() ==
+             llvm::FunctionType::get(CGM.VoidTy, false) &&
+         "Argument to atexit has a wrong type.");
+
   llvm::FunctionType *atexitTy =
       llvm::FunctionType::get(IntTy, dtorStub->getType(), false);
 
   llvm::FunctionCallee atexit =
       CGM.CreateRuntimeFunction(atexitTy, "atexit", llvm::AttributeList(),
                                 /*Local=*/true);
   if (llvm::Function *atexitFn = dyn_cast<llvm::Function>(atexit.getCallee()))
     atexitFn->setDoesNotThrow();
 
   EmitNounwindRuntimeCall(atexit, dtorStub);
 }
 
+llvm::Value *
+CodeGenFunction::unregisterGlobalDtorWithUnAtExit(llvm::Function *dtorStub) {
+  // The unatexit subroutine unregisters __dtor functions that were previously
+  // registered by the atexit subroutine. If the referenced function is found,
+  // it is removed from the list of functions that are called at normal program
+  // termination and the unatexit returns a value of 0, otherwise a non-zero
+  // value is returned.
+  //
+  // extern "C" int unatexit(void (*f)(void));
+  assert(dtorStub->getFunctionType() ==
+             llvm::FunctionType::get(CGM.VoidTy, false) &&
+         "Argument to unatexit has a wrong type.");
+
+  llvm::FunctionType *unatexitTy =
+      llvm::FunctionType::get(IntTy, {dtorStub->getType()}, /*isVarArg=*/false);
+
+  llvm::FunctionCallee unatexit =
+      CGM.CreateRuntimeFunction(unatexitTy, "unatexit", llvm::AttributeList());
+
+  cast<llvm::Function>(unatexit.getCallee())->setDoesNotThrow();
+
+  return EmitNounwindRuntimeCall(unatexit, dtorStub);
+}
+
 void CodeGenFunction::EmitCXXGuardedInit(const VarDecl &D,
                                          llvm::GlobalVariable *DeclPtr,
                                          bool PerformInit) {
   // If we've been asked to forbid guard variables, emit an error now.
   // This diagnostic is hard-coded for Darwin's use case;  we can find
   // better phrasing if someone else needs it.
   if (CGM.getCodeGenOpts().ForbidGuardVariables)
     CGM.Error(D.getLocation(),
void CodeGenFunction::EmitCXXGuardedInitBranch(llvm::Value *NeedsInit,
   static const uint64_t InitsPerTLSVar = 1024;
   static const uint64_t InitsPerLocalVar = 1024 * 1024;
 
   llvm::MDNode *Weights;
   if (Kind == GuardKind::VariableGuard && !D->isLocalVarDecl()) {
     // For non-local variables, don't apply any weighting for now. Due to our
     // use of COMDATs, we expect there to be at most one initialization of the
     // variable per DSO, but we have no way to know how many DSOs will try to
     // initialize the variable.
     Weights = nullptr;
   } else {
     uint64_t NumInits;
     // FIXME: For the TLS case, collect and use profiling information to
     // determine a more accurate brach weight.
     if (Kind == GuardKind::TlsGuard || D->getTLSKind())
       NumInits = InitsPerTLSVar;
     else
       NumInits = InitsPerLocalVar;
 
     // The probability of us entering the initializer is
     //   1 / (total number of times we attempt to initialize the variable).
     llvm::MDBuilder MDHelper(CGM.getLLVMContext());
     Weights = MDHelper.createBranchWeights(1, NumInits - 1);
   }
 
   Builder.CreateCondBr(NeedsInit, InitBlock, NoInitBlock, Weights);
 }
 
-llvm::Function *CodeGenModule::CreateGlobalInitOrDestructFunction(
+llvm::Function *CodeGenModule::CreateGlobalInitOrCleanUpFunction(
     llvm::FunctionType *FTy, const Twine &Name, const CGFunctionInfo &FI,
-    SourceLocation Loc, bool TLS) {
-  llvm::Function *Fn =
-    llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage,
-                           Name, &getModule());
+    SourceLocation Loc, bool TLS, bool IsExternalLinkage) {
+  llvm::Function *Fn = llvm::Function::Create(
+      FTy,
+      IsExternalLinkage ? llvm::GlobalValue::ExternalLinkage
+                        : llvm::GlobalValue::InternalLinkage,
+
   if (!getLangOpts().AppleKext && !TLS) {
     // Set the section if needed.
     if (const char *Section = getTarget().getStaticInitSectionSpecifier())
       Fn->setSection(Section);
   }
 
+  if (Fn->hasInternalLinkage())
     SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);
 
   Fn->setCallingConv(getRuntimeCC());
 
   if (!getLangOpts().Exceptions)
     Fn->setDoesNotThrow();
 
   if (getLangOpts().Sanitize.has(SanitizerKind::Address) &&
       !isInSanitizerBlacklist(SanitizerKind::Address, Fn, Loc))
CodeGenModule::EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,
   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
   SmallString<256> FnName;
   {
     llvm::raw_svector_ostream Out(FnName);
     getCXXABI().getMangleContext().mangleDynamicInitializer(D, Out);
   }
 
   // Create a variable initialization function.
-  llvm::Function *Fn =
-      CreateGlobalInitOrDestructFunction(FTy, FnName.str(),
-                                         getTypes().arrangeNullaryFunction(),
-                                         D->getLocation());
+  llvm::Function *Fn = CreateGlobalInitOrCleanUpFunction(
+      FTy, FnName.str(), getTypes().arrangeNullaryFunction(), D->getLocation());
 
   auto *ISA = D->getAttr<InitSegAttr>();
   CodeGenFunction(*this).GenerateCXXGlobalVarDeclInitFunc(Fn, D, Addr,
                                                           PerformInit);
 
   llvm::GlobalVariable *COMDATKey =
       supportsCOMDAT() && D->isExternallyVisible() ? Addr : nullptr;
 
void CodeGenModule::EmitCXXThreadLocalInitFunc() {
   getCXXABI().EmitThreadLocalInitFuncs(
       *this, CXXThreadLocals, CXXThreadLocalInits, CXXThreadLocalInitVars);
 
   CXXThreadLocalInits.clear();
   CXXThreadLocalInitVars.clear();
   CXXThreadLocals.clear();
 }
 
 static SmallString<128> getTransformedFileName(llvm::Module &M) {
   SmallString<128> FileName = llvm::sys::path::filename(M.getName());
 
   if (FileName.empty())
     FileName = "<null>";
 
   for (size_t i = 0; i < FileName.size(); ++i) {
     // Replace everything that's not [a-zA-Z0-9._] with a _. This set happens
     // to be the set of C preprocessing numbers.
     if (!isPreprocessingNumberBody(FileName[i]))
       FileName[i] = '_';
   }
 
   return FileName;
 }
 
 void
 CodeGenModule::EmitCXXGlobalInitFunc() {
   while (!CXXGlobalInits.empty() && !CXXGlobalInits.back())
     CXXGlobalInits.pop_back();
 
   if (CXXGlobalInits.empty() && PrioritizedCXXGlobalInits.empty())
     return;
 
+  const bool UseSinitAndSterm = getCXXABI().useSinitAndSterm();
+  if (UseSinitAndSterm) {
+    GlobalUniqueModuleId = getUniqueModuleId(&getModule());
+
+    // FIXME: We need to figure out what to hash on or encode into the unique ID
+    // we need.
+    if (GlobalUniqueModuleId.compare("") == 0)
+      llvm::report_fatal_error(
+          "cannot produce a unique identifier for this module"
+          " based on strong external symbols");
+    GlobalUniqueModuleId = GlobalUniqueModuleId.substr(1);
+  }
+
   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
   const CGFunctionInfo &FI = getTypes().arrangeNullaryFunction();
 
-  // Create our global initialization function.
+  // Create our global prioritized initialization function.
   if (!PrioritizedCXXGlobalInits.empty()) {
+    assert(!UseSinitAndSterm && "Prioritized sinit and sterm functions are not"
+                                " supported yet.");
+
     SmallVector<llvm::Function *, 8> LocalCXXGlobalInits;
     llvm::array_pod_sort(PrioritizedCXXGlobalInits.begin(),
                          PrioritizedCXXGlobalInits.end());
     // Iterate over "chunks" of ctors with same priority and emit each chunk
     // into separate function. Note - everything is sorted first by priority,
     // second - by lex order, so we emit ctor functions in proper order.
     for (SmallVectorImpl<GlobalInitData >::iterator
            I = PrioritizedCXXGlobalInits.begin(),
            E = PrioritizedCXXGlobalInits.end(); I != E; ) {
       SmallVectorImpl<GlobalInitData >::iterator
         PrioE = std::upper_bound(I + 1, E, *I, GlobalInitPriorityCmp());
 
       LocalCXXGlobalInits.clear();
       unsigned Priority = I->first.priority;
       // Compute the function suffix from priority. Prepend with zeroes to make
       // sure the function names are also ordered as priorities.
       std::string PrioritySuffix = llvm::utostr(Priority);
       // Priority is always <= 65535 (enforced by sema).
       PrioritySuffix = std::string(6-PrioritySuffix.size(), '0')+PrioritySuffix;
-      llvm::Function *Fn = CreateGlobalInitOrDestructFunction(
+      llvm::Function *Fn = CreateGlobalInitOrCleanUpFunction(
           FTy, "_GLOBAL__I_" + PrioritySuffix, FI);
 
       for (; I < PrioE; ++I)
         LocalCXXGlobalInits.push_back(I->second);
 
       CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, LocalCXXGlobalInits);
       AddGlobalCtor(Fn, Priority);
     }
     PrioritizedCXXGlobalInits.clear();
   }
 
+  if (UseSinitAndSterm && CXXGlobalInits.empty())
+    return;
+
+  // Create our global initialization function.
+  SmallString<128> FuncName;
+  bool IsExternalLinkage = false;
+  if (UseSinitAndSterm) {
+    llvm::Twine("__sinit80000000_clang_", GlobalUniqueModuleId)
+        .toVector(FuncName);
+    IsExternalLinkage = true;
+  } else {
     // Include the filename in the symbol name. Including "sub_" matches gcc
     // and makes sure these symbols appear lexicographically behind the symbols
     // with priority emitted above.
-  llvm::Function *Fn = CreateGlobalInitOrDestructFunction(
-      FTy,
-      llvm::Twine("_GLOBAL__sub_I_", getTransformedFileName(getModule())), FI);
+    llvm::Twine("_GLOBAL__sub_I_", getTransformedFileName(getModule()))
+        .toVector(FuncName);
+  }
+
+  llvm::Function *Fn = CreateGlobalInitOrCleanUpFunction(
+      FTy, FuncName, FI, SourceLocation(), false /* TLS */,
+      IsExternalLinkage);
 
   CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, CXXGlobalInits);
   AddGlobalCtor(Fn);
 
   // In OpenCL global init functions must be converted to kernels in order to
   // be able to launch them from the host.
   // FIXME: Some more work might be needed to handle destructors correctly.
   // Current initialization function makes use of function pointers callbacks.
CodeGenModule::EmitCXXGlobalInitFunc() {
   if (getLangOpts().HIP) {
     Fn->setCallingConv(llvm::CallingConv::AMDGPU_KERNEL);
     Fn->addFnAttr("device-init");
   }
 
   CXXGlobalInits.clear();
 }
 
-void CodeGenModule::EmitCXXGlobalDtorFunc() {
-  if (CXXGlobalDtors.empty())
+void CodeGenModule::EmitCXXGlobalCleanUpFunc() {
+  if (CXXGlobalDtorsOrStermFinalizers.empty())
     return;
 
   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
-
-  // Create our global destructor function.
   const CGFunctionInfo &FI = getTypes().arrangeNullaryFunction();
-  llvm::Function *Fn =
-      CreateGlobalInitOrDestructFunction(FTy, "_GLOBAL__D_a", FI);
 
-  CodeGenFunction(*this).GenerateCXXGlobalDtorsFunc(Fn, CXXGlobalDtors);
+  // Create our global cleanup function.
+  llvm::Function *Fn = nullptr;
+  if (getCXXABI().useSinitAndSterm()) {
+    if (GlobalUniqueModuleId.empty()) {
+      GlobalUniqueModuleId = getUniqueModuleId(&getModule());
+      // FIXME: We need to figure out what to hash on or encode into the unique
+      // ID we need.
+      if (GlobalUniqueModuleId.compare("") == 0)
+        llvm::report_fatal_error(
+            "cannot produce a unique identifier for this module"
+            " based on strong external symbols");
+      GlobalUniqueModuleId = GlobalUniqueModuleId.substr(1);
+    }
+
+    Fn = CreateGlobalInitOrCleanUpFunction(
+        FTy, llvm::Twine("__sterm80000000_clang_", GlobalUniqueModuleId), FI,
+        SourceLocation(), false /* TLS */, true /* IsExternalLinkage */);
+  } else {
+    Fn = CreateGlobalInitOrCleanUpFunction(FTy, "_GLOBAL__D_a", FI);
+  }
+
+  CodeGenFunction(*this).GenerateCXXGlobalCleanUpFunc(
+      Fn, CXXGlobalDtorsOrStermFinalizers);
   AddGlobalDtor(Fn);
-  CXXGlobalDtors.clear();
+  CXXGlobalDtorsOrStermFinalizers.clear();
 }
 
 /// Emit the code necessary to initialize the given global variable.
 void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
                                                        const VarDecl *D,
                                                  llvm::GlobalVariable *Addr,
                                                        bool PerformInit) {
   // Check if we need to emit debug info for variable initializer.
if (ExitBlock) {
       Builder.CreateBr(ExitBlock);
       EmitBlock(ExitBlock);
     }
   }
 
   FinishFunction();
 }
 
-void CodeGenFunction::GenerateCXXGlobalDtorsFunc(
+void CodeGenFunction::GenerateCXXGlobalCleanUpFunc(
     llvm::Function *Fn,
     const std::vector<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,
-                                 llvm::Constant *>> &DtorsAndObjects) {
+                                 llvm::Constant *>> &DtorsOrStermFinalizers) {
   {
     auto NL = ApplyDebugLocation::CreateEmpty(*this);
     StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
                   getTypes().arrangeNullaryFunction(), FunctionArgList());
     // Emit an artificial location for this function.
     auto AL = ApplyDebugLocation::CreateArtificial(*this);
 
-    // Emit the dtors, in reverse order from construction.
-    for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) {
+    // Emit the cleanups, in reverse order from construction.
+    for (unsigned i = 0, e = DtorsOrStermFinalizers.size(); i != e; ++i) {
       llvm::FunctionType *CalleeTy;
       llvm::Value *Callee;
       llvm::Constant *Arg;
-      std::tie(CalleeTy, Callee, Arg) = DtorsAndObjects[e - i - 1];
-      llvm::CallInst *CI = Builder.CreateCall(CalleeTy, Callee, Arg);
+      std::tie(CalleeTy, Callee, Arg) = DtorsOrStermFinalizers[e - i - 1];
+
+      llvm::CallInst *CI = nullptr;
+      if (Arg == nullptr) {
+        assert(
+            CGM.getCXXABI().useSinitAndSterm() &&
+            "Arg could not be nullptr unless using sinit and sterm functions.");
+        CI = Builder.CreateCall(CalleeTy, Callee);
+      } else
+        CI = Builder.CreateCall(CalleeTy, Callee, Arg);
+
       // Make sure the call and the callee agree on calling convention.
       if (llvm::Function *F = dyn_cast<llvm::Function>(Callee))
         CI->setCallingConv(F->getCallingConv());
     }
   }
 
   FinishFunction();
 }
 
 /// generateDestroyHelper - Generates a helper function which, when
 /// invoked, destroys the given object.  The address of the object
 /// should be in global memory.
 llvm::Function *CodeGenFunction::generateDestroyHelper(
     Address addr, QualType type, Destroyer *destroyer,
     bool useEHCleanupForArray, const VarDecl *VD) {
   FunctionArgList args;
   ImplicitParamDecl Dst(getContext(), getContext().VoidPtrTy,
                         ImplicitParamDecl::Other);
   args.push_back(&Dst);
 
   const CGFunctionInfo &FI =
     CGM.getTypes().arrangeBuiltinFunctionDeclaration(getContext().VoidTy, args);
   llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
-  llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction(
+  llvm::Function *fn = CGM.CreateGlobalInitOrCleanUpFunction(
       FTy, "__cxx_global_array_dtor", FI, VD->getLocation());
 
   CurEHLocation = VD->getBeginLoc();
 
   StartFunction(VD, getContext().VoidTy, fn, FI, args);
 
   emitDestroy(addr, type, destroyer, useEHCleanupForArray);
 
   FinishFunction();
 
   return fn;
 }

clang/lib/CodeGen/CGOpenMPRuntime.cpp

if (CGM.getLangOpts().CPlusPlus && PerformInit) {
                             ImplicitParamDecl::Other);
       Args.push_back(&Dst);
 
       const auto &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(
           CGM.getContext().VoidPtrTy, Args);
       llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
       std::string Name = getName({"__kmpc_global_ctor_", ""});
       llvm::Function *Fn =
-          CGM.CreateGlobalInitOrDestructFunction(FTy, Name, FI, Loc);
+          CGM.CreateGlobalInitOrCleanUpFunction(FTy, Name, FI, Loc);
       CtorCGF.StartFunction(GlobalDecl(), CGM.getContext().VoidPtrTy, Fn, FI,
                             Args, Loc, Loc);
       llvm::Value *ArgVal = CtorCGF.EmitLoadOfScalar(
           CtorCGF.GetAddrOfLocalVar(&Dst), /*Volatile=*/false,
           CGM.getContext().VoidPtrTy, Dst.getLocation());
       Address Arg = Address(ArgVal, VDAddr.getAlignment());
       Arg = CtorCGF.Builder.CreateElementBitCast(
           Arg, CtorCGF.ConvertTypeForMem(ASTTy));
if (VD->getType().isDestructedType() != QualType::DK_none) {
                             ImplicitParamDecl::Other);
       Args.push_back(&Dst);
 
       const auto &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(
           CGM.getContext().VoidTy, Args);
       llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
       std::string Name = getName({"__kmpc_global_dtor_", ""});
       llvm::Function *Fn =
-          CGM.CreateGlobalInitOrDestructFunction(FTy, Name, FI, Loc);
+          CGM.CreateGlobalInitOrCleanUpFunction(FTy, Name, FI, Loc);
       auto NL = ApplyDebugLocation::CreateEmpty(DtorCGF);
       DtorCGF.StartFunction(GlobalDecl(), CGM.getContext().VoidTy, Fn, FI, Args,
                             Loc, Loc);
       // Create a scope with an artificial location for the body of this function.
       auto AL = ApplyDebugLocation::CreateArtificial(DtorCGF);
       llvm::Value *ArgVal = DtorCGF.EmitLoadOfScalar(
           DtorCGF.GetAddrOfLocalVar(&Dst),
           /*Volatile=*/false, CGM.getContext().VoidPtrTy, Dst.getLocation());
if (Dtor == nullptr) {
                                              /*isVarArg=*/false)
                          ->getPointerTo();
       Dtor = llvm::Constant::getNullValue(DtorTy);
     }
     if (!CGF) {
       auto *InitFunctionTy =
           llvm::FunctionType::get(CGM.VoidTy, /*isVarArg*/ false);
       std::string Name = getName({"__omp_threadprivate_init_", ""});
-      llvm::Function *InitFunction = CGM.CreateGlobalInitOrDestructFunction(
+      llvm::Function *InitFunction = CGM.CreateGlobalInitOrCleanUpFunction(
           InitFunctionTy, Name, CGM.getTypes().arrangeNullaryFunction());
       CodeGenFunction InitCGF(CGM);
       FunctionArgList ArgList;
       InitCGF.StartFunction(GlobalDecl(), CGM.getContext().VoidTy, InitFunction,
                             CGM.getTypes().arrangeNullaryFunction(), ArgList,
                             Loc, Loc);
       emitThreadPrivateVarInit(InitCGF, VDAddr, Ctor, CopyCtor, Dtor, Loc);
       InitCGF.FinishFunction();
if (CGM.getLangOpts().CPlusPlus && PerformInit) {
     llvm::Constant *ID;
     if (CGM.getLangOpts().OpenMPIsDevice) {
       // Generate function that re-emits the declaration's initializer into
       // the threadprivate copy of the variable VD
       CodeGenFunction CtorCGF(CGM);
 
       const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
       llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
-      llvm::Function *Fn = CGM.CreateGlobalInitOrDestructFunction(
+      llvm::Function *Fn = CGM.CreateGlobalInitOrCleanUpFunction(
           FTy, Twine(Buffer, "_ctor"), FI, Loc);
       auto NL = ApplyDebugLocation::CreateEmpty(CtorCGF);
       CtorCGF.StartFunction(GlobalDecl(), CGM.getContext().VoidTy, Fn, FI,
                             FunctionArgList(), Loc, Loc);
       auto AL = ApplyDebugLocation::CreateArtificial(CtorCGF);
       CtorCGF.EmitAnyExprToMem(Init,
                                Address(Addr, CGM.getContext().getDeclAlign(VD)),
                                Init->getType().getQualifiers(),
if (VD->getType().isDestructedType() != QualType::DK_none) {
     llvm::Constant *ID;
     if (CGM.getLangOpts().OpenMPIsDevice) {
       // Generate function that emits destructor call for the threadprivate
       // copy of the variable VD
       CodeGenFunction DtorCGF(CGM);
 
       const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
       llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
-      llvm::Function *Fn = CGM.CreateGlobalInitOrDestructFunction(
+      llvm::Function *Fn = CGM.CreateGlobalInitOrCleanUpFunction(
           FTy, Twine(Buffer, "_dtor"), FI, Loc);
       auto NL = ApplyDebugLocation::CreateEmpty(DtorCGF);
       DtorCGF.StartFunction(GlobalDecl(), CGM.getContext().VoidTy, Fn, FI,
                             FunctionArgList(), Loc, Loc);
       // Create a scope with an artificial location for the body of this
       // function.
       auto AL = ApplyDebugLocation::CreateArtificial(DtorCGF);
       DtorCGF.emitDestroy(Address(Addr, CGM.getContext().getDeclAlign(VD)),
llvm::Function *CGOpenMPRuntime::emitRequiresDirectiveRegFun() {
   ASTContext &C = CGM.getContext();
 
   llvm::Function *RequiresRegFn;
   {
     CodeGenFunction CGF(CGM);
     const auto &FI = CGM.getTypes().arrangeNullaryFunction();
     llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
     std::string ReqName = getName({"omp_offloading", "requires_reg"});
-    RequiresRegFn = CGM.CreateGlobalInitOrDestructFunction(FTy, ReqName, FI);
+    RequiresRegFn = CGM.CreateGlobalInitOrCleanUpFunction(FTy, ReqName, FI);
     CGF.StartFunction(GlobalDecl(), C.VoidTy, RequiresRegFn, FI, {});
     OpenMPOffloadingRequiresDirFlags Flags = OMP_REQ_NONE;
     // TODO: check for other requires clauses.
     // The requires directive takes effect only when a target region is
     // present in the compilation unit. Otherwise it is ignored and not
     // passed to the runtime. This avoids the runtime from throwing an error
     // for mismatching requires clauses across compilation units that don't
     // contain at least 1 target region.

clang/lib/CodeGen/CodeGenFunction.h

public:
   /// Call atexit() with a function that passes the given argument to
   /// the given function.
   void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::FunctionCallee fn,
                                     llvm::Constant *addr);
 
   /// Call atexit() with function dtorStub.
   void registerGlobalDtorWithAtExit(llvm::Constant *dtorStub);
 
+  /// Call unatexit() with function dtorStub.
+  llvm::Value *unregisterGlobalDtorWithUnAtExit(llvm::Function *dtorStub);
+
   /// Emit code in this function to perform a guarded variable
   /// initialization.  Guarded initializations are used when it's not
   /// possible to prove that an initialization will be done exactly
   /// once, e.g. with a static local variable or a static data member
   /// of a class template.
   void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr,
                           bool PerformInit);
 
   enum class GuardKind { VariableGuard, TlsGuard };
 
   /// Emit a branch to select whether or not to perform guarded initialization.
   void EmitCXXGuardedInitBranch(llvm::Value *NeedsInit,
                                 llvm::BasicBlock *InitBlock,
                                 llvm::BasicBlock *NoInitBlock,
                                 GuardKind Kind, const VarDecl *D);
 
   /// GenerateCXXGlobalInitFunc - Generates code for initializing global
   /// variables.
   void
   GenerateCXXGlobalInitFunc(llvm::Function *Fn,
                             ArrayRef<llvm::Function *> CXXThreadLocals,
                             ConstantAddress Guard = ConstantAddress::invalid());
 
-  /// GenerateCXXGlobalDtorsFunc - Generates code for destroying global
+  /// GenerateCXXGlobalCleanUpFunc - Generates code for cleaning up global
   /// variables.
-  void GenerateCXXGlobalDtorsFunc(
+  void GenerateCXXGlobalCleanUpFunc(
       llvm::Function *Fn,
       const std::vector<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,
-                                   llvm::Constant *>> &DtorsAndObjects);
+                                   llvm::Constant *>> &DtorsOrStermFinalizers);
 
   void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
                                         const VarDecl *D,
                                         llvm::GlobalVariable *Addr,
                                         bool PerformInit);
 
   void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest);
 

clang/lib/CodeGen/CodeGenModule.h

 
 #ifndef LLVM_CLANG_LIB_CODEGEN_CODEGENMODULE_H
 #define LLVM_CLANG_LIB_CODEGEN_CODEGENMODULE_H
 
 #include "CGVTables.h"
 #include "CodeGenTypeCache.h"
 #include "CodeGenTypes.h"
 #include "SanitizerMetadata.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclOpenMP.h"
 #include "clang/AST/GlobalDecl.h"
 #include "clang/AST/Mangle.h"
 #include "clang/Basic/ABI.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/SanitizerBlacklist.h"
private:
   /// Store the list of global constructors and their respective priorities to
   /// be emitted when the translation unit is complete.
   CtorList GlobalCtors;
 
   /// Store the list of global destructors and their respective priorities to be
   /// emitted when the translation unit is complete.
   CtorList GlobalDtors;
 
+  /// A unique trailing identifier as a part of sinit/sterm function when
+  /// UseSinitAndSterm of CXXABI is set as true.
+  std::string GlobalUniqueModuleId;
+
   /// An ordered map of canonical GlobalDecls to their mangled names.
   llvm::MapVector<GlobalDecl, StringRef> MangledDeclNames;
   llvm::StringMap<GlobalDecl, llvm::BumpPtrAllocator> Manglings;
 
   // An ordered map of canonical GlobalDecls paired with the cpu-index for
   // cpu-specific name manglings.
   llvm::MapVector<std::pair<GlobalDecl, unsigned>, StringRef>
       CPUSpecificMangledDeclNames;
bool operator()(const GlobalInitData &LHS,
       return LHS.first.priority < RHS.first.priority;
     }
   };
 
   /// Global variables with initializers whose order of initialization is set by
   /// init_priority attribute.
   SmallVector<GlobalInitData, 8> PrioritizedCXXGlobalInits;
 
   /// Global destructor functions and arguments that need to run on termination.
+  /// When UseSinitAndSterm is set, it instead contains sterm finalizer
+  /// functions, which also run on unloading a shared library.
   std::vector<
       std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH, llvm::Constant *>>
-      CXXGlobalDtors;
+      CXXGlobalDtorsOrStermFinalizers;
 
   /// The complete set of modules that has been imported.
   llvm::SetVector<clang::Module *> ImportedModules;
 
   /// The set of modules for which the module initializers
   /// have been emitted.
   llvm::SmallPtrSet<clang::Module *, 16> EmittedModuleInitializers;
 
public:
   /// different type already exists then a new  variable with the right type
   /// will be created and all uses of the old variable will be replaced with a
   /// bitcast to the new variable.
   llvm::GlobalVariable *
   CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty,
                                     llvm::GlobalValue::LinkageTypes Linkage,
                                     unsigned Alignment);
 
-  llvm::Function *
-  CreateGlobalInitOrDestructFunction(llvm::FunctionType *ty, const Twine &name,
-                                     const CGFunctionInfo &FI,
-                                     SourceLocation Loc = SourceLocation(),
-                                     bool TLS = false);
+  llvm::Function *CreateGlobalInitOrCleanUpFunction(
+      llvm::FunctionType *ty, const Twine &name, const CGFunctionInfo &FI,
+      SourceLocation Loc = SourceLocation(), bool TLS = false,
+      bool IsExternalLinkage = false);
 
   /// Return the AST address space of the underlying global variable for D, as
   /// determined by its declaration. Normally this is the same as the address
   /// space of D's type, but in CUDA, address spaces are associated with
   /// declarations, not types. If D is nullptr, return the default address
   /// space for global variable.
   ///
   /// For languages without explicit address spaces, if D has default address
public:
   /// Add a global to a list to be added to the llvm.used metadata.
   void addUsedGlobal(llvm::GlobalValue *GV);
 
   /// Add a global to a list to be added to the llvm.compiler.used metadata.
   void addCompilerUsedGlobal(llvm::GlobalValue *GV);
 
   /// Add a destructor and object to add to the C++ global destructor function.
   void AddCXXDtorEntry(llvm::FunctionCallee DtorFn, llvm::Constant *Object) {
-    CXXGlobalDtors.emplace_back(DtorFn.getFunctionType(), DtorFn.getCallee(),
-                                Object);
+    CXXGlobalDtorsOrStermFinalizers.emplace_back(DtorFn.getFunctionType(),
+                                                 DtorFn.getCallee(), Object);
+  }
+
+  /// Add an sterm finalizer to the C++ global cleanup function.
+  void AddCXXStermFinalizerEntry(llvm::FunctionCallee DtorFn) {
+    CXXGlobalDtorsOrStermFinalizers.emplace_back(DtorFn.getFunctionType(),
+                                                 DtorFn.getCallee(), nullptr);
   }
 
   /// Create or return a runtime function declaration with the specified type
   /// and name. If \p AssumeConvergent is true, the call will have the
   /// convergent attribute added.
   llvm::FunctionCallee
   CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name,
                         llvm::AttributeList ExtraAttrs = llvm::AttributeList(),
                         bool Local = false, bool AssumeConvergent = false);
 
   /// Create or return a runtime function declaration with the specified type
   /// and name. This will automatically add the convergent attribute to the
   /// function declaration.
private:
   void EmitLinkageSpec(const LinkageSpecDecl *D);
 
   /// Emit the function that initializes C++ thread_local variables.
   void EmitCXXThreadLocalInitFunc();
 
   /// Emit the function that initializes C++ globals.
   void EmitCXXGlobalInitFunc();
 
-  /// Emit the function that destroys C++ globals.
-  void EmitCXXGlobalDtorFunc();
+  /// Emit the function that performs cleanup associated with C++ globals.
+  void EmitCXXGlobalCleanUpFunc();
 
   /// Emit the function that initializes the specified global (if PerformInit is
   /// true) and registers its destructor.
   void EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,
                                     llvm::GlobalVariable *Addr,
                                     bool PerformInit);
 
   void EmitPointerToInitFunc(const VarDecl *VD, llvm::GlobalVariable *Addr,

clang/lib/CodeGen/CodeGenModule.cpp

 void CodeGenModule::Release() {
   EmitDeferred();
   EmitVTablesOpportunistically();
   applyGlobalValReplacements();
   applyReplacements();
   checkAliases();
   emitMultiVersionFunctions();
   EmitCXXGlobalInitFunc();
-  EmitCXXGlobalDtorFunc();
+  EmitCXXGlobalCleanUpFunc();
   registerGlobalDtorsWithAtExit();
   EmitCXXThreadLocalInitFunc();
   if (ObjCRuntime)
     if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
       AddGlobalCtor(ObjCInitFunction);
   if (Context.getLangOpts().CUDA && !Context.getLangOpts().CUDAIsDevice &&
       CUDARuntime) {
     if (llvm::Function *CudaCtorFunction =

clang/lib/CodeGen/ItaniumCXXABI.cpp

 class XLCXXABI final : public ItaniumCXXABI {
 public:
   explicit XLCXXABI(CodeGen::CodeGenModule &CGM)
       : ItaniumCXXABI(CGM) {}
 
   void registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
                           llvm::FunctionCallee dtor,
                           llvm::Constant *addr) override;
+
+  bool useSinitAndSterm() const override { return true; }
+
+private:
+  void emitCXXStermFinalizer(const VarDecl &D, llvm::Function *dtorStub,
+                             llvm::Constant *addr);
 };
 }
 
 CodeGen::CGCXXABI *CodeGen::CreateItaniumCXXABI(CodeGenModule &CGM) {
   switch (CGM.getTarget().getCXXABI().getKind()) {
   // For IR-generation purposes, there's no significant difference
   // between the ARM and iOS ABIs.
   case TargetCXXABI::GenericARM:
for (const auto &I : DtorsUsingAtExit) {
     // priorities, destructors are registered in non-descending order of their
     // priorities, and since destructor functions are run in the reverse order
     // of their registration, destructor functions are run in non-ascending
     // order of their priorities.
     CodeGenFunction CGF(*this);
     std::string GlobalInitFnName =
         std::string("__GLOBAL_init_") + llvm::to_string(Priority);
     llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
-    llvm::Function *GlobalInitFn = CreateGlobalInitOrDestructFunction(
+    llvm::Function *GlobalInitFn = CreateGlobalInitOrCleanUpFunction(
         FTy, GlobalInitFnName, getTypes().arrangeNullaryFunction(),
         SourceLocation());
     ASTContext &Ctx = getContext();
     QualType ReturnTy = Ctx.VoidTy;
     QualType FunctionTy = Ctx.getFunctionType(ReturnTy, llvm::None, {});
     FunctionDecl *FD = FunctionDecl::Create(
         Ctx, Ctx.getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
         &Ctx.Idents.get(GlobalInitFnName), FunctionTy, nullptr, SC_Static,
else
       OrderedInits.push_back(CXXThreadLocalInits[I]);
   }
 
   if (!OrderedInits.empty()) {
     // Generate a guarded initialization function.
     llvm::FunctionType *FTy =
         llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
     const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
-    InitFunc = CGM.CreateGlobalInitOrDestructFunction(FTy, "__tls_init", FI,
-                                                      SourceLocation(),
-                                                      /*TLS=*/true);
+    InitFunc = CGM.CreateGlobalInitOrCleanUpFunction(FTy, "__tls_init", FI,
     llvm::GlobalVariable *Guard = new llvm::GlobalVariable(
         CGM.getModule(), CGM.Int8Ty, /*isConstant=*/false,
         llvm::GlobalVariable::InternalLinkage,
         llvm::ConstantInt::get(CGM.Int8Ty, 0), "__tls_guard");
     Guard->setThreadLocal(true);
     Guard->setThreadLocalMode(CGM.GetDefaultLLVMTLSModel());
 
     CharUnits GuardAlign = CharUnits::One();
CGF.EHStack.pushCleanup<CatchRetScope>(
         NormalCleanup, cast<llvm::CatchPadInst>(CGF.CurrentFuncletPad));
   ItaniumCXXABI::emitBeginCatch(CGF, C);
 }
 
 /// Register a global destructor as best as we know how.
 void XLCXXABI::registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
                                   llvm::FunctionCallee dtor,
                                   llvm::Constant *addr) {
-  llvm::report_fatal_error("Static initialization has not been implemented on"
-                           " XL ABI yet.");
+  if (D.getTLSKind() != VarDecl::TLS_None)
+    llvm::report_fatal_error("thread local storage not yet implemented on AIX");
+
+  // Create __dtor function for the var decl.
+  llvm::Function *dtorStub = CGF.createAtExitStub(D, dtor, addr);
+
+  if (CGM.getCodeGenOpts().CXAAtExit)
+    llvm::report_fatal_error("using __cxa_atexit unsupported on AIX");
+  // Register above __dtor with atexit().
+  CGF.registerGlobalDtorWithAtExit(dtorStub);
+
+  // Emit __finalize function to unregister __dtor and (as appropriate) call
+  // __dtor.
+  emitCXXStermFinalizer(D, dtorStub, addr);
+}
+
+void XLCXXABI::emitCXXStermFinalizer(const VarDecl &D, llvm::Function *dtorStub,
+                                     llvm::Constant *addr) {
+  llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
+  SmallString<256> FnName;
+  {
+    llvm::raw_svector_ostream Out(FnName);
+    getMangleContext().mangleDynamicStermFinalizer(&D, Out);
+  }
+
+  // Create the finalization action associated with a variable.
+  const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
+  llvm::Function *StermFinalizer = CGM.CreateGlobalInitOrCleanUpFunction(
+      FTy, FnName.str(), FI, D.getLocation());
+
+  CodeGenFunction CGF(CGM);
+
+  CGF.StartFunction(GlobalDecl(), CGM.getContext().VoidTy, StermFinalizer, FI,
+                    FunctionArgList());
+
+  // The unatexit subroutine unregisters __dtor functions that were previously
+  // registered by the atexit subroutine. If the referenced function is found,
+  // the unatexit returns a value of 0, meaning that the cleanup is still
+  // pending (and we should call the __dtor function).
+  llvm::Value *V = CGF.unregisterGlobalDtorWithUnAtExit(dtorStub);
+
+  llvm::Value *NeedsDestruct = CGF.Builder.CreateIsNull(V, "needs_destruct");
+
+  llvm::BasicBlock *DestructCallBlock = CGF.createBasicBlock("destruct.call");
+  llvm::BasicBlock *EndBlock = CGF.createBasicBlock("destruct.end");
+
+  // Check if unatexit returns a value of 0. If it does, jump to
+  // DestructCallBlock, otherwise jump to EndBlock directly.
+  CGF.Builder.CreateCondBr(NeedsDestruct, DestructCallBlock, EndBlock);
+
+  CGF.EmitBlock(DestructCallBlock);
+
+  // Emit the call to dtorStub.
+  llvm::CallInst *CI = CGF.Builder.CreateCall(dtorStub);
+
+  // Make sure the call and the callee agree on calling convention.
+  CI->setCallingConv(dtorStub->getCallingConv());
+
+  CGF.EmitBlock(EndBlock);
+
+  CGF.FinishFunction();
+
+  CGM.AddCXXStermFinalizerEntry(StermFinalizer);
 }

clang/lib/CodeGen/MicrosoftCXXABI.cpp

if (llvm::Comdat *C = GV->getComdat())
       AddToXDU(F)->setComdat(C);
     else
       NonComdatInits.push_back(F);
   }
 
   if (!NonComdatInits.empty()) {
     llvm::FunctionType *FTy =
         llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
-    llvm::Function *InitFunc = CGM.CreateGlobalInitOrDestructFunction(
+    llvm::Function *InitFunc = CGM.CreateGlobalInitOrCleanUpFunction(
         FTy, "__tls_init", CGM.getTypes().arrangeNullaryFunction(),
         SourceLocation(), /*TLS=*/true);
     CodeGenFunction(CGM).GenerateCXXGlobalInitFunc(InitFunc, NonComdatInits);
 
     AddToXDU(InitFunc);
   }
 }
 

clang/lib/Sema/SemaDeclAttr.cpp

case ParsedAttr::AT_Common:
     break;
   case ParsedAttr::AT_CUDAConstant:
     handleConstantAttr(S, D, AL);
     break;
   case ParsedAttr::AT_PassObjectSize:
     handlePassObjectSizeAttr(S, D, AL);
     break;
   case ParsedAttr::AT_Constructor:
+    if (S.Context.getTargetInfo().getTriple().isOSAIX())
+      llvm::report_fatal_error(
+          "'constructor' attribute is not yet supported on AIX");
+    else
       handleConstructorAttr(S, D, AL);
     break;
   case ParsedAttr::AT_Deprecated:
     handleDeprecatedAttr(S, D, AL);
     break;
   case ParsedAttr::AT_Destructor:
+    if (S.Context.getTargetInfo().getTriple().isOSAIX())
+      llvm::report_fatal_error("'destructor' attribute is not yet supported on AIX");
+    else
       handleDestructorAttr(S, D, AL);
     break;
   case ParsedAttr::AT_EnableIf:
     handleEnableIfAttr(S, D, AL);
     break;
   case ParsedAttr::AT_DiagnoseIf:
     handleDiagnoseIfAttr(S, D, AL);
     break;
   case ParsedAttr::AT_NoBuiltin:
case ParsedAttr::AT_ReqdWorkGroupSize:
     break;
   case ParsedAttr::AT_OpenCLIntelReqdSubGroupSize:
     handleSubGroupSize(S, D, AL);
     break;
   case ParsedAttr::AT_VecTypeHint:
     handleVecTypeHint(S, D, AL);
     break;
   case ParsedAttr::AT_InitPriority:
+    if (S.Context.getTargetInfo().getTriple().isOSAIX())
+      llvm::report_fatal_error(
+          "'init_priority' attribute is not yet supported on AIX");
+    else
       handleInitPriorityAttr(S, D, AL);
     break;
   case ParsedAttr::AT_Packed:
     handlePackedAttr(S, D, AL);
     break;
   case ParsedAttr::AT_Section:
     handleSectionAttr(S, D, AL);
     break;
   case ParsedAttr::AT_SpeculativeLoadHardening:

clang/test/CodeGen/aix-constructor-attribute.cpp

+// RUN: not %clang_cc1 -triple powerpc-ibm-aix-xcoff -x c++ -emit-llvm < %s \
+// RUN:     2>&1 | \
+// RUN:   FileCheck %s
+// RUN: not %clang_cc1 -triple powerpc64-ibm-aix-xcoff -x c++ -emit-llvm < %s \
+// RUN:     2>&1 | \
+// RUN:   FileCheck %s
+
+int foo() __attribute__((constructor(180)));
+
+class test {
+  int a;
+
+public:
+  test(int c) { a = c; }
+  ~test() { a = 0; }
+};
+
+test t(1);
+
+// CHECK: fatal error: error in backend: 'constructor' attribute is not yet supported on AIX

clang/test/CodeGen/aix-destructor-attribute.cpp

+// RUN: not %clang_cc1 -triple powerpc-ibm-aix-xcoff -x c++ -emit-llvm < %s \
+// RUN:     2>&1 | \
+// RUN:   FileCheck %s
+// RUN: not %clang_cc1 -triple powerpc64-ibm-aix-xcoff -x c++ -emit-llvm < %s \
+// RUN:     2>&1 | \
+// RUN:   FileCheck %s
+
+int bar() __attribute__((destructor(180)));
+
+class test {
+  int a;
+
+public:
+  test(int c) { a = c; }
+  ~test() { a = 0; }
+};
+
+test t(1);
+
+// CHECK: fatal error: error in backend: 'destructor' attribute is not yet supported on AIX

clang/test/CodeGen/aix-init-priority-attribute.cpp

+// RUN: not %clang_cc1 -triple powerpc-ibm-aix-xcoff -x c++ -emit-llvm < %s \
+// RUN:     2>&1 | \
+// RUN:   FileCheck %s
+// RUN: not %clang_cc1 -triple powerpc64-ibm-aix-xcoff -x c++ -emit-llvm < %s \
+// RUN:     2>&1 | \
+// RUN:   FileCheck %s
+
+class test {
+  int a;
+
+public:
+  test(int c) { a = c; }
+  ~test() { a = 0; }
+};
+
+__attribute__((init_priority(2000)))
+test t(1);
+
+// CHECK: fatal error: error in backend: 'init_priority' attribute is not yet supported on AIX

clang/test/CodeGen/static-init.cpp

-// RUN: not %clang_cc1 -triple powerpc-ibm-aix-xcoff -S -emit-llvm -x c++ %s \
-// RUN: -o /dev/null 2>&1 | FileCheck %s
-
-// RUN: not %clang_cc1 -triple powerpc64-ibm-aix-xcoff -S -emit-llvm -x c++ %s \
-// RUN: -o /dev/null 2>&1 | FileCheck %s
-
-struct test {
-  test();
-  ~test();
-} t;
-
-// CHECK: error in backend: Static initialization has not been implemented on XL ABI yet.

clang/test/CodeGenCXX/aix-static-init.cpp

+// RUN: %clang_cc1 -triple powerpc-ibm-aix-xcoff -S -emit-llvm -x c++ \
+// RUN:     -fno-use-cxa-atexit -std=c++2a < %s | \
+// RUN:   FileCheck --check-prefixes=CHECK,CHECK32 %s
+
+// RUN: %clang_cc1 -triple powerpc64-ibm-aix-xcoff -S -emit-llvm -x c++ \
+// RUN:     -fno-use-cxa-atexit -std=c++2a < %s | \
+// RUN:   FileCheck --check-prefixes=CHECK,CHECK64 %s
+
+namespace test1 {
+  struct Test1 {
+    Test1();
+    ~Test1();
+  } t1, t2;
+} // namespace test1
+
+namespace test2 {
+  int foo() { return 3; }
+  int x = foo();
+} // namespace test2
+
+namespace test3 {
+  struct Test3 {
+    constexpr Test3() {};
+    ~Test3() {};
+  };
+
+  constinit Test3 t;
+} // namespace test3
+
+namespace test4 {
+  struct Test4 {
+    Test4();
+    ~Test4();
+  };
+
+  void f() {
+    static Test4 staticLocal;
+  }
+} // namespace test4
+
+// CHECK: @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @__sinit80000000_clang_1145401da454a7baad10bfe313c46638, i8* null }]
+// CHECK: @llvm.global_dtors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @__sterm80000000_clang_1145401da454a7baad10bfe313c46638, i8* null }]
+
+// CHECK: define internal void @__cxx_global_var_init() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   call void @_ZN5test15Test1C1Ev(%"struct.test1::Test1"* @_ZN5test12t1E)
+// CHECK:   %0 = call i32 @atexit(void ()* @__dtor__ZN5test12t1E)
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: define internal void @__dtor__ZN5test12t1E() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   call void @_ZN5test15Test1D1Ev(%"struct.test1::Test1"* @_ZN5test12t1E)
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: declare i32 @atexit(void ()*)
+
+// CHECK: define internal void @__finalize__ZN5test12t1E() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   %0 = call i32 @unatexit(void ()* @__dtor__ZN5test12t1E)
+// CHECK:   %needs_destruct = icmp eq i32 %0, 0
+// CHECK:   br i1 %needs_destruct, label %destruct.call, label %destruct.end
+
+// CHECK: destruct.call:
+// CHECK:   call void @__dtor__ZN5test12t1E()
+// CHECK:   br label %destruct.end
+
+// CHECK: destruct.end:
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: declare i32 @unatexit(void ()*)
+
+// CHECK: define internal void @__cxx_global_var_init.1() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   call void @_ZN5test15Test1C1Ev(%"struct.test1::Test1"* @_ZN5test12t2E)
+// CHECK:   %0 = call i32 @atexit(void ()* @__dtor__ZN5test12t2E)
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: define internal void @__dtor__ZN5test12t2E() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   call void @_ZN5test15Test1D1Ev(%"struct.test1::Test1"* @_ZN5test12t2E)
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: define internal void @__finalize__ZN5test12t2E() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   %0 = call i32 @unatexit(void ()* @__dtor__ZN5test12t2E)
+// CHECK:   %needs_destruct = icmp eq i32 %0, 0
+// CHECK:   br i1 %needs_destruct, label %destruct.call, label %destruct.end
+
+// CHECK: destruct.call:
+// CHECK:   call void @__dtor__ZN5test12t2E()
+// CHECK:   br label %destruct.end
+
+// CHECK: destruct.end:
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: define internal void @__cxx_global_var_init.2() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK32: %call = call i32 @_ZN5test23fooEv()
+// CHECK64: %call = call signext i32 @_ZN5test23fooEv()
+// CHECK:   store i32 %call, i32* @_ZN5test21xE
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: define internal void @__cxx_global_var_init.3() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   %0 = call i32 @atexit(void ()* @__dtor__ZN5test31tE)
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: define internal void @__dtor__ZN5test31tE() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   call void @_ZN5test35Test3D1Ev(%"struct.test3::Test3"* @_ZN5test31tE)
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: define internal void @__finalize__ZN5test31tE() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   %0 = call i32 @unatexit(void ()* @__dtor__ZN5test31tE)
+// CHECK:   %needs_destruct = icmp eq i32 %0, 0
+// CHECK:   br i1 %needs_destruct, label %destruct.call, label %destruct.end
+
+// CHECK: destruct.call:
+// CHECK:   call void @__dtor__ZN5test31tE()
+// CHECK:   br label %destruct.end
+
+// CHECK: destruct.end:
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: define void @_ZN5test41fEv() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   %0 = load atomic i8, i8* bitcast (i64* @_ZGVZN5test41fEvE11staticLocal to i8*) acquire
+// CHECK:   %guard.uninitialized = icmp eq i8 %0, 0
+// CHECK:   br i1 %guard.uninitialized, label %init.check, label %init.end
+
+// CHECK: init.check:
+// CHECK:   %1 = call i32 @__cxa_guard_acquire(i64* @_ZGVZN5test41fEvE11staticLocal)
+// CHECK:   %tobool = icmp ne i32 %1, 0
+// CHECK:   br i1 %tobool, label %init, label %init.end
+
+// CHECK: init:
+// CHECK:   call void @_ZN5test45Test4C1Ev(%"struct.test4::Test4"* @_ZZN5test41fEvE11staticLocal)
+// CHECK:   %2 = call i32 @atexit(void ()* @__dtor__ZZN5test41fEvE11staticLocal)
+// CHECK:   call void @__cxa_guard_release(i64* @_ZGVZN5test41fEvE11staticLocal)
+// CHECK:   br label %init.end
+
+// CHECK: init.end:
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: define internal void @__dtor__ZZN5test41fEvE11staticLocal() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   call void @_ZN5test45Test4D1Ev(%"struct.test4::Test4"* @_ZZN5test41fEvE11staticLocal)
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: define internal void @__finalize__ZZN5test41fEvE11staticLocal() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   %0 = call i32 @unatexit(void ()* @__dtor__ZZN5test41fEvE11staticLocal)
+// CHECK:   %needs_destruct = icmp eq i32 %0, 0
+// CHECK:   br i1 %needs_destruct, label %destruct.call, label %destruct.end
+
+// CHECK: destruct.call:
+// CHECK:   call void @__dtor__ZZN5test41fEvE11staticLocal()
+// CHECK:   br label %destruct.end
+
+// CHECK: destruct.end:
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: define void @__sinit80000000_clang_1145401da454a7baad10bfe313c46638() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   call void @__cxx_global_var_init()
+// CHECK:   call void @__cxx_global_var_init.1()
+// CHECK:   call void @__cxx_global_var_init.2()
+// CHECK:   call void @__cxx_global_var_init.3()
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: define void @__sterm80000000_clang_1145401da454a7baad10bfe313c46638() [[ATTR:#[0-9]+]] {
+// CHECK: entry:
+// CHECK:   call void @__finalize__ZZN5test41fEvE11staticLocal()
+// CHECK:   call void @__finalize__ZN5test31tE()
+// CHECK:   call void @__finalize__ZN5test12t2E()
+// CHECK:   call void @__finalize__ZN5test12t1E()
+// CHECK:   ret void
+// CHECK: }