[AIX] Handling the label alignment of a global variable with its multiple aliases.

[Esme]

Summary

This patch handles the case where a variable has multiple aliases.
AIX's assembly directive .set is not usable for aliasing purpose, and using different labels allows AIX to emulate symbol aliases. If there is data emitted between any two labels, meaning they are not aligned, XCOFF will automatically calculate the offset for them.

This patch implements:

1. Emits the label of the alias just before emitting the value of the sub-element that the alias referred to.

2. A set of aliases that refers to the same offset should be aligned.

3. We didn't emit aliasing labels for common and zero-initialized local symbols in PPCAIXAsmPrinter::emitGlobalVariableHelper, but emitted linkage for them in AsmPrinter::emitGlobalAlias, which caused a FAILURE. This patch fixes the bug by blocking emitting linkage for the alias without a label.

[DiggerLin]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2463

only one line code, do not need { and }

2470

need a test case for the code ?

[Esme]

Addressed @DiggerLin's comments, THX.

[Esme]

Gentle ping.

[shchenz]

llvm/test/CodeGen/PowerPC/aix-alias.ll

87

These two .vbyte seems regression to me. Now we request more space in .data section than needed.

102

Same like above. We don't need this .vbyte?

[Esme]

Addresses comments.

[shchenz]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2379

Maybe we need an assertion if we don't support other cases. Returning 0 quietly will cause mis-compile?

llvm/test/CodeGen/PowerPC/aix-alias-alignment.ll

39 ↗

