[AIX][TLS] Generate TLS variables in assembly files

[NeHuang]

Summary

This patch allows generating TLS variables in assembly files on AIX.
Initialized and external uninitialized variables are generated with the
.csect pseudo-op and local uninitialized variables are generated with
the .comm/.lcomm pseudo-ops. The patch also adds a check to
explicitly say that TLS is not yet supported on AIX.

[bsaleil]

Add support for variables with internal linkage.

[jasonliu]

LGTM with minor nit.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2171

nit: reformat as the suggestion.

llvm/lib/MC/MCSectionXCOFF.cpp

41

nit:

[amyk]

llvm/lib/MC/MCSectionXCOFF.cpp

41

Would it be helpful to mention in the comment that the initialized data are generated with the .csect pseudo-op?

[daltenty]

llvm/test/CodeGen/PowerPC/aix-tls-variables.ll

15

nit: technically we emit into separate csects. not XCOFF sections.

16

same as above

[daltenty]

llvm/test/CodeGen/PowerPC/aix-tls-variables.ll

22

It's out of scope for this patch, but there is definitely a delta here between how we emit thread-local (to .tbss) and non-thread local uninitialized data (i.e. to regular data section instead of bss) beyond just the thread-local part. Not sure if that's something we should address.

[daltenty]

LGTM, with minor nit

[daltenty]

llvm/test/CodeGen/PowerPC/aix-tls-variables.ll

22

As a follow on, as discussed offline, using common for uninitialized data may have linkage considerations. We should consider if this applies to .tbss data as well before using .comm directives.

[bsaleil]

Generate uninitialized external TLS data with the .csect directive instead of .comm

[sfertile]

LGTM. Please wait until David has given it the OK too though.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2164

Maybe if you add a comment before : XCOFF::XMC_UL; clang-format will end up keeping a similar layout to what you already have. If not we should follow clang-format even though its inferior in this instance 😦 .

[daltenty]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2068

!GV->hasExternalLinkage() doesn't actually imply the symbol is local, we probably want something more like isLocalLinkage()

We should add some testcases for other non-local linkages like weak.

[NeHuang]

@daltenty As per discussion offline

• Update the code to check isLocalLinkage
• More test coverage for weak linkage and update test case
• clangformat the patch

[daltenty]

llvm/test/CodeGen/PowerPC/aix-tls-variables.ll

54

We're missing the csect directives here

123

Was this supposed to be initialized?

[NeHuang]

• Fix the missing directives printing for weak linkage.
• Update the test case accordingly.

[NeHuang]

llvm/test/CodeGen/PowerPC/aix-tls-variables.ll

123

Yes, updated.

[lei]

llvm/test/CodeGen/PowerPC/aix-tls-variables.ll

112

it would be easier to verify these checks if they were placed right before the declaration of the variable they are checking. Similar to what is done when we write checks for multiple functions.

[daltenty]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2163

Remove the second sentence here. Where other things get mapped depends on data-sections and other factors that aren't relevant to this block.

2165

I'm thinking this condition is important enough for us to provide a convince function. Something like isEligibleForCommonCsect and use it in the other three places where this exact condition should appear.

llvm/lib/MC/MCObjectFileInfo.cpp

886

We should initialize and use the TLSBSSSection where appropriate.

llvm/test/CodeGen/PowerPC/aix-tls-variables.ll

53

Should probably be UL, since this is uninitialized

[daltenty]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2227

We should have another case for Kind.isThreadBSS, where we should probably use either a csect with XMC_UL or TLSBSSSection depending on TM.getDataSections()

[NeHuang]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2227

Agree, we should add the coverage for non-initialized cases using Kind.isThreadBSS()
Should we use Kind.isThreadData() check instead of Kind.isThreadLocal() for the initialized cases?

llvm/lib/MC/MCSectionXCOFF.cpp

71

We would also need isEligibleForCommonCsect check to be aligned here.

83

We need to cover the other TLS scenario here which is not eligible for commonCsect - to print CsectDirective.

llvm/test/CodeGen/PowerPC/aix-tls-variables.ll

112

Sure. Will also alternate the test cases as below
non-tls variable
tls variable
...
...

