[AIX] emit .extern and .weak directive linkage

[DiggerLin]

Summary

1. emit .extern and .weak directive linkage

the c source code for test cases aix-extern.ll , aix-weak.ll , aix-extern-weak.ll as
bash> cat aix_extern.c

extern int bar_extern(int* ip);
extern int bar_ref();
extern int b_e;

void foo(){ }

int (*bar_p)() = bar_ref;

int main() {
   bar_extern(&b_e);
   foo();
   bar_p();
   bar_ref();
}

bash>cat aix_weak.c

__attribute__ ((weak)) void foo_weak(int *p){
  (*p)++;
}

__attribute__ ((weak)) void foo_ref_weak(){
}

void (*foo_weak_p)() = foo_ref_weak;
int __attribute__ ((weak)) b;

int main() {
   foo_weak_p();
   foo_weak(&b);
   foo_ref_weak();
}

bash>cat aix_extern_weak.c

extern __attribute__ ((weak)) void foo_ext_weak(int* );
extern __attribute__ ((weak)) void foo_ext_weak_ref(void);
extern __attribute__ ((weak)) int b;

void (*foo_ext_weak_p)() = foo_ext_weak_ref;
void (*foo_ext_weak_p_nocall)() = foo_ext_weak_ref;

int main() {
   foo_ext_weak_p();
   foo_ext_weak(&b);
}

[DiggerLin]

clang reformat

[DiggerLin]

delete -u from clang test case aix-as.c

[DiggerLin]

llvm/include/llvm/MC/MCDirectives.h

47

@hubert.reinterpretcast , @jasonliu , do we need to create a NFC patch for the clang format problem of the above first ?

[hubert.reinterpretcast]

llvm/include/llvm/MC/MCDirectives.h

47

I think it would help; yes. Please drop one at your earliest convenience and then rebase this patch on top of it.

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1523

This query asked if the target supports .extern. However, .extern is not the only directive that could get emitted here. We could also emit .weak.

1529

I'm surprised we do not enter here for foo_ext_weak(). The result of that is we need to do something in lowerConstant(), which I would want to avoid if possible.
Should we look into why isDeclarationForLinker() returns false for foo_ext_weak() here?
My guess is we returned false for !F->isMaterializable(). And I'm not sure if foo_ext_weak is materializable is the correct answer here.

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1529

Sorry, ignore the above comment. I think we did entered here for emitLinkage for foo_ext_weak. But the hasContainingCsect query blocked the emission there.

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1578

I hope we can find a better solution here. IMO, we don't even want to override this function in this patch.
GVSym should be the right one from what caller passed in. It's caller's responsibility to pass in the right GVSym.
When caller calls emitLinkage, we should emitLinkage. It's weird when emitLinkage is called, but none is emitted (when hasContainingCsect() returns false).

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1597–1598

If it's possible, I would like to not emitLinkage here. I don't think it's the right place. Could we emitLinkage for the symbols needed in AsmPrinter::doFinalization instead?

[DiggerLin]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1578

