[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

2468

need a test case for the code ?

2470

only one line code, do not need { and }

[Esme]

Addressed @DiggerLin's comments, THX.

[Esme]

Gentle ping.

[shchenz]

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

93

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

101

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

[Esme]

Addresses comments.

[shchenz]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2397

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

40

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

54

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

40

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.

54

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–482

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

3287

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

3287

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/include/llvm/CodeGen/AsmPrinter.h

 class Constant;
 class ConstantArray;
 class DataLayout;
 class DIE;
 class DIEAbbrev;
 class DwarfDebug;
 class GCMetadataPrinter;
 class GCStrategy;
+class GlobalAlias;
 class GlobalObject;
 class GlobalValue;
 class GlobalVariable;
 class MachineBasicBlock;
 class MachineConstantPoolValue;
 class MachineDominatorTree;
 class MachineFunction;
 class MachineInstr;
public:
   /// correctness.
   void emitAlignment(Align Alignment, const GlobalObject *GV = nullptr,
                      unsigned MaxBytesToEmit = 0) const;
 
   /// Lower the specified LLVM Constant to an MCExpr.
   virtual const MCExpr *lowerConstant(const Constant *CV);
 
   /// Print a general LLVM constant to the .s file.
-  void emitGlobalConstant(const DataLayout &DL, const Constant *CV);
+  /// On AIX, when an alias refers to a sub-element of a global variable, the
+  /// label of that alias needs to be emitted before the corresponding element.
+  using AliasMapTy = DenseMap<uint64_t, SmallVector<const GlobalAlias *, 1>>;
+  void emitGlobalConstant(const DataLayout &DL, const Constant *CV,
+                          AliasMapTy *AliasList = nullptr);
 
   /// Unnamed constant global variables solely contaning a pointer to
   /// another globals variable act like a global variable "proxy", or GOT
   /// equivalents, i.e., it's only used to hold the address of the latter. One
   /// optimization is to replace accesses to these proxies by using the GOT
   /// entry for the final global instead. Hence, we select GOT equivalent
   /// candidates among all the module global variables, avoid emitting them
   /// unnecessarily and finally replace references to them by pc relative

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;
   }
case Instruction::Add: {
     return MCBinaryExpr::createAdd(LHS, RHS, Ctx);
   }
   }
 }
 
 static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *C,
                                    AsmPrinter &AP,
                                    const Constant *BaseCV = nullptr,
-                                   uint64_t Offset = 0);
+                                   uint64_t Offset = 0,
+                                   AsmPrinter::AliasMapTy *AliasList = nullptr);
 
 static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP);
 static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP);
 
 /// isRepeatedByteSequence - Determine whether the given value is
 /// composed of a repeated sequence of identical bytes and return the
 /// byte value.  If it is not a repeated sequence, return -1.
 static int isRepeatedByteSequence(const ConstantDataSequential *V) {
static int isRepeatedByteSequence(const Value *V, const DataLayout &DL) {
   }
 
   if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(V))
     return isRepeatedByteSequence(CDS);
 
   return -1;
 }
 