[NeHuang]

Rebased the patch to be aligned with interface change of function getXCOFFSection

[NeHuang]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2068

Update the comments to explain all the scenarios.

2075

check if "GV->hasInternalLinkage()" and "GVKind.isThreadBSS() && GlobalValue::isLocalLinkage(GV->getLinkage())" are equivalent

[daltenty]

LGTM with minor comment and naming fixes

llvm/test/CodeGen/PowerPC/aix-tls-variables-ppc32.ll

23 ↗

(On Diff #327424)

As discussed offline, we should rename these from TL/UL to something a bit more descriptive

[daltenty]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2236

As we recently found out XCOFF::XMC_UL implies XCOFF::XTY_CM in the assembler.

Since we may have external linkage symbols inside this section, we cannot use XCOFF::XTY_CM, so we must use XMC_TL here.

2239

Same as earlier, we cannot emit this to TLSBSSSection. Any external linkage symbols inside it will make the assembler unhappy.

llvm/lib/MC/MCObjectFileInfo.cpp

887

Based on testing XMC_UL implies XMC_CM so this isn't actually a legal combination. We should probably add an assert to that extent in a follow on patch.

Also, we can't actually use this section as is in this patch anymore, so I suggest we leave out the initialization and move it to a follow on patch.

[NeHuang]

llvm/lib/MC/MCSectionXCOFF.cpp

41

here should be initialized TLS data

[NeHuang]

Addressed the review comments to

• Fix the storaging map class for zero-initialized TLS data with external/weak linkage and update the test cases.
• Renaming the test cases with proper description (zero-initialized, val-initialized and uninitialized
• Add more comments for the implementation and correct some minors.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

if (GO->isDeclarationForLinker())
           ->getQualNameSymbol();
 
     SectionKind GOKind = getKindForGlobal(GO, TM);
     if (GOKind.isText())
       return cast<MCSectionXCOFF>(
                  getSectionForFunctionDescriptor(cast<Function>(GO), TM))
           ->getQualNameSymbol();
     if ((TM.getDataSections() && !GO->hasSection()) || GOKind.isCommon() ||
-        GOKind.isBSSLocal())
+        GOKind.isBSSLocal() ||
+        (GOKind.isThreadBSS() && !GO->hasExternalLinkage()))
       return cast<MCSectionXCOFF>(SectionForGlobal(GO, GOKind, TM))
           ->getQualNameSymbol();
   }
 
   // For all other cases, fall back to getSymbol to return the unqualified name.
   return nullptr;
 }
 
return getContext().getXCOFFSection(
       Name, isa<Function>(GO) ? XCOFF::XMC_DS : XCOFF::XMC_UA, XCOFF::XTY_ER,
       SectionKind::getMetadata());
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::SelectSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
   // Common symbols go into a csect with matching name which will get mapped
   // into the .bss section.