In the function

 bool AsmPrinter::doFinalization(Module &M) {
  // Emit remaining GOT equivalent globals.
  emitGlobalGOTEquivs();

  // Emit visibility info for declarations
  for (const Function &F : M) {
  ....
}

there is function name .llvm.stackprotector in the M. the function is declared . it go to emitLinkage();

we need
if (XCOFFSym->hasContainingCsect()) {

}

to exclude emit linkage for function .llvm.stackprotector

I think over it , do you have any good suggestion to distinguish .llvm.stackprotector from other extern declared function.

[DiggerLin]

address comment

[jasonliu]

This comment was removed by jasonliu.

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1501

Comment should change to something similar to:
Emit linkage(XCOFF) and visibility info for declarations.

1541

What if we have

void foo();
void (*foo_ptr)() = foo;
int bar() {
  foo();
}

We would need both .extern .foo and .extern foo[DS].
Also, please have a similar case into the lit test.

llvm/lib/MC/MCXCOFFStreamer.cpp

38

Please remove llvm:: for MCSA_Extern and MCSA_Weak to make the style consistent.

48

Maybe we should just move Symbol->setExternal(true); outside of the switch, as it is set for every attribute that we are going to emit.

llvm/lib/MC/XCOFFObjectWriter.cpp

356–357

line 353 to 365 did not align properly.

357

We should continue here if the rest of the logic does not matter.

358

A new line after '}'.

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

18

Nit: Please remove #0, #1 from the test case.

56

A proper space alignment would make the expected result more readable.

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

403

Could we verify if these Linkage should also always emit .weak?
We do have one test case that tests LinkOnceODRLinkage in llvm/test/CodeGen/PowerPC/aix-LinkOnceODRLinkage.ll, but no other linkages here is tested and confirmed the behavior is right for AIX.
Also LinkOnceODRLinkage.ll test needs to get update as well, since we will emit .weak _Z3fooIiEvT_[DS] now.

[DiggerLin]

1. address comment
2. add two new test cases.
3. split a bit test case into three small test case.

[DiggerLin]

llvm/lib/MC/MCXCOFFStreamer.cpp

48

I think there is Symbol->setExternal(false ) in other switch cases later .

llvm/lib/MC/XCOFFObjectWriter.cpp

357

thanks.

[jasonliu]

Thanks for splitting the test case. I think it helps a lot for reading and maintainability.

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1521

This line is not used before XCOFF specialized code, we should move it down.

1526

If I understand correctly, we do not want to touch how we interact with visibility in this patch.
If that's the case, we don't want to continue here and in line 1512 since the early continue will change the code flow for visibility.
Suggestion:
if (TM.getTargetTriple().isOSBinFormatXCOFF() && !F.isIntrinsic()) {
and remove continue in line 1512.

1529

nit: I don't think it's a good idea here to assign back to Name here, as Name will also get used in emitVisibility below and we want to keep it as it is. Let's create a new MCSymbol* here.

1531

1. We need to rebase here, as it is called hasRepresentedCsectSet() instead of hasContainingCsect() now.
2. I'm slightly worried here to rely on hasRepresentedCsectSet() to check if a linkage should be emitted. This is based on the assumption that we will not ever change our implementation for .bl foo to .bl foo[PR]. But in https://reviews.llvm.org/D77080#inline-706207, we discussed about this possibility. So this assumption might not be true in the future. However, I'm not sure if there is another way to check if this function have been called directly.

So if there is another way to check, we should pursue the alternative instead. If there is not, then we need to add an assert here, like assert(Name->getName().equals(cast<MCSymbolXCOFF>(Name)->getUnqualifiedName()) to make sure we don't get a qualname here.

Have a comment here and tell people what we are doing here.
For example,
// If there is a direct call to external function, then we need to emit linkage for its function entry point.

1534

Comment need to mention what we are trying to do here:
// If address is taken from an extern function, we need to emit linkage for its function descriptor symbol.

1535

nit: for -> For,
and we don't need space between as and :

1541

nit: We don't need to assign it back to Name.
emitLinkage(&F, Csect->getQualNameSymbol());

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

10

Do we also want to test WeakAnyLinkage?

[DiggerLin]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1531

when we implement .bl foo to .bl foo[PR]
the SymbolName will change from .bl[SMC] and check the .bl[SMC]->hasRepresentedCsectSet()

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

10

WeakAnyLinkage should be weak
It has been tested in aix-weak.ll

define weak void @foo_weak(i32* %p) {
entry:

%p.addr = alloca i32*, align 4
store i32* %p, i32** %p.addr, align 4
%0 = load i32*, i32** %p.addr, align 4
%1 = load i32, i32* %0, align 4
%inc = add nsw i32 %1, 1
store i32 %inc, i32* %0, align 4
ret void

}

[DiggerLin]

address comment and rebased the patch on D77080 [NFC][XCOFF][AIX] Refactor get/setContainingCsect

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1531

Yes, but foo[PR]->hasRepresentedCsectSet() will always return true, because whenever we created a qualname will always have csect set. How will we know if foo() function is called directly then?

[hubert.reinterpretcast]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

397–399

I have my doubts that CommonLinkage should produce .weak for XCOFF. It is working right because we don't actually get here from PPCAIXAsmPrinter::emitGlobalVariable for that case. I'm not sure what the best way would be to add an assertion here though.

435

Similarly, this is okay without extra checks because non-XCOFF cases should never get here. A check would be nice but I'm not sure how to formulate it in this context.

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

12

I would prefer to test the function call and the take-address-of-function cases separately here.

14

There should be testing for extern_weak variables as well.

[DiggerLin]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1531

we only deal with extern function(we do not deal with definition function) here, for extern function, it not always has MCSectionXCOFF, it only create the extern function be called directly in the llvm/lib/CodeGen/MachineModuleInfo.cpp line 108~116, unless we delete the code later. if the code is not changed. for extern function foo , the .foo[PR] -> hasRepresentedCsectSet() when directly call. otherwise false.

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1531

Okk. I think I got what you mean. If .foo[PR] is created then it means there is a direct call. Otherwise, we will not have a .foo[PR], and of course that newly created .foo[PR] will not have a RepresentedCsect.
Thanks.

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1512

Based on our discussion, this assertion could be removed.
And please add a comment saying
// If there is a direct call to this extern function, we need to emit linkage for its function entry point symbol.

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

12

I think this is to test when the function is both taken address, and get called directly, will we emit linkage for both function entry point and function descriptor symbol? The original implementation only emit one of them.
Maybe it makes sense to have a separate test case like this to test the linkage emit in all circumstance:

void foo_called();
void foo_refed();
void foo_called_refed();

void (*foo_refed_p)() = foo_refed;
void (*foo_called_refed_p)() = foo_called_refed;

void bar(){
  foo_called();
  foo_called_refed();
}

[jasonliu]

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

15

nit: Function Attrs and #0 could be removed

[DiggerLin]

address comment and add a new test case

[DiggerLin]

address comment

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

435

Maybe an assert on isOSBinFormatXCOFF is better?
If not, could we remove the else and llvm_unreachable to let it fall through? Will it have warnings?
Or we could just only remove else here.

1506

This block of code and D78045 will have conflict. One of us will need to rebase.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1618–1619

This comment does not apply any more.

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

11

Do we care to check the 64 bit object generation error here and for other test cases that are applicable?

30

Could we align the assembly output in aix-extern-weak.ll, aix-extern.ll, aix-weak.ll?

49

If the plan is not emit function entry point if it's not necessary, let's CHECK-NOT that.

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

15

This comment is not addressed.

[DiggerLin]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

435

yes. remove else , and let it fall through , there is a warning.

1506

the one who land later will rebase.

[DiggerLin]

address comment

[jasonliu]

LGTM. Please wait a day or two to see if @hubert.reinterpretcast have further comments.

[hubert.reinterpretcast]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

439

We can fall through using an annotation to suppress the warning:

LLVM_FALLTHROUGH;

1506

My understanding is that this would need a semantic reconciliation. I'd like to see the rebase of this patch before approving. Also, this would be another place to look into for the follow-up mentioned in https://reviews.llvm.org/D78045?id=257331#inline-714634 @jasonliu.

1515

A comment here to explain that we are emitting linkage for the function descriptor would help.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2136

Swap the order of the two LinkOnce* cases to match their definition order.

2141–2142

Since AvailableExternallyLinkage is the only value left, just replace default with that and change the report_fatal_error to say AvailableExternallyLinkage for its first instance of "linkage".

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1619–1620

This should probably be isDeclarationForLinker. It seems we need a larger followup for AvailableExternallyLinkage that would involve checking our calls to isDeclaration:

define void @_Z1gv() {
entry:
  call void @_Z1fIiEvv()
  ret void
}

; Function Attrs: inlinehint nounwind
define available_externally void @_Z1fIiEvv() #0 {
entry:
  ret void
}

attributes #0 = { inlinehint nounwind }

[DiggerLin]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1506

rebase the patch on the D78045

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1619–1620

bool isDeclarationForLinker() const {
  if (hasAvailableExternallyLinkage())
    return true;
 
  return isDeclaration();
}

since we do not deal with AvailableExternallyLinkage in AsmPrinter::emitLinkage()

if change to isDeclarationForLinker here , it will hit a report_fatal_error.

[DiggerLin]

rebase the patch on the D78045 and address comment.

[hubert.reinterpretcast]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2142–2144

It seems my editing instruction got confused for the text. This is what I meant:

"Unhandled AvailableExternallyLinkage when mapping linkage to StorageClass"

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1619–1620

What happens for the case above? We need to generate MCSA_Extern for the reference. The definition should not appear in the output.

[DiggerLin]

handle getSymbol returning a function descriptor symbol after rebase on the D78045

[DiggerLin]

I think I address all the comments. thanks hubert.

[hubert.reinterpretcast]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1506

Add a comment that this gives us the function descriptor symbol.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2147

Replicate the

llvm_unreachable("Unknown linkage type!");

here before falling off the end of a function that does not return void.

[hubert.reinterpretcast]

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

10

No need for two consecutive spaces here.

46

This has a prefix that is not checked by the RUN lines. Note also that it would only prevent the appearance of the subject line until the next positive match. Running FileCheck a second time on the same output may be necessary to check that it does not appear anywhere in an active manner. The passive method is to count on the block of COMMON-NEXT to exclude it.

[hubert.reinterpretcast]

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

175

This should be relative to Index.

215

Same comment.

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

10

Same comments for this test.

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

10

Same comments for this test.

[DiggerLin]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2147

thanks

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

46

thanks for let me know

[DiggerLin]

address comment

[hubert.reinterpretcast]

LGTM with minor comment.

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

9

Please fix the two consecutive spaces.

[DiggerLin]

take out the functionality of "remove -u from clang"

[hubert.reinterpretcast]

LGTM with minor comment.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2143

The beginning of report_fatal_error messages should not be capitalized in the style of a sentence.

[MaskRay]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

397–399

Note, there is a -Wimplicit-fallthrough issue in -DLLVM_ENABLE_ASSERTIONS=off builds which has been fixed by 31db4dbbbebd135c837014033a548eec15664ea8

llvm/include/llvm/MC/MCAsmInfo.h

protected:
   /// True if this target supports the MachO .no_dead_strip directive.  Defaults
   /// to false.
   bool HasNoDeadStrip = false;
 
   /// True if this target supports the MachO .alt_entry directive.  Defaults to
   /// false.
   bool HasAltEntry = false;
 
+  /// True if this target supports the XCOFF .extern directive.  Defaults to
+  /// false.
+  bool HasDotExternDirective = false;
+
   /// Used to declare a global as being a weak symbol. Defaults to ".weak".
   const char *WeakDirective;
 
   /// This directive, if non-null, is used to declare a global as being a weak
   /// undefined symbol.  Defaults to nullptr.
   const char *WeakRefDirective = nullptr;
 
   /// True if we have a directive to declare a global as being a weak defined
public:
   }
 
   bool hasFunctionAlignment() const { return HasFunctionAlignment; }
   bool hasDotTypeDotSizeDirective() const { return HasDotTypeDotSizeDirective; }
   bool hasSingleParameterDotFile() const { return HasSingleParameterDotFile; }
   bool hasIdentDirective() const { return HasIdentDirective; }
   bool hasNoDeadStrip() const { return HasNoDeadStrip; }
   bool hasAltEntry() const { return HasAltEntry; }
+  bool hasDotExternDirective() const { return HasDotExternDirective; }
   const char *getWeakDirective() const { return WeakDirective; }
   const char *getWeakRefDirective() const { return WeakRefDirective; }
   bool hasWeakDefDirective() const { return HasWeakDefDirective; }
 
   bool hasWeakDefCanBeHiddenDirective() const {
     return HasWeakDefCanBeHiddenDirective;
   }
 

llvm/include/llvm/MC/MCDirectives.h

enum MCSymbolAttr {
   MCSA_ELF_TypeIndFunction,     ///< .type _foo, STT_GNU_IFUNC
   MCSA_ELF_TypeObject,          ///< .type _foo, STT_OBJECT  # aka @object
   MCSA_ELF_TypeTLS,             ///< .type _foo, STT_TLS     # aka @tls_object
   MCSA_ELF_TypeCommon,          ///< .type _foo, STT_COMMON  # aka @common
   MCSA_ELF_TypeNoType,          ///< .type _foo, STT_NOTYPE  # aka @notype
   MCSA_ELF_TypeGnuUniqueObject, /// .type _foo, @gnu_unique_object
   MCSA_Global,                  ///< .globl
   MCSA_LGlobal,                 ///< .lglobl (XCOFF)
+  MCSA_Extern,                  ///< .extern (XCOFF)
   MCSA_Hidden,                  ///< .hidden (ELF)
   MCSA_IndirectSymbol,          ///< .indirect_symbol (MachO)
   MCSA_Internal,                ///< .internal (ELF)
   MCSA_LazyReference,           ///< .lazy_reference (MachO)
   MCSA_Local,                   ///< .local (ELF)
   MCSA_NoDeadStrip,             ///< .no_dead_strip (MachO)
   MCSA_SymbolResolver,          ///< .symbol_resolver (MachO)
   MCSA_AltEntry,                ///< .alt_entry (MachO)
   MCSA_PrivateExtern,           ///< .private_extern (MachO)
   MCSA_Protected,               ///< .protected (ELF)
   MCSA_Reference,               ///< .reference (MachO)
   MCSA_Weak,                    ///< .weak
   MCSA_WeakDefinition,          ///< .weak_definition (MachO)
   MCSA_WeakReference,           ///< .weak_reference (MachO)
   MCSA_WeakDefAutoPrivate       ///< .weak_def_can_be_hidden (MachO)
 };
 
 enum MCAssemblerFlag {
   MCAF_SyntaxUnified,         ///< .syntax (ARM/ELF)
   MCAF_SubsectionsViaSymbols, ///< .subsections_via_symbols (MachO)
   MCAF_Code16,                ///< .code16 (X86) / .code 16 (ARM)
   MCAF_Code32,                ///< .code32 (X86) / .code 32 (ARM)
   MCAF_Code64                 ///< .code64 (X86)

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (!MAI.hasWeakDefCanBeHiddenDirective())
     return false;
 
   return GV->canBeOmittedFromSymbolTable();
 }
 
 void AsmPrinter::emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const {
   GlobalValue::LinkageTypes Linkage = GV->getLinkage();
   switch (Linkage) {
   case GlobalValue::CommonLinkage:
+    assert(!TM.getTargetTriple().isOSBinFormatXCOFF() &&
+           "CommonLinkage of XCOFF should not come to this path.");
   case GlobalValue::LinkOnceAnyLinkage:
   case GlobalValue::LinkOnceODRLinkage:
   case GlobalValue::WeakAnyLinkage:
   case GlobalValue::WeakODRLinkage:
     if (MAI->hasWeakDefDirective()) {
       // .globl _foo
       OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global);
 
       if (!canBeHidden(GV, *MAI))
         // .weak_definition _foo
         OutStreamer->emitSymbolAttribute(GVSym, MCSA_WeakDefinition);
       else
         OutStreamer->emitSymbolAttribute(GVSym, MCSA_WeakDefAutoPrivate);
     } else if (MAI->avoidWeakIfComdat() && GV->hasComdat()) {
       // .globl _foo
       OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global);
       //NOTE: linkonce is handled by the section the symbol was assigned to.
     } else {
       // .weak _foo
       OutStreamer->emitSymbolAttribute(GVSym, MCSA_Weak);
     }
     return;
   case GlobalValue::ExternalLinkage:
-    // If external, declare as a global symbol: .globl _foo
+    if (MAI->hasDotExternDirective() && GV->isDeclaration())
+      OutStreamer->emitSymbolAttribute(GVSym, MCSA_Extern);
+    else
       OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global);
     return;
   case GlobalValue::PrivateLinkage:
     return;
   case GlobalValue::InternalLinkage:
     if (MAI->hasDotLGloblDirective())
       OutStreamer->emitSymbolAttribute(GVSym, MCSA_LGlobal);
     return;
