[XCOFF] dynamically allocating the section and csect group

[shchenz]

Summary

We add DWARF support in https://reviews.llvm.org/D97184. For DWARF sections, because there are many of them especially for DWARF 5, 20 DWARF sections without split-dwarf feature and 30 sections with split-dwarf support, it is not good to predefine them as we do for csect sections(text, data, bss). We should dynamically allocate section entries for DWARF sections.

This patch refactors the generation for csect sections to be dynamically allocated, so csect sections can be handled the same way as DWARF sections.

This patch also refactors the groups to be dynamically allocated in one csect section.

Because of dynamically allocating, the order of the sections/groups is determined by the object writer's caller. As shown in the test, the order of BSSCsects and FuncDSCsects is changed after this patch.

[shchenz]

1: LINT warning fix

[jasonliu]

Thanks for working on this version of the patch. It's always good to have something concrete to talk about instead of imaging how it's going to look like when everything is in place.
I'm still not convinced that dynamically allocating csect groups is the way to go though.
As you could see in the patch, the code are more complicated with dynamic allocation, and less efficient(doing more loopings to find the correct CsectGroup).
Also, we now lose control of how the CsectGroup are going to layout inside of a section, and how each section is going to layout in the object file (It now comes in a first come first serve order I believe).
This could bring some practical issues for us. For example, we may prefer to have layouts like: text -> data -> bss -> tdata -> tbss -> dwarf raw datas. But now, I think it's possible that we start having text -> data -> tdata -> bss -> tbss -> dwarf raw datas, which is not quite right when you have tdata cut in between of normal datas.
And I don't see a lot of benefit of having a single vector to contain DWARF sections and csect section. In D97184, we actually handles DWARF sections and csect sections quite differently (i.e. a large block of if/else statement for dwarf and csects).
I would still prefer only dynamically allocating DWARF raw datas, and have pre-defined csect sections. It's less of an issue to dynamically allocating DWARF raw datas because we do not really care the layout between different dwarf raw datas (as long as they are at the end of the object files).

@hubert.reinterpretcast @daltenty @DiggerLin What's your opinions on this? Should we have an offline discussion about the direction?

llvm/lib/MC/XCOFFObjectWriter.cpp

95

If we are doing dynamic allocation for CsectGroup, why do we need to store pointers?

232

I don't think it's necessary to have a unique_ptr of UndefinedCsects as well.

[shchenz]

hi @jasonliu , thanks a lot for your review.

Also, we now lose control of how the CsectGroup are going to layout inside of a section, and how each section is going to layout in the object file (It now comes in a first come first serve order I believe).
This could bring some practical issues for us. For example, we may prefer to have layouts like: text -> data -> bss -> tdata -> tbss -> dwarf raw datas. But now, I think it's possible that we start having text -> data -> tdata -> bss -> tbss -> dwarf raw datas, which is not quite right when you have tdata cut in between of normal datas.

I think the layout of the object should not be done in XCOFFObjectWriter. In file XCOFFObjectWriter, we only call executePostLayoutBinding which theoretically should not do something to the layout? Instead, if we have any specific requirement for the layout of the object, does it make more sense to implement it in another virtual function finishLayout() or in MCAssembler::layout()? finishLayout() is before the calling to executePostLayoutBinding in class MCAssembler.

And I don't see a lot of benefit of having a single vector to contain DWARF sections and csect section. In D97184, we actually handles DWARF sections and csect sections quite differently (i.e. a large block of if/else statement for dwarf and csects).

Hmm, I did a prototype to change the patch D97184 to create a virtual function writeSection() in class XCOFFObjectWriter and override this function in class DwarfSectionEntry and CsectSectionEntry, so we can use a single interface to write sections for both control section and DWARF section. We can also do the same change for other interfaces like writing symbols. I gave this up to avoid to big changes and thought maybe it is better to do that in another patch.

I would still prefer only dynamically allocating DWARF raw datas, and have pre-defined csect sections. It's less of an issue to dynamically allocating DWARF raw datas because we do not really care the layout between different dwarf raw datas (as long as they are at the end of the object files).

Yeah, this is also a good way if we decide we don't need this refactoring.

llvm/lib/MC/XCOFFObjectWriter.cpp

95

If we use CsectGroup instead of a pointer, so we need to allocate a CsectGroup object in stack and then insert the std::move-d stack object to the deque? I am not sure the benefit of allocating the object in stack and in heap? Could you help to explain more? Thanks.

[shchenz]

This is not needed anymore. Now we use different containers for csect and dwarf sections

llvm/lib/MC/XCOFFObjectWriter.cpp

XCOFFSection(const MCSectionXCOFF *MCSec)
       : MCSec(MCSec), SymbolTableIndex(-1), Address(-1), Size(0) {}
 };
 
 // Type to be used for a container representing a set of csects with
 // (approximately) the same storage mapping class. For example all the csects
 // with a storage mapping class of `xmc_pr` will get placed into the same
 // container.
 using CsectGroup = std::deque<XCOFFSection>;