(On Diff #431856)

This is not right as we allocate other space for var2/var3 which should be aliased to _MergedGlobals. _MergedGlobals has 8 bytes allocated in previous two .vbyte.
You can check the symbol table after assembling the assembly, below is what I get on AIX:

[7]	m   0x00000034     .data     1  extern                    foo
[8]	a4  0x0000000c       0    0     SD       DS    0    0
[9]	m   0x00000040     .data     1  unamex                    L.._MergedGlobals
[10]	a4  0x00000010       0    0     SD       RW    0    0
[11]	m   0x00000048     .data     1  unamex                    var1
[12]	a4  0x00000009       0    0     LD       RW    0    0
[13]	m   0x0000004c     .data     1  unamex                    var2
[14]	a4  0x00000009       0    0     LD       RW    0    0
[15]	m   0x0000004c     .data     1  extern                    var3
[16]	a4  0x00000009       0    0     LD       RW    0    0
[17]	m   0x00000050     .data     1  unamex                    L..base
[18]	a4  0x0000000c       0    0     SD       RW    0    0
[19]	m   0x00000058     .data     1  unamex                    var4
[20]	a4  0x00000011       0    0     LD       RW    0    0
[21]	m   0x00000058     .data     1  extern                    var5
[22]	a4  0x00000011       0    0     LD       RW    0    0
[23]	m   0x0000005c     .data     1  unamex                    TOC
[24]	a4  0x00000000       0    0     SD      TC0    0    0
[25]	m   0x0000005c     .data     1  unamex                    L.._MergedGlobals
[26]	a4  0x00000004       0    0     SD       TC    0    0
[27]	m   0x00000060     .data     1  unamex                    L..base
[28]	a4  0x00000004       0    0     SD       TC    0    0

You can see that section _MergedGlobals now is 16 bytes but it should be 8 bytes and var1 are not aligned with _MergedGlobals too.

I think for data-section enabled, the expected assembly generated from compiler should be like:

assembly
	.csect L.._MergedGlobals[RW],2
	.align	2                               # @_MergedGlobals
var1:
	.vbyte	4, 1                            # 0x1
	.lglobl	var1
var2:
var3:
	.vbyte	4, 2                            # 0x2
	.lglobl	var2
	.globl	var3
	.csect L..base[RW],2
	.align	2                               # @base
	.vbyte	4, 1                            # 0x1
var4:
var5:
	.vbyte	4, 2                            # 0x2
	.lglobl	var4
	.globl	var5

With above assembly, I get:

[9]	m   0x00000040     .data     1  unamex                    L.._MergedGlobals
[10]	a4  0x00000008       0    0     SD       RW    0    0
[11]	m   0x00000040     .data     1  unamex                    var1
[12]	a4  0x00000009       0    0     LD       RW    0    0
[13]	m   0x00000044     .data     1  unamex                    var2
[14]	a4  0x00000009       0    0     LD       RW    0    0
[15]	m   0x00000044     .data     1  extern                    var3
[16]	a4  0x00000009       0    0     LD       RW    0    0
[17]	m   0x00000048     .data     1  unamex                    L..base
[18]	a4  0x00000008       0    0     SD       RW    0    0
[19]	m   0x0000004c     .data     1  unamex                    var4
[20]	a4  0x00000011       0    0     LD       RW    0    0
[21]	m   0x0000004c     .data     1  extern                    var5
[22]	a4  0x00000011       0    0     LD       RW    0    0
[23]	m   0x00000050     .data     1  unamex                    TOC
[24]	a4  0x00000000       0    0     SD      TC0    0    0
[25]	m   0x00000050     .data     1  unamex                    L.._MergedGlobals
[26]	a4  0x00000004       0    0     SD       TC    0    0
[27]	m   0x00000054     .data     1  unamex                    L..base
[28]	a4  0x00000004       0    0     SD       TC    0    0

53 ↗

(On Diff #431856)

For data-section disabled case, the current patch also has .vbyte issue, however, even I changed the assembly like above, I still can not get right symbol table. I changed the assembly like:

        .csect .data[RW],2
        .align  2                               # @_MergedGlobals
L.._MergedGlobals:
var1:
        .vbyte  4, 1                            # 0x1
        .lglobl var1
var2:
var3:
        .vbyte  4, 2                            # 0x2
        .lglobl var2
        .globl  var3
        .align  2                               # @base
L..base:
        .vbyte  4, 1                            # 0x1
var4:
var5:
        .vbyte  4, 2                            # 0x2
        .lglobl var4
        .globl  var5

I get:

[9]	m   0x00000040     .data     1  unamex                    .data
[10]	a4  0x00000010       0    0     SD       RW    0    0
[11]	m   0x00000040     .data     1  unamex                    var1
[12]	a4  0x00000009       0    0     LD       RW    0    0
[13]	m   0x00000044     .data     1  unamex                    var2
[14]	a4  0x00000009       0    0     LD       RW    0    0
[15]	m   0x00000044     .data     1  extern                    var3
[16]	a4  0x00000009       0    0     LD       RW    0    0
[17]	m   0x0000004c     .data     1  unamex                    var4
[18]	a4  0x00000009       0    0     LD       RW    0    0
[19]	m   0x0000004c     .data     1  extern                    var5
[20]	a4  0x00000009       0    0     LD       RW    0    0
[21]	m   0x00000050     .data     1  unamex                    TOC
[22]	a4  0x00000000       0    0     SD      TC0    0    0
[23]	m   0x00000050     .data     1  unamex                    L.._MergedGlobals
[24]	a4  0x00000004       0    0     SD       TC    0    0
[25]	m   0x00000054     .data     1  unamex                    L..base
[26]	a4  0x00000004       0    0     SD       TC    0    0

You can see that, no way to change the content in .data section for var1/var2/var3, we only have TOC entry for L.._MergedGlobals but not associated to any SD/LD symbol in the .data section. If we want to support them, we may need to add TOC entry for var1/var2/var3/var4/var5 or find a way to make assembler generate two LD symbols to same location.

I suggest in this patch, we only handle data-sections enabled case.

[Esme]

llvm/test/CodeGen/PowerPC/aix-alias-alignment.ll

39 ↗

(On Diff #431856)

Thank you for your comments!
I doubt that AIX's assembly format can support such strict alignment requirements.
As you suggest, element values in a base AliaseeObject are not emitted under its label but its aliases' labels, which would solve the problem in my test case, but consider the following case, where should the third element value (.vbyte 4, 3) be emitted?

;; base has three elements and only the second one has alias.
@base = global <{ i32, i32, i32 }> <{ i32 1, i32 2, i32 3 }>, align 4
@var1 = internal alias i32, getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @base, i32 0, i32 1)
@var2 = alias i32, i32* @var1

Consider a more complex example:

base has 4 elements:  { i32 1, i32 2, i32 3, i32 4 }, align 4
var1 is the alias to {i32 1, i32 2}
var2 is the alias to {i32 2, i32 3}

I have no idea what the assembly of this case should be in order to meet the correct values and alignment.

53 ↗

(On Diff #431856)

The missing linkage info caused the issue, ie. the directive .globl is not emitted for private global variables. I'm not sure whether the behavior is reasonable. However, it's out of this patch's scope and I'll investigate it as follow-up work.
Using @_MergedGlobals = global <{ i32, i32 }> <{ i32 1, i32 2 }>, align 4 emits the directive .globl _MergedGlobals, which fixed the problem.

[Esme]

Thank you for your comments. @shchenz
I had a misunderstanding about the behavior of label alignment on AIX.
Please ignore my previous replies. I've addressed your comments in this update.

1. Emit the label of the alias just before emitting the value of the sub-element that the alias referred to.
2. Emit the linkage of alias together with the global variable‘s, that is, before labels and values, although there is no impact on the functionality I think this is more appropriate.
3. Remove the test case that is unnecessary for the current patch.
4. Check the symbol table after assembling the assembly to verify no space allocation regression.

[shchenz]

Thanks. The assembly for PowerPC part looks right now. I have some more comments about the array and vector types.

llvm/include/llvm/CodeGen/AsmPrinter.h

478 ↗

(On Diff #439176)

Nit: do we need to doc this comment? If so, you may need /// instead of //

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2369

Nit: we may need another fatal_error if the second operand is not a constant integer expression.

[shchenz]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

3247

No idea why my comments here is lost in my last post. I will re-post it.

I tested some array and vector cases, I think current patch may not be able to handle them well on AIX. Could you please verify? As you are also handling array here, so do we plan to fix them all? Or we just want to fix ConstantStruct type?

case 1: vector type, ConstantDataSequential

@_MergedGlobals = global <2 x i64> <i64 12, i64 34>, align 4
@var1 = alias i64, getelementptr inbounds (<2 x i64>, <2 x i64>* @_MergedGlobals, i32 0, i32 1)

define void @foo(i64 %a1) {
  store i64 %a1, i64* getelementptr inbounds (<2 x i64>, <2 x i64>* @_MergedGlobals, i32 0, i32 1), align 4
  ret void
}

case 2: array type, ConstantDataSequential:

@_MergedGlobals = global [2 x i64] [i64 12, i64 34], align 4
@var1 = alias i64, getelementptr inbounds ([2 x i64], [2 x i64]* @_MergedGlobals, i32 0, i32 1)

define void @foo(i64 %a1) {
  store i64 %a1, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @_MergedGlobals, i32 0, i32 1), align 4
  ret void
}

case 3: array type, ConstantArray:

%struct.B = type { i64 }
@_MergedGlobals = global [2 x %struct.B] [%struct.B {i64 12}, %struct.B {i64 34}], align 4
@var1 = alias %struct.B, getelementptr inbounds ([2 x %struct.B], [2 x %struct.B]* @_MergedGlobals, i32 0, i32 0)

define void @foo(%struct.B %a1) {
  store %struct.B %a1, %struct.B* getelementptr inbounds ([2 x %struct.B], [2 x %struct.B]* @_MergedGlobals, i32 0, i32 1), align 4
  ret void
}

[Esme]

Addressed comments.

[Esme]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

3247

Thanks for pointing this out!
I have added support for these types in the new revision.

[shchenz]

LGTM. Thanks for patience and this good improvement.

[efriedma]

After reading this patch, I'm confused about how it's supposed to work in general. In particular, what happens if we never call emitGlobalAliasInline() with the correct offset? Do we just throw away the symbol?

[shchenz]

After reading this patch, I'm confused about how it's supposed to work in general. In particular, what happens if we never call emitGlobalAliasInline() with the correct offset? Do we just throw away the symbol?

If there is a alias symbol which has an offset can not be recognized by this patch, I think a fatal error will be emitted. See PPCAIXAsmPrinter::getAliasOffset(). @Esme could you confirm that?

[Esme]

In D124654#3634386, @shchenz wrote:

After reading this patch, I'm confused about how it's supposed to work in general. In particular, what happens if we never call emitGlobalAliasInline() with the correct offset? Do we just throw away the symbol?

If there is a alias symbol which has an offset can not be recognized by this patch, I think a fatal error will be emitted. See PPCAIXAsmPrinter::getAliasOffset(). @Esme could you confirm that?

Yes, @shchenz is right. In this patch, we emit the alias label before the sub-element value only if they have the same offset. In general, if the alias's offset doesn't match to any sub-element's offset, we will not emit the label for that alias symbol since we don't know where to emit it. So we must guarantee the offset is valid when we get it in PPCAIXAsmPrinter::getAliasOffset().

[efriedma]

I don't think that addresses my concern. I'm specifically concerned about cases like the following:

@ConstVector1 = global <2 x i64> zeroinitializer
@var1 = alias i64, getelementptr inbounds (<2 x i64>, ptr @ConstVector1, i32 0, i32 1)

@ConstVector2 = global <2 x i64> <i64 1, i64 2>
@var2 = alias i64, getelementptr inbounds (i8, ptr @ConstVector2, i32 1)

Currently, we silently throw away the definitions of "var1" and "var2".

[Esme]

In D124654#3636463, @efriedma wrote:

I don't think that addresses my concern. I'm specifically concerned about cases like the following:

@ConstVector1 = global <2 x i64> zeroinitializer
@var1 = alias i64, getelementptr inbounds (<2 x i64>, ptr @ConstVector1, i32 0, i32 1)

@ConstVector2 = global <2 x i64> <i64 1, i64 2>
@var2 = alias i64, getelementptr inbounds (i8, ptr @ConstVector2, i32 1)

Currently, we silently throw away the definitions of "var1" and "var2".

Thanks, this is a really interesting case!
Targets like ppc64le-linux express such case with an expression like .set var2, ConstVector2+1.
However AIX doesn't support the .set directive.
I need to do some investigation into how the AIX assembly expresses the case where the alias offset doesn't refer to any sub-element.

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

void AsmPrinter::emitGlobalAlias(Module &M, const GlobalAlias &GA) {
 
   // AIX's assembly directive `.set` is not usable for aliasing purpose,
   // so AIX has to use the extra-label-at-definition strategy. At this
   // point, all the extra label is emitted, we just have to emit linkage for
   // those labels.
   if (TM.getTargetTriple().isOSBinFormatXCOFF()) {
     assert(MAI->hasVisibilityOnlyWithLinkage() &&
            "Visibility should be handled with emitLinkage() on AIX.");
+    // Linkage for alias of global variable has been emitted.
+    if (isa<GlobalVariable>(GA.getAliaseeObject()))
+      return;
     emitLinkage(&GA, Name);
     // If it's a function, also emit linkage for aliases of function entry
     // point.
     if (IsFunction)
       emitLinkage(&GA,
                   getObjFileLowering().getFunctionEntryPointSymbol(&GA, TM));
     return;
   }
if (isa<ConstantPointerNull>(CV)) {
     AP.OutStreamer->emitIntValue(0, Size);
     return;
   }
 
   if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(CV))
     return emitGlobalConstantDataSequential(DL, CDS, AP);
 
   if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV))
     return emitGlobalConstantArray(DL, CVA, AP, BaseCV, Offset);
 
   if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))
     return emitGlobalConstantStruct(DL, CVS, AP, BaseCV, Offset);
 
   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
     // Look through bitcasts, which might not be able to be MCExpr'ized (e.g. of
     // vectors).
     if (CE->getOpcode() == Instruction::BitCast)

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