+  case GlobalValue::ExternalWeakLinkage:
+    if (TM.getTargetTriple().isOSBinFormatXCOFF()) {
+      OutStreamer->emitSymbolAttribute(GVSym, MCSA_Weak);
+      return;
+    }
+    LLVM_FALLTHROUGH;
   case GlobalValue::AppendingLinkage:
   case GlobalValue::AvailableExternallyLinkage:
-  case GlobalValue::ExternalWeakLinkage:
     llvm_unreachable("Should never emit this");
   }
   llvm_unreachable("Unknown linkage type!");
 }
 
 void AsmPrinter::getNameWithPrefix(SmallVectorImpl<char> &Name,
                                    const GlobalValue *GV) const {
   TM.getNameWithPrefix(Name, GV, getObjFileLowering().getMangler());
bool AsmPrinter::doFinalization(Module &M) {
 
   // Emit global variables.
   for (const auto &G : M.globals())
     emitGlobalVariable(&G);
 
   // Emit remaining GOT equivalent globals.
   emitGlobalGOTEquivs();
 
-  // Emit visibility info for declarations
+  // Emit linkage(XCOFF) and visibility info for declarations
   for (const Function &F : M) {
     if (!F.isDeclarationForLinker())
       continue;
+
+    MCSymbol *Name = getSymbol(&F);
+    // Function getSymbol gives us the function descriptor symbol for XCOFF.
+    if (TM.getTargetTriple().isOSBinFormatXCOFF() && !F.isIntrinsic()) {
+
+      // Get the function entry point symbol.
+      MCSymbol *FnEntryPointSym = OutContext.getOrCreateSymbol(
+          "." + cast<MCSymbolXCOFF>(Name)->getUnqualifiedName());
+      if (cast<MCSymbolXCOFF>(FnEntryPointSym)->hasRepresentedCsectSet())
+        // Emit linkage for the function entry point.
+        emitLinkage(&F, FnEntryPointSym);
+
+      // Emit linkage for the function descriptor.
+      emitLinkage(&F, Name);
+    }
+
     GlobalValue::VisibilityTypes V = F.getVisibility();
     if (V == GlobalValue::DefaultVisibility)
       continue;
 
-    MCSymbol *Name = getSymbol(&F);
     emitVisibility(Name, V, false);
   }
 
   // Emit the remarks section contents.
   // FIXME: Figure out when is the safest time to emit this section. It should
   // not come after debug info.
   if (remarks::RemarkStreamer *RS = M.getContext().getMainRemarkStreamer())
     emitRemarksSection(*RS);
 
   const TargetLoweringObjectFile &TLOF = getObjFileLowering();
 
   TLOF.emitModuleMetadata(*OutStreamer, M);
 
   if (TM.getTargetTriple().isOSBinFormatELF()) {
     MachineModuleInfoELF &MMIELF = MMI->getObjFileInfo<MachineModuleInfoELF>();
 
     // Output stubs for external and common global variables.
     MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList();
     if (!Stubs.empty()) {
       OutStreamer->SwitchSection(TLOF.getDataSection());
       const DataLayout &DL = M.getDataLayout();
 
       emitAlignment(Align(DL.getPointerSize()));
       for (const auto &Stub : Stubs) {
         OutStreamer->emitLabel(Stub.first);

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

XCOFF::StorageClass TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(
   switch (GO->getLinkage()) {
   case GlobalValue::InternalLinkage:
   case GlobalValue::PrivateLinkage:
     return XCOFF::C_HIDEXT;
   case GlobalValue::ExternalLinkage:
   case GlobalValue::CommonLinkage:
     return XCOFF::C_EXT;
   case GlobalValue::ExternalWeakLinkage:
+  case GlobalValue::LinkOnceAnyLinkage:
   case GlobalValue::LinkOnceODRLinkage:
+  case GlobalValue::WeakAnyLinkage:
+  case GlobalValue::WeakODRLinkage:
     return XCOFF::C_WEAKEXT;
   case GlobalValue::AppendingLinkage:
     report_fatal_error(
         "There is no mapping that implements AppendingLinkage for XCOFF.");
-  default:
-    report_fatal_error(
-        "Unhandled linkage when mapping linkage to StorageClass.");
+  case GlobalValue::AvailableExternallyLinkage:
+    report_fatal_error("unhandled AvailableExternallyLinkage when mapping "
+                       "linkage to StorageClass");
   }
+  llvm_unreachable("Unknown linkage type!");
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForFunctionDescriptor(
     const Function *F, const TargetMachine &TM) const {
   SmallString<128> NameStr;
   getNameWithPrefix(NameStr, F, TM);
   return getContext().getXCOFFSection(NameStr, XCOFF::XMC_DS, XCOFF::XTY_SD,
                                       getStorageClassForGlobal(F),
                                       SectionKind::getData());
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForTOCEntry(
     const MCSymbol *Sym) const {
   return getContext().getXCOFFSection(
       cast<MCSymbolXCOFF>(Sym)->getUnqualifiedName(), XCOFF::XMC_TC,
       XCOFF::XTY_SD, XCOFF::C_HIDEXT, SectionKind::getData());
 }

llvm/lib/MC/MCAsmInfoXCOFF.cpp

 
 using namespace llvm;
 
 void MCAsmInfoXCOFF::anchor() {}
 
 MCAsmInfoXCOFF::MCAsmInfoXCOFF() {
   IsLittleEndian = false;
   HasDotTypeDotSizeDirective = false;
+  HasDotExternDirective = true;
   COMMDirectiveAlignmentIsInBytes = false;
   LCOMMDirectiveAlignmentType = LCOMM::Log2Alignment;
   UseDotAlignForAlignment = true;
   AsciiDirective = nullptr; // not supported
   AscizDirective = nullptr; // not supported
   NeedsFunctionDescriptors = true;
   HasDotLGloblDirective = true;
   Data64bitsDirective = "\t.llong\t";

llvm/lib/MC/MCAsmStreamer.cpp

case MCSA_NoDeadStrip:
     break;
   case MCSA_SymbolResolver: OS << "\t.symbol_resolver\t"; break;
   case MCSA_AltEntry:       OS << "\t.alt_entry\t";       break;
   case MCSA_PrivateExtern:
     OS << "\t.private_extern\t";
     break;
   case MCSA_Protected:      OS << "\t.protected\t";       break;
   case MCSA_Reference:      OS << "\t.reference\t";       break;
+  case MCSA_Extern:
+    OS << "\t.extern\t";
+    break;
   case MCSA_Weak:           OS << MAI->getWeakDirective(); break;
   case MCSA_WeakDefinition:
     OS << "\t.weak_definition\t";
     break;
       // .weak_reference
   case MCSA_WeakReference:  OS << MAI->getWeakRefDirective(); break;
   case MCSA_WeakDefAutoPrivate: OS << "\t.weak_def_can_be_hidden\t"; break;
   case MCSA_Cold:

llvm/lib/MC/MCXCOFFStreamer.cpp

 
 bool MCXCOFFStreamer::emitSymbolAttribute(MCSymbol *Sym,
                                           MCSymbolAttr Attribute) {
   auto *Symbol = cast<MCSymbolXCOFF>(Sym);
   getAssembler().registerSymbol(*Symbol);
 
   switch (Attribute) {
   case MCSA_Global:
+  case MCSA_Extern:
     Symbol->setStorageClass(XCOFF::C_EXT);
     Symbol->setExternal(true);
     break;
   case MCSA_LGlobal:
     Symbol->setStorageClass(XCOFF::C_HIDEXT);
     Symbol->setExternal(true);
     break;
+  case llvm::MCSA_Weak:
+    Symbol->setStorageClass(XCOFF::C_WEAKEXT);
+    Symbol->setExternal(true);
+    break;
   default:
     report_fatal_error("Not implemented yet.");
   }
   return true;
 }
 
 void MCXCOFFStreamer::emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                        unsigned ByteAlignment) {

llvm/lib/MC/XCOFFObjectWriter.cpp

if (S.isTemporary())
       continue;
 
     const MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(&S);
     const MCSectionXCOFF *ContainingCsect = getContainingCsect(XSym);
 
     if (ContainingCsect->getCSectType() == XCOFF::XTY_ER) {
       // Handle undefined symbol.
       UndefinedCsects.emplace_back(ContainingCsect);
       SectionMap[ContainingCsect] = &UndefinedCsects.back();
-    } else {
-      // If the symbol is the csect itself, we don't need to put the symbol
-      // into csect's Syms.
-      if (XSym == ContainingCsect->getQualNameSymbol())
-        continue;
+      if (nameShouldBeInStringTable(ContainingCsect->getName()))
+        Strings.add(ContainingCsect->getName());
+      continue;
+    }
+
 
-      // Only put a label into the symbol table when it is an external label.
-      if (!XSym->isExternal())
-        continue;
 
-      assert(SectionMap.find(ContainingCsect) != SectionMap.end() &&
-             "Expected containing csect to exist in map");
-      // Lookup the containing csect and add the symbol to it.
-      SectionMap[ContainingCsect]->Syms.emplace_back(XSym);
-    }
 
     // If the name does not fit in the storage provided in the symbol table
     // entry, add it to the string table.
     if (nameShouldBeInStringTable(XSym->getName()))
       Strings.add(XSym->getName());
   }
 
   Strings.finalize();

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

if (Subtarget->isPPC64()) {
     OutStreamer->emitIntValue(0, 8/*size*/);
   }
 }
 
 void PPCAIXAsmPrinter::SetupMachineFunction(MachineFunction &MF) {
   // Setup CurrentFnDescSym and its containing csect.
   MCSectionXCOFF *FnDescSec =
       cast<MCSectionXCOFF>(getObjFileLowering().getSectionForFunctionDescriptor(
           &MF.getFunction(), TM));
   FnDescSec->setAlignment(Align(Subtarget->isPPC64() ? 8 : 4));
 
   CurrentFnDescSym = FnDescSec->getQualNameSymbol();
 
   return AsmPrinter::SetupMachineFunction(MF);
 }
 
 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->hasSection())
     report_fatal_error("Custom section for Data not yet supported.");
 
   if (GV->hasComdat())
     report_fatal_error("COMDAT not yet supported by AIX.");
 }
 
 static bool isSpecialLLVMGlobalArrayForStaticInit(const GlobalVariable *GV) {
   return StringSwitch<bool>(GV->getName())
       .Cases("llvm.global_ctors", "llvm.global_dtors", true)
       .Default(false);
 }
 
 void PPCAIXAsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
   ValidateGV(GV);
 
   // TODO: Update the handling of global arrays for static init when we support
   // the ".ref" directive.
   // Otherwise, we can skip these arrays, because the AIX linker collects
   // static init functions simply based on their name.
   if (isSpecialLLVMGlobalArrayForStaticInit(GV))
     return;
 
   // Create the symbol, set its storage class.
   MCSymbolXCOFF *GVSym = cast<MCSymbolXCOFF>(getSymbol(GV));
   GVSym->setStorageClass(
       TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GV));
 
-  // External global variables are already handled.
-  if (GV->isDeclaration())
+  if (GV->isDeclarationForLinker()) {
+    emitLinkage(GV, GVSym);
     return;
+  }
 
   SectionKind GVKind = getObjFileLowering().getKindForGlobal(GV, TM);
   if (!GVKind.isGlobalWriteableData() && !GVKind.isReadOnly())
     report_fatal_error("Encountered a global variable kind that is "
                        "not supported yet.");
 
   MCSectionXCOFF *Csect = cast<MCSectionXCOFF>(
       getObjFileLowering().SectionForGlobal(GV, GVKind, TM));

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

 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | \
 ; RUN: FileCheck %s
 
 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff < %s | \
 ; RUN: FileCheck %s
 
-define linkonce_odr void @_Z3fooIiEvT_() {
+define linkonce void @_Z3fooIiEvT_() {
 entry:
   ret void
 }
 
-; CHECK: .weak   _Z3fooIiEvT_
+; CHECK: .weak   _Z3fooIiEvT_[DS]
 ; CHECK: .weak   ._Z3fooIiEvT_

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

 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | \
 ; RUN: FileCheck %s
 
 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff < %s | \
 ; RUN: FileCheck %s
 
 define linkonce_odr void @_Z3fooIiEvT_() {
 entry:
   ret void
 }
 
-; CHECK: .weak   _Z3fooIiEvT_
+; CHECK: .weak   _Z3fooIiEvT_[DS]
 ; CHECK: .weak   ._Z3fooIiEvT_

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

 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | \
 ; RUN: FileCheck %s
 
 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff < %s | \
 ; RUN: FileCheck %s
 
-define linkonce_odr void @_Z3fooIiEvT_() {
+define weak_odr void @_Z3fooIiEvT_() {
 entry:
   ret void
 }
 
-; CHECK: .weak   _Z3fooIiEvT_
+; CHECK: .weak   _Z3fooIiEvT_[DS]
 ; CHECK: .weak   ._Z3fooIiEvT_

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec < %s | FileCheck --check-prefixes=COMMON,BIT32 %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec < %s | FileCheck --check-prefixes=COMMON,BIT64 %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec < %s | FileCheck  %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefix=CHECKSYM %s
+
+; RUN: not --crash llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff \
+; RUN: -mattr=-altivec -filetype=obj -o %t.o 2>&1 < %s | FileCheck --check-prefix=XCOFF64 %s
+; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+
+
+@foo_ext_weak_p = global void (...)* bitcast (void ()* @foo_ext_weak_ref to void (...)*)
+@b_w = extern_weak global i32
+
+declare extern_weak void @foo_ext_weak_ref()
+
+define i32 @main() {
+entry:
+  %0 = load void (...)*, void (...)** @foo_ext_weak_p
+  %callee.knr.cast = bitcast void (...)* %0 to void ()*
+  call void %callee.knr.cast()
+  call void @foo_ext_weak(i32* @b_w)
+  ret i32 0
+}
+
+declare extern_weak void @foo_ext_weak(i32*)
+
+; COMMON:         .globl  main[DS]                # -- Begin function main
+; COMMON-NEXT:    .globl  .main
+; COMMON-NEXT:    .align  4
+; COMMON-NEXT:    .csect main[DS]
+; BIT32-NEXT:     .long .main                   # @main
+; BIT32-NEXT:     .long TOC[TC0]
+; BIT32-NEXT:     .long 0
+; BIT64-NEXT:     .llong  .main                   # @main
+; BIT64-NEXT:     .llong  TOC[TC0]
+; BIT64-NEXT:     .llong  0
+; COMMON-NEXT:    .csect  .text[PR]
+; COMMON-NEXT:    .main:
+
+; COMMON:         .csect  .data[RW]
+; COMMON:         .globl  foo_ext_weak_p
+; BIT32-NEXT:     .align  2
+; BIT64-NEXT:     .align  3
+; COMMON-NEXT: foo_ext_weak_p:
+; BIT32-NEXT:     .long foo_ext_weak_ref[DS]
+; BIT64-NEXT:     .llong  foo_ext_weak_ref[DS]
+; COMMON-NEXT:    .weak   b_w[UA]
+; COMMON-NEXT:    .weak   foo_ext_weak_ref[DS]
+; COMMON-NEXT:    .weak   .foo_ext_weak
+; COMMON-NEXT:    .weak   foo_ext_weak[DS]
+; COMMON-NEXT:    .toc
+; COMMON-NEXT: LC0:
+; COMMON-NEXT:    .tc foo_ext_weak_p[TC],foo_ext_weak_p
+; COMMON-NEXT: LC1:
+; COMMON-NEXT:    .tc b_w[TC],b_w[UA]
+
+; CHECK-NOT:      .weak   .foo_ext_weak_ref
+
+; CHECKSYM:      Symbols [
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index:]]
+; CHECKSYM-NEXT:     Name: .foo_ext_weak
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: N_UNDEF
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+1]]
+; CHECKSYM-NEXT:       SectionLen: 0
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+2]]
+; CHECKSYM-NEXT:     Name: foo_ext_weak_ref
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: N_UNDEF
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+3]]
+; CHECKSYM-NEXT:       SectionLen: 0
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+4]]
+; CHECKSYM-NEXT:     Name: b_w
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: N_UNDEF
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+5]]
+; CHECKSYM-NEXT:       SectionLen: 0
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_UA (0x4)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+6]]
+; CHECKSYM-NEXT:     Name: foo_ext_weak
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: N_UNDEF
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+7]]
+; CHECKSYM-NEXT:       SectionLen: 0
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+8]]
+; CHECKSYM-NEXT:     Name: .text
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: .text
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+9]]
+; CHECKSYM-NEXT:       SectionLen: 80
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 4
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+10]]
+; CHECKSYM-NEXT:     Name: .main
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: .text
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+11]]
+; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+8]]
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+12]]
+; CHECKSYM-NEXT:     Name: .data
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x50
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+13]]
+; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+14]]
+; CHECKSYM-NEXT:     Name: foo_ext_weak_p
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x50
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+15]]
+; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+12]]
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+16]]
+; CHECKSYM-NEXT:     Name: main
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x54
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+17]]
+; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+18]]
+; CHECKSYM-NEXT:     Name: TOC
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x60
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+19]]
+; CHECKSYM-NEXT:       SectionLen: 0
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+20]]
+; CHECKSYM-NEXT:     Name: foo_ext_weak_p
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x60
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+21]]
+; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+22]]
+; CHECKSYM-NEXT:     Name: b_w
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x64
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+23]]
+; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT: ]

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