-static void emitGlobalConstantDataSequential(const DataLayout &DL,
-                                             const ConstantDataSequential *CDS,
-                                             AsmPrinter &AP) {
+static void emitGlobalAliasInline(AsmPrinter &AP, uint64_t Offset,
+                                  AsmPrinter::AliasMapTy *AliasList) {
+  if (AliasList) {
+    auto AliasIt = AliasList->find(Offset);
+    if (AliasIt != AliasList->end()) {
+      for (const GlobalAlias *GA : AliasIt->second)
+        AP.OutStreamer->emitLabel(AP.getSymbol(GA));
+      AliasList->erase(Offset);
+    }
+  }
+}
+
+static void emitGlobalConstantDataSequential(
+    const DataLayout &DL, const ConstantDataSequential *CDS, AsmPrinter &AP,
+    AsmPrinter::AliasMapTy *AliasList) {
   // See if we can aggregate this into a .fill, if so, emit it as such.
   int Value = isRepeatedByteSequence(CDS, DL);
   if (Value != -1) {
     uint64_t Bytes = DL.getTypeAllocSize(CDS->getType());
     // Don't emit a 1-byte object as a .fill.
     if (Bytes > 1)
       return AP.OutStreamer->emitFill(Bytes, Value);
   }
 
   // If this can be emitted with .ascii/.asciz, emit it as such.
   if (CDS->isString())
     return AP.OutStreamer->emitBytes(CDS->getAsString());
 
   // Otherwise, emit the values in successive locations.
   unsigned ElementByteSize = CDS->getElementByteSize();
   if (isa<IntegerType>(CDS->getElementType())) {
-    for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
+    for (unsigned I = 0, E = CDS->getNumElements(); I != E; ++I) {
+      emitGlobalAliasInline(AP, ElementByteSize * I, AliasList);
       if (AP.isVerbose())
         AP.OutStreamer->getCommentOS()
-            << format("0x%" PRIx64 "\n", CDS->getElementAsInteger(i));
-      AP.OutStreamer->emitIntValue(CDS->getElementAsInteger(i),
+            << format("0x%" PRIx64 "\n", CDS->getElementAsInteger(I));
+      AP.OutStreamer->emitIntValue(CDS->getElementAsInteger(I),
                                    ElementByteSize);
     }
   } else {
     Type *ET = CDS->getElementType();
-    for (unsigned I = 0, E = CDS->getNumElements(); I != E; ++I)
+    for (unsigned I = 0, E = CDS->getNumElements(); I != E; ++I) {
+      emitGlobalAliasInline(AP, ElementByteSize * I, AliasList);
       emitGlobalConstantFP(CDS->getElementAsAPFloat(I), ET, AP);
     }
+  }
 
   unsigned Size = DL.getTypeAllocSize(CDS->getType());
   unsigned EmittedSize =
       DL.getTypeAllocSize(CDS->getElementType()) * CDS->getNumElements();
   assert(EmittedSize <= Size && "Size cannot be less than EmittedSize!");
   if (unsigned Padding = Size - EmittedSize)
     AP.OutStreamer->emitZeros(Padding);
 }
 
 static void emitGlobalConstantArray(const DataLayout &DL,
                                     const ConstantArray *CA, AsmPrinter &AP,
-                                    const Constant *BaseCV, uint64_t Offset) {
+                                    const Constant *BaseCV, uint64_t Offset,
+                                    AsmPrinter::AliasMapTy *AliasList) {
   // See if we can aggregate some values.  Make sure it can be
   // represented as a series of bytes of the constant value.
   int Value = isRepeatedByteSequence(CA, DL);
 
   if (Value != -1) {
     uint64_t Bytes = DL.getTypeAllocSize(CA->getType());
     AP.OutStreamer->emitFill(Bytes, Value);
-  }
-  else {
-    for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) {
-      emitGlobalConstantImpl(DL, CA->getOperand(i), AP, BaseCV, Offset);
-      Offset += DL.getTypeAllocSize(CA->getOperand(i)->getType());
+  } else {
+    for (unsigned I = 0, E = CA->getNumOperands(); I != E; ++I) {
+      emitGlobalConstantImpl(DL, CA->getOperand(I), AP, BaseCV, Offset,
+                             AliasList);
+      Offset += DL.getTypeAllocSize(CA->getOperand(I)->getType());
     }
   }
 }
 
 static void emitGlobalConstantVector(const DataLayout &DL,
-                                     const ConstantVector *CV, AsmPrinter &AP) {
-  for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i)
-    emitGlobalConstantImpl(DL, CV->getOperand(i), AP);
+                                     const ConstantVector *CV, AsmPrinter &AP,
+                                     AsmPrinter::AliasMapTy *AliasList) {
+  for (unsigned I = 0, E = CV->getType()->getNumElements(); I != E; ++I) {
+    emitGlobalAliasInline(AP, DL.getTypeAllocSize(CV->getType()) * I, AliasList);
+    emitGlobalConstantImpl(DL, CV->getOperand(I), AP);
+  }
 
   unsigned Size = DL.getTypeAllocSize(CV->getType());
   unsigned EmittedSize = DL.getTypeAllocSize(CV->getType()->getElementType()) *
                          CV->getType()->getNumElements();
   if (unsigned Padding = Size - EmittedSize)
     AP.OutStreamer->emitZeros(Padding);
 }
 
 static void emitGlobalConstantStruct(const DataLayout &DL,
                                      const ConstantStruct *CS, AsmPrinter &AP,
-                                     const Constant *BaseCV, uint64_t Offset) {
+                                     const Constant *BaseCV, uint64_t Offset,
+                                     AsmPrinter::AliasMapTy *AliasList) {
   // Print the fields in successive locations. Pad to align if needed!
   unsigned Size = DL.getTypeAllocSize(CS->getType());
   const StructLayout *Layout = DL.getStructLayout(CS->getType());
   uint64_t SizeSoFar = 0;
-  for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i) {
-    const Constant *Field = CS->getOperand(i);
+  for (unsigned I = 0, E = CS->getNumOperands(); I != E; ++I) {
+    const Constant *Field = CS->getOperand(I);
 
     // Print the actual field value.
-    emitGlobalConstantImpl(DL, Field, AP, BaseCV, Offset + SizeSoFar);
+    emitGlobalConstantImpl(DL, Field, AP, BaseCV, Offset + SizeSoFar,
+                           AliasList);
 
     // Check if padding is needed and insert one or more 0s.
     uint64_t FieldSize = DL.getTypeAllocSize(Field->getType());
-    uint64_t PadSize = ((i == e-1 ? Size : Layout->getElementOffset(i+1))
-                        - Layout->getElementOffset(i)) - FieldSize;
+    uint64_t PadSize = ((I == E - 1 ? Size : Layout->getElementOffset(I + 1)) -
+                        Layout->getElementOffset(I)) -
+                       FieldSize;
     SizeSoFar += FieldSize + PadSize;
 
     // Insert padding - this may include padding to increase the size of the
     // current field up to the ABI size (if the struct is not packed) as well
     // as padding to ensure that the next field starts at the right offset.
     AP.OutStreamer->emitZeros(PadSize);
   }
   assert(SizeSoFar == Layout->getSizeInBytes() &&
static void handleIndirectSymViaGOTPCRel(AsmPrinter &AP, const MCExpr **ME,
   // Update GOT equivalent usage information
   --NumUses;
   if (NumUses >= 0)
     AP.GlobalGOTEquivs[GOTEquivSym] = std::make_pair(GV, NumUses);
 }
 
 static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *CV,
                                    AsmPrinter &AP, const Constant *BaseCV,
-                                   uint64_t Offset) {
+                                   uint64_t Offset,
+                                   AsmPrinter::AliasMapTy *AliasList) {
+  emitGlobalAliasInline(AP, Offset, AliasList);
   uint64_t Size = DL.getTypeAllocSize(CV->getType());
 
   // Globals with sub-elements such as combinations of arrays and structs
   // are handled recursively by emitGlobalConstantImpl. Keep track of the
   // constant symbol base and the current position with BaseCV and Offset.
   if (!BaseCV && CV->hasOneUse())
     BaseCV = dyn_cast<Constant>(CV->user_back());
 
if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV))
     return emitGlobalConstantFP(CFP, AP);
 
   if (isa<ConstantPointerNull>(CV)) {
     AP.OutStreamer->emitIntValue(0, Size);
     return;
   }
 
   if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(CV))