private:
 
   uint16_t getNumberOfVRSaved();
   void emitTracebackTable();
 
   SmallVector<const GlobalVariable *, 8> TOCDataGlobalVars;
 
   void emitGlobalVariableHelper(const GlobalVariable *);
 
+  // Get the offset of an alias based on its AliaseeObject.
+  uint64_t getAliasOffset(const Constant *C);
+
 public:
   PPCAIXAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer)
       : PPCAsmPrinter(TM, std::move(Streamer)) {
     if (MAI->isLittleEndian())
       report_fatal_error(
           "cannot create AIX PPC Assembly Printer for a little-endian target");
   }
 
if (isSpecialLLVMGlobalArrayToSkip(GV) || isSpecialLLVMGlobalArrayForStaticInit(GV))
     return;
 
   // If the Global Variable has the toc-data attribute, it needs to be emitted
   // when we emit the .toc section.
   if (GV->hasAttribute("toc-data")) {
     TOCDataGlobalVars.push_back(GV);
     return;
   }
 
   emitGlobalVariableHelper(GV);
 }
 
+uint64_t PPCAIXAsmPrinter::getAliasOffset(const Constant *C) {
+  if (auto *GA = dyn_cast<GlobalAlias>(C))
+    return getAliasOffset(GA->getAliasee());
+  if (auto *CE = dyn_cast<ConstantExpr>(C)) {
+    const MCExpr *LowC = lowerConstant(CE);
+    const MCBinaryExpr *CBE = dyn_cast<MCBinaryExpr>(LowC);
+    // Currently only the case of adding an offset is considered.
+    if (!CBE || CBE->getOpcode() != MCBinaryExpr::Add)
+      return 0;
+    if (auto *RHS = dyn_cast<MCConstantExpr>(CBE->getRHS()))
+      return RHS->getValue();
+  }
+  return 0;
+}
+
 void PPCAIXAsmPrinter::emitGlobalVariableHelper(const GlobalVariable *GV) {
   assert(!GV->getName().startswith("llvm.") &&
          "Unhandled intrinsic global variable.");
 
   if (GV->hasComdat())
     report_fatal_error("COMDAT not yet supported by AIX.");
 
   MCSymbolXCOFF *GVSym = cast<MCSymbolXCOFF>(getSymbol(GV));
void PPCAIXAsmPrinter::emitGlobalVariableHelper(const GlobalVariable *GV) {
   }
 
   MCSymbol *EmittedInitSym = GVSym;
   emitLinkage(GV, EmittedInitSym);
   emitAlignment(getGVAlignment(GV, DL), GV);
 
   // When -fdata-sections is enabled, every GlobalVariable will
   // be put into its own csect; therefore, label is not necessary here.
-  if (!TM.getDataSections() || GV->hasSection()) {
+  bool LabelForGV = (!TM.getDataSections() || GV->hasSection());
+  if (LabelForGV)
     OutStreamer->emitLabel(EmittedInitSym);
+
+  // No need to consider label alignment for GlobalVariable and GlobalAlias.
+  if (!LabelForGV || !GOAliasMap[GV].size())
+    emitGlobalConstant(DL, GV->getInitializer());
+
+  // No alias to emit.
+  if (!GOAliasMap[GV].size())
+    return;
+
+  // Aliases with the same offset should be aligned. Record the list of aliases
+  // associated with the offset.
+  DenseMap<uint64_t, SmallVector<const GlobalAlias *, 1>> AliasList;
+  for (const GlobalAlias *GA : GOAliasMap[GV]) {
+    AliasList[getAliasOffset(GA->getAliasee())].push_back(GA);
   }
 
-  // Emit aliasing label for global variable.
-  llvm::for_each(GOAliasMap[GV], [this](const GlobalAlias *Alias) {
-    OutStreamer->emitLabel(getSymbol(Alias));
-  });
+  // Emit the value of GlobalVariable before aliases if it is not aligned with
+  // the first set of aliases.
+  if (LabelForGV && AliasList.begin()->first != 0)
+    emitGlobalConstant(DL, GV->getInitializer());
+
+  for (auto I = AliasList.begin(); I != AliasList.end(); ++I) {
+    std::set<const Constant *> UniqueAliasee;
+    for (const GlobalAlias *GA : I->second) {
+      // Emit label for alias.
+      OutStreamer->emitLabel(getSymbol(GA));
+      UniqueAliasee.insert(GA->getAliasee());
+    }
 
-  emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer());
+    // Emit the value of GlobalVariable.
+    if (LabelForGV && I->first == 0)
+      emitGlobalConstant(DL, GV->getInitializer());
+
+    // Emit value for alias.
+    for (const Constant *Aliasee : UniqueAliasee)
+      emitGlobalConstant(DL, Aliasee);
+
+    // Emit linkage for alias.
+    for (const GlobalAlias *Alias : I->second) {
+      emitLinkage(Alias, getSymbol(Alias));
+    }
+  }
 }
 
 void PPCAIXAsmPrinter::emitFunctionDescriptor() {
   const DataLayout &DL = getDataLayout();
   const unsigned PointerSize = DL.getPointerSizeInBits() == 64 ? 8 : 4;
 
   MCSectionSubPair Current = OutStreamer->getCurrentSection();
   // Emit function descriptor.

llvm/test/CodeGen/PowerPC/aix-alias-merge.ll

+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -data-sections=false < %s | FileCheck --check-prefix=ASM %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 < %s |\
+; RUN:   FileCheck --check-prefix=NOGVLABEL %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -data-sections=false -filetype=obj -o %t.o < %s
+; RUN: llvm-objdump -dr %t.o | FileCheck --check-prefix=OBJ %s
+; RUN: llvm-objdump --syms %t.o | FileCheck --check-prefix=SYM %s
+
+@_MergedGlobals = private global <{ i32, i32 }> <{ i32 1, i32 2 }>, align 4
+@var1 = internal alias i32, getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @_MergedGlobals, i32 0, i32 0)
+@var2 = internal alias i32, getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @_MergedGlobals, i32 0, i32 1)
+@var3 = alias i32, i32* @var2
+
+define void @foo(i32 %a1, i32 %a2) {
+  store i32 %a1, i32* getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @_MergedGlobals, i32 0, i32 0), align 4
+  store i32 %a2, i32* getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @_MergedGlobals, i32 0, i32 1), align 4
+  ret void
+}
+
+; ASM:      # -- End function
+; ASM-NEXT:         .csect .data[RW],2
+; ASM-NEXT:         .align  2  # @_MergedGlobals
+; ASM-NEXT: L.._MergedGlobals:
+; ASM-NEXT: var1:
+; ASM-NEXT:         .vbyte  4, 1  # 0x1
+; ASM-NEXT:         .vbyte  4, 2  # 0x2
+; ASM-NEXT:         .vbyte  4, L.._MergedGlobals
+; ASM-NEXT:         .lglobl var1
+; ASM-NEXT: var2:
+; ASM-NEXT: var3:
+; ASM-NEXT:         .vbyte  4, L.._MergedGlobals+4
+; ASM-NEXT:         .vbyte  4, var2
+; ASM-NEXT:         .lglobl var2
+; ASM-NEXT:         .globl  var3
+; ASM-NEXT:         .toc
+; ASM-NEXT: L..C0:
+; ASM-NEXT:         .tc L.._MergedGlobals[TC],L.._MergedGlobals
+
+; NOGVLABEL:      # -- End function
+; NOGVLABEL-NEXT:         .csect L.._MergedGlobals[RW],2
+; NOGVLABEL-NEXT:         .align  2    # @_MergedGlobals
+; NOGVLABEL-NEXT:         .vbyte  4, 1 # 0x1
+; NOGVLABEL-NEXT:         .vbyte  4, 2 # 0x2
+; NOGVLABEL-NEXT: var1:
+; NOGVLABEL-NEXT:         .vbyte  4, L.._MergedGlobals[RW]
+; NOGVLABEL-NEXT:         .lglobl var1
+; NOGVLABEL-NEXT: var2:
+; NOGVLABEL-NEXT: var3:
+; NOGVLABEL-NEXT:         .vbyte  4, L.._MergedGlobals[RW]+4
+; NOGVLABEL-NEXT:         .vbyte  4, var2
+; NOGVLABEL-NEXT:         .lglobl var2
+; NOGVLABEL-NEXT:         .globl  var3
+; NOGVLABEL-NEXT:         .toc
+; NOGVLABEL-NEXT: L..C0:
+; NOGVLABEL-NEXT:         .tc L.._MergedGlobals[TC],L.._MergedGlobals[RW]
+
+; OBJ:      00000000 <.foo>:
+; OBJ-NEXT:        0: 80 a2 00 00   lwz 5, 0(2)
+; OBJ-NEXT:       00000002:  R_TOC  L.._MergedGlobals
+; OBJ-NEXT:        4: 90 65 00 00   stw 3, 0(5)
+; OBJ-NEXT:        8: 90 85 00 04   stw 4, 4(5)
+
+; SYM:      SYMBOL TABLE:
+; SYM-NEXT: 00000000      df *DEBUG*  00000000 .file
+; SYM-NEXT: 00000000 l       .text  00000029 .text
+; SYM-NEXT: 00000000 g     F .text (csect: .text)   00000000 .foo
+; SYM-NEXT: 0000002c l       .data  00000014 .data
+; SYM-NEXT: 0000002c l     O .data (csect: .data)   00000000 var1
+; SYM-NEXT: 00000038 l     O .data (csect: .data)   00000000 var2
+; SYM-NEXT: 00000038 g     O .data (csect: .data)   00000000 var3
+; SYM-NEXT: 00000040 g     O .data  0000000c foo
+; SYM-NEXT: 0000004c l       .data  00000000 TOC
+; SYM-NEXT: 0000004c l     O .data  00000004 L.._MergedGlobals