+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec < %s | FileCheck --check-prefixes=COMMON,BIT32 %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec < %s | FileCheck --check-prefixes=COMMON,BIT64 %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefix=CHECKSYM %s
+
+; RUN: not --crash llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff \
+; RUN: -mattr=-altivec -filetype=obj -o %t.o 2>&1 < %s | FileCheck --check-prefix=XCOFF64 %s
+; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+
+@bar_p = global i32 (...)* @bar_ref, align 4
+@b_e = external global i32, align 4
+
+; Function Attrs: noinline nounwind optnone
+define void @foo() {
+entry:
+  ret void
+}
+
+declare i32 @bar_ref(...)
+
+; Function Attrs: noinline nounwind optnone
+define i32 @main() {
+entry:
+  %call = call i32 @bar_extern(i32* @b_e)
+  call void @foo()
+  %0 = load i32 (...)*, i32 (...)** @bar_p, align 4
+  %callee.knr.cast = bitcast i32 (...)* %0 to i32 ()*
+  %call1 = call i32 %callee.knr.cast()
+  %call2 = call i32 bitcast (i32 (...)* @bar_ref to i32 ()*)()
+  ret i32 0
+}
+
+declare i32 @bar_extern(i32*)
+
+
+; COMMON:           .globl  foo[DS]                 # -- Begin function foo
+; COMMON-NEXT:      .globl  .foo
+; COMMON-NEXT:      .align  4
+; COMMON-NEXT:      .csect foo[DS]
+; BIT32-NEXT:       .long .foo                    # @foo
+; BIT32-NEXT:       .long TOC[TC0]
+; BIT32-NEXT:       .long 0
+; BIT64-NEXT:       .llong  .foo                    # @foo
+; BIT64-NEXT:       .llong  TOC[TC0]
+; BIT64-NEXT:       .llong  0
+; COMMON-NEXT:      .csect .text[PR]
+; COMMON-NEXT: .foo:
+
+; COMMON:           .globl  main[DS]                # -- Begin function main
+; COMMON-NEXT:      .globl  .main
+; COMMON-NEXT:      .align  4
+; COMMON-NEXT:      .csect main[DS]
+; BIT32-NEXT:       .long .main                   # @main
+; BIT32-NEXT:       .long TOC[TC0]
+; BIT32-NEXT:       .long 0
+; BIT64-NEXT:       .llong  .main                   # @main
+; BIT64-NEXT:       .llong  TOC[TC0]
+; BIT64-NEXT:       .llong  0
+; COMMON-NEXT:      .csect .text[PR]
+; COMMON-NEXT: .main:
+
+; COMMON:           .csect .data[RW]
+; COMMON-NEXT:      .globl  bar_p
+; BIT32-NEXT:       .align  2
+; BIT64-NEXT:       .align  3
+; COMMON-NEXT: bar_p:
+; BIT32-NEXT:       .long bar_ref[DS]
+; BIT64-NEXT:       .llong  bar_ref[DS]
+; COMMON-NEXT:      .extern b_e[UA]
+; COMMON-NEXT:      .extern .bar_ref
+; COMMON-NEXT:      .extern bar_ref[DS]
+; COMMON-NEXT:      .extern .bar_extern
+; COMMON-NEXT:      .extern     bar_extern[DS]
+; COMMON-NEXT:      .toc
+; COMMON-NEXT: LC0:
+; COMMON-NEXT:      .tc b_e[TC],b_e[UA]
+; COMMON-NEXT: LC1:
+; COMMON-NEXT:      .tc bar_p[TC],bar_p
+
+; CHECKSYM:       Symbols [
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index:]]
+; CHECKSYM-NEXT:     Name: .bar_extern
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: N_UNDEF
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+1]]
+; CHECKSYM-NEXT:       SectionLen: 0
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+2]]
+; CHECKSYM-NEXT:     Name: .bar_ref
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: N_UNDEF
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+3]]
+; CHECKSYM-NEXT:       SectionLen: 0
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+4]]
+; CHECKSYM-NEXT:     Name: bar_ref
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: N_UNDEF
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+5]]
+; CHECKSYM-NEXT:       SectionLen: 0
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+6]]
+; CHECKSYM-NEXT:     Name: b_e
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: N_UNDEF
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+7]]
+; CHECKSYM-NEXT:       SectionLen: 0
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_UA (0x4)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+8]]
+; CHECKSYM-NEXT:     Name: bar_extern
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: N_UNDEF
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+9]]
+; CHECKSYM-NEXT:       SectionLen: 0
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+10]]
+; CHECKSYM-NEXT:     Name: .text
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: .text
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+11]]
+; CHECKSYM-NEXT:       SectionLen: 112
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 4
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+12]]
+; CHECKSYM-NEXT:     Name: .foo
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: .text
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+13]]
+; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+10]]
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+14]]
+; CHECKSYM-NEXT:     Name: .main
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x10
+; CHECKSYM-NEXT:     Section: .text
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+15]]
+; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+10]]
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+16]]
+; CHECKSYM-NEXT:     Name: .data
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x70
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+17]]
+; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+18]]
+; CHECKSYM-NEXT:     Name: bar_p
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x70
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+19]]
+; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+16]]
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+20]]
+; CHECKSYM-NEXT:     Name: foo
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x74
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+21]]
+; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+22]]
+; CHECKSYM-NEXT:     Name: main
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x80
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+23]]
+; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+24]]
+; CHECKSYM-NEXT:     Name: TOC
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x8C
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+25]]
+; CHECKSYM-NEXT:       SectionLen: 0
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+26]]
+; CHECKSYM-NEXT:     Name: b_e
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x8C
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+27]]
+; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+28]]
+; CHECKSYM-NEXT:     Name: bar_p
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x90
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+29]]
+; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT: ]