-using CsectGroups = std::deque<CsectGroup *>;
+using CsectGroups = std::deque<std::unique_ptr<CsectGroup>>;
 
 // The basic section entry defination. This Section represents a section entry
 // in XCOFF section header table.
 struct SectionEntry {
   char Name[XCOFF::NameSize];
   // The physical/virtual address of the section. For an object file
   // these values are equivalent.
   uint32_t Address;

 // TOCBase and TOC-entry csects.
 struct CsectSectionEntry : public SectionEntry {
   // Virtual sections do not need storage allocated in the object file.
   const bool IsVirtual;
 
   // This is a section containing csect groups.
   CsectGroups Groups;
 
-  CsectSectionEntry(StringRef N, XCOFF::SectionTypeFlags Flags, bool IsVirtual,
-                    CsectGroups Groups)
-      : SectionEntry(N, Flags), IsVirtual(IsVirtual), Groups(Groups) {
+  CsectSectionEntry(StringRef N, XCOFF::SectionTypeFlags Flags, bool IsVirtual)
+      : SectionEntry(N, Flags), IsVirtual(IsVirtual) {
     assert(N.size() <= XCOFF::NameSize && "section name too long");
     memcpy(Name, N.data(), N.size());
   }
 
   void reset() override {
     SectionEntry::reset();
     // Clear any csects we have stored.
-    for (auto *Group : Groups)
+    for (auto &Group : Groups)
       Group->clear();
   }
 
   virtual ~CsectSectionEntry() {}
 
   uint32_t getSectionEntryKind() const override { return SectionEntryCsect; };
   static bool classof(const SectionEntry *Sec) {
     return Sec->getSectionEntryKind() == SectionEntryCsect;
class XCOFFObjectWriter : public MCObjectWriter {
   // wrapper. Needed for finding the XCOFFSection to insert an MCSymbol into
   // from its containing MCSectionXCOFF.
   DenseMap<const MCSectionXCOFF *, XCOFFSection *> SectionMap;
 
   // Maps the MCSymbol representation to its corrresponding symbol table index.
   // Needed for relocation.
   DenseMap<const MCSymbol *, uint32_t> SymbolIndexMap;
 
-  // CsectGroups. These store the csects which make up different parts of
-  // the sections. Should have one for each set of csects that get mapped into
-  // the same section and get handled in a 'similar' way.
-  CsectGroup UndefinedCsects;
-  CsectGroup ProgramCodeCsects;
-  CsectGroup ReadOnlyCsects;
-  CsectGroup DataCsects;
-  CsectGroup FuncDSCsects;
-  CsectGroup TOCCsects;
-  CsectGroup BSSCsects;
-
-  // The Predefined sections.
-  CsectSectionEntry Text;
-  CsectSectionEntry Data;
-  CsectSectionEntry BSS;
-
-  // All the XCOFF sections, in the order they will appear in the section header
-  // table.
-  std::array<SectionEntry *const, 3> Sections{{&Text, &Data, &BSS}};
+  std::unique_ptr<CsectGroup> UndefinedCsects;
 
-  CsectGroup &getCsectGroup(const MCSectionXCOFF *MCSec);
+  // All the XCOFF sections.
+  SmallVector<std::unique_ptr<SectionEntry>, 4> Sections;
 
   virtual void reset() override;
 
   void executePostLayoutBinding(MCAssembler &, const MCAsmLayout &) override;
 
   void recordRelocation(MCAssembler &, const MCAsmLayout &, const MCFragment *,
                         const MCFixup &, MCValue, uint64_t &) override;
 
class XCOFFObjectWriter : public MCObjectWriter {
   // *) Calculates physical/virtual addresses, raw-pointer offsets, and section
   //    sizes.
   // *) Assigns symbol table indices.
   // *) Builds up the section header table by adding any non-empty sections to
   //    `Sections`.
   void assignAddressesAndIndices(const MCAsmLayout &);
   void finalizeSectionInfo();
 
+  // Find the CsectGroup in the Sectons, return the CsectGroup if found and
+  // nullptr if not found.
+  std::unique_ptr<CsectGroup> *getCsectGroup(const MCSectionXCOFF *MCSec);
+
+  // Find the SectionEntry in the Sectons, return the SectionEntry if found and
+  // nullptr if not found.
+  std::unique_ptr<SectionEntry> *getCsectSectionEntry(const CsectGroup *Group);
+
   bool
   needsAuxiliaryHeader() const { /* TODO aux header support not implemented. */
     return false;
   }
 
   // Returns the size of the auxiliary header to be written to the object file.
   size_t auxiliaryHeaderSize() const {
     assert(!needsAuxiliaryHeader() &&
            "Auxiliary header support not implemented.");
     return 0;
   }
 
+  bool isProgramCodeCsects(const MCSectionXCOFF *MCSec) {
+    return MCSec->getMappingClass() == XCOFF::XMC_PR;
+  }
+  bool isReadOnlyCsects(const MCSectionXCOFF *MCSec) {
+    return MCSec->getMappingClass() == XCOFF::XMC_RO;
+  }
+  bool isBSSCsects(const MCSectionXCOFF *MCSec) {
+    return (MCSec->getMappingClass() == XCOFF::XMC_RW &&
+            MCSec->getCSectType() == XCOFF::XTY_CM) ||
+           (MCSec->getMappingClass() == XCOFF::XMC_BS);
+  }
+  bool isDataCsects(const MCSectionXCOFF *MCSec) {
+    return MCSec->getMappingClass() == XCOFF::XMC_RW &&
+           MCSec->getCSectType() == XCOFF::XTY_SD;
+  }
+  bool isFuncDSCsects(const MCSectionXCOFF *MCSec) {
+    return MCSec->getMappingClass() == XCOFF::XMC_DS;
+  }
+  bool isTOCCsects(const MCSectionXCOFF *MCSec) {
+    XCOFF::StorageMappingClass SMC = MCSec->getMappingClass();
+    return SMC == XCOFF::XMC_TC0 || SMC == XCOFF::XMC_TC ||
+           SMC == XCOFF::XMC_TE;
+  }
+
+  bool isTextSectionEntry(const CsectGroup *Group) {
+    assert(!Group->empty() && "Empty Group!");
+    return isProgramCodeCsects(Group->front().MCSec) ||
+           isReadOnlyCsects(Group->front().MCSec);
+  }
+  bool isDataSectionEntry(const CsectGroup *Group) {
+    assert(!Group->empty() && "Empty Group!");
+    return isDataCsects(Group->front().MCSec) ||
+           isFuncDSCsects(Group->front().MCSec) ||
+           isTOCCsects(Group->front().MCSec);
+  }
+  bool isBSSSectionEntry(const CsectGroup *Group) {
+    assert(!Group->empty() && "Empty Group!");
+    return isBSSCsects(Group->front().MCSec);
+  }
+
 public:
   XCOFFObjectWriter(std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW,
                     raw_pwrite_stream &OS);
 };
 
 XCOFFObjectWriter::XCOFFObjectWriter(
     std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS)
     : W(OS, support::big), TargetObjectWriter(std::move(MOTW)),
       Strings(StringTableBuilder::XCOFF),
-      Text(".text", XCOFF::STYP_TEXT, /* IsVirtual */ false,
-           CsectGroups{&ProgramCodeCsects, &ReadOnlyCsects}),
-      Data(".data", XCOFF::STYP_DATA, /* IsVirtual */ false,
-           CsectGroups{&DataCsects, &FuncDSCsects, &TOCCsects}),
-      BSS(".bss", XCOFF::STYP_BSS, /* IsVirtual */ true,
-          CsectGroups{&BSSCsects}) {}
+      UndefinedCsects(std::make_unique<CsectGroup>()) {}
 
 void XCOFFObjectWriter::reset() {
   // Clear the mappings we created.
   SymbolIndexMap.clear();
   SectionMap.clear();
 
-  UndefinedCsects.clear();
+  UndefinedCsects->clear();
   // Reset any sections we have written to, and empty the section header table.
-  for (auto *Sec : Sections)
+  for (auto &Sec : Sections)
     Sec->reset();
 
+  Sections.clear();
+
   // Reset states in XCOFFObjectWriter.
   SymbolTableEntryCount = 0;
   SymbolTableOffset = 0;
   SectionCount = 0;
   RelocationEntryOffset = 0;
   Strings.clear();
 
   MCObjectWriter::reset();
 }
 
-CsectGroup &XCOFFObjectWriter::getCsectGroup(const MCSectionXCOFF *MCSec) {
-  switch (MCSec->getMappingClass()) {
-  case XCOFF::XMC_PR:
-    assert(XCOFF::XTY_SD == MCSec->getCSectType() &&
-           "Only an initialized csect can contain program code.");
-    return ProgramCodeCsects;
-  case XCOFF::XMC_RO:
-    assert(XCOFF::XTY_SD == MCSec->getCSectType() &&
-           "Only an initialized csect can contain read only data.");
-    return ReadOnlyCsects;
-  case XCOFF::XMC_RW:
-    if (XCOFF::XTY_CM == MCSec->getCSectType())
-      return BSSCsects;
-
-    if (XCOFF::XTY_SD == MCSec->getCSectType())
-      return DataCsects;
-
-    report_fatal_error("Unhandled mapping of read-write csect to section.");
-  case XCOFF::XMC_DS:
-    return FuncDSCsects;
-  case XCOFF::XMC_BS:
-    assert(XCOFF::XTY_CM == MCSec->getCSectType() &&
-           "Mapping invalid csect. CSECT with bss storage class must be "
-           "common type.");
-    return BSSCsects;
-  case XCOFF::XMC_TC0:
-    assert(XCOFF::XTY_SD == MCSec->getCSectType() &&
-           "Only an initialized csect can contain TOC-base.");
-    assert(TOCCsects.empty() &&
-           "We should have only one TOC-base, and it should be the first csect "
-           "in this CsectGroup.");
-    return TOCCsects;
-  case XCOFF::XMC_TC:
-  case XCOFF::XMC_TE:
-    assert(XCOFF::XTY_SD == MCSec->getCSectType() &&
-           "Only an initialized csect can contain TC entry.");
-    assert(!TOCCsects.empty() &&
-           "We should at least have a TOC-base in this CsectGroup.");
-    return TOCCsects;
-  default:
-    report_fatal_error("Unhandled mapping of csect to section.");
+// Currently we support
+// ProgramCodeCsects/ReadOnlyCsects/BSSCsects/DataCsects/FuncDSCsects/TOCCsects.
+std::unique_ptr<CsectGroup> *
+XCOFFObjectWriter::getCsectGroup(const MCSectionXCOFF *MCSec) {
+  if (Sections.empty())
+    return nullptr;
+
+  for (auto &SectionEntry : Sections) {
+    if (CsectSectionEntry *Csect =
+            dyn_cast<CsectSectionEntry>(SectionEntry.get())) {
+      for (auto &Group : Csect->Groups) {
+        // For FuncDSCsects, it only requires the mapping class. While for other
+        // section group, it requires both the mapping class and the symbol
+        // type.
+        if (MCSec->getMappingClass() == XCOFF::XMC_DS &&
+            Group->front().MCSec->getMappingClass() == XCOFF::XMC_DS)
+          return &Group;
+        // For ProgramCodeCsects/ReadOnlyCsects/BSSCsects/DataCsects/TOCCsects.
+        if (Group->front().MCSec->getMappingClass() ==
+                MCSec->getMappingClass() &&
+            Group->front().MCSec->getCSectType() == MCSec->getCSectType())
+          return &Group;
+      }
     }
   }
 
+  return nullptr;
+}
+
+std::unique_ptr<SectionEntry> *
+XCOFFObjectWriter::getCsectSectionEntry(const CsectGroup *Group) {
+  if (Sections.empty())
+    return nullptr;
+
+  bool IsText = isTextSectionEntry(Group);
+  bool IsData = isDataSectionEntry(Group);
+  bool IsBSS = isBSSSectionEntry(Group);
+  assert((IsText + IsData + IsBSS == 1) &&
+         "One Group should only be mapped to one section entry!");
+
+  for (auto &SectionEntry : Sections)
+    if (CsectSectionEntry *Csect =
+            dyn_cast<CsectSectionEntry>(SectionEntry.get()))
+      if ((IsText && Csect->Flags == XCOFF::STYP_TEXT) ||
+          (IsData && Csect->Flags == XCOFF::STYP_DATA) ||
+          (IsBSS && Csect->Flags == XCOFF::STYP_BSS))
+        return &SectionEntry;
+
+  return nullptr;
+}
+
 static MCSectionXCOFF *getContainingCsect(const MCSymbolXCOFF *XSym) {
   if (XSym->isDefined())
     return cast<MCSectionXCOFF>(XSym->getFragment()->getParent());
   return XSym->getRepresentedCsect();
 }
 
 void XCOFFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
                                                  const MCAsmLayout &Layout) {
   if (TargetObjectWriter->is64Bit())
     report_fatal_error("64-bit XCOFF object files are not supported yet.");
 
+  auto CreateNewSectionEntry =
+      [&](const CsectGroup *Group) -> std::unique_ptr<CsectSectionEntry> {
+    bool IsText = isTextSectionEntry(Group);
+    bool IsData = isDataSectionEntry(Group);
+    bool IsBSS = isBSSSectionEntry(Group);
+    assert((IsText + IsData + IsBSS == 1) &&
+           "One Group should only be mapped to one section entry!");
+    if (IsText)
+      return std::make_unique<CsectSectionEntry>(".text", XCOFF::STYP_TEXT,
+                                                 /* IsVirtual */ false);
+    if (IsData)
+      return std::make_unique<CsectSectionEntry>(".data", XCOFF::STYP_DATA,
+                                                 /* IsVirtual */ false);
+    assert(IsBSS && "unsupport section type!");
+    return std::make_unique<CsectSectionEntry>(".bss", XCOFF::STYP_BSS,
+                                               /* IsVirtual */ true);
+  };
+
   for (const auto &S : Asm) {
     const auto *MCSec = cast<const MCSectionXCOFF>(&S);
     assert(SectionMap.find(MCSec) == SectionMap.end() &&
            "Cannot add a section twice.");
     assert(XCOFF::XTY_ER != MCSec->getCSectType() &&
            "An undefined csect should not get registered.");
 
     // If the name does not fit in the storage provided in the symbol table
     // entry, add it to the string table.
     if (nameShouldBeInStringTable(MCSec->getSymbolTableName()))
       Strings.add(MCSec->getSymbolTableName());
 
-    CsectGroup &Group = getCsectGroup(MCSec);
-    Group.emplace_back(MCSec);
-    SectionMap[MCSec] = &Group.back();
+    // Check if the CsectGroup is already generated before.
+    bool IsGroupFound = true;
+    std::unique_ptr<CsectGroup> *Group = getCsectGroup(MCSec);
+    std::unique_ptr<CsectGroup> G;
+    // Create the new CsectGroup.
+    if (!Group) {
+      // If the Group is not found in the Sections, it needs to be added later.
+      IsGroupFound = false;
+      G = std::make_unique<CsectGroup>();
+      Group = &G;
+    }
+
+    // Add the MCSec to the Group.
+    (*Group)->emplace_back(MCSec);
+    SectionMap[MCSec] = &((*Group)->back());
+
+    // Check if the SectionEntry is alredy generated before.
+    std::unique_ptr<SectionEntry> *CsectEntry =
+        getCsectSectionEntry(Group->get());
+
+    bool IsSectionEntryFound = true;
+    std::unique_ptr<SectionEntry> SE;
+    // Create the new CsectSetionEntry.
+    if (!CsectEntry) {
+      SE = CreateNewSectionEntry(Group->get());
+      CsectEntry = &SE;
+      IsSectionEntryFound = false;
+    }
+    assert(!(IsGroupFound && !IsSectionEntryFound) &&
+           "Group exists in non-exist Csect section entry!");
+
+    // If the Group is not in the section entry, now add it.
+    if (!IsGroupFound)
+      (dyn_cast<CsectSectionEntry>((*CsectEntry).get()))
+          ->Groups.emplace_back(std::move(*Group));
+
+    // If the Seciton entry is not in the Sections of the object, now add it.
+    if (!IsSectionEntryFound)
+      Sections.push_back(std::move(*CsectEntry));
   }
 
   for (const MCSymbol &S : Asm.symbols()) {
     // Nothing to do for temporary symbols.
     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();
+      UndefinedCsects->emplace_back(ContainingCsect);
+      SectionMap[ContainingCsect] = &(UndefinedCsects->back());
       if (nameShouldBeInStringTable(ContainingCsect->getSymbolTableName()))
         Strings.add(ContainingCsect->getSymbolTableName());
       continue;
     }
 
     // If the symbol is the csect itself, we don't need to put the symbol
     // into csect's Syms.
     if (XSym == ContainingCsect->getQualNameSymbol())
auto getVirtualAddress = [this,
                             &Layout](const MCSymbol *Sym,
                                      const MCSectionXCOFF *ContainingCsect) {
     // If Sym is a csect, return csect's address.
     // If Sym is a label, return csect's address + label's offset from the csect.
     return SectionMap[ContainingCsect]->Address +
            (Sym->isDefined() ? Layout.getSymbolOffset(*Sym) : 0);
   };
 
+  auto GetTOCSectionGroup = [&]() -> std::unique_ptr<CsectGroup> & {
+    for (auto &Section : Sections) {
+      if (Section->Flags == XCOFF::STYP_DATA) {
+        for (auto &Group :
+             (dyn_cast<CsectSectionEntry>(Section.get()))->Groups) {
+          XCOFF::StorageMappingClass SMC =
+              Group->front().MCSec->getMappingClass();
+          if (SMC == XCOFF::XMC_TC0 || SMC == XCOFF::XMC_TC ||
+              SMC == XCOFF::XMC_TE)
+            return Group;
+        }
+      }
+    }
+    report_fatal_error("TOC section group is not found!");
+  };
+
   const MCSymbol *const SymA = &Target.getSymA()->getSymbol();
 
   MCAsmBackend &Backend = Asm.getBackend();
   bool IsPCRel = Backend.getFixupKindInfo(Fixup.getKind()).Flags &
                  MCFixupKindInfo::FKF_IsPCRel;
 
   uint8_t Type;
   uint8_t SignAndSize;
if (Type == XCOFF::RelocationType::R_POS)
     // The FixedValue should be symbol's virtual address in this object file
     // plus any constant value that we might get.
     FixedValue = getVirtualAddress(SymA, SymASec) + Target.getConstant();
   else if (Type == XCOFF::RelocationType::R_TOC ||
            Type == XCOFF::RelocationType::R_TOCL) {
     // The FixedValue should be the TOC entry offset from the TOC-base plus any
     // constant offset value.
     const int64_t TOCEntryOffset = SectionMap[SymASec]->Address -
-                                   TOCCsects.front().Address +
+                                   GetTOCSectionGroup()->front().Address +
                                    Target.getConstant();
     if (Type == XCOFF::RelocationType::R_TOC && !isInt<16>(TOCEntryOffset))
       report_fatal_error("TOCEntryOffset overflows in small code model mode");
 
     FixedValue = TOCEntryOffset;
   }
 
   assert(
void XCOFFObjectWriter::recordRelocation(MCAssembler &Asm,
   // We already folded "SymbolA + imm64" above when Type is R_POS for SymbolA,
   // now we just need to fold "- SymbolB" here.
   FixedValue -= getVirtualAddress(SymB, SymBSec);
 }
 
 void XCOFFObjectWriter::writeSections(const MCAssembler &Asm,
                                       const MCAsmLayout &Layout) {
   uint32_t CurrentAddressLocation = 0;
-  for (const auto *Section : Sections) {
-    assert(isa<CsectSectionEntry>(Section) && "Only csect entry is supported!");
-    const auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section);
+  for (const auto &Section : Sections) {
+    assert(isa<CsectSectionEntry>(Section.get()) &&
+           "Only csect entry is supported!");
+    const auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get());
     // Nothing to write for this Section.
     if (CsectEntry->Index == SectionEntry::UninitializedIndex ||
         CsectEntry->IsVirtual)
       continue;
 
     // There could be a gap (without corresponding zero padding) between
     // sections.
     assert(CurrentAddressLocation <= CsectEntry->Address &&
            "CurrentAddressLocation should be less than or equal to section "
            "address.");
 
     CurrentAddressLocation = CsectEntry->Address;
 
-    for (const auto *Group : CsectEntry->Groups) {
+    for (const auto &Group : CsectEntry->Groups) {
       for (const auto &Csect : *Group) {
         if (uint32_t PaddingSize = Csect.Address - CurrentAddressLocation)
           W.OS.write_zeros(PaddingSize);
         if (Csect.Size)
           Asm.writeSectionData(W.OS, Csect.MCSec, Layout);
         CurrentAddressLocation = Csect.Address + Csect.Size;
       }
     }
void XCOFFObjectWriter::writeFileHeader() {
   W.write<int32_t>(SymbolTableEntryCount);
   // Size of the optional header.
   W.write<uint16_t>(0);
   // Flags.
   W.write<uint16_t>(0);
 }
 
 void XCOFFObjectWriter::writeSectionHeaderTable() {
-  for (const auto *Sec : Sections) {
+  for (const auto &Sec : Sections) {
     // Nothing to write for this Section.
     if (Sec->Index == SectionEntry::UninitializedIndex)
       continue;
 
     // Write Name.
     ArrayRef<char> NameRef(Sec->Name, XCOFF::NameSize);
     W.write(NameRef);
 
void XCOFFObjectWriter::writeRelocation(XCOFFRelocation Reloc,
                                         const XCOFFSection &CSection) {
   W.write<uint32_t>(CSection.Address + Reloc.FixupOffsetInCsect);
   W.write<uint32_t>(Reloc.SymbolTableIndex);
   W.write<uint8_t>(Reloc.SignAndSize);
   W.write<uint8_t>(Reloc.Type);
 }
 
 void XCOFFObjectWriter::writeRelocations() {
-  for (const auto *Section : Sections) {
+  for (const auto &Section : Sections) {
     if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to write for this Section.
       continue;
 
-    assert(isa<CsectSectionEntry>(Section) && "Only csect entry is supported!");
-    const auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section);
+    assert(isa<CsectSectionEntry>(Section.get()) &&
+           "Only csect entry is supported!");
+    const auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get());
 
-    for (const auto *Group : CsectEntry->Groups) {
+    for (const auto &Group : CsectEntry->Groups) {
       if (Group->empty())
         continue;
 
       for (const auto &Csect : *Group) {
         for (const auto Reloc : Csect.Relocations)
           writeRelocation(Reloc, Csect);
       }
     }
void XCOFFObjectWriter::writeSymbolTable(const MCAsmLayout &Layout) {
   W.write<uint16_t>(0);
   // n_sclass. The C_FILE symbol provides source file-name information,
   // source-language ID and CPU-version ID information and some other optional
   // infos.
   W.write<uint8_t>(XCOFF::C_FILE);
   // n_numaux. No aux entry for now.
   W.write<uint8_t>(0);
 
-  for (const auto &Csect : UndefinedCsects) {
+  for (const auto &Csect : *UndefinedCsects) {
     writeSymbolTableEntryForControlSection(Csect,
                                            XCOFF::ReservedSectionNum::N_UNDEF,
                                            Csect.MCSec->getStorageClass());
   }
 
-  for (const auto *Section : Sections) {
+  for (const auto &Section : Sections) {
     if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to write for this Section.
       continue;
 
-    assert(isa<CsectSectionEntry>(Section) && "Only csect entry is supported!");
-    const auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section);
+    assert(isa<CsectSectionEntry>(Section.get()) &&
+           "Only csect entry is supported!");
+    const auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get());
 
-    for (const auto *Group : CsectEntry->Groups) {
+    for (const auto &Group : CsectEntry->Groups) {
       if (Group->empty())
         continue;
 
       const int16_t SectionIndex = CsectEntry->Index;
       for (const auto &Csect : *Group) {
         // Write out the control section first and then each symbol in it.
         writeSymbolTableEntryForControlSection(Csect, SectionIndex,
                                                Csect.MCSec->getStorageClass());
 
         for (const auto &Sym : Csect.Syms)
           writeSymbolTableEntryForCsectMemberLabel(
               Sym, Csect, SectionIndex, Layout.getSymbolOffset(*(Sym.MCSym)));
       }
     }
   }
 }
 
 void XCOFFObjectWriter::finalizeSectionInfo() {
-  for (auto *Section : Sections) {
+  for (auto &Section : Sections) {
     if (Section->Index == SectionEntry::UninitializedIndex)
       // Nothing to record for this Section.
       continue;
 
-    assert(isa<CsectSectionEntry>(Section) && "Only csect entry is supported!");
-    auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section);
+    assert(isa<CsectSectionEntry>(Section.get()) &&
+           "Only csect entry is supported!");
+    auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get());
 
-    for (const auto *Group : CsectEntry->Groups) {
+    for (const auto &Group : CsectEntry->Groups) {
       if (Group->empty())
         continue;
 
       for (auto &Csect : *Group) {
         const size_t CsectRelocCount = Csect.Relocations.size();
         if (CsectRelocCount >= XCOFF::RelocOverflow ||
             Section->RelocationCount >= XCOFF::RelocOverflow - CsectRelocCount)
           report_fatal_error(
               "relocation entries overflowed; overflow section is "
               "not implemented yet");
 
         CsectEntry->RelocationCount += CsectRelocCount;
       }
     }
   }
 
   // Calculate the file offset to the relocation entries.
   uint64_t RawPointer = RelocationEntryOffset;
-  for (auto Sec : Sections) {
-    assert(isa<CsectSectionEntry>(Sec) && "Only csect entry is supported!");
-    auto *CsectEntry = dyn_cast<CsectSectionEntry>(Sec);
+  for (auto &Sec : Sections) {
+    assert(isa<CsectSectionEntry>(Sec.get()) &&
+           "Only csect entry is supported!");
+    auto *CsectEntry = dyn_cast<CsectSectionEntry>(Sec.get());
 
     if (CsectEntry->Index == SectionEntry::UninitializedIndex ||
         !CsectEntry->RelocationCount)
       continue;
 
     CsectEntry->FileOffsetToRelocations = RawPointer;
     const uint32_t RelocationSizeInSec =
         CsectEntry->RelocationCount * XCOFF::RelocationSerializationSize32;
     RawPointer += RelocationSizeInSec;
     if (RawPointer > UINT32_MAX)
       report_fatal_error("Relocation data overflowed this object file.");
   }
 
   // TODO Error check that the number of symbol table entries fits in 32-bits
   // signed ...
   if (SymbolTableEntryCount)
     SymbolTableOffset = RawPointer;
 }
 
 void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
   // The first symbol table entry (at index 0) is for the file name.
   uint32_t SymbolTableIndex = 1;
 
   // Calculate indices for undefined symbols.
-  for (auto &Csect : UndefinedCsects) {
+  for (auto &Csect : *UndefinedCsects) {
     Csect.Size = 0;
     Csect.Address = 0;
     Csect.SymbolTableIndex = SymbolTableIndex;
     SymbolIndexMap[Csect.MCSec->getQualNameSymbol()] = Csect.SymbolTableIndex;
     // 1 main and 1 auxiliary symbol table entry for each contained symbol.
     SymbolTableIndex += 2;
   }
 
   // The address corrresponds to the address of sections and symbols in the
   // object file. We place the shared address 0 immediately after the
   // section header table.
   uint32_t Address = 0;
   // Section indices are 1-based in XCOFF.
   int32_t SectionIndex = 1;
 
-  for (auto *Section : Sections) {
-    assert(isa<CsectSectionEntry>(Section) && "Only csect entry is supported!");
-    auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section);
-    const bool IsEmpty =
-        llvm::all_of(CsectEntry->Groups,
-                     [](const CsectGroup *Group) { return Group->empty(); });
+  for (auto &Section : Sections) {
+    assert(isa<CsectSectionEntry>(Section.get()) &&
+           "Only csect entry is supported!");
+    auto *CsectEntry = dyn_cast<CsectSectionEntry>(Section.get());
+    const bool IsEmpty = llvm::all_of(
+        CsectEntry->Groups,
+        [](std::unique_ptr<CsectGroup> &Group) { return Group->empty(); });
     if (IsEmpty)
       continue;
 
     if (SectionIndex > MaxSectionIndex)
       report_fatal_error("Section index overflow!");
     CsectEntry->Index = SectionIndex++;
     SectionCount++;
 
     bool SectionAddressSet = false;
-    for (auto *Group : CsectEntry->Groups) {
+    for (auto &Group : CsectEntry->Groups) {
       if (Group->empty())
         continue;
 
       for (auto &Csect : *Group) {
         const MCSectionXCOFF *MCSec = Csect.MCSec;
         Csect.Address = alignTo(Address, MCSec->getAlignment());
         Csect.Size = Layout.getSectionAddressSize(MCSec);
         Address = Csect.Address + Csect.Size;
for (auto &Section : Sections) {
     CsectEntry->Size = Address - CsectEntry->Address;
   }
 
   SymbolTableEntryCount = SymbolTableIndex;
 
   // Calculate the RawPointer value for each section.
   uint64_t RawPointer = sizeof(XCOFF::FileHeader32) + auxiliaryHeaderSize() +
                         SectionCount * sizeof(XCOFF::SectionHeader32);
-  for (auto *Sec : Sections) {
-    assert(isa<CsectSectionEntry>(Sec) && "Only csect entry is supported!");
-    auto *CsectEntry = dyn_cast<CsectSectionEntry>(Sec);
+  for (auto &Sec : Sections) {
+    assert(isa<CsectSectionEntry>(Sec.get()) &&
+           "Only csect entry is supported!");
+    auto *CsectEntry = dyn_cast<CsectSectionEntry>(Sec.get());
     if (CsectEntry->Index == SectionEntry::UninitializedIndex ||
         CsectEntry->IsVirtual)
       continue;
 
     CsectEntry->FileOffsetToData = RawPointer;
     RawPointer += CsectEntry->Size;
     if (RawPointer > UINT32_MAX)
       report_fatal_error("Section raw data overflowed this object file.");

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

 ; 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: .data
+; CHECKSYM-NEXT:     Name: main
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x50
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
-; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+15]]
-; CHECKSYM-NEXT:       SectionLen: 4
+; 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_RW (0x5)
+; 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_ext_weak_p
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x50
+; CHECKSYM-NEXT:     Name: .data
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x5C
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
-; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+17]]
-; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+14]]
+; CHECKSYM-NEXT:       SectionLen: 4
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
-; CHECKSYM-NEXT:       SymbolType: XTY_LD (0x2)
+; 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: main
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x54
+; CHECKSYM-NEXT:     Name: foo_ext_weak_p
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x5C
 ; 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:       ContainingCsectSymbolIndex: [[#Index+16]]
 ; 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:       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: TOC
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x60

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

 ; 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:     Name: foo
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x70
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
-; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+17]]
-; CHECKSYM-NEXT:       SectionLen: 4
+; 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_RW (0x5)
+; 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: bar_p
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x70
+; CHECKSYM-NEXT:     Name: main
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x7C
 ; 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:       SectionLen: 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:       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: foo
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x74
+; CHECKSYM-NEXT:     Name: .data
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x88
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
-; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+21]]
-; CHECKSYM-NEXT:       SectionLen: 12
+; 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_DS (0xA)
+; 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+22]]
-; CHECKSYM-NEXT:     Name: main
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x80
+; CHECKSYM-NEXT:     Name: bar_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+23]]
-; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+20]]
 ; 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:       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+24]]
 ; CHECKSYM-NEXT:     Name: TOC
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x8C

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

 ;CHECKOBJ:      00000000 <.text>:
 ;CHECKOBJ-NEXT:       0: 38 60 00 37                    li 3, 55
 ;CHECKOBJ-NEXT:       4: 4e 80 00 20                    blr{{[[:space:]] *}}
 ;CHECKOBJ-NEXT: 00000008 <.rodata.str1.1>:
 ;CHECKOBJ-NEXT:       8: 68 65 6c 6c                   xori 5, 3, 27756
 ;CHECKOBJ-NEXT:       c: 6f 77 6f 72 xoris 23, 27, 28530
 ;CHECKOBJ-NEXT:      10: 0a 00 00 00 tdlti 0, 0{{[[:space:]] *}}
 ;CHECKOBJ-NEXT: Disassembly of section .data:{{[[:space:]] *}}
-;CHECKOBJ-NEXT: 00000018 <a>:
-;CHECKOBJ-NEXT:      18: 00 01 23 45                   <unknown>
-;CHECKOBJ-NEXT:      1c: 67 8a bc de                   oris 10, 28, 48350{{[[:space:]] *}}
-;CHECKOBJ-NEXT: 00000020 <d>:
-;CHECKOBJ-NEXT:      20: 40 14 00 00                   bdnzf   20, 0x20
-;CHECKOBJ-NEXT:      24: 00 00 00 00                   <unknown>{{[[:space:]] *}}
-;CHECKOBJ-NEXT: 00000028 <foo>:
-;CHECKOBJ-NEXT:      28: 00 00 00 00                   <unknown>
-;CHECKOBJ-NEXT:      2c: 00 00 00 34                   <unknown>
-;CHECKOBJ-NEXT:      30: 00 00 00 00                   <unknown>
+;CHECKOBJ-NEXT: 00000014 <foo>:
+;CHECKOBJ-NEXT:      14: 00 00 00 00                   <unknown>
+;CHECKOBJ-NEXT:      18: 00 00 00 30                   <unknown>
+;CHECKOBJ-NEXT:      1c: 00 00 00 00                   <unknown>{{[[:space:]] *}}
+;CHECKOBJ-NEXT: 00000020 <a>:
+;CHECKOBJ-NEXT:      20: 00 01 23 45                   <unknown>
+;CHECKOBJ-NEXT:      24: 67 8a bc de                   oris 10, 28, 48350{{[[:space:]] *}}
+;CHECKOBJ-NEXT: 00000028 <d>:
+;CHECKOBJ-NEXT:      28: 40 14 00 00                   bdnzf   20, 0x28
+;CHECKOBJ-NEXT:      2c: 00 00 00 00                   <unknown>
 
 ;CHECKSECT: Sections [
 ;CHECKSECT-NEXT:   Section {
 ;CHECKSECT-NEXT:     Index: 1
 ;CHECKSECT-NEXT:     Name: .text
 ;CHECKSECT-NEXT:     PhysicalAddress: 0x0
 ;CHECKSECT-NEXT:     VirtualAddress: 0x0
 ;CHECKSECT-NEXT:     Size: 0x14
 ;CHECKSECT-NEXT:     RawDataOffset: 0x64
 ;CHECKSECT-NEXT:     RelocationPointer: 0x0
 ;CHECKSECT-NEXT:     LineNumberPointer: 0x0
 ;CHECKSECT-NEXT:     NumberOfRelocations: 0
 ;CHECKSECT-NEXT:     NumberOfLineNumbers: 0
 ;CHECKSECT-NEXT:     Type: STYP_TEXT (0x20)
 ;CHECKSECT-NEXT:   }
 ;CHECKSECT-NEXT:   Section {
 ;CHECKSECT-NEXT:     Index: 2
 ;CHECKSECT-NEXT:     Name: .data
-;CHECKSECT-NEXT:     PhysicalAddress: 0x18
-;CHECKSECT-NEXT:     VirtualAddress: 0x18
+;CHECKSECT-NEXT:     PhysicalAddress: 0x14
+;CHECKSECT-NEXT:     VirtualAddress: 0x14
 ;CHECKSECT-NEXT:     Size: 0x1C
 ;CHECKSECT-NEXT:     RawDataOffset: 0x78
 ;CHECKSECT-NEXT:     RelocationPointer: 0x94
 ;CHECKSECT-NEXT:     LineNumberPointer: 0x0
 ;CHECKSECT-NEXT:     NumberOfRelocations: 2
 ;CHECKSECT-NEXT:     NumberOfLineNumbers: 0
 ;CHECKSECT-NEXT:     Type: STYP_DATA (0x40)
 ;CHECKSECT-NEXT:   }
 ;CHECKSECT-NEXT: ]

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

 ; 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:     Name: foo_weak
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x88
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
-; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+9]]
-; CHECKSYM-NEXT:       SectionLen: 8
+; 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_RW (0x5)
+; 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: foo_weak_p
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x88
+; CHECKSYM-NEXT:     Name: foo_ref_weak
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x94
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
-; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+11]]
-; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+8]]
+; CHECKSYM-NEXT:       SectionLen: 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:       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+12]]
-; CHECKSYM-NEXT:     Name: b
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x8C
+; CHECKSYM-NEXT:     Name: main
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xA0
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
-; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+13]]
-; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+8]]
+; CHECKSYM-NEXT:       SectionLen: 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:       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+14]]
-; CHECKSYM-NEXT:     Name: foo_weak
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x90
+; CHECKSYM-NEXT:     Name: .data
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xAC
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
-; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+15]]
-; CHECKSYM-NEXT:       SectionLen: 12
+; 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_DS (0xA)
+; 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: foo_ref_weak
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x9C
+; CHECKSYM-NEXT:     Name: foo_weak_p
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xAC
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
-; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
+; 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:       ContainingCsectSymbolIndex: [[#Index+14]]
 ; 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:       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+18]]