llvm/test/CodeGen/PowerPC/aix-alias.ll

 ; ASM:       var:
 ; ASM-NEXT:  var1:
 ; ASM-NEXT:  var2:
 ; ASM-NEXT:  var_l:
 ; ASM-NEXT:  var_i:
 ; ASM-NEXT:  var_h:
 ; ASM-NEXT:  var_p:
 ; ASM-NEXT:    .vbyte  4, 42
-; ASM-NEXT:   .globl array
+; ASM-NEXT:    .vbyte  {{[0-9]+}}, var
+; ASM-NEXT:    .vbyte  {{[0-9]+}}, var1
+; ASM-NEXT:    .globl  var1
+; ASM-NEXT:    .globl  var2
+; ASM-NEXT:    .weak   var_l
+; ASM-NEXT:    .lglobl var_i
+; ASM-NEXT:    .globl  var_h,hidden
+; ASM-NEXT:    .globl  var_p,protected
+; ASM-NEXT:    .globl  array
 ; ASM:       array:
 ; ASM-NEXT:    .vbyte 4, 1 # 0x1
 ; ASM-NEXT:    .vbyte 4, 2 # 0x2
 ; ASM-NEXT:    .globl x
 ; ASM:       x:
 ; ASM-NEXT:  bitcast_alias:
 ; ASM-NEXT:    .vbyte  {{[0-9]+}}, array+4