llvm/test/CodeGen/PowerPC/aix-reference-func-addr-const.ll

 ;CHECK-NEXT:     .globl  foo_ptr
 ;CHECK-NEXT:     .align  2
 ;CHECK-NEXT:     foo_ptr:
 ;CHECK-NEXT:     .long   foo[DS]
 ;CHECK-NEXT:     .globl  bar_ptr1
 ;CHECK-NEXT:     .align  2
 ;CHECK-NEXT:     bar_ptr1:
 ;CHECK-NEXT:     .long   bar[DS]
+;CHECK-NEXT:     .extern foo[DS]
 
 ;CHECK64:         .csect .data[RW]
 ;CHECK64-NEXT:         .globl  foo_ptr
 ;CHECK64-NEXT:         .align  3
 ;CHECK64-NEXT:    foo_ptr:
 ;CHECK64-NEXT:         .llong  foo[DS]
 ;CHECK64-NEXT:         .globl  bar_ptr1
 ;CHECK64-NEXT:         .align  3
 ;CHECK64-NEXT:    bar_ptr1:
 ;CHECK64-NEXT:         .llong  bar[DS]
+;CHECK64-NEXT:         .extern foo[DS]

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

+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec < %s | FileCheck --check-prefixes=COMMON,BIT32 %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec < %s | FileCheck --check-prefixes=COMMON,BIT64 %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefix=CHECKSYM %s
+
+; RUN: not --crash llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff \
+; RUN: -mattr=-altivec -filetype=obj -o %t.o 2>&1 < %s | FileCheck --check-prefix=XCOFF64 %s
+; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+
+@foo_weak_p = global void (...)* bitcast (void ()* @foo_ref_weak to void (...)*), align 4
+@b = weak global i32 0, align 4
+
+define weak void @foo_weak(i32* %p)  {
+entry:
+  %p.addr = alloca i32*, align 4
+  store i32* %p, i32** %p.addr, align 4
+  %0 = load i32*, i32** %p.addr, align 4
+  %1 = load i32, i32* %0, align 4
+  %inc = add nsw i32 %1, 1
+  store i32 %inc, i32* %0, align 4
+  ret void
+}
+
+define weak void @foo_ref_weak()  {
+entry:
+  ret void
+}
+
+define i32 @main()  {
+entry:
+  %0 = load void (...)*, void (...)** @foo_weak_p, align 4
+  %callee.knr.cast = bitcast void (...)* %0 to void ()*
+  call void %callee.knr.cast()
+  call void @foo_weak(i32* @b)
+  call void @foo_ref_weak()
+  ret i32 0
+}
+
+; COMMON:               .weak foo_weak[DS]            # -- Begin function foo_weak
+; COMMON-NEXT:          .weak .foo_weak
+; COMMON-NEXT:          .align  4
+; COMMON-NEXT:          .csect foo_weak[DS]
+; BIT32-NEXT:           .long .foo_weak               # @foo_weak
+; BIT32-NEXT:           .long TOC[TC0]
+; BIT32-NEXT:           .long 0
+; BIT64-NEXT:           .llong  .foo_weak               # @foo_weak
+; BIT64-NEXT:           .llong  TOC[TC0]
+; BIT64-NEXT:           .llong  0
+; COMMON-NEXT:          .csect .text[PR]
+; COMMON-NEXT:  .foo_weak:
+
+; COMMON:               .weak   foo_ref_weak[DS]        # -- Begin function foo_ref_weak
+; COMMON-NEXT:          .weak .foo_ref_weak
+; COMMON-NEXT:          .align  4
+; COMMON-NEXT:          .csect foo_ref_weak[DS]
+; BIT32-NEXT:           .long .foo_ref_weak           # @foo_ref_weak
+; BIT32-NEXT:           .long TOC[TC0]
+; BIT32-NEXT:           .long 0
+; BIT64-NEXT:           .llong  .foo_ref_weak           # @foo_ref_weak
+; BIT64-NEXT:           .llong  TOC[TC0]
+; BIT64-NEXT:           .llong  0
+; COMMON-NEXT:          .csect .text[PR]
+; COMMON-NEXT:  .foo_ref_weak:
+
+; COMMON:               .globl  main[DS]                # -- Begin function main
+; COMMON-NEXT:          .globl  .main
+; COMMON-NEXT:          .align  4
+; COMMON-NEXT:          .csect main[DS]
+; BIT32-NEXT:           .long .main                   # @main
+; BIT32-NEXT:           .long TOC[TC0]
+; BIT32-NEXT:           .long 0
+; BIT64-NEXT:           .llong  .main                   # @main
+; BIT64-NEXT:           .llong  TOC[TC0]
+; BIT64-NEXT:           .llong  0
+; COMMON-NEXT:          .csect .text[PR]
+; COMMON-NEXT:  .main:
+
+; COMMON:               .csect .data[RW]
+; COMMON-NEXT:          .globl  foo_weak_p
+; BIT32-NEXT:           .align  2
+; BIT64-NEXT:           .align  3
+; COMMON-NEXT:  foo_weak_p:
+; BIT32-NEXT:           .long foo_ref_weak[DS]
+; BIT64-NEXT:           .llong  foo_ref_weak[DS]
+; COMMON-NEXT:          .weak b
+; COMMON-NEXT:          .align  2
+; COMMON-NEXT:  b:
+; COMMON-NEXT:          .long 0                       # 0x0
+; COMMON-NEXT:          .toc
+; COMMON-NEXT:  LC0:
+; COMMON-NEXT:          .tc foo_weak_p[TC],foo_weak_p
+; COMMON-NEXT:  LC1:
+; COMMON-NEXT:          .tc b[TC],b
+
+
+; CHECKSYM:      Symbols [
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index:]]
+; CHECKSYM-NEXT:     Name: .text
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: .text
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+1]]
+; CHECKSYM-NEXT:       SectionLen: 136
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 4
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+2]]
+; CHECKSYM-NEXT:     Name: .foo_weak
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: .text
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+3]]
+; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index]]
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+4]]
+; CHECKSYM-NEXT:     Name: .foo_ref_weak
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x20
+; CHECKSYM-NEXT:     Section: .text
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+5]]
+; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index]]
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+6]]
+; CHECKSYM-NEXT:     Name: .main
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x30
+; CHECKSYM-NEXT:     Section: .text
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+7]]
+; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index]]
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+8]]
+; CHECKSYM-NEXT:     Name: .data
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x88
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+9]]
+; CHECKSYM-NEXT:       SectionLen: 8
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+10]]
+; CHECKSYM-NEXT:     Name: foo_weak_p
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x88
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+11]]
+; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+8]]
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+12]]
+; CHECKSYM-NEXT:     Name: b
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x8C
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+13]]
+; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+8]]
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+14]]
+; CHECKSYM-NEXT:     Name: foo_weak
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x90
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+15]]
+; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+16]]
+; CHECKSYM-NEXT:     Name: foo_ref_weak
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x9C
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+17]]
+; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+18]]
+; CHECKSYM-NEXT:     Name: main
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xA8
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+19]]
+; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+20]]
+; CHECKSYM-NEXT:     Name: TOC
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xB4
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+21]]
+; CHECKSYM-NEXT:       SectionLen: 0
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+22]]
+; CHECKSYM-NEXT:     Name: foo_weak_p
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xB4
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+23]]
+; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT:   Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index+24]]
+; CHECKSYM-NEXT:     Name: b
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xB8
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+25]]
+; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+; CHECKSYM-NEXT: ]