-; CHECKSYM-NEXT:     Name: main
-; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xA8
+; CHECKSYM-NEXT:     Name: b
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xB0
 ; CHECKSYM-NEXT:     Section: .data
 ; CHECKSYM-NEXT:     Type: 0x0
-; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     StorageClass: C_WEAKEXT (0x6F)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+19]]
-; CHECKSYM-NEXT:       SectionLen: 12
+; CHECKSYM-NEXT:       ContainingCsectSymbolIndex: [[#Index+14]]
 ; 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:       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: TOC
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0xB4

llvm/test/CodeGen/PowerPC/aix-xcoff-data-sections.ll

 ; CHECKOBJ-EMPTY:
 ; CHECKOBJ-NEXT:   0000003c (idx: 9) .rodata.str1.1L...str[RO]:
 ; CHECKOBJ-NEXT:         3c: 61 62 63 64
 ; CHECKOBJ-NEXT:         40: 65 66 67 68
 ; CHECKOBJ-NEXT:         44: 00 00 00 00   <unknown>
 ; CHECKOBJ-EMPTY:
 ; CHECKOBJ-NEXT:   Disassembly of section .data:
 ; CHECKOBJ-EMPTY:
-; CHECKOBJ-NEXT:   00000048 (idx: 11) ivar[RW]:
-; CHECKOBJ-NEXT:         48: 00 00 00 23   <unknown>
+; CHECKOBJ-NEXT:   00000048 (idx: 11) foo[DS]:
+; CHECKOBJ-NEXT:         48: 00 00 00 00   <unknown>
+; CHECKOBJ-NEXT:         4c: 00 00 00 68   <unknown>
+; CHECKOBJ-NEXT:         50: 00 00 00 00   <unknown>
 ; CHECKOBJ-EMPTY:
-; CHECKOBJ-NEXT:   0000004c (idx: 13) p[RW]:
-; CHECKOBJ-NEXT:         4c: 00 00 00 3c   <unknown>
+; CHECKOBJ-NEXT:   00000054 (idx: 13) bar[DS]:
+; CHECKOBJ-NEXT:         54: 00 00 00 10   <unknown>
+; CHECKOBJ-NEXT:         58: 00 00 00 68   <unknown>
+; CHECKOBJ-NEXT:         5c: 00 00 00 00   <unknown>
 ; CHECKOBJ-EMPTY:
-; CHECKOBJ-NEXT:   00000050 (idx: 15) foo[DS]:
-; CHECKOBJ-NEXT:         50: 00 00 00 00   <unknown>
-; CHECKOBJ-NEXT:         54: 00 00 00 68   <unknown>
-; CHECKOBJ-NEXT:         58: 00 00 00 00   <unknown>
+; CHECKOBJ-NEXT:   00000060 (idx: 15) ivar[RW]:
+; CHECKOBJ-NEXT:         60: 00 00 00 23   <unknown>
 ; CHECKOBJ-EMPTY:
-; CHECKOBJ-NEXT:   0000005c (idx: 17) bar[DS]:
-; CHECKOBJ-NEXT:         5c: 00 00 00 10   <unknown>
-; CHECKOBJ-NEXT:         60: 00 00 00 68   <unknown>
-; CHECKOBJ-NEXT:         64: 00 00 00 00   <unknown>
+; CHECKOBJ-NEXT:   00000064 (idx: 17) p[RW]:
+; CHECKOBJ-NEXT:         64: 00 00 00 3c   <unknown>
 ; CHECKOBJ-EMPTY:
 ; CHECKOBJ-NEXT:   00000068 (idx: 21) p[TC]:
-; CHECKOBJ-NEXT:         68: 00 00 00 4c   <unknown>
+; CHECKOBJ-NEXT:         68: 00 00 00 64   <unknown>
 ; CHECKOBJ-EMPTY:
 ; CHECKOBJ-NEXT:   0000006c (idx: 23) ivar[TC]:
-; CHECKOBJ-NEXT:         6c: 00 00 00 48   <unknown>
+; CHECKOBJ-NEXT:         6c: 00 00 00 60   <unknown>
 ; CHECKOBJ-EMPTY:
 ; CHECKOBJ-NEXT:   00000070 (idx: 25) a[TC]:
 ; CHECKOBJ-NEXT:         70: 00 00 00 78   <unknown>
 ; CHECKOBJ-EMPTY:
 ; CHECKOBJ-NEXT:   00000074 (idx: 27) f[TC]:
 ; CHECKOBJ-NEXT:         74: 00 00 00 7c   <unknown>
 ; CHECKOBJ-EMPTY:
 ; CHECKOBJ-NEXT:   Disassembly of section .bss:

 ; CHECKSYM:        SymbolType: XTY_SD (0x1)
 ; CHECKSYM:        StorageMappingClass: XMC_RO (0x1)
 ; CHECKSYM:        StabInfoIndex: 0x0
 ; CHECKSYM:        StabSectNum: 0x0
 ; CHECKSYM:      }
 ; CHECKSYM:    }
 ; CHECKSYM:    Symbol {
 ; CHECKSYM:      Name: ivar
-; CHECKSYM:      Value (RelocatableAddress): 0x48
+; CHECKSYM:      Value (RelocatableAddress): 0x60
 ; CHECKSYM:      Section: .data
 ; CHECKSYM:      Type: 0x0
 ; CHECKSYM:      StorageClass: C_EXT (0x2)
 ; CHECKSYM:      NumberOfAuxEntries: 1
 ; CHECKSYM:      CSECT Auxiliary Entry {
 ; CHECKSYM:        SectionLen: 4
 ; CHECKSYM:        ParameterHashIndex: 0x0
 ; CHECKSYM:        TypeChkSectNum: 0x0
 ; CHECKSYM:        SymbolAlignmentLog2: 2
 ; CHECKSYM:        SymbolType: XTY_SD (0x1)
 ; CHECKSYM:        StorageMappingClass: XMC_RW (0x5)
 ; CHECKSYM:        StabInfoIndex: 0x0
 ; CHECKSYM:        StabSectNum: 0x0
 ; CHECKSYM:      }
 ; CHECKSYM:    }
 ; CHECKSYM:    Symbol {
 ; CHECKSYM:      Name: p
-; CHECKSYM:      Value (RelocatableAddress): 0x4C
+; CHECKSYM:      Value (RelocatableAddress): 0x64
 ; CHECKSYM:      Section: .data
 ; CHECKSYM:      Type: 0x0
 ; CHECKSYM:      StorageClass: C_EXT (0x2)
 ; CHECKSYM:      NumberOfAuxEntries: 1
 ; CHECKSYM:      CSECT Auxiliary Entry {
 ; CHECKSYM:        SectionLen: 4
 ; CHECKSYM:        ParameterHashIndex: 0x0
 ; CHECKSYM:        TypeChkSectNum: 0x0

llvm/test/CodeGen/PowerPC/aix-xcoff-explicit-section.ll

 ; CHECKOBJ-NEXT:         14: 38 63 00 01   addi 3, 3, 1
 ; CHECKOBJ-NEXT:         18: 4e 80 00 20   blr
 ; CHECKOBJ-EMPTY:
 ; CHECKOBJ-NEXT:   0000001c (idx: 9) ext_const:
 ; CHECKOBJ-NEXT:         1c: 00 00 00 01   <unknown>
 ; CHECKOBJ-EMPTY:
 ; CHECKOBJ-NEXT:   Disassembly of section .data:
 ; CHECKOBJ-EMPTY:
-; CHECKOBJ-NEXT:   00000020 (idx: 13) ext_var:
-; CHECKOBJ-NEXT:         20: 00 00 00 01   <unknown>
+; CHECKOBJ-NEXT:   00000020 (idx: 11) ext_fun[DS]:
+; CHECKOBJ-NEXT:         20: 00 00 00 00   <unknown>
+; CHECKOBJ-NEXT:         24: 00 00 00 34   <unknown>
+; CHECKOBJ-NEXT:         28: 00 00 00 00   <unknown>
 ; CHECKOBJ-EMPTY:
-; CHECKOBJ-NEXT:   00000024 (idx: 17) ext_zvar:
-; CHECKOBJ-NEXT:         24: 00 00 00 00   <unknown>
+; CHECKOBJ-NEXT:   0000002c (idx: 15) ext_var:
+; CHECKOBJ-NEXT:         2c: 00 00 00 01   <unknown>
 ; CHECKOBJ-EMPTY:
-; CHECKOBJ-NEXT:   00000028 (idx: 19) ext_fun[DS]:
-; CHECKOBJ-NEXT:         28: 00 00 00 00   <unknown>
-; CHECKOBJ-NEXT:         2c: 00 00 00 34   <unknown>
+; CHECKOBJ-NEXT:   00000030 (idx: 19) ext_zvar:
 ; CHECKOBJ-NEXT:         30: 00 00 00 00   <unknown>
 ; CHECKOBJ-EMPTY:
 ; CHECKOBJ-NEXT:   00000034 (idx: 23) ext_var[TC]:
-; CHECKOBJ-NEXT:         34: 00 00 00 20   <unknown>
+; CHECKOBJ-NEXT:         34: 00 00 00 2c   <unknown>
 ; CHECKOBJ-EMPTY:
 ; CHECKOBJ-NEXT:   00000038 (idx: 25) ext_zvar[TC]:
-; CHECKOBJ-NEXT:         38: 00 00 00 24   <unknown>
+; CHECKOBJ-NEXT:         38: 00 00 00 30   <unknown>
 
 ; CHECKSYM:       Symbol {{[{][[:space:]] *}}Index: [[#INDX:]]{{[[:space:]] *}}Name: .ext_fun_sec
 ; 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:        SymbolType: XTY_LD (0x2)
 ; CHECKSYM-NEXT:        StorageMappingClass: XMC_RO (0x1)
 ; CHECKSYM-NEXT:        StabInfoIndex: 0x0
 ; CHECKSYM-NEXT:        StabSectNum: 0x0
 ; CHECKSYM-NEXT:      }
 ; CHECKSYM-NEXT:    }
 ; CHECKSYM-NEXT:    Symbol {
 ; CHECKSYM-NEXT:      Index: [[#INDX+8]]
-; CHECKSYM-NEXT:      Name: .ext_var_sec
+; CHECKSYM-NEXT:      Name: ext_fun
 ; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x20
 ; CHECKSYM-NEXT:      Section: .data
 ; CHECKSYM-NEXT:      Type: 0x0
-; CHECKSYM-NEXT:      StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:      StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:      NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:      CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:        Index: [[#INDX+9]]
-; CHECKSYM-NEXT:        SectionLen: 4
+; 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_RW (0x5)
+; CHECKSYM-NEXT:        StorageMappingClass: XMC_DS (0xA)
 ; CHECKSYM-NEXT:        StabInfoIndex: 0x0
 ; CHECKSYM-NEXT:        StabSectNum: 0x0
 ; CHECKSYM-NEXT:      }
 ; CHECKSYM-NEXT:    }
 ; CHECKSYM-NEXT:    Symbol {
 ; CHECKSYM-NEXT:      Index: [[#INDX+10]]
-; CHECKSYM-NEXT:      Name: ext_var
-; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x20
+; CHECKSYM-NEXT:      Name: .ext_var_sec
+; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x2C
 ; CHECKSYM-NEXT:      Section: .data
 ; CHECKSYM-NEXT:      Type: 0x0
-; CHECKSYM-NEXT:      StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:      StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:      NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:      CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:        Index: [[#INDX+11]]
-; CHECKSYM-NEXT:        ContainingCsectSymbolIndex: [[#INDX+8]]
+; CHECKSYM-NEXT:        SectionLen: 4
 ; CHECKSYM-NEXT:        ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:        TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:        SymbolAlignmentLog2: 0
-; CHECKSYM-NEXT:        SymbolType: XTY_LD (0x2)
+; 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: [[#INDX+12]]
-; CHECKSYM-NEXT:      Name: .ext_zvar_sec
-; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x24
+; CHECKSYM-NEXT:      Name: ext_var
+; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x2C
 ; CHECKSYM-NEXT:      Section: .data
 ; CHECKSYM-NEXT:      Type: 0x0
-; CHECKSYM-NEXT:      StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:      StorageClass: C_EXT (0x2)
 ; CHECKSYM-NEXT:      NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:      CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:        Index: [[#INDX+13]]
-; CHECKSYM-NEXT:        SectionLen: 4
+; CHECKSYM-NEXT:        ContainingCsectSymbolIndex: [[#INDX+10]]
 ; CHECKSYM-NEXT:        ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:        TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:        SymbolAlignmentLog2: 2
-; CHECKSYM-NEXT:        SymbolType: XTY_SD (0x1)
+; 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: [[#INDX+14]]
-; CHECKSYM-NEXT:      Name: ext_zvar
-; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x24
+; CHECKSYM-NEXT:      Name: .ext_zvar_sec
+; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x30
 ; CHECKSYM-NEXT:      Section: .data
 ; CHECKSYM-NEXT:      Type: 0x0
-; CHECKSYM-NEXT:      StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:      StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:      NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:      CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:        Index: [[#INDX+15]]
-; CHECKSYM-NEXT:        ContainingCsectSymbolIndex: [[#INDX+12]]
+; CHECKSYM-NEXT:        SectionLen: 4
 ; CHECKSYM-NEXT:        ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:        TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:        SymbolAlignmentLog2: 0
-; CHECKSYM-NEXT:        SymbolType: XTY_LD (0x2)
+; 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: [[#INDX+16]]
-; CHECKSYM-NEXT:      Name: ext_fun
-; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x28
+; CHECKSYM-NEXT:      Name: ext_zvar
+; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x30
 ; 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: [[#INDX+17]]
-; CHECKSYM-NEXT:        SectionLen: 12
+; CHECKSYM-NEXT:        ContainingCsectSymbolIndex: [[#INDX+14]]
 ; 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:        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:    }

llvm/test/CodeGen/PowerPC/aix-xcoff-lower-comm.ll

 ; CHECK-NEXT:pointer:
 ; ASM32-NEXT:        .vbyte 4, common[RW]
 ; ASM64-NEXT:        .vbyte 8, common[RW]
 
 
 ; RELOC:      Relocations [
 ; RELOC-NEXT:   Section (index: {{[0-9]+}}) .data {
 ; RELOC-NEXT:   Relocation {
-; RELOC-NEXT:     Virtual Address: 0x0
+; RELOC-NEXT:     Virtual Address: 0x4
 ; RELOC-NEXT:     Symbol: common ([[#COM_INDX:]])
 ; 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:        Symbol {{[{][[:space:]] *}}Index: [[#INDX:]]{{[[:space:]] *}}Name: .data
+; SYM:        Symbol {{[{][[:space:]] *}}Index: [[#COM_INDX:]]{{[[:space:]] *}}Name: common
 ; SYM-NEXT:     Value (RelocatableAddress): 0x0
-; SYM-NEXT:     Section: .data
+; SYM-NEXT:     Section: .bss
 ; SYM-NEXT:     Type: 0x0
-; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: [[#INDX+1]]
+; SYM-NEXT:       Index: [[#COM_INDX+1]]
 ; SYM-NEXT:       SectionLen: 4
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 2
-; SYM-NEXT:       SymbolType: XTY_SD (0x1)
+; SYM-NEXT:       SymbolType: XTY_CM (0x3)
 ; SYM-NEXT:       StorageMappingClass: XMC_RW (0x5)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
-; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: [[#INDX+2]]
-; SYM-NEXT:     Name: pointer
-; SYM-NEXT:     Value (RelocatableAddress): 0x0
+; SYM-NEXT:   Symbol {{[{][[:space:]] *}}Index: [[#INDX:]]{{[[:space:]] *}}Name: .data
+; SYM-NEXT:     Value (RelocatableAddress): 0x4
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
-; SYM-NEXT:     StorageClass: C_EXT (0x2)
+; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: [[#INDX+3]]
-; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
+; SYM-NEXT:       Index: [[#INDX+1]]
+; SYM-NEXT:       SectionLen: 4
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
-; SYM-NEXT:       SymbolAlignmentLog2: 0
-; SYM-NEXT:       SymbolType: XTY_LD (0x2)
+; 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: [[#COM_INDX]]
-; SYM-NEXT:     Name: common
+; SYM-NEXT:     Index: [[#INDX+2]]
+; SYM-NEXT:     Name: pointer
 ; SYM-NEXT:     Value (RelocatableAddress): 0x4
-; SYM-NEXT:     Section: .bss
+; 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: [[#COM_INDX+1]]
-; SYM-NEXT:       SectionLen: 4
+; SYM-NEXT:       Index: [[#INDX+3]]
+; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX]]
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
-; SYM-NEXT:       SymbolAlignmentLog2: 2
-; SYM-NEXT:       SymbolType: XTY_CM (0x3)
+; 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:   }

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

 ; 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 (15)
+; RELOC-NEXT:   Virtual Address: 0x40
+; RELOC-NEXT:   Symbol: .foo (7)
 ; 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 (7)
+; RELOC-NEXT:   Virtual Address: 0x44
+; RELOC-NEXT:   Symbol: TOC (21)
 ; 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 (21)
+; RELOC-NEXT:   Virtual Address: 0x7C
+; RELOC-NEXT:   Symbol: arr (17)
 ; 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 (11)
+; RELOC-NEXT:   Symbol: globalA (13)
 ; 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 (13)
+; RELOC-NEXT:   Symbol: globalB (15)
 ; 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_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: [[#INDX+8]]
-; SYM-NEXT:     Name: .data
+; SYM-NEXT:     Name: foo
 ; SYM-NEXT:     Value (RelocatableAddress): 0x40
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
-; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; SYM-NEXT:     StorageClass: C_EXT (0x2)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+9]]
-; SYM-NEXT:       SectionLen: 52
+; 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_RW (0x5)
+; SYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+10]]
-; SYM-NEXT:     Name: globalA
-; SYM-NEXT:     Value (RelocatableAddress): 0x40
+; SYM-NEXT:     Name: .data
+; SYM-NEXT:     Value (RelocatableAddress): 0x4C
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
-; SYM-NEXT:     StorageClass: C_EXT (0x2)
+; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+11]]
-; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX+8]]
+; SYM-NEXT:       SectionLen: 52
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
-; SYM-NEXT:       SymbolAlignmentLog2: 0
-; SYM-NEXT:       SymbolType: XTY_LD (0x2)
+; 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: [[#INDX+12]]
-; SYM-NEXT:     Name: globalB
-; SYM-NEXT:     Value (RelocatableAddress): 0x44
+; SYM-NEXT:     Name: globalA
+; SYM-NEXT:     Value (RelocatableAddress): 0x4C
 ; 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: [[#INDX+13]]
-; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX+8]]
+; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX+10]]
 ; 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: [[#INDX+14]]
-; SYM-NEXT:     Name: arr
-; SYM-NEXT:     Value (RelocatableAddress): 0x48
+; SYM-NEXT:     Name: globalB
+; SYM-NEXT:     Value (RelocatableAddress): 0x50
 ; 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: [[#INDX+15]]
-; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX+8]]
+; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX+10]]
 ; 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: [[#INDX+16]]
-; SYM-NEXT:     Name: p
-; SYM-NEXT:     Value (RelocatableAddress): 0x70
+; SYM-NEXT:     Name: arr
+; SYM-NEXT:     Value (RelocatableAddress): 0x54
 ; 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: [[#INDX+17]]
-; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX+8]]
+; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX+10]]
 ; 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: [[#INDX+18]]
-; SYM-NEXT:     Name: foo
-; SYM-NEXT:     Value (RelocatableAddress): 0x74
+; SYM-NEXT:     Name: p
+; SYM-NEXT:     Value (RelocatableAddress): 0x7C
 ; 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: [[#INDX+19]]
-; SYM-NEXT:       SectionLen: 12
+; SYM-NEXT:       ContainingCsectSymbolIndex: [[#INDX+10]]
 ; 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:       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: [[#INDX+20]]
 ; SYM-NEXT:     Name: TOC
 ; SYM-NEXT:     Value (RelocatableAddress): 0x80

 ; DIS-NEXT:       28: 7c 63 22 14                   add 3, 3, 4
 ; DIS-NEXT:       2c: 7c 63 2a 14                   add 3, 3, 5
 ; DIS-NEXT:       30: 38 21 00 40                   addi 1, 1, 64
 ; DIS-NEXT:       34: 80 01 00 08                   lwz 0, 8(1)
 ; DIS-NEXT:       38: 7c 08 03 a6                   mtlr 0
 ; DIS-NEXT:       3c: 4e 80 00 20                   blr
 
 ; DIS:      Disassembly of section .data:
-; DIS:      00000040 <globalA>:
-; DIS-NEXT:       40: 00 00 00 01                   <unknown>
-; DIS:      00000044 <globalB>:
-; DIS-NEXT:       44: 00 00 00 02                   <unknown>
-; DIS:      00000048 <arr>:
-; DIS-NEXT:       48: 00 00 00 03                   <unknown>
+; DIS:      00000040 <foo>:
+; DIS-NEXT:       40: 00 00 00 00                   <unknown>
+; DIS-NEXT:       44: 00 00 00 80                   <unknown>
+; DIS-NEXT:       48: 00 00 00 00                   <unknown>
+; DIS:      0000004c <globalA>:
+; DIS-NEXT:       4c: 00 00 00 01                   <unknown>
+; DIS:      00000050 <globalB>:
+; DIS-NEXT:       50: 00 00 00 02                   <unknown>
+; DIS:      00000054 <arr>:
+; DIS-NEXT:       54: 00 00 00 03                   <unknown>
 ; DIS-NEXT:                 ...
-; DIS:      00000070 <p>:
-; DIS-NEXT:       70: 00 00 00 58                   <unknown>
-; DIS:      00000074 <foo>:
-; DIS-NEXT:       74: 00 00 00 00                   <unknown>
-; DIS-NEXT:       78: 00 00 00 80                   <unknown>
-; DIS-NEXT:       7c: 00 00 00 00                   <unknown>
+; DIS:      0000007c <p>:
+; DIS-NEXT:       7c: 00 00 00 64                   <unknown>
 ; DIS:      00000080 <globalA>:
-; DIS-NEXT:       80: 00 00 00 40                   <unknown>
+; DIS-NEXT:       80: 00 00 00 4c                   <unknown>
 ; DIS:      00000084 <globalB>:
-; DIS-NEXT:       84: 00 00 00 44                   <unknown>
+; DIS-NEXT:       84: 00 00 00 50                   <unknown>
 
 ; DIS_REL:       {{.*}}aix-xcoff-reloc.ll.tmp.o:   file format aixcoff-rs6000
 ; DIS_REL:       RELOCATION RECORDS FOR [.text]:
 ; DIS_REL-NEXT:  OFFSET   TYPE                     VALUE
 ; DIS_REL-NEXT:  00000010 R_RBR                    .bar
 ; DIS_REL-NEXT:  0000001a R_TOC                    globalA
 ; DIS_REL-NEXT:  0000001e R_TOC                    globalB
 ; DIS_REL:       RELOCATION RECORDS FOR [.data]:
 ; DIS_REL-NEXT:  OFFSET   TYPE                     VALUE
-; DIS_REL-NEXT:  00000030 R_POS                    arr
-; DIS_REL-NEXT:  00000034 R_POS                    .foo
-; DIS_REL-NEXT:  00000038 R_POS                    TOC
+; DIS_REL-NEXT:  00000000 R_POS                    .foo
+; DIS_REL-NEXT:  00000004 R_POS                    TOC
+; DIS_REL-NEXT:  0000003c R_POS                    arr
 ; DIS_REL-NEXT:  00000040 R_POS                    globalA
 ; DIS_REL-NEXT:  00000044 R_POS                    globalB

llvm/test/CodeGen/PowerPC/aix-xcoff-symbol-rename.ll

 ; OBJ-EMPTY:
 ; OBJ-NEXT:  00000060 (idx: 11) .f&_o:
 ; OBJ-NEXT:        60: 80 62 00 04   lwz 3, 4(2)
 ; OBJ-NEXT:                          00000062:  R_TOC        (idx: 27) f@o[TC]
 ; OBJ-NEXT:        64: 4e 80 00 20   blr
 ; OBJ-EMPTY:
 ; OBJ-NEXT:  Disassembly of section .data:
 ; OBJ-EMPTY:
-; OBJ-NEXT:  00000068 (idx: 15) f`o:
-; OBJ-NEXT:        68: 00 00 00 0a   <unknown>
+; OBJ-NEXT:  00000068 (idx: 13) f$o[DS]:
+; OBJ-NEXT:        68: 00 00 00 00   <unknown>
+; OBJ-NEXT:                          00000068:  R_POS        (idx: 7) .f$o
+; OBJ-NEXT:        6c: 00 00 00 90   <unknown>
+; OBJ-NEXT:                          0000006c:  R_POS        (idx: 23) TOC[TC0]
+; OBJ-NEXT:        70: 00 00 00 00   <unknown>
+; OBJ-EMPTY:
+; OBJ-NEXT:  00000074 (idx: 15) f&o[DS]:
+; OBJ-NEXT:        74: 00 00 00 30   <unknown>
+; OBJ-NEXT:                          00000074:  R_POS        (idx: 9) .f&o
+; OBJ-NEXT:        78: 00 00 00 90   <unknown>
+; OBJ-NEXT:                          00000078:  R_POS        (idx: 23) TOC[TC0]
+; OBJ-NEXT:        7c: 00 00 00 00   <unknown>
+; OBJ-EMPTY:
+; OBJ-NEXT:  00000080 (idx: 17) f&_o[DS]:
+; OBJ-NEXT:        80: 00 00 00 60   <unknown>
+; OBJ-NEXT:                          00000080:  R_POS        (idx: 11) .f&_o
+; OBJ-NEXT:        84: 00 00 00 90   <unknown>
+; OBJ-NEXT:                          00000084:  R_POS        (idx: 23) TOC[TC0]
+; OBJ-NEXT:        88: 00 00 00 00   <unknown>
 ; OBJ-EMPTY:
-; OBJ-NEXT:  0000006c (idx: 17) f$o[DS]:
-; OBJ-NEXT:        6c: 00 00 00 00   <unknown>
-; OBJ-NEXT:                          0000006c:  R_POS        (idx: 7) .f$o
-; OBJ-NEXT:        70: 00 00 00 90   <unknown>
-; OBJ-NEXT:                          00000070:  R_POS        (idx: 23) TOC[TC0]
-; OBJ-NEXT:        74: 00 00 00 00   <unknown>
-; OBJ-EMPTY:
-; OBJ-NEXT:  00000078 (idx: 19) f&o[DS]:
-; OBJ-NEXT:        78: 00 00 00 30   <unknown>
-; OBJ-NEXT:                          00000078:  R_POS        (idx: 9) .f&o
-; OBJ-NEXT:        7c: 00 00 00 90   <unknown>
-; OBJ-NEXT:                          0000007c:  R_POS        (idx: 23) TOC[TC0]
-; OBJ-NEXT:        80: 00 00 00 00   <unknown>
-; OBJ-EMPTY:
-; OBJ-NEXT:  00000084 (idx: 21) f&_o[DS]:
-; OBJ-NEXT:        84: 00 00 00 60   <unknown>
-; OBJ-NEXT:                          00000084:  R_POS        (idx: 11) .f&_o
-; OBJ-NEXT:        88: 00 00 00 90   <unknown>
-; OBJ-NEXT:                          00000088:  R_POS        (idx: 23) TOC[TC0]
-; OBJ-NEXT:        8c: 00 00 00 00   <unknown>
+; OBJ-NEXT:  0000008c (idx: 21) f`o:
+; OBJ-NEXT:        8c: 00 00 00 0a   <unknown>
 ; OBJ-EMPTY:
 ; OBJ-NEXT:  00000090 (idx: 25) f=o[TC]:
 ; OBJ-NEXT:        90: 00 00 00 9c   <unknown>
 ; OBJ-NEXT:                          00000090:  R_POS        (idx: 31) f=o[BS]
 ; OBJ-EMPTY:
 ; OBJ-NEXT:  00000094 (idx: 27) f@o[TC]:
 ; OBJ-NEXT:        94: 00 00 00 00   <unknown>
 ; OBJ-NEXT:                          00000094:  R_POS        (idx: 3) f@o[DS]
 ; OBJ-EMPTY:
 ; OBJ-NEXT:  Disassembly of section .bss:
 ; OBJ-EMPTY:
 ; OBJ-NEXT:  00000098 (idx: 29) f"o"[RW]:
 ; OBJ-NEXT:  ...
 ; OBJ-EMPTY:
 ; OBJ-NEXT:  0000009c (idx: 31) f=o[BS]:
 ; OBJ-NEXT:  ...