thread_local support for AIX

[jamieschmeiser]

Summary

Changes to support thread_local storage on AIX.

The AIX linker will produce errors on unresolved weak symbols. Change the
generated code to not check for the initialization function but just call
it and ensure that it always exists. Also, the AIX atexit routine has a
different name (and signature) so call it correctly. Update the lit tests
to test on AIX appropriately.

[jamieschmeiser]

Fix formatting problem.

[hubert.reinterpretcast]

clang/test/CodeGenCXX/cxx11-thread-local-reference.cpp

12

Fix typo. Also, if the Linux and the AIX pattern is the same, adding a NONDARWIN prefix could help.

25–26

Can use {{.*}} in place of comdat to common up the Linux and the AIX pattern.

clang/test/CodeGenCXX/cxx11-thread-local.cpp

13

Minor nit: I think this should be moved to after line 5.

18

Same comment as for the earlier file re: adding a prefix to handle the common Linux and AIX lines.

214

Same comment as earlier about comdat.

[jamieschmeiser]

Respond to review comments: Update to tests to create common LINUX/AIX portions.

[hubert.reinterpretcast]

clang/lib/CodeGen/ItaniumCXXABI.cpp

4773

The function registered needs to be something more like what createAtExitStub stub creates. Otherwise, the destructor will not be able to reference *this correctly.

As it is, the registered function is currently just the destructor itself:

$ clang++ -target powerpc64-ibm-aix -emit-llvm -S -o - -xc++ -<<<$'struct A { ~A(); }; thread_local A a;' | grep -C2 __pt_atexit_np
define internal void @__cxx_global_var_init() #0 {
entry:
  %0 = call i32 (i32, i32 (i32, ...)*, ...) @__pt_atexit_np(i32 0, i32 (i32, ...)* bitcast (void (%struct.A*)* @_ZN1AD1Ev to i32 (i32, ...)*)) #3
  ret void
}
--
declare void @_ZN1AD1Ev(%struct.A* nonnull align 1 dereferenceable(1)) unnamed_addr #1

declare i32 @__pt_atexit_np(i32, i32 (i32, ...)*, ...)

; Function Attrs: noinline
Return:  0x00:0   Mon Jul 12 15:24:15 2021 EDT

[hubert.reinterpretcast]

clang/lib/CodeGen/ItaniumCXXABI.cpp

2995–2996

Minor nit: The coding guidelines have been updated for some time to discourage mixed bracing on if/else chains (see example

// Use braces for the `if` block to keep it uniform with the else block.

).

4773

Just noting that the callback function registered by the IBM XL compiler does not make an effort to return 0 (but the documentation says the handler "must" return 0: https://www.ibm.com/docs/en/aix/7.2?topic=p-pthread-atexit-np-subroutine).

[hubert.reinterpretcast]

clang/lib/CodeGen/ItaniumCXXABI.cpp

2996

Clarify that this statement does not apply if the type is not a class type or (possibly multi-dimenional) array of class type and the variable is also constinit.

[hubert.reinterpretcast]

clang/lib/CodeGen/ItaniumCXXABI.cpp

2954

The linkage of the init function here should not be hard-coded as weak: If the strong definition of the variable has no dynamic initialization/finalization, then the init function the wrapper functions call should resolve to the empty version created here.

[hubert.reinterpretcast]

clang/lib/CodeGen/ItaniumCXXABI.cpp

2959

Unfortunately needsDestruction cannot be counted on at this time for some incomplete types, see https://llvm.org/pr51079.

2960–2963

This comment block is a copy/paste from above and is meant to describe a case where only a declaration of the init func is being emitted into the IR.

[jamieschmeiser]

Respond to review comments: create stub functions, return 0 from function and other fixes

[jamieschmeiser]

Respond to review comments: update comments and make functions not weak

[jamieschmeiser]

clang/lib/CodeGen/ItaniumCXXABI.cpp

2959

I think it is okay to leave the code as-is as it will then be fixed when that problem is fixed.

[jamieschmeiser]

Remove accidental inclusion

[hubert.reinterpretcast]

clang/lib/CodeGen/CGDeclCXX.cpp

265

Since the function has some specifics about the stub function type and return value behaviour:
s/atexit/__pt_atexit_np/;

clang/lib/CodeGen/ItaniumCXXABI.cpp

2959

An assertion that Init is null should be appropriate here: If it is non-null, then the pre-existing logic above would either be defining the function to be an alias or is declaring the function with the expectation that the definition of the variable is elsewhere.

2961

The linkage should be weak for a variable defined to be weak. For example, the code higher up uses Var->getLinkage() to produce the alias.

2988–2989

This does not say that a thread_local variable of type int that is not constinit does have a guaranteed init routine.

Suggestion:
On AIX, except if constinit and also neither of class type or of (possibly multi-dimensional) array of class type, thread_local vars will have init routines regardless of whether they are const-initialized.

clang/test/CodeGenCXX/cxx11-thread-local.cpp

241

Since the code to generate the stub is new, I believe inspecting the body of the stub in the test would be appropriate.

[jamieschmeiser]

Respond to review comments, formatting: fix comments, add assertion, fix
linkage, expand test to include body of generated function.

[hubert.reinterpretcast]

I think we're good after some last updates.

clang/lib/CodeGen/ItaniumCXXABI.cpp

340–343

See suggested change for renaming the parameter name from IgnoreAttrs to InspectInitForWeakDef.

349

2957–2958

The block here is meant to be entered only if there is a definition of the variable (even if weak) in the current translation unit. This is mostly enforced with isEmittedWithConstantInitializer, but that will return true for constinit even if only a declaration is available.

2959

Yes: I think (if the code works correctly), the needsDestruction query here only becomes significant when the type is complete -- and, in that case, we want it to work the way it currently does in relation to classes.

[jamieschmeiser]

Respond to review comments: Change parameter name and tighten up conditions.

[hubert.reinterpretcast]

LGTM; thanks!

clang/lib/CodeGen/CGDeclCXX.cpp

if (auto *dtorFn = dyn_cast<llvm::Function>(
           dtor.getCallee()->stripPointerCastsAndAliases()))
     call->setCallingConv(dtorFn->getCallingConv());
 
   CGF.FinishFunction();
 
   return fn;
 }
 