+; ASM-NEXT:    .vbyte  {{[0-9]+}}, x
+; ASM-NEXT:    .globl  bitcast_alias
 ; ASM-NEXT:    .globl  fun_ptr
 ; ASM:       fun_ptr:
 ; ASM-NEXT:    .vbyte  {{[0-9]+}}, fun_weak
-; ASM-NEXT:    .globl  var1
-; ASM-NEXT:    .globl  var2
-; ASM-NEXT:    .weak var_l
-; ASM-NEXT:    .lglobl var_i
-; ASM-NEXT:    .globl  var_h,hidden
-; ASM-NEXT:    .globl  var_p,protected
-; ASM-NEXT:    .globl bitcast_alias
-; ASM-NEXT:    .weak fun_weak
-; ASM-NEXT:    .weak .fun_weak
+; ASM-NEXT:    .weak   fun_weak
+; ASM-NEXT:    .weak   .fun_weak
 ; ASM-NEXT:    .globl  fun_hidden,hidden
 ; ASM-NEXT:    .globl  .fun_hidden,hidden
 ; ASM-NEXT:    .toc
 ; ASM-NEXT:  L..C0:
 ; ASM-NEXT:    .tc var1[TC],var1
 ; ASM-NEXT:  L..C1:
 ; ASM-NEXT:    .tc var2[TC],var2
 ; ASM-NEXT:  L..C2:
 ; ASM-NEXT:    .tc var_i[TC],var_i
 ; ASM-NEXT:  L..C3:
 ; ASM-NEXT:    .tc fun_weak[TC],fun_weak

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

 ; SECTION-NEXT:   }
 ; SECTION-NEXT:   Section {
 ; SECTION-NEXT:     Index: 2
 ; SECTION-NEXT:     Name: .tdata
 ; SECTION-NEXT:     PhysicalAddress: 0x0
 ; SECTION-NEXT:     VirtualAddress: 0x0
 ; SECTION-NEXT:     Size: 0x30
 ; SECTION-NEXT:     RawDataOffset: 0x90
-; SECTION-NEXT:     RelocationPointer: 0x0
+; SECTION-NEXT:     RelocationPointer: 0xC0
 ; SECTION-NEXT:     LineNumberPointer: 0x0
-; SECTION-NEXT:     NumberOfRelocations: 0
+; SECTION-NEXT:     NumberOfRelocations: 1
 ; SECTION-NEXT:     NumberOfLineNumbers: 0
 ; SECTION-NEXT:     Type: STYP_TDATA (0x400)
 ; SECTION-NEXT:   }
 ; SECTION-NEXT:   Section {
 ; SECTION-NEXT:     Index: 3
 ; SECTION-NEXT:     Name: .tbss
 ; SECTION-NEXT:     PhysicalAddress: 0x30
 ; SECTION-NEXT:     VirtualAddress: 0x30

 ; SYMS:          Name: tls_global_int_external_val_initialized
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x0
 ; SYMS-NEXT:     Section: .tdata
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-DATASECT:        Index: [[#INDX+9]]
-; SYMS-DATASECT-NEXT:   SectionLen: 4
+; SYMS-DATASECT-NEXT:   SectionLen: 8
 ; SYMS-NODATASECT:      Index: [[#INDX+13]]
 ; SYMS-NODATASECT-NEXT: ContainingCsectSymbolIndex: [[#INDX+10]]
 ; SYMS:            ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-DATASECT:        SymbolAlignmentLog2: 2
 ; SYMS-DATASECT-NEXT:   SymbolType: XTY_SD (0x1)
 ; SYMS-NODATASECT:      SymbolAlignmentLog2: 0
 ; SYMS-NODATASECT-NEXT: SymbolType: XTY_LD (0x2)
 ; SYMS:            StorageMappingClass: XMC_TL (0x14)
 ; SYMS-NEXT:       StabInfoIndex: 0x0
 ; SYMS-NEXT:       StabSectNum: 0x0
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-DATASECT:   Index: [[#INDX+10]]
 ; SYMS-NODATASECT: Index: [[#INDX+14]]
 ; SYMS:          Name: tls_global_alias_int_external_val_initialized
-; SYMS-NEXT:     Value (RelocatableAddress): 0x0
-; SYMS-NEXT:     Section: .tdata
+; SYMS-DATASECT:   Value (RelocatableAddress): 0x4
+; SYMS-NODATASECT: Value (RelocatableAddress): 0x0
+; SYMS:          Section: .tdata
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-DATASECT:        Index: [[#INDX+11]]
 ; SYMS-DATASECT-NEXT:   ContainingCsectSymbolIndex: [[#INDX+8]]
 ; SYMS-NODATASECT:      Index: [[#INDX+15]]
 ; SYMS-NODATASECT-NEXT: ContainingCsectSymbolIndex: [[#INDX+10]]
 ; SYMS:            ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
 ; SYMS-NEXT:       SymbolAlignmentLog2: 0
 ; SYMS-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYMS-NEXT:       StorageMappingClass: XMC_TL (0x14)
 ; SYMS-NEXT:       StabInfoIndex: 0x0
 ; SYMS-NEXT:       StabSectNum: 0x0
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-DATASECT:   Index: [[#INDX+12]]
 ; SYMS-NODATASECT: Index: [[#INDX+16]]
 ; SYMS:          Name: tls_global_int_external_zero_initialized
-; SYMS-NEXT:     Value (RelocatableAddress): 0x4
+; SYMS-NEXT:     Value (RelocatableAddress): 0x8
 ; SYMS-NEXT:     Section: .tdata
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-DATASECT:        Index: [[#INDX+13]]
 ; SYMS-DATASECT-NEXT:   SectionLen: 4
 ; SYMS-NODATASECT:      Index: [[#INDX+17]]

 ; SYMS-NEXT:       StabSectNum: 0x0
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-DATASECT:   Index: [[#INDX+14]]
 ; SYMS-NODATASECT: Index: [[#INDX+18]]
 ; SYMS:          Name: tls_global_int_local_val_initialized
-; SYMS-NEXT:     Value (RelocatableAddress): 0x8
+; SYMS-NEXT:     Value (RelocatableAddress): 0xC
 ; SYMS-NEXT:     Section: .tdata
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-DATASECT:        Index: [[#INDX+15]]
 ; SYMS-DATASECT-NEXT:   SectionLen: 4
 ; SYMS-NODATASECT:      Index: [[#INDX+19]]

 ; SYMS-NEXT:       StabSectNum: 0x0
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-DATASECT:   Index: [[#INDX+16]]
 ; SYMS-NODATASECT: Index: [[#INDX+20]]
 ; SYMS:          Name: tls_global_int_weak_zero_initialized
-; SYMS-NEXT:     Value (RelocatableAddress): 0xC
+; SYMS-NEXT:     Value (RelocatableAddress): 0x10
 ; SYMS-NEXT:     Section: .tdata
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-DATASECT:        Index: [[#INDX+17]]
 ; SYMS-DATASECT-NEXT:   SectionLen: 4
 ; SYMS-NODATASECT:      Index: [[#INDX+21]]

 ; SYMS-NEXT:       StabSectNum: 0x0
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS:        Symbol {
 ; SYMS-DATASECT:   Index: [[#INDX+18]]
 ; SYMS-NODATASECT: Index: [[#INDX+22]]
 ; SYMS:          Name: tls_global_int_weak_val_initialized
-; SYMS-NEXT:     Value (RelocatableAddress): 0x10
+; SYMS-NEXT:     Value (RelocatableAddress): 0x14
 ; SYMS-NEXT:     Section: .tdata
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-DATASECT:        Index: [[#INDX+19]]
 ; SYMS-DATASECT-NEXT:   SectionLen: 4
 ; SYMS-NODATASECT:      Index: [[#INDX+23]]

 
 ; OBJDUMP-DATASECT:        Disassembly of section .text:
 ; OBJDUMP-DATASECT-EMPTY:
 ; OBJDUMP-DATASECT-NEXT:   00000000 (idx: 7) const_ivar[RO]:
 ; OBJDUMP-DATASECT-NEXT:   0: 00 00 00 06   <unknown>
 ; OBJDUMP-DATASECT-EMPTY:
 ; OBJDUMP-DATASECT-NEXT:   Disassembly of section .tdata:
 ; OBJDUMP-DATASECT-EMPTY:
-; OBJDUMP-DATASECT-NEXT:   00000000 (idx: 11) tls_global_alias_int_external_val_initialized:
+; OBJDUMP-DATASECT-NEXT:   00000000 (idx: 9) tls_global_int_external_val_initialized[TL]:
 ; OBJDUMP-DATASECT-NEXT:   0: 00 00 00 01   <unknown>
 ; OBJDUMP-DATASECT-EMPTY:
-; OBJDUMP-DATASECT-NEXT:   00000004 (idx: 13) tls_global_int_external_zero_initialized[TL]:
+; OBJDUMP-DATASECT-NEXT:   00000004 (idx: 11) tls_global_alias_int_external_val_initialized:
 ; OBJDUMP-DATASECT-NEXT:   4: 00 00 00 00   <unknown>
 ; OBJDUMP-DATASECT-EMPTY:
-; OBJDUMP-DATASECT-NEXT:   00000008 (idx: 15) tls_global_int_local_val_initialized[TL]:
-; OBJDUMP-DATASECT-NEXT:   8: 00 00 00 02   <unknown>
+; OBJDUMP-DATASECT-NEXT:   00000008 (idx: 13) tls_global_int_external_zero_initialized[TL]:
+; OBJDUMP-DATASECT-NEXT:   8: 00 00 00 00   <unknown>
 ; OBJDUMP-DATASECT-EMPTY:
-; OBJDUMP-DATASECT-NEXT:   0000000c (idx: 17) tls_global_int_weak_zero_initialized[TL]:
-; OBJDUMP-DATASECT-NEXT:   c: 00 00 00 00   <unknown>
+; OBJDUMP-DATASECT-NEXT:   0000000c (idx: 15) tls_global_int_local_val_initialized[TL]:
+; OBJDUMP-DATASECT-NEXT:   c: 00 00 00 02   <unknown>
 ; OBJDUMP-DATASECT-EMPTY:
-; OBJDUMP-DATASECT-NEXT:   00000010 (idx: 19) tls_global_int_weak_val_initialized[TL]:
-; OBJDUMP-DATASECT-NEXT:   10: 00 00 00 01   <unknown>
-; OBJDUMP-DATASECT-NEXT:   14: 00 00 00 00   <unknown>
+; OBJDUMP-DATASECT-NEXT:   00000010 (idx: 17) tls_global_int_weak_zero_initialized[TL]:
+; OBJDUMP-DATASECT-NEXT:   10: 00 00 00 00   <unknown>
+; OBJDUMP-DATASECT-EMPTY:
+; OBJDUMP-DATASECT-NEXT:   00000014 (idx: 19) tls_global_int_weak_val_initialized[TL]:
+; OBJDUMP-DATASECT-NEXT:   14: 00 00 00 01   <unknown>
 ; OBJDUMP-DATASECT-EMPTY:
 ; OBJDUMP-DATASECT-NEXT:   00000018 (idx: 21) tls_global_long_long_internal_val_initialized[TL]:
 ; OBJDUMP-DATASECT-NEXT:   18: 00 00 00 00   <unknown>
 ; OBJDUMP-DATASECT-NEXT:   1c: 00 00 00 01   <unknown>
 ; OBJDUMP-DATASECT-EMPTY:
 ; OBJDUMP-DATASECT-NEXT:   00000020 (idx: 23) tls_global_long_long_weak_val_initialized[TL]:
 ; OBJDUMP-DATASECT-NEXT:   20: 00 00 00 00   <unknown>
 ; OBJDUMP-DATASECT-NEXT:   24: 00 00 00 01   <unknown>

 
 ; OBJDUMP-NODATASECT:       Disassembly of section .text:
 ; OBJDUMP-NODATASECT-EMPTY:
 ; OBJDUMP-NODATASECT-NEXT:  00000000 (idx: 9) const_ivar:
 ; OBJDUMP-NODATASECT-NEXT:  0: 00 00 00 06   <unknown>
 ; OBJDUMP-NODATASECT-EMPTY:
 ; OBJDUMP-NODATASECT-NEXT:  Disassembly of section .tdata:
 ; OBJDUMP-NODATASECT-EMPTY:
-; OBJDUMP-NODATASECT:       00000000 (idx: 13) tls_global_int_external_val_initialized:
+; OBJDUMP-NODATASECT-NEXT:  00000000 (idx: 13) tls_global_int_external_val_initialized:
 ; OBJDUMP-NODATASECT-NEXT:  0: 00 00 00 01   <unknown>
-; OBJDUMP-NODATASECT-EMPTY:
-; OBJDUMP-NODATASECT-NEXT:  00000004 (idx: 17) tls_global_int_external_zero_initialized:
 ; OBJDUMP-NODATASECT-NEXT:  4: 00 00 00 00   <unknown>
 ; OBJDUMP-NODATASECT-EMPTY:
-; OBJDUMP-NODATASECT-NEXT:  00000008 (idx: 19) tls_global_int_local_val_initialized:
-; OBJDUMP-NODATASECT-NEXT:  8: 00 00 00 02   <unknown>
+; OBJDUMP-NODATASECT-NEXT:  00000008 (idx: 17) tls_global_int_external_zero_initialized:
+; OBJDUMP-NODATASECT-NEXT:  8: 00 00 00 00   <unknown>
+; OBJDUMP-NODATASECT-EMPTY:
+; OBJDUMP-NODATASECT-NEXT:  0000000c (idx: 19) tls_global_int_local_val_initialized:
+; OBJDUMP-NODATASECT-NEXT:  c: 00 00 00 02   <unknown>
 ; OBJDUMP-NODATASECT-EMPTY:
-; OBJDUMP-NODATASECT-NEXT:  0000000c (idx: 21) tls_global_int_weak_zero_initialized:
-; OBJDUMP-NODATASECT-NEXT:  c: 00 00 00 00   <unknown>
+; OBJDUMP-NODATASECT-NEXT:  00000010 (idx: 21) tls_global_int_weak_zero_initialized:
+; OBJDUMP-NODATASECT-NEXT:  10: 00 00 00 00   <unknown>
 ; OBJDUMP-NODATASECT-EMPTY:
-; OBJDUMP-NODATASECT-NEXT:  00000010 (idx: 23) tls_global_int_weak_val_initialized:
-; OBJDUMP-NODATASECT-NEXT:  10: 00 00 00 01   <unknown>
-; OBJDUMP-NODATASECT-NEXT:  14: 00 00 00 00   <unknown>
+; OBJDUMP-NODATASECT-NEXT:  00000014 (idx: 23) tls_global_int_weak_val_initialized:
+; OBJDUMP-NODATASECT-NEXT:  14: 00 00 00 01   <unknown>
 ; OBJDUMP-NODATASECT-EMPTY:
 ; OBJDUMP-NODATASECT-NEXT:  00000018 (idx: 25) tls_global_long_long_internal_val_initialized:
 ; OBJDUMP-NODATASECT-NEXT:  18: 00 00 00 00   <unknown>
 ; OBJDUMP-NODATASECT-NEXT:  1c: 00 00 00 01   <unknown>
 ; OBJDUMP-NODATASECT-EMPTY:
 ; OBJDUMP-NODATASECT-NEXT:  00000020 (idx: 27) tls_global_long_long_weak_val_initialized:
 ; OBJDUMP-NODATASECT-NEXT:  20: 00 00 00 00   <unknown>
 ; OBJDUMP-NODATASECT-NEXT:  24: 00 00 00 01   <unknown>