-    return emitGlobalConstantDataSequential(DL, CDS, AP);
+    return emitGlobalConstantDataSequential(DL, CDS, AP, AliasList);
 
   if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV))
-    return emitGlobalConstantArray(DL, CVA, AP, BaseCV, Offset);
+    return emitGlobalConstantArray(DL, CVA, AP, BaseCV, Offset, AliasList);
 
   if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))
-    return emitGlobalConstantStruct(DL, CVS, AP, BaseCV, Offset);
+    return emitGlobalConstantStruct(DL, CVS, AP, BaseCV, Offset, AliasList);
 
   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)
       return emitGlobalConstantImpl(DL, CE->getOperand(0), AP);
 
     if (Size > 8) {
       // If the constant expression's size is greater than 64-bits, then we have
       // to emit the value in chunks. Try to constant fold the value and emit it
       // that way.
       Constant *New = ConstantFoldConstant(CE, DL);
       if (New != CE)
         return emitGlobalConstantImpl(DL, New, AP);
     }
   }
 
   if (const ConstantVector *V = dyn_cast<ConstantVector>(CV))
-    return emitGlobalConstantVector(DL, V, AP);
+    return emitGlobalConstantVector(DL, V, AP, AliasList);
 
   // Otherwise, it must be a ConstantExpr.  Lower it to an MCExpr, then emit it
   // thread the streamer with EmitValue.
   const MCExpr *ME = AP.lowerConstant(CV);
 
   // Since lowerConstant already folded and got rid of all IR pointer and
   // integer casts, detect GOT equivalent accesses by looking into the MCExpr
   // directly.
   if (AP.getObjFileLowering().supportIndirectSymViaGOTPCRel())
     handleIndirectSymViaGOTPCRel(AP, &ME, BaseCV, Offset);
 
   AP.OutStreamer->emitValue(ME, Size);
 }
 
 /// EmitGlobalConstant - Print a general LLVM constant to the .s file.