-  if (Kind.isBSSLocal() || Kind.isCommon()) {
+  // Uninitialized local TLS symbols go into a csect with matching name which
+  // will get mapped into the .tbss section. Uninitialized external symbols are
+  // generated into the .tdata section.
+  if (Kind.isBSSLocal() || Kind.isCommon() ||
+      (Kind.isThreadBSS() && !GO->hasExternalLinkage())) {
     SmallString<128> Name;
     getNameWithPrefix(Name, GO, TM);
-    return getContext().getXCOFFSection(
-        Name, Kind.isBSSLocal() ? XCOFF::XMC_BS : XCOFF::XMC_RW, XCOFF::XTY_CM,
-        Kind);
+    XCOFF::StorageMappingClass SMC = Kind.isBSSLocal() ? XCOFF::XMC_BS
+                                     : Kind.isCommon() ? XCOFF::XMC_RW
+                                                       : XCOFF::XMC_UL;
+    return getContext().getXCOFFSection(Name, SMC, XCOFF::XTY_CM, Kind);
   }
 
   if (Kind.isMergeableCString()) {
     Align Alignment = GO->getParent()->getDataLayout().getPreferredAlign(
         cast<GlobalVariable>(GO));
 
     unsigned EntrySize = getEntrySizeForKind(Kind);
     std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
if (TM.getDataSections()) {
       SmallString<128> Name;
       getNameWithPrefix(Name, GO, TM);
       return getContext().getXCOFFSection(Name, XCOFF::XMC_RO, XCOFF::XTY_SD,
                                           SectionKind::getReadOnly());
     }
     return ReadOnlySection;
   }
 
+  if (Kind.isThreadLocal()) {
+    // If data sections are enabled, we emit thread data into separate sections.
+    // Otherwise, we emit thread data into the .tdata section.
+    if (TM.getDataSections()) {
+      SmallString<128> Name;
+      getNameWithPrefix(Name, GO, TM);
+      return getContext().getXCOFFSection(Name, XCOFF::XMC_TL, XCOFF::XTY_SD,
+                                          SectionKind::getThreadData());
+    }
+    return TLSDataSection;
+  }
+
   report_fatal_error("XCOFF other section types not yet implemented.");
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForJumpTable(
     const Function &F, const TargetMachine &TM) const {
   assert (!F.getComdat() && "Comdat not supported on XCOFF.");
 
   if (!TM.getFunctionSections())
     return ReadOnlySection;

llvm/lib/MC/MCObjectFileInfo.cpp

void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
   DataSection = Ctx->getXCOFFSection(
       ".data", XCOFF::StorageMappingClass::XMC_RW, XCOFF::XTY_SD,
       SectionKind::getData(), /* MultiSymbolsAllowed*/ true);
 
   ReadOnlySection = Ctx->getXCOFFSection(
       ".rodata", XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD,
       SectionKind::getReadOnly(), /* MultiSymbolsAllowed*/ true);
 
+  TLSDataSection = Ctx->getXCOFFSection(
+      ".tdata", XCOFF::StorageMappingClass::XMC_TL, XCOFF::XTY_SD,
+      SectionKind::getThreadData(), /* MultiSymbolsAllowed*/ true);
+
   TOCBaseSection =
       Ctx->getXCOFFSection("TOC", XCOFF::StorageMappingClass::XMC_TC0,
                            XCOFF::XTY_SD, SectionKind::getData());
 
   // The TOC-base always has 0 size, but 4 byte alignment.
   TOCBaseSection->setAlignment(Align(4));
 
   LSDASection = Ctx->getXCOFFSection(".gcc_except_table",
                                      XCOFF::StorageMappingClass::XMC_RO,

llvm/lib/MC/MCSectionXCOFF.cpp

void MCSectionXCOFF::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
 
   if (getKind().isReadOnly()) {
     if (getMappingClass() != XCOFF::XMC_RO)
       report_fatal_error("Unhandled storage-mapping class for .rodata csect.");
     printCsectDirective(OS);
     return;
   }
 
+  // Initialized and external uninitialized TLS data.
+  if (getKind().isThreadData()) {
+    // We only expect XMC_TL here because XMC_UL is for uninitialized TLS
+    // data only.
+    if (getMappingClass() != XCOFF::XMC_TL)
+      report_fatal_error("Unhandled storage-mapping class for .tdata csect.");
+    printCsectDirective(OS);
+    return;
+  }
+
   if (getKind().isData()) {
     switch (getMappingClass()) {
     case XCOFF::XMC_RW:
     case XCOFF::XMC_DS:
       printCsectDirective(OS);
       break;
     case XCOFF::XMC_TC:
     case XCOFF::XMC_TE:
       break;
     case XCOFF::XMC_TC0:
       OS << "\t.toc\n";
       break;
     default:
       report_fatal_error(
           "Unhandled storage-mapping class for .data csect.");
     }
     return;
   }
 
-  if (getKind().isBSSLocal() || getKind().isCommon()) {
+  if (getKind().isBSSLocal() || getKind().isCommon() ||
+      getKind().isThreadBSS()) { // Local uninitialized TLS data.
     assert((getMappingClass() == XCOFF::XMC_RW ||
-            getMappingClass() == XCOFF::XMC_BS) &&
+            getMappingClass() == XCOFF::XMC_BS ||
+            getMappingClass() == XCOFF::XMC_UL) &&
            "Generated a storage-mapping class for a common/bss csect we don't "
            "understand how to switch to.");
     assert(getCSectType() == XCOFF::XTY_CM &&
            "wrong csect type for .bss csect");
-    // Don't have to print a directive for switching to section for commons.
-    // '.comm' and '.lcomm' directives for the variable will create the needed
-    // csect.
+    // Don't have to print a directive for switching to section for commons and
+    // uninitialized TLS data. '.comm' and '.lcomm' directives for the variable
+    // will create the needed csect.
     return;
   }
 
   report_fatal_error("Printing for this SectionKind is unimplemented.");
 }
 
 bool MCSectionXCOFF::UseCodeAlign() const { return getKind().isText(); }
 
 bool MCSectionXCOFF::isVirtualSection() const { return XCOFF::XTY_CM == Type; }

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

private:
   /// Symbols lowered from ExternalSymbolSDNodes, we will need to emit extern
   /// linkage for them in AIX.
   SmallPtrSet<MCSymbol *, 8> ExtSymSDNodeSymbols;
 
   /// A format indicator and unique trailing identifier to form part of the
   /// sinit/sterm function names.
   std::string FormatIndicatorAndUniqueModId;
 
-  static void ValidateGV(const GlobalVariable *GV);
   // Record a list of GlobalAlias associated with a GlobalObject.
   // This is used for AIX's extra-label-at-definition aliasing strategy.
   DenseMap<const GlobalObject *, SmallVector<const GlobalAlias *, 1>>
       GOAliasMap;
 
   void emitTracebackTable();
 
 public:
if (ExtensionTableFlag & ExtendedTBTableFlag::TB_EH_INFO) {
     OutStreamer->AddComment("EHInfo Table");
     OutStreamer->emitValue(Exp, DL.getPointerSize());
   }
 
 #undef GENBOOLCOMMENT
 #undef GENVALUECOMMENT
 }
 
-void PPCAIXAsmPrinter::ValidateGV(const GlobalVariable *GV) {
-  // Early error checking limiting what is supported.
-  if (GV->isThreadLocal())
-    report_fatal_error("Thread local not yet supported on AIX.");
-
-  if (GV->hasComdat())
-    report_fatal_error("COMDAT not yet supported by AIX.");
-}
-
 static bool isSpecialLLVMGlobalArrayToSkip(const GlobalVariable *GV) {
   return GV->hasAppendingLinkage() &&
          StringSwitch<bool>(GV->getName())
              // TODO: Linker could still eliminate the GV if we just skip
              // handling llvm.used array. Skipping them for now until we or the
              // AIX OS team come up with a good solution.
              .Case("llvm.used", true)
              // It's correct to just skip llvm.compiler.used array here.

 
 void PPCAIXAsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
   // Special LLVM global arrays have been handled at the initialization.
   if (isSpecialLLVMGlobalArrayToSkip(GV) || isSpecialLLVMGlobalArrayForStaticInit(GV))
     return;
 
   assert(!GV->getName().startswith("llvm.") &&
          "Unhandled intrinsic global variable.");
-  ValidateGV(GV);
+
+  if (GV->hasComdat())
+    report_fatal_error("COMDAT not yet supported by AIX.");
 
   MCSymbolXCOFF *GVSym = cast<MCSymbolXCOFF>(getSymbol(GV));
 
   if (GV->isDeclarationForLinker()) {
     emitLinkage(GV, GVSym);
     return;
   }
 
   SectionKind GVKind = getObjFileLowering().getKindForGlobal(GV, TM);
-  if (!GVKind.isGlobalWriteableData() && !GVKind.isReadOnly())
+  if (!GVKind.isGlobalWriteableData() && !GVKind.isReadOnly() &&
+      !GVKind.isThreadLocal()) // Checks for both ThreadData and ThreadBSS.
     report_fatal_error("Encountered a global variable kind that is "
                        "not supported yet.");
 
   MCSectionXCOFF *Csect = cast<MCSectionXCOFF>(
       getObjFileLowering().SectionForGlobal(GV, GVKind, TM));
 
   // Switch to the containing csect.
   OutStreamer->SwitchSection(Csect);
 
   const DataLayout &DL = GV->getParent()->getDataLayout();
 
-  // Handle common symbols.
-  if (GVKind.isCommon() || GVKind.isBSSLocal()) {
+  // Handle common and uninitialized local TLS symbols.
+  if (GVKind.isCommon() || GVKind.isBSSLocal() ||
+      (GVKind.isThreadBSS() && !GV->hasExternalLinkage())) {
     Align Alignment = GV->getAlign().getValueOr(DL.getPreferredAlign(GV));
     uint64_t Size = DL.getTypeAllocSize(GV->getType()->getElementType());
     GVSym->setStorageClass(
         TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GV));
 
-    if (GVKind.isBSSLocal())
+    // For local uninitialized TLS data, we only support internal and common
+    // linkage for now.
+    if (GVKind.isThreadBSS() && !GV->hasInternalLinkage() &&
+        !GV->hasCommonLinkage())
+      report_fatal_error(
+          "Encountered a linkage type that is not supported yet.");
+
+    if (GVKind.isBSSLocal() ||
+        (GVKind.isThreadBSS() && GV->hasInternalLinkage()))
       OutStreamer->emitXCOFFLocalCommonSymbol(
           OutContext.getOrCreateSymbol(GVSym->getSymbolTableName()), Size,
           GVSym, Alignment.value());
     else
       OutStreamer->emitCommonSymbol(GVSym, Size, Alignment.value());
     return;
   }
 

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

SDValue PPCTargetLowering::LowerBlockAddress(SDValue Op,
   getLabelAccessInfo(IsPIC, Subtarget, MOHiFlag, MOLoFlag);
   SDValue TgtBAHi = DAG.getTargetBlockAddress(BA, PtrVT, 0, MOHiFlag);
   SDValue TgtBALo = DAG.getTargetBlockAddress(BA, PtrVT, 0, MOLoFlag);
   return LowerLabelRef(TgtBAHi, TgtBALo, IsPIC, DAG);
 }
 
 SDValue PPCTargetLowering::LowerGlobalTLSAddress(SDValue Op,
                                               SelectionDAG &DAG) const {
+  if (Subtarget.isAIXABI())
+    report_fatal_error("TLS is not yet supported on AIX.");
   // FIXME: TLS addresses currently use medium model code sequences,
   // which is the most useful form.  Eventually support for small and
   // large models could be added if users need it, at the cost of
   // additional complexity.
   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
   if (DAG.getTarget().useEmulatedTLS())
     return LowerToTLSEmulatedModel(GA, DAG);
 

llvm/test/CodeGen/PowerPC/aix-tls-checks.ll

+; RUN: not --crash llc -verify-machineinstrs -mcpu=pwr7 -mattr=-altivec \
+; RUN:   -mtriple powerpc-ibm-aix-xcoff < %s - 2>&1 | FileCheck %s
+; RUN: not --crash llc -verify-machineinstrs -mcpu=pwr7 -mattr=-altivec \
+; RUN:   -mtriple powerpc64-ibm-aix-xcoff < %s - 2>&1 | FileCheck %s
+
+; CHECK: TLS is not yet supported on AIX
+
+@tls1 = thread_local global i32 0, align 4
+
+define i32* @getTls1Addr() {
+entry:
+  ret i32* @tls1
+}

llvm/test/CodeGen/PowerPC/aix-tls-variables.ll

+; This file tests TLS variable generation.
+
+; RUN: llc  -verify-machineinstrs -mcpu=pwr7 -mattr=-altivec -mtriple \
+; RUN:      powerpc-ibm-aix-xcoff < %s | FileCheck %s
+; RUN: llc  -verify-machineinstrs -mcpu=pwr7 -mattr=-altivec -mtriple \
+; RUN:      powerpc64-ibm-aix-xcoff < %s | FileCheck %s
+; RUN: llc  -verify-machineinstrs -mcpu=pwr7 -mattr=-altivec -mtriple \
+; RUN:      powerpc-ibm-aix-xcoff -data-sections=false < %s | FileCheck %s \
+; RUN:      --check-prefix=NODATASEC
+; RUN: llc  -verify-machineinstrs -mcpu=pwr7 -mattr=-altivec -mtriple \
+; RUN:      powerpc64-ibm-aix-xcoff -data-sections=false < %s | FileCheck %s \
+; RUN:      --check-prefix=NODATASEC
+
+; When data-sections is true (default), we emit data into separate sections.
+; When data-sections is false, we emit data into the .data / .tdata sections.
+
+; CHECK: .csect glo1[RW],2
+; CHECK-NEXT: .globl  glo1[RW]
+; CHECK-NEXT: .align  2
+; CHECK-NEXT: .vbyte  4, 1
+; CHECK-NEXT: .csect glo2[RW],2
+; CHECK-NEXT: .globl  glo2[RW]
+; CHECK-NEXT: .align  2
+; CHECK-NEXT: .vbyte  4, 0
+; CHECK-NEXT: .csect glo3[RW],2
+; CHECK-NEXT: .lglobl glo3[RW]
+; CHECK-NEXT: .align  2
+; CHECK-NEXT: .vbyte  4, 2
+; CHECK-NEXT: .lcomm  glo4,4,glo4[BS],2
+; CHECK-NEXT: .comm glo5[RW],4,2
+; CHECK-NEXT: .csect tls1[TL],2
+; CHECK-NEXT: .globl  tls1[TL]
+; CHECK-NEXT: .align  2
+; CHECK-NEXT: .vbyte  4, 1
+; CHECK-NEXT: .csect tls2[TL],2
+; CHECK-NEXT: .globl  tls2[TL]
+; CHECK-NEXT: .align  2
+; CHECK-NEXT: .vbyte  4, 0
+; CHECK-NEXT: .csect tls3[TL],2
+; CHECK-NEXT: .lglobl tls3[TL]
+; CHECK-NEXT: .align  2
+; CHECK-NEXT: .vbyte  4, 2
+; CHECK-NEXT: .lcomm  tls4,4,tls4[UL],2
+; CHECK-NEXT: .comm tls5[UL],4,2
+
+; NODATASEC:  .csect .data[RW],2
+; NODATASEC-NEXT:  .globl glo1
+; NODATASEC-NEXT:  .align 2
+; NODATASEC-NEXT:glo1:
+; NODATASEC-NEXT:  .vbyte 4, 1
+; NODATASEC-NEXT:  .globl glo2
+; NODATASEC-NEXT:  .align 2
+; NODATASEC-NEXT:glo2:
+; NODATASEC-NEXT:  .vbyte 4, 0
+; NODATASEC-NEXT:  .lglobl  glo3
+; NODATASEC-NEXT:  .align 2
+; NODATASEC-NEXT:glo3:
+; NODATASEC-NEXT:  .vbyte 4, 2
+; NODATASEC-NEXT:  .lcomm glo4,4,glo4[BS],2
+; NODATASEC-NEXT:  .comm  glo5[RW],4,2
+; NODATASEC-NEXT:  .csect .tdata[TL],2
+; NODATASEC-NEXT:  .globl tls1
+; NODATASEC-NEXT:  .align 2
+; NODATASEC-NEXT:tls1:
+; NODATASEC-NEXT:  .vbyte 4, 1
+; NODATASEC-NEXT:  .globl tls2
+; NODATASEC-NEXT:  .align 2
+; NODATASEC-NEXT:tls2:
+; NODATASEC-NEXT:  .vbyte 4, 0
+; NODATASEC-NEXT:  .lglobl  tls3
+; NODATASEC-NEXT:  .align 2
+; NODATASEC-NEXT:tls3:
+; NODATASEC-NEXT:  .vbyte 4, 2
+; NODATASEC-NEXT:  .lcomm tls4,4,tls4[UL],2
+; NODATASEC-NEXT:  .comm  tls5[UL],4,2
+
+@glo1 = global i32 1, align 4
+@glo2 = global i32 0, align 4
+@glo3 = internal global i32 2, align 4
+@glo4 = internal global i32 0, align 4
+@glo5 = common global i32 0, align 4
+
+@tls1 = thread_local global i32 1, align 4
+@tls2 = thread_local global i32 0, align 4
+@tls3 = internal thread_local global i32 2, align 4
+@tls4 = internal thread_local global i32 0, align 4
+@tls5 = common thread_local global i32 0, align 4