llvm/test/CodeGen/PowerPC/aix-xcoff-reloc.ll

 ; OBJ-NEXT: Format: aixcoff-rs6000
 ; OBJ-NEXT: Arch: powerpc
 ; OBJ-NEXT: AddressSize: 32bit
 ; OBJ-NEXT: FileHeader {
 ; OBJ-NEXT:   Magic: 0x1DF
 ; OBJ-NEXT:   NumberOfSections: 2
 ; OBJ-NEXT:   TimeStamp: None (0x0)
 ; OBJ-NEXT:   SymbolTableOffset: 0x13C
-; OBJ-NEXT:   SymbolTableEntries: 24
+; OBJ-NEXT:   SymbolTableEntries: 26
 ; OBJ-NEXT:   OptionalHeaderSize: 0x0
 ; OBJ-NEXT:   Flags: 0x0
 ; OBJ-NEXT: }
 ; OBJ-NEXT: Sections [
 ; OBJ-NEXT:   Section {
 ; OBJ-NEXT:     Index: 1
 ; OBJ-NEXT:     Name: .text
 ; OBJ-NEXT:     PhysicalAddress: 0x0

 ; RELOC-NEXT:     Symbol: .bar (0)
 ; RELOC-NEXT:     IsSigned: Yes
 ; RELOC-NEXT:     FixupBitValue: 0
 ; RELOC-NEXT:     Length: 26
 ; RELOC-NEXT:     Type: R_RBR (0x1A)
 ; RELOC-NEXT:   }
 ; RELOC-NEXT:   Relocation {
 ; RELOC-NEXT:     Virtual Address: 0x1A
-; RELOC-NEXT:     Symbol: globalA (20)
+; RELOC-NEXT:     Symbol: globalA (22)
 ; RELOC-NEXT:     IsSigned: No
 ; RELOC-NEXT:     FixupBitValue: 0
 ; RELOC-NEXT:     Length: 16
 ; RELOC-NEXT:     Type: R_TOC (0x3)
 ; RELOC-NEXT:   }
 ; RELOC-NEXT:   Relocation {
 ; RELOC-NEXT:     Virtual Address: 0x1E
-; RELOC-NEXT:     Symbol: globalB (22)
+; RELOC-NEXT:     Symbol: globalB (24)
 ; RELOC-NEXT:     IsSigned: No
 ; RELOC-NEXT:     FixupBitValue: 0
 ; RELOC-NEXT:     Length: 16
 ; RELOC-NEXT:     Type: R_TOC (0x3)
 ; RELOC-NEXT:   }
 ; RELOC-NEXT: }
 ; RELOC-NEXT: Section (index: 2) .data {
 ; RELOC-NEXT: Relocation {
 ; RELOC-NEXT:   Virtual Address: 0x70
-; RELOC-NEXT:   Symbol: arr (12)
+; RELOC-NEXT:   Symbol: arr (14)
 ; RELOC-NEXT:   IsSigned: No
 ; RELOC-NEXT:   FixupBitValue: 0
 ; RELOC-NEXT:   Length: 32
 ; RELOC-NEXT:   Type: R_POS (0x0)
 ; RELOC-NEXT: }
 ; RELOC-NEXT: Relocation {
 ; RELOC-NEXT:   Virtual Address: 0x74
-; RELOC-NEXT:   Symbol: .foo (4)
+; RELOC-NEXT:   Symbol: .foo (6)
 ; RELOC-NEXT:   IsSigned: No
 ; RELOC-NEXT:   FixupBitValue: 0
 ; RELOC-NEXT:   Length: 32
 ; RELOC-NEXT:   Type: R_POS (0x0)
 ; RELOC-NEXT: }
 ; RELOC-NEXT: Relocation {
 ; RELOC-NEXT:   Virtual Address: 0x78
-; RELOC-NEXT:   Symbol: TOC (18)
+; RELOC-NEXT:   Symbol: TOC (20)
 ; RELOC-NEXT:   IsSigned: No
 ; RELOC-NEXT:   FixupBitValue: 0
 ; RELOC-NEXT:   Length: 32
 ; RELOC-NEXT:   Type: R_POS (0x0)
 ; RELOC-NEXT: }
 ; RELOC-NEXT: Relocation {
 ; RELOC-NEXT:   Virtual Address: 0x80
-; RELOC-NEXT:   Symbol: globalA (8)
+; RELOC-NEXT:   Symbol: globalA (10)
 ; RELOC-NEXT:   IsSigned: No
 ; RELOC-NEXT:   FixupBitValue: 0
 ; RELOC-NEXT:   Length: 32
 ; RELOC-NEXT:   Type: R_POS (0x0)
 ; RELOC-NEXT: }
 ; RELOC-NEXT: Relocation {
 ; RELOC-NEXT:   Virtual Address: 0x84
-; RELOC-NEXT:   Symbol: globalB (10)
+; RELOC-NEXT:   Symbol: globalB (12)
 ; RELOC-NEXT:   IsSigned: No
 ; RELOC-NEXT:   FixupBitValue: 0
 ; RELOC-NEXT:   Length: 32
 ; RELOC-NEXT:   Type: R_POS (0x0)
 ; RELOC-NEXT: }
 ; RELOC-NEXT: }
 ; RELOC-NEXT: ]
 

 ; SYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; SYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: 2