-void AsmPrinter::emitGlobalConstant(const DataLayout &DL, const Constant *CV) {
+void AsmPrinter::emitGlobalConstant(const DataLayout &DL, const Constant *CV,
+                                    AliasMapTy *AliasList) {
   uint64_t Size = DL.getTypeAllocSize(CV->getType());
   if (Size)
-    emitGlobalConstantImpl(DL, CV, *this);
+    emitGlobalConstantImpl(DL, CV, *this, nullptr, 0, AliasList);
   else if (MAI->hasSubsectionsViaSymbols()) {
     // If the global has zero size, emit a single byte so that two labels don't
     // look like they are at the same location.
     OutStreamer->emitIntValue(0, 1);
   }
 }
 
 void AsmPrinter::emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) {

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");
   }
 

 }
 
 static bool isSpecialLLVMGlobalArrayForStaticInit(const GlobalVariable *GV) {
   return StringSwitch<bool>(GV->getName())
       .Cases("llvm.global_ctors", "llvm.global_dtors", true)
       .Default(false);
 }
 
+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);
+    if (!CBE)
+      return 0;
+    if (CBE->getOpcode() != MCBinaryExpr::Add)
+      report_fatal_error("Only adding an offset is supported now.");
+    auto *RHS = dyn_cast<MCConstantExpr>(CBE->getRHS());
+    if (!RHS)
+      report_fatal_error("Unable to get the offset of alias.");
+    return RHS->getValue();
+  }
+  return 0;
+}
+
 void PPCAIXAsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
   // Special LLVM global arrays have been handled at the initialization.
   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);
 }
 
 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));
 
   if (GV->isDeclarationForLinker()) {
     emitLinkage(GV, GVSym);
     return;
   }
 
   SectionKind GVKind = getObjFileLowering().getKindForGlobal(GV, TM);
if (GVKind.isBSSLocal() || GVKind.isThreadBSSLocal())
           OutContext.getOrCreateSymbol(GVSym->getSymbolTableName()), Size,
           GVSym, Alignment.value());
     else
       OutStreamer->emitCommonSymbol(GVSym, Size, Alignment.value());
     return;
   }
 
   MCSymbol *EmittedInitSym = GVSym;
+
+  // Emit linkage for the global variable and its aliases.
   emitLinkage(GV, EmittedInitSym);
+  for (const GlobalAlias *GA : GOAliasMap[GV])
+    emitLinkage(GA, getSymbol(GA));
+
   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()) {
+  if (!TM.getDataSections() || GV->hasSection())
     OutStreamer->emitLabel(EmittedInitSym);
-  }
-
-  // Emit aliasing label for global variable.
-  for (const GlobalAlias *Alias : GOAliasMap[GV])
-    OutStreamer->emitLabel(getSymbol(Alias));
 
+  // No alias to emit.
+  if (!GOAliasMap[GV].size()) {
     emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer());
+    return;
+  }
+
+  // Aliases with the same offset should be aligned. Record the list of aliases
+  // associated with the offset.
+  AliasMapTy AliasList;
+  for (const GlobalAlias *GA : GOAliasMap[GV])
+    AliasList[getAliasOffset(GA->getAliasee())].push_back(GA);
+
+  // Emit alias label and element value for global variable.
+  emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer(),
+                     &AliasList);
 }
 
 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-alignment-2.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 \