+/// Create a stub function, suitable for being passed to atexit,
+/// which passes the given address to the given destructor function.
+llvm::Function *CodeGenFunction::createTLSAtExitStub(
+    const VarDecl &D, llvm::FunctionCallee Dtor, llvm::Constant *Addr,
+    llvm::FunctionCallee &AtExit) {
+  SmallString<256> FnName;
+  {
+    llvm::raw_svector_ostream Out(FnName);
+    CGM.getCXXABI().getMangleContext().mangleDynamicAtExitDestructor(&D, Out);
+  }
+
+  const CGFunctionInfo &FI = CGM.getTypes().arrangeLLVMFunctionInfo(
+      getContext().IntTy, /*instanceMethod=*/false, /*chainCall=*/false,
+      {getContext().IntTy}, FunctionType::ExtInfo(), {}, RequiredArgs::All);
+
+  // Get the stub function type, int(*)(int,...).
+  llvm::FunctionType *StubTy = llvm::FunctionType::get(
+      CGM.IntTy, {CGM.IntTy}, true);
+
+  llvm::Function *DtorStub = CGM.CreateGlobalInitOrCleanUpFunction(
+      StubTy, FnName.str(), FI, D.getLocation());
+
+  CodeGenFunction CGF(CGM);
+
+  FunctionArgList Args;
+  ImplicitParamDecl IPD(CGM.getContext(), CGM.getContext().IntTy,
+                        ImplicitParamDecl::Other);
+  Args.push_back(&IPD);
+  QualType ResTy = CGM.getContext().IntTy;
+
+  CGF.StartFunction(GlobalDecl(&D, DynamicInitKind::AtExit), ResTy,
+                    DtorStub, FI, Args, D.getLocation(),
+                    D.getInit()->getExprLoc());
+
+  // Emit an artificial location for this function.
+  auto AL = ApplyDebugLocation::CreateArtificial(CGF);
+
+  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());
+
+  // Return 0 from function
+  CGF.Builder.CreateStore(llvm::Constant::getNullValue(CGM.IntTy),
+        CGF.ReturnValue);
+
+  CGF.FinishFunction();
+
+  return DtorStub;
+}
+
 /// 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);
 }

clang/lib/CodeGen/CodeGenFunction.h

public:
   /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
   /// variable with global storage.
   void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr,
                                 bool PerformInit);
 
   llvm::Function *createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor,
                                    llvm::Constant *Addr);
 
+  llvm::Function *createTLSAtExitStub(const VarDecl &VD,
+              llvm::FunctionCallee Dtor,
+              llvm::Constant *Addr,
+              llvm::FunctionCallee &AtExit);
+
   /// 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);
 

clang/lib/CodeGen/ItaniumCXXABI.cpp

void EmitThreadLocalInitFuncs(
       CodeGenModule &CGM,
       ArrayRef<const VarDecl *> CXXThreadLocals,
       ArrayRef<llvm::Function *> CXXThreadLocalInits,
       ArrayRef<const VarDecl *> CXXThreadLocalInitVars) override;
 
   /// Determine whether we will definitely emit this variable with a constant
   /// initializer, either because the language semantics demand it or because
   /// we know that the initializer is a constant.