+; SYM-NEXT:     Name: bar
+; SYM-NEXT:     Value (RelocatableAddress): 0x0
+; SYM-NEXT:     Section: N_UNDEF
+; SYM-NEXT:     Type: 0x0
+; SYM-NEXT:     StorageClass: C_EXT (0x2)
+; SYM-NEXT:     NumberOfAuxEntries: 1
+; SYM-NEXT:     CSECT Auxiliary Entry {
+; SYM-NEXT:       Index: 3
+; SYM-NEXT:       SectionLen: 0
+; SYM-NEXT:       ParameterHashIndex: 0x0
+; SYM-NEXT:       TypeChkSectNum: 0x0
+; SYM-NEXT:       SymbolAlignmentLog2: 0
+; SYM-NEXT:       SymbolType: XTY_ER (0x0)
+; SYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
+; SYM-NEXT:       StabInfoIndex: 0x0
+; SYM-NEXT:       StabSectNum: 0x0
+; SYM-NEXT:     }
+; SYM-NEXT:   }
+; SYM-NEXT:   Symbol {
+; SYM-NEXT:     Index: 4
 ; SYM-NEXT:     Name: .text
 ; SYM-NEXT:     Value (RelocatableAddress): 0x0
 ; SYM-NEXT:     Section: .text
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 3
+; SYM-NEXT:       Index: 5
 ; SYM-NEXT:       SectionLen: 64
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 4
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: 4
+; SYM-NEXT:     Index: 6
 ; SYM-NEXT:     Name: .foo
 ; SYM-NEXT:     Value (RelocatableAddress): 0x0
 ; SYM-NEXT:     Section: .text
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 5
-; SYM-NEXT:       ContainingCsectSymbolIndex: 2
+; SYM-NEXT:       Index: 7
+; SYM-NEXT:       ContainingCsectSymbolIndex: 4
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 0
 ; SYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: 6
+; SYM-NEXT:     Index: 8
 ; SYM-NEXT:     Name: .data
 ; SYM-NEXT:     Value (RelocatableAddress): 0x40
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 7
+; SYM-NEXT:       Index: 9
 ; SYM-NEXT:       SectionLen: 52
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 2
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: 8
+; SYM-NEXT:     Index: 10
 ; SYM-NEXT:     Name: globalA
 ; SYM-NEXT:     Value (RelocatableAddress): 0x40
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 9
-; SYM-NEXT:       ContainingCsectSymbolIndex: 6
+; SYM-NEXT:       Index: 11
+; SYM-NEXT:       ContainingCsectSymbolIndex: 8
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 0
 ; SYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: 10
+; SYM-NEXT:     Index: 12
 ; SYM-NEXT:     Name: globalB
 ; SYM-NEXT:     Value (RelocatableAddress): 0x44
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 11
-; SYM-NEXT:       ContainingCsectSymbolIndex: 6
+; SYM-NEXT:       Index: 13
+; SYM-NEXT:       ContainingCsectSymbolIndex: 8
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 0
 ; SYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: 12
+; SYM-NEXT:     Index: 14
 ; SYM-NEXT:     Name: arr
 ; SYM-NEXT:     Value (RelocatableAddress): 0x48
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 13
-; SYM-NEXT:       ContainingCsectSymbolIndex: 6
+; SYM-NEXT:       Index: 15
+; SYM-NEXT:       ContainingCsectSymbolIndex: 8
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 0
 ; SYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: 14
+; SYM-NEXT:     Index: 16
 ; SYM-NEXT:     Name: p
 ; SYM-NEXT:     Value (RelocatableAddress): 0x70
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 15
-; SYM-NEXT:       ContainingCsectSymbolIndex: 6
+; SYM-NEXT:       Index: 17
+; SYM-NEXT:       ContainingCsectSymbolIndex: 8
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 0
 ; SYM-NEXT:       SymbolType: XTY_LD (0x2)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: 16
+; SYM-NEXT:     Index: 18
 ; SYM-NEXT:     Name: foo
 ; SYM-NEXT:     Value (RelocatableAddress): 0x74
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 17
+; SYM-NEXT:       Index: 19
 ; SYM-NEXT:       SectionLen: 12
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 2
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: 18
+; SYM-NEXT:     Index: 20
 ; SYM-NEXT:     Name: TOC
 ; SYM-NEXT:     Value (RelocatableAddress): 0x80
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 19
+; SYM-NEXT:       Index: 21
 ; SYM-NEXT:       SectionLen: 0
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 2
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: 20
+; SYM-NEXT:     Index: 22
 ; SYM-NEXT:     Name: globalA
 ; SYM-NEXT:     Value (RelocatableAddress): 0x80
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 21
+; SYM-NEXT:       Index: 23
 ; SYM-NEXT:       SectionLen: 4
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 2
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: 22
+; SYM-NEXT:     Index: 24
 ; SYM-NEXT:     Name: globalB
 ; SYM-NEXT:     Value (RelocatableAddress): 0x84
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 23
+; SYM-NEXT:       Index: 25
 ; SYM-NEXT:       SectionLen: 4
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 2
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0