+; RUN:     -data-sections=false -filetype=obj -o %t.o < %s
+; RUN: llvm-objdump --syms %t.o | FileCheck --check-prefix=SYM %s
+
+@ConstVector = global <2 x i64> <i64 12, i64 34>, align 4
+@var1 = alias i64, getelementptr inbounds (<2 x i64>, <2 x i64>* @ConstVector, i32 0, i32 1)
+define void @foo1(i64 %a1) {
+  store i64 %a1, i64* getelementptr inbounds (<2 x i64>, <2 x i64>* @ConstVector, i32 0, i32 1), align 4
+  ret void
+}
+
+; ASM:           .globl     ConstVector  # @ConstVector
+; ASM-NEXT:      .globl     var1
+; ASM-NEXT:      .align     4
+; ASM-NEXT: ConstVector:
+; ASM-NEXT:      .vbyte     4, 0         # 0xc
+; ASM-NEXT:      .vbyte     4, 12
+; ASM-NEXT: var1:
+; ASM-NEXT:      .vbyte     4, 0         # 0x22
+; ASM-NEXT:      .vbyte     4, 34
+
+@ConstDataSeq = global [2 x i64] [i64 12, i64 34], align 4
+@var2 = alias i64, getelementptr inbounds ([2 x i64], [2 x i64]* @ConstDataSeq, i32 0, i32 1)
+define void @foo2(i64 %a1) {
+  store i64 %a1, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @ConstDataSeq, i32 0, i32 1), align 4
+  ret void
+}
+
+; ASM:           .globl     ConstDataSeq   # @ConstDataSeq
+; ASM-NEXT:      .globl     var2
+; ASM-NEXT:      .align     3
+; ASM-NEXT: ConstDataSeq:
+; ASM-NEXT:      .vbyte     4, 0           # 0xc
+; ASM-NEXT:      .vbyte     4, 12
+; ASM-NEXT: var2:
+; ASM-NEXT:      .vbyte     4, 0           # 0x22
+; ASM-NEXT:      .vbyte     4, 34
+
+%struct.B = type { i64 }
+@ConstArray = global [2 x %struct.B] [%struct.B {i64 12}, %struct.B {i64 34}], align 4
+@var3 = alias %struct.B, getelementptr inbounds ([2 x %struct.B], [2 x %struct.B]* @ConstArray, i32 0, i32 0)
+define void @foo3(%struct.B %a1) {
+  store %struct.B %a1, %struct.B* getelementptr inbounds ([2 x %struct.B], [2 x %struct.B]* @ConstArray, i32 0, i32 1), align 4
+  ret void
+}
+
+; ASM:           .globl     ConstArray  # @ConstArray
+; ASM-NEXT:      .globl     var3
+; ASM-NEXT:      .align     3
+; ASM-NEXT: ConstArray:
+; ASM-NEXT: var3:
+; ASM-NEXT:      .vbyte     4, 0        # 0xc
+; ASM-NEXT:      .vbyte     4, 12
+; ASM-NEXT:      .vbyte     4, 0        # 0x22
+; ASM-NEXT:      .vbyte     4, 34
+
+; SYM:      SYMBOL TABLE:
+; SYM-NEXT: 00000000      df *DEBUG*  00000000 <stdin>
+; SYM-NEXT: 00000000 l       .text  0000008a .text
+; SYM-NEXT: 00000000 g     F .text (csect: .text)   00000000 .foo1
+; SYM-NEXT: 00000030 g     F .text (csect: .text)   00000000 .foo2
+; SYM-NEXT: 00000060 g     F .text (csect: .text)   00000000 .foo3
+; SYM-NEXT: 00000090 l       .data  00000030 .data
+; SYM-NEXT: 00000090 g     O .data (csect: .data)   00000000 ConstVector
+; SYM-NEXT: 00000098 g     O .data (csect: .data)   00000000 var1
+; SYM-NEXT: 000000a0 g     O .data (csect: .data)   00000000 ConstDataSeq
+; SYM-NEXT: 000000a8 g     O .data (csect: .data)   00000000 var2
+; SYM-NEXT: 000000b0 g     O .data (csect: .data)   00000000 ConstArray
+; SYM-NEXT: 000000b0 g     O .data (csect: .data)   00000000 var3
+; SYM-NEXT: 000000c0 g     O .data  0000000c foo1
+; SYM-NEXT: 000000cc g     O .data  0000000c foo2
+; SYM-NEXT: 000000d8 g     O .data  0000000c foo3
+; SYM-NEXT: 000000e4 l       .data  00000000 TOC
+; SYM-NEXT: 000000e4 l     O .data  00000004 ConstVector
+; SYM-NEXT: 000000e8 l     O .data  00000004 ConstDataSeq
+; SYM-NEXT: 000000ec l     O .data  00000004 ConstArray