-  bool isEmittedWithConstantInitializer(const VarDecl *VD) const {
+  // Ignore all attributes except ConstInit when IgnoreAttrs is true.
+  bool isEmittedWithConstantInitializer(const VarDecl *VD,
+                                        bool IgnoreAttrs = false) const {
     VD = VD->getMostRecentDecl();
     if (VD->hasAttr<ConstInitAttr>())
       return true;
 
     // All later checks examine the initializer specified on the variable. If
     // the variable is weak, such examination would not be correct.
-    if (VD->isWeak() || VD->hasAttr<SelectAnyAttr>())
+    if (!IgnoreAttrs && (VD->isWeak() || VD->hasAttr<SelectAnyAttr>()))
       return false;
 
     const VarDecl *InitDecl = VD->getInitializingDeclaration();
     if (!InitDecl)
       return false;
 
     // If there's no initializer to run, this is constant initialization.
     if (!InitDecl->hasInit())
void ItaniumCXXABI::EmitGuardedInit(CodeGenFunction &CGF,
 
   CGF.EmitBlock(EndBlock);
 }
 
 /// Register a global destructor using __cxa_atexit.
 static void emitGlobalDtorWithCXAAtExit(CodeGenFunction &CGF,
                                         llvm::FunctionCallee dtor,
                                         llvm::Constant *addr, bool TLS) {
+  assert(!CGF.getTarget().getTriple().isOSAIX() &&
+         "unexpected call to emitGlobalDtorWithCXAAtExit");
   assert((TLS || CGF.getTypes().getCodeGenOpts().CXAAtExit) &&
          "__cxa_atexit is disabled");
   const char *Name = "__cxa_atexit";
   if (TLS) {
     const llvm::Triple &T = CGF.getTarget().getTriple();
     Name = T.isOSDarwin() ?  "_tlv_atexit" : "__cxa_thread_atexit";
   }
 
for (auto VDAndWrapper : ThreadWrappers) {
     if (Init) {
       Init->setVisibility(Var->getVisibility());
       // Don't mark an extern_weak function DSO local on windows.
       if (!CGM.getTriple().isOSWindows() || !Init->hasExternalWeakLinkage())
         Init->setDSOLocal(Var->isDSOLocal());
     }
 
     llvm::LLVMContext &Context = CGM.getModule().getContext();
+
+    // The linker on AIX is not happy with missing weak symbols.  However,
+    // other TUs will not know whether the initialization routine exists
+    // so create an empty, init function to satisfy the linker.
+    // This is needed whenever a thread wrapper function is not used, and
+    // also when the symbol is weak.
+    if (CGM.getTriple().isOSAIX() &&
+        isEmittedWithConstantInitializer(VD, true) &&
+        !VD->needsDestruction(getContext())) {
+      llvm::Function *Func = llvm::Function::Create(
+          InitFnTy, llvm::GlobalVariable::ExternalLinkage, InitFnName.str(),
+          &CGM.getModule());
+      const CGFunctionInfo &FI = CGM.getTypes().arrangeNullaryFunction();
+      CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI,
+                                    cast<llvm::Function>(Func),
+                                    /*IsThunk=*/false);
+      // Create a function body that just returns
+      llvm::BasicBlock *Entry = llvm::BasicBlock::Create(Context, "", Func);
+      CGBuilderTy Builder(CGM, Entry);
+      Builder.CreateRetVoid();
+    }
+
     llvm::BasicBlock *Entry = llvm::BasicBlock::Create(Context, "", Wrapper);
     CGBuilderTy Builder(CGM, Entry);
     if (HasConstantInitialization) {
       // No dynamic initialization to invoke.
     } else if (InitIsInitFunc) {
       if (Init) {
         llvm::CallInst *CallVal = Builder.CreateCall(InitFnTy, Init);
         if (isThreadWrapperReplaceable(VD, CGM)) {
           CallVal->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
           llvm::Function *Fn =
               cast<llvm::Function>(cast<llvm::GlobalAlias>(Init)->getAliasee());
           Fn->setCallingConv(llvm::CallingConv::CXX_FAST_TLS);
         }
       }
+    } else if (CGM.getTriple().isOSAIX()) {
+      // On AIX, thread_local vars, other than non-class types or (possibly
+      // multi-dimensional) arrays or such types, will have init routines
+      // regardless of whether they are const-initialized or not.  Since the
+      // routine is guaranteed to exist, we can unconditionally call it without
+      // testing for its existance.  This avoids potentially unresolved weak
+      // symbols which the AIX linker isn't happy with.
+      Builder.CreateCall(InitFnTy, Init);
     } else {
       // Don't know whether we have an init function. Call it if it exists.
       llvm::Value *Have = Builder.CreateIsNotNull(Init);
       llvm::BasicBlock *InitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
       llvm::BasicBlock *ExitBB = llvm::BasicBlock::Create(Context, "", Wrapper);
       Builder.CreateCondBr(Have, InitBB, ExitBB);
 
       Builder.SetInsertPoint(InitBB);
       Builder.CreateCall(InitFnTy, Init);
       Builder.CreateBr(ExitBB);
WebAssemblyCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
   // std::terminate and ignore the violating exception as in CGCXXABI.
   // TODO Consider code transformation that makes calling __clang_call_terminate
   // possible.
   return CGCXXABI::emitTerminateForUnexpectedException(CGF, Exn);
 }
 
 /// Register a global destructor as best as we know how.
 void XLCXXABI::registerGlobalDtor(CodeGenFunction &CGF, const VarDecl &D,
-                                  llvm::FunctionCallee dtor,
-                                  llvm::Constant *addr) {
-  if (D.getTLSKind() != VarDecl::TLS_None)
-    llvm::report_fatal_error("thread local storage not yet implemented on AIX");
+                                  llvm::FunctionCallee Dtor,
+                                  llvm::Constant *Addr) {
+  if (D.getTLSKind() != VarDecl::TLS_None) {
+    // atexit routine expects "int(*)(int,...)"
+    llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.IntTy, CGM.IntTy,
+                true);
+    llvm::PointerType *FpTy = FTy->getPointerTo();
+
+    // extern "C" int __pt_atexit_np(int flags, int(*)(int,...), ...);
+    llvm::FunctionType *AtExitTy =
+        llvm::FunctionType::get(CGM.IntTy, {CGM.IntTy, FpTy}, true);
+
+    // Fetch the actual function.
+    llvm::FunctionCallee AtExit =
+        CGM.CreateRuntimeFunction(AtExitTy, "__pt_atexit_np");
 
     // Create __dtor function for the var decl.
-  llvm::Function *dtorStub = CGF.createAtExitStub(D, dtor, addr);
+    llvm::Function *DtorStub = CGF.createTLSAtExitStub(D, Dtor, Addr, AtExit);
 
     // Register above __dtor with atexit().
-  CGF.registerGlobalDtorWithAtExit(dtorStub);
+    // First param is flags and must be 0, second param is function ptr
+    llvm::Value *NV = llvm::Constant::getNullValue(CGM.IntTy);
+    CGF.EmitNounwindRuntimeCall(AtExit, {NV, DtorStub});
+
+    // Cannot unregister TLS __dtor so done
+    return;
+  }
+
+  // Create __dtor function for the var decl.
+  llvm::Function *DtorStub = CGF.createAtExitStub(D, Dtor, Addr);
+
+  // Register above __dtor with atexit().
+  CGF.registerGlobalDtorWithAtExit(DtorStub);
 
   // Emit __finalize function to unregister __dtor and (as appropriate) call
   // __dtor.
-  emitCXXStermFinalizer(D, dtorStub, addr);
+  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);
void XLCXXABI::emitCXXStermFinalizer(const VarDecl &D, llvm::Function *dtorStub,
   // 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");
+    //  if (NeedZeroReturn) {
+    //    CGBuilderTy Builder(CGM, EndBlock);
+    //    Builder.CreateRet(llvm::Constant::getNullValue(CGM.IntTy));
+    //  }
 
   // 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.

clang/test/CodeGenCXX/cxx11-thread-local-reference.cpp

-// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck --check-prefix=CHECK --check-prefix=LINUX %s
+// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck --check-prefixes=CHECK,LINUX_AIX %s
+// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple powerpc64-unknown-aix-xcoff | FileCheck --check-prefixes=CHECK,LINUX_AIX %s
 // RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple x86_64-apple-darwin12 | FileCheck --check-prefix=CHECK --check-prefix=DARWIN %s
 
 int &f();
 
-// LINUX: @r ={{.*}} thread_local global i32* null
+// LINUX_AIX: @r ={{.*}} thread_local global i32* null
 // DARWIN: @r = internal thread_local global i32* null
 thread_local int &r = f();
 
-// LINUX: @_ZTH1r ={{.*}} alias void (), void ()* @__tls_init
+// LINUX_AIX: @_ZTH1r ={{.*}} alias void (), void ()* @__tls_init
 // DARWIN: @_ZTH1r = internal alias void (), void ()* @__tls_init
 
 int &g() { return r; }
 
 // CHECK: define {{.*}} @[[R_INIT:.*]]()
 // CHECK: call nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) i32* @_Z1fv()
 // CHECK: store i32* %{{.*}}, i32** @r, align 8
 
 // CHECK-LABEL: define{{.*}} nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) i32* @_Z1gv()
-// LINUX: call i32* @_ZTW1r()
+// LINUX_AIX: call i32* @_ZTW1r()
 // DARWIN: call cxx_fast_tlscc i32* @_ZTW1r()
 // CHECK: ret i32* %{{.*}}
 
-// LINUX: define weak_odr hidden i32* @_ZTW1r() [[ATTR0:#[0-9]+]] comdat {
+// LINUX_AIX: define weak_odr hidden i32* @_ZTW1r() [[ATTR0:#[0-9]+]]{{( comdat)?}} {
 // DARWIN: define cxx_fast_tlscc i32* @_ZTW1r() [[ATTR1:#[0-9]+]] {
-// LINUX: call void @_ZTH1r()
+// LINUX_AIX: call void @_ZTH1r()
 // DARWIN: call cxx_fast_tlscc void @_ZTH1r()
 // CHECK: load i32*, i32** @r, align 8
 // CHECK: ret i32* %{{.*}}
 
-// LINUX-LABEL: define internal void @__tls_init()
+// LINUX_AIX-LABEL: define internal void @__tls_init()
 // DARWIN-LABEL: define internal cxx_fast_tlscc void @__tls_init()
 // CHECK: call void @[[R_INIT]]()
 
-// LINUX: attributes [[ATTR0]] = { {{.*}}"target-features"{{.*}} }
+// LINUX_AIX: attributes [[ATTR0]] = { {{.*}}"target-features"{{.*}} }
 // DARWIN: attributes [[ATTR1]] = { {{.*}}nounwind{{.*}}"target-features"{{.*}}  }

clang/test/CodeGenCXX/cxx11-thread-local-visibility.cpp

-// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck --check-prefix=LINUX %s
+// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck --check-prefix=LINUX_AIX %s
+// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple powerpc64-unknown-aix-xcoff | FileCheck --check-prefix=LINUX_AIX %s
 // RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple x86_64-apple-darwin12 | FileCheck --check-prefix=DARWIN %s
 
 // Regression test for PR40327
 
-// LINUX: @default_tls ={{.*}} thread_local global i32
-// LINUX: @hidden_tls = hidden thread_local global i32
-// LINUX: define weak_odr hidden i32* @_ZTW11default_tls()
-// LINUX: define weak_odr hidden i32* @_ZTW10hidden_tls()
+// LINUX_AIX: @default_tls ={{.*}} thread_local global i32
+// LINUX_AIX: @hidden_tls ={{( hidden)?}} thread_local global i32
+// LINUX_AIX: define weak_odr hidden i32* @_ZTW11default_tls()
+// LINUX_AIX: define weak_odr hidden i32* @_ZTW10hidden_tls()
 //
 // DARWIN: @default_tls = internal thread_local global i32
 // DARWIN: @hidden_tls = internal thread_local global i32
 // DARWIN: define cxx_fast_tlscc i32* @_ZTW11default_tls()
 // DARWIN: define hidden cxx_fast_tlscc i32* @_ZTW10hidden_tls()
 
 __attribute__((visibility("default"))) thread_local int default_tls;
 __attribute__((visibility("hidden"))) thread_local int hidden_tls;

clang/test/CodeGenCXX/cxx11-thread-local.cpp

-// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck --check-prefix=CHECK --check-prefix=LINUX %s
-// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -O2 -disable-llvm-passes -o - -triple x86_64-linux-gnu | FileCheck --check-prefix=CHECK --check-prefix=LINUX --check-prefix=CHECK-OPT %s
+// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck --check-prefixes=CHECK,LINUX,LINUX_AIX %s
+// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -O2 -disable-llvm-passes -o - -triple x86_64-linux-gnu | FileCheck --check-prefixes=CHECK,LINUX,LINUX_AIX,CHECK-OPT %s
 // RUN: %clang_cc1 -std=c++11 -femulated-tls -emit-llvm %s -o - \
-// RUN:     -triple x86_64-linux-gnu 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=LINUX %s
+// RUN:     -triple x86_64-linux-gnu 2>&1 | FileCheck --check-prefixes=CHECK,LINUX,LINUX_AIX %s
 // RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple x86_64-apple-darwin12 | FileCheck --check-prefix=CHECK --check-prefix=DARWIN %s
+// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -triple powerpc64-unknown-aix-xcoff | FileCheck --check-prefixes=CHECK,AIX,LINUX_AIX %s
 
-// RUN: %clang_cc1 -std=c++11 -fno-use-cxa-atexit -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck --check-prefix=CHECK --check-prefix=LINUX %s
-// RUN: %clang_cc1 -std=c++11 -fno-use-cxa-atexit -emit-llvm %s -O2 -disable-llvm-passes -o - -triple x86_64-linux-gnu | FileCheck --check-prefix=CHECK --check-prefix=LINUX --check-prefix=CHECK-OPT %s
+// RUN: %clang_cc1 -std=c++11 -fno-use-cxa-atexit -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck --check-prefixes=CHECK,LINUX,LINUX_AIX %s
+// RUN: %clang_cc1 -std=c++11 -fno-use-cxa-atexit -emit-llvm %s -O2 -disable-llvm-passes -o - -triple x86_64-linux-gnu | FileCheck --check-prefixes=CHECK,LINUX,LINUX_AIX,CHECK-OPT %s
 // RUN: %clang_cc1 -std=c++11 -fno-use-cxa-atexit -femulated-tls -emit-llvm %s -o - \
-// RUN:     -triple x86_64-linux-gnu 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=LINUX %s
+// RUN:     -triple x86_64-linux-gnu 2>&1 | FileCheck --check-prefixes=CHECK,LINUX,LINUX_AIX %s
 // RUN: %clang_cc1 -std=c++11 -fno-use-cxa-atexit -emit-llvm %s -o - -triple x86_64-apple-darwin12 | FileCheck --check-prefix=CHECK --check-prefix=DARWIN %s
 
 int f();
 int g();
 
-// LINUX-DAG: @a ={{.*}} thread_local global i32 0
+// LINUX_AIX-DAG: @a ={{.*}} thread_local global i32 0
 // DARWIN-DAG: @a = internal thread_local global i32 0
 thread_local int a = f();
 extern thread_local int b;
 // CHECK-DAG: @c ={{.*}} global i32 0
 int c = b;
 // CHECK-DAG: @_ZL1d = internal thread_local global i32 0
 static thread_local int d = g();
 
 struct U { static thread_local int m; };
-// LINUX-DAG: @_ZN1U1mE ={{.*}} thread_local global i32 0
+// LINUX_AIX-DAG: @_ZN1U1mE ={{.*}} thread_local global i32 0
 // DARWIN-DAG: @_ZN1U1mE = internal thread_local global i32 0
 thread_local int U::m = f();
 
 namespace MismatchedInitType {
   // Check that we don't crash here when we're forced to create a new global
   // variable (with a different type) when we add the initializer.
   union U {
     int a;

 // CHECK-DAG: @_ZGRZ8tls_dtorvE1u_ = internal thread_local global
 
 // CHECK-DAG: @_ZGVN1VIiE1mE = linkonce_odr thread_local global i64 0
 
 // CHECK-DAG: @__tls_guard = internal thread_local global i8 0
 
 // CHECK-DAG: @llvm.global_ctors = appending global {{.*}} @[[GLOBAL_INIT:[^ ]*]]
 
-// LINUX-DAG: @_ZTH1a ={{.*}} alias void (), void ()* @__tls_init
+// LINUX_AIX-DAG: @_ZTH1a ={{.*}} alias void (), void ()* @__tls_init
 // DARWIN-DAG: @_ZTH1a = internal alias void (), void ()* @__tls_init
-// LINUX-DAG: @_ZTHN1U1mE ={{.*}} alias void (), void ()* @__tls_init
+// LINUX_AIX-DAG: @_ZTHN1U1mE ={{.*}} alias void (), void ()* @__tls_init
 // DARWIN-DAG: @_ZTHN1U1mE = internal alias void (), void ()* @__tls_init
 // CHECK-DAG: @_ZTHN1VIiE1mE = linkonce_odr alias void (), void ()* @[[V_M_INIT:[^, ]*]]
 // CHECK-DAG: @_ZTHN1XIiE1mE = linkonce_odr alias void (), void ()* @[[X_M_INIT:[^, ]*]]
 // CHECK-DAG: @_ZTHN1VIfE1mE = weak_odr alias void (), void ()* @[[VF_M_INIT:[^, ]*]]
 // CHECK-DAG: @_ZTHN1XIfE1mE = weak_odr alias void (), void ()* @[[XF_M_INIT:[^, ]*]]
 // FIXME: We really want a CHECK-DAG-NOT for these.
 // CHECK-NOT: @_ZTHN1WIiE1mE =
 // CHECK-NOT: @_ZTHN1WIfE1mE =
 // CHECK-NOT: @_ZTHL1d =
 
 
 // Individual variable initialization functions:
 
 // CHECK: define {{.*}} @[[A_INIT:.*]]()
-// CHECK: call i32 @_Z1fv()
+// CHECK: call{{.*}} i32 @_Z1fv()
 // CHECK-NEXT: store i32 {{.*}}, i32* @a, align 4
 
 // CHECK-LABEL: define{{.*}} i32 @_Z1fv()
 int f() {
   // CHECK: %[[GUARD:.*]] = load i8, i8* @_ZGVZ1fvE1n, align 1
   // CHECK: %[[NEED_INIT:.*]] = icmp eq i8 %[[GUARD]], 0
-  // CHECK: br i1 %[[NEED_INIT]]
+  // CHECK: br i1 %[[NEED_INIT]]{{.*}}
 
-  // CHECK: %[[CALL:.*]] = call i32 @_Z1gv()
+  // CHECK: %[[CALL:.*]] = call{{.*}} i32 @_Z1gv()
   // CHECK: store i32 %[[CALL]], i32* @_ZZ1fvE1n, align 4
   // CHECK: store i8 1, i8* @_ZGVZ1fvE1n
   // CHECK: br label
   static thread_local int n = g();
 
   // CHECK: load i32, i32* @_ZZ1fvE1n, align 4
   return n;
 }
 
 // CHECK: define {{.*}} @[[C_INIT:.*]]()
-// LINUX: call i32* @_ZTW1b()
+// LINUX_AIX: call i32* @_ZTW1b()
 // DARWIN: call cxx_fast_tlscc i32* @_ZTW1b()
 // CHECK-NEXT: load i32, i32* %{{.*}}, align 4
 // CHECK-NEXT: store i32 %{{.*}}, i32* @c, align 4
 
-// LINUX-LABEL: define linkonce_odr hidden i32* @_ZTW1b()
+// LINUX_AIX-LABEL: define linkonce_odr hidden i32* @_ZTW1b()
 // LINUX: br i1 icmp ne (void ()* @_ZTH1b, void ()* null),
+// AIX-NOT: br i1 icmp ne (void ()* @_ZTH1b, void ()* null),
 // not null:
-// LINUX: call void @_ZTH1b()
+// LINUX_AIX: call void @_ZTH1b()
 // LINUX: br label
+// AIX-NOT: br label
 // finally:
-// LINUX: ret i32* @b
+// LINUX_AIX: ret i32* @b
 // DARWIN-LABEL: declare cxx_fast_tlscc i32* @_ZTW1b()
 // There is no definition of the thread wrapper on Darwin for external TLV.
 
 // CHECK: define {{.*}} @[[D_INIT:.*]]()
-// CHECK: call i32 @_Z1gv()
+// CHECK: call{{.*}} i32 @_Z1gv()
 // CHECK-NEXT: store i32 %{{.*}}, i32* @_ZL1d, align 4
 
 // CHECK: define {{.*}} @[[U_M_INIT:.*]]()
-// CHECK: call i32 @_Z1fv()
+// CHECK: call{{.*}} i32 @_Z1fv()
 // CHECK-NEXT: store i32 %{{.*}}, i32* @_ZN1U1mE, align 4
 
 // CHECK: define {{.*}} @[[E_INIT:.*]]()
-// LINUX: call i32* @_ZTWN1VIiE1mE()
+// LINUX_AIX: call i32* @_ZTWN1VIiE1mE()
 // DARWIN: call cxx_fast_tlscc i32* @_ZTWN1VIiE1mE()
 // CHECK-NEXT: load i32, i32* %{{.*}}, align 4
-// LINUX: call {{.*}}* @_ZTWN1XIiE1mE()
+// LINUX_AIX: call {{.*}}* @_ZTWN1XIiE1mE()
 // DARWIN: call cxx_fast_tlscc {{.*}}* @_ZTWN1XIiE1mE()
 // CHECK: store {{.*}} @e
 
-// LINUX-LABEL: define weak_odr hidden i32* @_ZTWN1VIiE1mE()
+// LINUX_AIX-LABEL: define weak_odr hidden i32* @_ZTWN1VIiE1mE()
 // DARWIN-LABEL: define weak_odr hidden cxx_fast_tlscc i32* @_ZTWN1VIiE1mE()
-// LINUX: call void @_ZTHN1VIiE1mE()
+// LINUX_AIX: call void @_ZTHN1VIiE1mE()
 // DARWIN: call cxx_fast_tlscc void @_ZTHN1VIiE1mE()
 // CHECK: ret i32* @_ZN1VIiE1mE
 
-// LINUX-LABEL: define weak_odr hidden i32* @_ZTWN1WIiE1mE()
+// LINUX_AIX-LABEL: define weak_odr hidden i32* @_ZTWN1WIiE1mE()
 // DARWIN-LABEL: define weak_odr hidden cxx_fast_tlscc i32* @_ZTWN1WIiE1mE()
 // CHECK-NOT: call
 // CHECK: ret i32* @_ZN1WIiE1mE
 
-// LINUX-LABEL: define weak_odr hidden {{.*}}* @_ZTWN1XIiE1mE()
+// LINUX_AIX-LABEL: define weak_odr hidden {{.*}}* @_ZTWN1XIiE1mE()
 // DARWIN-LABEL: define weak_odr hidden cxx_fast_tlscc {{.*}}* @_ZTWN1XIiE1mE()
-// LINUX: call void @_ZTHN1XIiE1mE()
+// LINUX_AIX: call void @_ZTHN1XIiE1mE()
 // DARWIN: call cxx_fast_tlscc void @_ZTHN1XIiE1mE()
 // CHECK: ret {{.*}}* @_ZN1XIiE1mE
 
-// LINUX: define internal void @[[VF_M_INIT]]()
+// LINUX_AIX: define internal void @[[VF_M_INIT]]()
 // DARWIN: define internal cxx_fast_tlscc void @[[VF_M_INIT]]()
 // LINUX-SAME: comdat($_ZN1VIfE1mE)
 // DARWIN-NOT: comdat
 // CHECK: load i8, i8* bitcast (i64* @_ZGVN1VIfE1mE to i8*)
 // CHECK: %[[VF_M_INITIALIZED:.*]] = icmp eq i8 %{{.*}}, 0
 // CHECK: br i1 %[[VF_M_INITIALIZED]],
 // need init:
-// CHECK: call i32 @_Z1gv()
+// CHECK: call{{.*}} i32 @_Z1gv()
 // CHECK: store i32 %{{.*}}, i32* @_ZN1VIfE1mE, align 4
 // CHECK: store i8 1, i8* bitcast (i64* @_ZGVN1VIfE1mE to i8*)
 // CHECK: br label
 
-// LINUX: define internal void @[[XF_M_INIT]]()
+// LINUX_AIX: define internal void @[[XF_M_INIT]]()
 // DARWIN: define internal cxx_fast_tlscc void @[[XF_M_INIT]]()
 // LINUX-SAME: comdat($_ZN1XIfE1mE)
 // DARWIN-NOT: comdat
 // CHECK: load i8, i8* bitcast (i64* @_ZGVN1XIfE1mE to i8*)
 // CHECK: %[[XF_M_INITIALIZED:.*]] = icmp eq i8 %{{.*}}, 0
 // CHECK: br i1 %[[XF_M_INITIALIZED]],
 // need init:
+// AIX-NOT: br
 // LINUX: call {{.*}}__cxa_thread_atexit
+// AIX: call {{.*}}__pt_atexit_np
 // DARWIN: call {{.*}}_tlv_atexit
 // CHECK: store i8 1, i8* bitcast (i64* @_ZGVN1XIfE1mE to i8*)
 // CHECK: br label
 
 // LINUX: declare i32 @__cxa_thread_atexit(void (i8*)*, i8*, i8*)
+// AIX: declare i32 @__pt_atexit_np(i32, i32 (i32, ...)*, ...)
 // DARWIN: declare i32 @_tlv_atexit(void (i8*)*, i8*, i8*)
 
 // DARWIN: declare cxx_fast_tlscc i32* @_ZTWN1VIcE1mE()
-// LINUX: define linkonce_odr hidden i32* @_ZTWN1VIcE1mE() {{#[0-9]+}} comdat {
+// LINUX_AIX: define linkonce_odr hidden i32* @_ZTWN1VIcE1mE() {{#[0-9]+}}{{( comdat)?}} {
 // LINUX: br i1 icmp ne (void ()* @_ZTHN1VIcE1mE,
-// LINUX: call void @_ZTHN1VIcE1mE()
-// LINUX: ret i32* @_ZN1VIcE1mE
+// AIX-NOT: br i1 icmp ne (void ()* @_ZTHN1VIcE1mE
+// LINUX_AIX: call void @_ZTHN1VIcE1mE()
+// LINUX_AIX: ret i32* @_ZN1VIcE1mE
 
 // DARWIN: declare cxx_fast_tlscc i32* @_ZTWN1WIcE1mE()
-// LINUX: define linkonce_odr hidden i32* @_ZTWN1WIcE1mE() {{#[0-9]+}} comdat {
+// LINUX_AIX: define linkonce_odr hidden i32* @_ZTWN1WIcE1mE() {{#[0-9]+}}{{( comdat)?}} {
 // LINUX: br i1 icmp ne (void ()* @_ZTHN1WIcE1mE,
-// LINUX: call void @_ZTHN1WIcE1mE()
-// LINUX: ret i32* @_ZN1WIcE1mE
+// AIX-NOT: br i1 icmp ne (void ()* @_ZTHN1WIcE1mE,
+// LINUX_AIX: call void @_ZTHN1WIcE1mE()
+// LINUX_AIX: ret i32* @_ZN1WIcE1mE
 
 // DARWIN: declare cxx_fast_tlscc {{.*}}* @_ZTWN1XIcE1mE()
-// LINUX: define linkonce_odr hidden {{.*}}* @_ZTWN1XIcE1mE() {{#[0-9]+}} comdat {
+// LINUX_AIX: define linkonce_odr hidden {{.*}}* @_ZTWN1XIcE1mE() {{#[0-9]+}}{{( comdat)?}} {
 // LINUX: br i1 icmp ne (void ()* @_ZTHN1XIcE1mE,
-// LINUX: call void @_ZTHN1XIcE1mE()
-// LINUX: ret {{.*}}* @_ZN1XIcE1mE
+// AIX-NOT: br i1 icmp ne (void ()* @_ZTHN1XIcE1mE,
+// LINUX_AIX: call void @_ZTHN1XIcE1mE()
+// LINUX_AIX: ret {{.*}}* @_ZN1XIcE1mE
 
 struct S { S(); ~S(); };
 struct T { ~T(); };
 
 // CHECK-LABEL: define{{.*}} void @_Z8tls_dtorv()
 void tls_dtor() {
   // CHECK: load i8, i8* @_ZGVZ8tls_dtorvE1s
   // CHECK: call void @_ZN1SC1Ev(%struct.S* {{[^,]*}} @_ZZ8tls_dtorvE1s)
   // LINUX: call i32 @__cxa_thread_atexit({{.*}}@_ZN1SD1Ev {{.*}} @_ZZ8tls_dtorvE1s{{.*}} @__dso_handle
+  // AIX: call i32 (i32, i32 (i32, ...)*, ...) @__pt_atexit_np(i32 0, {{.*}}@__dtor__ZZ8tls_dtorvE1s){{.*}}
   // DARWIN: call i32 @_tlv_atexit({{.*}}@_ZN1SD1Ev {{.*}} @_ZZ8tls_dtorvE1s{{.*}} @__dso_handle
   // CHECK: store i8 1, i8* @_ZGVZ8tls_dtorvE1s
   static thread_local S s;
 
   // CHECK: load i8, i8* @_ZGVZ8tls_dtorvE1t
   // CHECK-NOT: _ZN1T
   // LINUX: call i32 @__cxa_thread_atexit({{.*}}@_ZN1TD1Ev {{.*}}@_ZZ8tls_dtorvE1t{{.*}} @__dso_handle
+  // AIX: call i32 (i32, i32 (i32, ...)*, ...) @__pt_atexit_np(i32 0, {{.*}}@__dtor__ZZ8tls_dtorvE1t){{.*}}
   // DARWIN: call i32 @_tlv_atexit({{.*}}@_ZN1TD1Ev {{.*}}@_ZZ8tls_dtorvE1t{{.*}} @__dso_handle
   // CHECK: store i8 1, i8* @_ZGVZ8tls_dtorvE1t
   static thread_local T t;
 
   // CHECK: load i8, i8* @_ZGVZ8tls_dtorvE1u
   // CHECK: call void @_ZN1SC1Ev(%struct.S* {{[^,]*}} @_ZGRZ8tls_dtorvE1u_)
   // LINUX: call i32 @__cxa_thread_atexit({{.*}}@_ZN1SD1Ev {{.*}} @_ZGRZ8tls_dtorvE1u_{{.*}} @__dso_handle
+  // AIX: call i32 (i32, i32 (i32, ...)*, ...) @__pt_atexit_np(i32 0, {{.*}}__dtor__ZZ8tls_dtorvE1u){{.*}}
   // DARWIN: call i32 @_tlv_atexit({{.*}}@_ZN1SD1Ev {{.*}} @_ZGRZ8tls_dtorvE1u_{{.*}} @__dso_handle
   // CHECK: store i8 1, i8* @_ZGVZ8tls_dtorvE1u
   static thread_local const S &u = S();
 }
 
 // CHECK: define {{.*}} @_Z7PR15991v(
 int PR15991() {
   thread_local int n;
   auto l = [] { return n; };
   return l();
 }
 
 struct PR19254 {
   static thread_local int n;
   int f();
 };
 // CHECK: define {{.*}} @_ZN7PR192541fEv(
 int PR19254::f() {
-  // LINUX: call void @_ZTHN7PR192541nE(
+  // LINUX_AIX: call void @_ZTHN7PR192541nE(
   // DARWIN: call cxx_fast_tlscc i32* @_ZTWN7PR192541nE(
   return this->n;
 }
 
 namespace {
 thread_local int anon_i{f()};
 }
 void set_anon_i() {
   anon_i = 2;
 }
-// LINUX-LABEL: define internal i32* @_ZTWN12_GLOBAL__N_16anon_iE()
+// LINUX_AIX-LABEL: define internal i32* @_ZTWN12_GLOBAL__N_16anon_iE()
 // DARWIN-LABEL: define internal cxx_fast_tlscc i32* @_ZTWN12_GLOBAL__N_16anon_iE()
 
-// LINUX: define internal void @[[V_M_INIT]]()
+// LINUX_AIX: define internal void @[[V_M_INIT]]()
 // DARWIN: define internal cxx_fast_tlscc void @[[V_M_INIT]]()
 // LINUX-SAME: comdat($_ZN1VIiE1mE)
 // DARWIN-NOT: comdat
 // CHECK: load i8, i8* bitcast (i64* @_ZGVN1VIiE1mE to i8*)
 // CHECK: %[[V_M_INITIALIZED:.*]] = icmp eq i8 %{{.*}}, 0
 // CHECK: br i1 %[[V_M_INITIALIZED]],
 // need init:
-// CHECK: call i32 @_Z1gv()
+// CHECK: call{{.*}} i32 @_Z1gv()
 // CHECK: store i32 %{{.*}}, i32* @_ZN1VIiE1mE, align 4
 // CHECK: store i8 1, i8* bitcast (i64* @_ZGVN1VIiE1mE to i8*)
 // CHECK: br label
 
-// LINUX: define internal void @[[X_M_INIT]]()
+// LINUX_AIX: define internal void @[[X_M_INIT]]()
 // DARWIN: define internal cxx_fast_tlscc void @[[X_M_INIT]]()
 // LINUX-SAME: comdat($_ZN1XIiE1mE)
 // DARWIN-NOT: comdat
 // CHECK: load i8, i8* bitcast (i64* @_ZGVN1XIiE1mE to i8*)
 // CHECK: %[[X_M_INITIALIZED:.*]] = icmp eq i8 %{{.*}}, 0
 // CHECK: br i1 %[[X_M_INITIALIZED]],
 // need init:
 // LINUX: call {{.*}}__cxa_thread_atexit
+// AIX: call {{.*}}__pt_atexit_np
 // DARWIN: call {{.*}}_tlv_atexit
 // CHECK: store i8 1, i8* bitcast (i64* @_ZGVN1XIiE1mE to i8*)
 // CHECK: br label
 
 // CHECK: define {{.*}}@[[GLOBAL_INIT:.*]]()
 // CHECK: call void @[[C_INIT]]()
 // CHECK: call void @[[E_INIT]]()
 

 // CHECK: call void @[[A_INIT]]()
 // CHECK-NOT: call void @[[V_M_INIT]]()
 // CHECK: call void @[[D_INIT]]()
 // CHECK-NOT: call void @[[V_M_INIT]]()
 // CHECK: call void @[[U_M_INIT]]()
 // CHECK-NOT: call void @[[V_M_INIT]]()
 
 
-// LINUX: define weak_odr hidden i32* @_ZTW1a()
+// LINUX_AIX: define weak_odr hidden i32* @_ZTW1a()
 // DARWIN: define cxx_fast_tlscc i32* @_ZTW1a()
-// LINUX:   call void @_ZTH1a()
+// LINUX_AIX:   call void @_ZTH1a()
 // DARWIN: call cxx_fast_tlscc void @_ZTH1a()
 // CHECK:   ret i32* @a
 // CHECK: }
 
 
 // Should not emit a thread wrapper for internal-linkage unused variable 'd'.
 // We separately check that 'd' does in fact get initialized with the other
 // thread-local variables in this TU.
 // CHECK-NOT: define {{.*}} @_ZTWL1d()
 
-// LINUX-LABEL: define weak_odr hidden i32* @_ZTWN1U1mE()
+// LINUX_AIX-LABEL: define weak_odr hidden i32* @_ZTWN1U1mE()
 // DARWIN-LABEL: define cxx_fast_tlscc i32* @_ZTWN1U1mE()
-// LINUX: call void @_ZTHN1U1mE()
+// LINUX_AIX: call void @_ZTHN1U1mE()
 // DARWIN: call cxx_fast_tlscc void @_ZTHN1U1mE()
 // CHECK: ret i32* @_ZN1U1mE
 
-// LINUX: declare extern_weak void @_ZTH1b() [[ATTR:#[0-9]+]]
+// LINUX_AIX: declare extern_weak void @_ZTH1b() [[ATTR:#[0-9]+]]
 
-// LINUX: attributes [[ATTR]] = { {{.+}} }
+// AIX: define void @_ZTHN1WIiE1mE(){{.*}} {
+// AIX-NEXT: ret void
+// AIX-NEXT: }
+// CHECK-NOT: @_ZTHN1WIfE1mE =
+// AIX: define void @_ZTHN1WIfE1mE(){{.*}} {
+// AIX-NEXT: ret void
+// AIX-NEXT: }
+
+// LINUX_AIX: attributes [[ATTR]] = { {{.+}} }