llvm/test/CodeGen/PowerPC/aix-alias-alignment.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 \
+; RUN:     -data-sections=true < %s | FileCheck --check-prefix=ASM-DATASECT %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 = global <{ i32, i32 }> <{ i32 1, i32 2 }>, align 4
+@var1 = alias i32, getelementptr inbounds (<{ i32, i32 }>, <{ i32, i32 }>* @_MergedGlobals, i32 0, i32 0)
+@var2 = 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, i32 %a3) {
+  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:         .globl  _MergedGlobals # @_MergedGlobals
+; ASM-NEXT:         .globl  var1
+; ASM-NEXT:         .globl  var2
+; ASM-NEXT:         .globl  var3
+; ASM-NEXT:         .align  2
+; ASM-NEXT: _MergedGlobals:
+; ASM-NEXT: var1:
+; ASM-NEXT:         .vbyte  4, 1 # 0x1
+; ASM-NEXT: var2:
+; ASM-NEXT: var3:
+; ASM-NEXT:         .vbyte  4, 2 # 0x2
+; ASM-NEXT:         .toc
+; ASM-NEXT: L..C0:
+; ASM-NEXT:         .tc _MergedGlobals[TC],_MergedGlobals
+
+; ASM-DATASECT:              # -- End function
+; ASM-DATASECT-NEXT:         .csect _MergedGlobals[RW],2
+; ASM-DATASECT-NEXT:         .globl  _MergedGlobals[RW] # @_MergedGlobals
+; ASM-DATASECT-NEXT:         .globl  var1
+; ASM-DATASECT-NEXT:         .globl  var2
+; ASM-DATASECT-NEXT:         .globl  var3
+; ASM-DATASECT-NEXT:         .align  2
+; ASM-DATASECT-NEXT: var1:
+; ASM-DATASECT-NEXT:         .vbyte  4, 1 # 0x1
+; ASM-DATASECT-NEXT: var2:
+; ASM-DATASECT-NEXT: var3:
+; ASM-DATASECT-NEXT:         .vbyte  4, 2 # 0x2
+; ASM-DATASECT-NEXT:         .toc
+; ASM-DATASECT-NEXT: L..C0:
+; ASM-DATASECT-NEXT:         .tc _MergedGlobals[TC],_MergedGlobals[RW]
+
+; OBJ:      00000000 <.foo>:
+; OBJ-NEXT:        0: 80 a2 00 00   lwz 5, 0(2)
+; OBJ-NEXT:       00000002:  R_TOC  _MergedGlobals
+; OBJ-NEXT:        4: 90 65 00 00   stw 3, 0(5)
+; OBJ-NEXT:        8: 90 85 00 04   stw 4, 4(5)
+; OBJ-NEXT:        c: 4e 80 00 20   blr
+
+; SYM:      SYMBOL TABLE:
+; SYM-NEXT: 00000000      df *DEBUG*  00000000 <stdin>
+; SYM-NEXT: 00000000 l       .text  00000029 .text
+; SYM-NEXT: 00000000 g     F .text (csect: .text)   00000000 .foo
+; SYM-NEXT: 0000002c l       .data  00000008 .data
+; SYM-NEXT: 0000002c g     O .data (csect: .data)   00000000 _MergedGlobals
+; SYM-NEXT: 0000002c g     O .data (csect: .data)   00000000 var1
+; SYM-NEXT: 00000030 g     O .data (csect: .data)   00000000 var2
+; SYM-NEXT: 00000030 g     O .data (csect: .data)   00000000 var3
+; SYM-NEXT: 00000034 g     O .data  0000000c foo
+; SYM-NEXT: 00000040 l       .data  00000000 TOC
+; SYM-NEXT: 00000040 l     O .data  00000004 _MergedGlobals

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

 ; ASM:         bl .fun
 ; ASM-NEXT:    nop
 ; ASM:         bl .fun_weak
 ; ASM-NEXT:    nop
 ; ASM:         bl .fun_hidden
 ; ASM:                                               # -- End function
 ; ASM-NEXT:    .csect .data[RW]
 ; ASM-NEXT:    .globl  var
+; 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:       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:    .globl array
 ; ASM:       array:
 ; ASM-NEXT:    .vbyte 4, 1 # 0x1
 ; ASM-NEXT:    .vbyte 4, 2 # 0x2
 ; ASM-NEXT:    .globl x
+; ASM-NEXT:    .globl  bitcast_alias
 ; ASM:       x:
 ; ASM-NEXT:  bitcast_alias:
 ; ASM-NEXT:    .vbyte  {{[0-9]+}}, array+4
 ; 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:    .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