[PowerPC][AIX] Adds support for writing the data section in object files

[xingxue]

Summary

Adds support for generating the XCOFF data section in object files for global variables with initialization.

[jasonliu]

llvm/lib/MC/XCOFFObjectWriter.cpp

541

We assigned Index and Size to Data section. But we haven't assign Address to it. By default, the address would be 0. It's correct if you do not have a Text section. But once you have text section, the Data's address as 0 would wrong.

[sfertile]

llvm/lib/MC/XCOFFObjectWriter.cpp

308

minor nit: CSections --> control sections or csects.

478

Storage class should come from CSection.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

478

I have changed the interface of void writeSymbolTableEntryForSymbol(const Symbol &, const ControlSection &,

                                    const int16_t, uint64_t);
void writeSymbolTableEntryForControlSection(const ControlSection &,
                                            const int16_t,
                                            XCOFF::StorageClass);

in the https://reviews.llvm.org/D66969. I think here also need to modification based on the new API.

480

ditto

539

there is assert in the https://reviews.llvm.org/D66969 after for (auto &Csect : ProgramCodeCsects) {
}
maybe we can remove this one.

541

The Address value will been changed in the if (!ProgramCodeCsects.empty()) { }
if there is Text Section.

[xingxue]

Addressed comments:

• use csects in comment.
• use section storage class from CSection.
• set the section start address as the address after the previous section.

[xingxue]

llvm/lib/MC/XCOFFObjectWriter.cpp

480

Will follow up when changes in D66969 is updated.

541

Good catch, fixed.

[xingxue]

Changed from Data to Data.Index.

[hubert.reinterpretcast]

Generally, the problems copy/pasted from D66969 will also need to be fixed in this patch.

llvm/lib/MC/XCOFFObjectWriter.cpp

309

Please don't copy the ControlSections.

309

Please see comment on D66969:
We already use Sec and Csect for similar cases. I don't think we need to add CSection into the mix.

476

Please don't copy the ControlSections.

538

In D66969, we try to check for overflow on the section index. We should do so here too to be consistent.

542

This is the third copy of this code or thereabouts. At what point are we going to factor this code into a function?

556

Suggestion: "Make sure that the address of the next section will be aligned to DefaultSectionAlign."

566

This belongs in D66969 and not here. @DiggerLin, please fix.

[hubert.reinterpretcast]

The lack of testing with regards to what gets written for the raw data of the .data XCOFF section ought to be addressed. At the very least, some testing of the .data section header (especially the length) should be present. Proper testing should also verify what the base virtual address associated with the .bss section is.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

480

please do not use copy construct here. please change to for (const auto& Sym : CSection.Syms) {

[hubert.reinterpretcast]

Just following up on my previous comments on this patch based on developments in D66969.

llvm/lib/MC/XCOFFObjectWriter.cpp

538

We stopped checking for overflow on the section index (at least for now). There is a limited number of sections that we will generate.

566

The review of D66969 ended up with the conclusion that adding SectionStartAddress does not help readability.

[xingxue]

llvm/lib/MC/XCOFFObjectWriter.cpp

542

@jasonliu is preparing an NFC patch to common up this code.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

309

changed , thanks

476

changed , thanks

556

changed

566

changed

566

changed , thanks

[xingxue]

Addressed comments:

• Changed variable name CSection -> Csect;
• Added the checking of section headers in the object file.

[xingxue]

Revised based on changes in patch https://reviews.llvm.org/D69112.

[daltenty]

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

1

nit: I think it's worth while to add a comment to the beginning of this test indicating what we are hoping to test (i.e. initialized data). We are starting to have a lot of overlapping test cases, and for simplicity it would be nice to state the intent up front.

21

I'm a bit confused why we are adding this, we don't refer to them in the object writing case. If it's to make sure we don't start emitting uninitialized data into .text shouldn't we have put some check-not's in?

67

Do we want to check this? We currently don't in the object writing case (and this overlaps with aix-xcoff-common.ll).

[xingxue]

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

1

WIll do.

21

These are added to check if the addresses for .bss in the header are correct after the .data section.

67

Again, these are added to check if the addresses for .bss in the header are correct after the .data section.

[daltenty]

I don't think that initialized global data should be coming out as label symbols (everything appears to be contained in a ".data" csect). As I understand it only static data should be glob'd into one big csect, as per the XCOFF spec "An initialized definition for a global data scalar or structure ... is contained in its own csect". So each of these globals should have their own csect, which is the behavior exhibited by XLC.

I've observed that GCC on AIX is currently exhibiting this initalized-globals-in-one-csect behavior, but as we might expect, it interferes with the linkers ability to garbage collect unneeded global data.

I believe this is also an issue in the assembly path in D66154

[sfertile]

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

18

Minor nit: No need to change the name of this global.

21

Lets add the other members from aix-xcoff-common.ll lit test, and perform the checking while dumping the object and then we can get rid of aix-xcoff-common.ll

[daltenty]

In D67125#1725332, @daltenty wrote:

I don't think that initialized global data should be coming out as label symbols (everything appears to be contained in a ".data" csect). As I understand it only static data should be glob'd into one big csect, as per the XCOFF spec "An initialized definition for a global data scalar or structure ... is contained in its own csect". So each of these globals should have their own csect, which is the behavior exhibited by XLC.

I've observed that GCC on AIX is currently exhibiting this initalized-globals-in-one-csect behavior, but as we might expect, it interferes with the linkers ability to garbage collect unneeded global data.

I believe this is also an issue in the assembly path in D66154

As per out of band discussion, we will revisit this behavior under an option flag in a future revision and adopt the GCC behavior for now.

[daltenty]

Other than the minor test cleanup proposed by @sfertile, LGTM

[sfertile]

In D67125#1725439, @daltenty wrote:

In D67125#1725332, @daltenty wrote:

I don't think that initialized global data should be coming out as label symbols (everything appears to be contained in a ".data" csect). As I understand it only static data should be glob'd into one big csect, as per the XCOFF spec "An initialized definition for a global data scalar or structure ... is contained in its own csect". So each of these globals should have their own csect, which is the behavior exhibited by XLC.

I've observed that GCC on AIX is currently exhibiting this initalized-globals-in-one-csect behavior, but as we might expect, it interferes with the linkers ability to garbage collect unneeded global data.

I believe this is also an issue in the assembly path in D66154

As per out of band discussion, we will revisit this behavior under an option flag in a future revision and adopt the GCC behavior for now.

Yep, I was expecting we would transition to the described behaviour once we implement support for --ffunction-sections and --fdata-sections.

llvm/lib/MC/XCOFFObjectWriter.cpp

class XCOFFObjectWriter : public MCObjectWriter {
   StringTableBuilder Strings;
 
   // The non-empty sections, in the order they will appear in the section header
   // table.
   std::vector<Section *> Sections;
 
   // The Predefined sections.
   Section Text;
+  Section Data;
   Section BSS;
 
   // ControlSections. 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.
   ControlSections ProgramCodeCsects;
+  ControlSections DataCsects;
   ControlSections BSSCsects;
 
   uint32_t SymbolTableEntryCount = 0;
   uint32_t SymbolTableOffset = 0;
 
   virtual void reset() override;
 
   void executePostLayoutBinding(MCAssembler &, const MCAsmLayout &) override;
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),
+      Data(".data", XCOFF::STYP_DATA, /* IsVirtual */ false),
       BSS(".bss", XCOFF::STYP_BSS, /* IsVirtual */ true) {}
 
 void XCOFFObjectWriter::reset() {
   // Reset any sections we have written to, and empty the section header table.
   for (auto *Sec : Sections)
     Sec->reset();
   Sections.clear();
 
   // Clear any csects we have stored.
   ProgramCodeCsects.clear();
+  DataCsects.clear();
   BSSCsects.clear();
 
   // Reset the symbol table and string table.
   SymbolTableEntryCount = 0;
   SymbolTableOffset = 0;
   Strings.clear();
 
   MCObjectWriter::reset();
case XCOFF::XMC_PR:
       WrapperMap[MCSec] = &ProgramCodeCsects.back();
       break;
     case XCOFF::XMC_RW:
       if (XCOFF::XTY_CM == MCSec->getCSectType()) {
         BSSCsects.emplace_back(MCSec);
         WrapperMap[MCSec] = &BSSCsects.back();
         break;
       }
+      if (XCOFF::XTY_SD == MCSec->getCSectType()) {
+        DataCsects.emplace_back(MCSec);
+        WrapperMap[MCSec] = &DataCsects.back();
+        break;
+      }
       report_fatal_error("Unhandled mapping of read-write csect to section.");
     case XCOFF::XMC_TC0:
       // TODO FIXME Handle emiting the TOC-base.
       break;
     case XCOFF::XMC_BS:
       assert(XCOFF::XTY_CM == MCSec->getCSectType() &&
              "Mapping invalid csect. CSECT with bss storage class must be "
              "common type.");
void XCOFFObjectWriter::recordRelocation(MCAssembler &, const MCAsmLayout &,
   report_fatal_error("XCOFF relocations not supported.");
 }
 
 void XCOFFObjectWriter::writeSections(const MCAssembler &Asm,
                                       const MCAsmLayout &Layout) {
   // Write the program code control sections one at a time.
   for (const auto CSection : ProgramCodeCsects)
     Asm.writeSectionData(W.OS, CSection.MCCsect, Layout);
+
+  // Write the data csects one at a time.
+  for (const auto CSection : DataCsects)
+    Asm.writeSectionData(W.OS, CSection.MCCsect, Layout);
 }
 
 uint64_t XCOFFObjectWriter::writeObject(MCAssembler &Asm,
                                         const llvm::MCAsmLayout &Layout) {
   // We always emit a timestamp of 0 for reproducibility, so ensure incremental
   // linking is not enabled, in case, like with Windows COFF, such a timestamp
   // is incompatible with incremental linking of XCOFF.
   if (Asm.isIncrementalLinkerCompatible())
for (const auto CSection : ProgramCodeCsects) {
     writeSymbolTableEntryForControlSection(CSection, Text,
                                            CSection.MCCsect->getStorageClass());
     for (const auto Sym : CSection.Syms) {
       writeSymbolTableEntryForSymbol(Sym, CSection, Text,
                                      Layout.getSymbolOffset(*(Sym.MCSym)));
     }
   }
 
+  // Print out symbol table for the data section.
+  for (const auto CSection : DataCsects) {
+    // Write out the control section first and then each symbol in it.
+    writeSymbolTableEntryForControlSection(CSection, Data.Index,
+                                           CSection.MCCsect->getStorageClass());
+    for (const auto Sym : CSection.Syms) {
+      writeSymbolTableEntryForSymbol(Sym, CSection, Data.Index,
+                                     Layout.getSymbolOffset(*(Sym.MCSym)));
+    }
+  }
+
   // The BSS Section is special in that the csects must contain a single symbol,
   // and the contained symbol cannot be represented in the symbol table as a
   // label definition.
   for (auto &Sec : BSSCsects) {
     assert(Sec.Syms.size() == 1 &&
            "Uninitialized csect cannot contain more then 1 symbol.");
     Symbol &Sym = Sec.Syms.back();
     writeSymbolTableEntryForControlSection(Sec, BSS, Sym.getStorageClass());
   }
 }
 
 void XCOFFObjectWriter::assignAddressesAndIndices(
     const llvm::MCAsmLayout &Layout) {
   // 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;
+  uint32_t SectionStartAddress = 0;
   // Section indices are 1-based in XCOFF.
   uint16_t SectionIndex = 1;
   // The first symbol table entry is for the file name. We are not emitting it
   // yet, so start at index 0.
   uint32_t SymbolTableIndex = 0;
 
   // Text section comes first.
   if (!ProgramCodeCsects.empty()) {
     Sections.push_back(&Text);
     Text.Index = SectionIndex++;
-    uint32_t StartAddress = Address;
+    uint32_t Address = SectionStartAddress;
     for (auto &Csect : ProgramCodeCsects) {
       const MCSectionXCOFF *MCSec = Csect.MCCsect;
       Address = alignTo(Address, MCSec->getAlignment());
       Csect.Address = Address;
       Address += Layout.getSectionAddressSize(MCSec);
       Csect.SymbolTableIndex = SymbolTableIndex;
       // 1 main and 1 auxiliary symbol table entry for the csect.
       SymbolTableIndex += 2;
       Csect.Size = Layout.getSectionAddressSize(MCSec);
       for (auto &Sym : Csect.Syms) {
         Sym.SymbolTableIndex = SymbolTableIndex;
         // 1 main and 1 auxiliary symbol table entry for each contained symbol
         SymbolTableIndex += 2;
       }
     }
     assert(alignTo(Address, DefaultSectionAlign) == Address &&
            "Improperly aligned address for section.");
-    Text.Size = Address - StartAddress;
+    Text.Size = Address - SectionStartAddress;
+    SectionStartAddress = Address;
   }
 
-  // Data section Second. TODO
+  // Data section second.
+  if (!DataCsects.empty()) {
+    Sections.push_back(&Data);
+    Data.Index = SectionIndex++;
+    Data.Address = SectionStartAddress;
+    uint32_t Address = SectionStartAddress;
+    for (auto &Csect : DataCsects) {
+      const MCSectionXCOFF *MCSec = Csect.MCCsect;
+      Address = alignTo(Address, MCSec->getAlignment());
+      Csect.Address = Address;
+      Address += Layout.getSectionAddressSize(MCSec);
+      Csect.SymbolTableIndex = SymbolTableIndex;
+      // 1 main and 1 auxiliary symbol table entry for the csect.
+      SymbolTableIndex += 2;
+      Csect.Size = Layout.getSectionAddressSize(MCSec);
+      for (auto &Sym : Csect.Syms) {
+        Sym.SymbolTableIndex = SymbolTableIndex;
+        // 1 main and 1 auxiliary symbol table entry for each contained symbol.
+        SymbolTableIndex += 2;
+      }
+    }
+    // Make sure the address of the next section aligned to DefaultSectionAlign.
+    Address = alignTo(Address, DefaultSectionAlign);
+    Data.Size = Address - SectionStartAddress;
+    SectionStartAddress = Address;
+  }
 
   // BSS Section third.
   if (!BSSCsects.empty()) {
     Sections.push_back(&BSS);
     BSS.Index = SectionIndex++;
-    uint32_t StartAddress = Address;
+    BSS.Address = SectionStartAddress;
+    uint32_t Address = SectionStartAddress;
     for (auto &Csect : BSSCsects) {
       const MCSectionXCOFF *MCSec = Csect.MCCsect;
       Address = alignTo(Address, MCSec->getAlignment());
       Csect.Address = Address;
       Address += Layout.getSectionAddressSize(MCSec);
       Csect.SymbolTableIndex = SymbolTableIndex;
       // 1 main and 1 auxiliary symbol table entry for the csect.
       SymbolTableIndex += 2;
       Csect.Size = Layout.getSectionAddressSize(MCSec);
 
       assert(Csect.Syms.size() == 1 &&
              "csect in the BSS can only contain a single symbol.");
       Csect.Syms[0].SymbolTableIndex = Csect.SymbolTableIndex;
     }
     // Pad out Address to the default alignment. This is to match how the system
     // assembler handles the .bss section. Its size is always a multiple of 4.
     Address = alignTo(Address, DefaultSectionAlign);
-    BSS.Size = Address - StartAddress;
+    BSS.Size = Address - SectionStartAddress;
+    SectionStartAddress = Address;
   }
 
   SymbolTableEntryCount = SymbolTableIndex;
 
   // Calculate the RawPointer value for each section.
   uint64_t RawPointer = sizeof(XCOFF::FileHeader32) + auxiliaryHeaderSize() +
                         Sections.size() * sizeof(XCOFF::SectionHeader32);
   for (auto *Sec : Sections) {

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

 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck %s
 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff < %s | FileCheck %s
 
+; RUN: llc -mtriple powerpc-ibm-aix-xcoff -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --symbols %t.o | \
+; RUN: FileCheck --check-prefix=OBJ %s
+
+; RUN: not llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj < %s 2>&1 | \
+; RUN: FileCheck --check-prefix=XCOFF64 %s
+; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+
 @ivar = local_unnamed_addr global i32 35, align 4
 @llvar = local_unnamed_addr global i64 36, align 8
 @svar = local_unnamed_addr global i16 37, align 2
 @fvar = local_unnamed_addr global float 8.000000e+02, align 4
 @dvar = local_unnamed_addr global double 9.000000e+02, align 8
 @over_aligned = local_unnamed_addr global double 9.000000e+02, align 32
 @charr = local_unnamed_addr global [4 x i8] c"abcd", align 1
 @dblarr = local_unnamed_addr global [4 x double] [double 1.000000e+00, double 2.000000e+00, double 3.000000e+00, double 4.000000e+00], align 8
 
 ; CHECK:      .csect .data[RW]
 ; CHECK-NEXT: .globl  ivar
 ; CHECK-NEXT: .align  2
 ; CHECK-NEXT: ivar:
 ; CHECK-NEXT: .long   35
 
 ; CHECK:      .globl  llvar
 ; CHECK-NEXT: .align  3
 ; CHECK-NEXT: llvar:

 
 ; CHECK:      .globl  dblarr
 ; CHECK-NEXT: .align  3
 ; CHECK-NEXT: dblarr:
 ; CHECK-NEXT: .llong  4607182418800017408
 ; CHECK-NEXT: .llong  4611686018427387904
 ; CHECK-NEXT: .llong  4613937818241073152
 ; CHECK-NEXT: .llong  4616189618054758400
+
+; OBJ:      File: {{.*}}aix-xcoff-data.ll.tmp.o
+; OBJ-NEXT: Format: aixcoff-rs6000
+; OBJ-NEXT: Arch: powerpc
+; OBJ-NEXT: AddressSize: 32bit
+
+; OBJ:      Symbols [
+; OBJ:        Symbol {
+; OBJ-NEXT:     Index: [[#INDX:]]
+; OBJ-NEXT:     Name: .text
+; OBJ-NEXT:     Value (RelocatableAddress): 0x0
+; OBJ-NEXT:     Section: .text
+; OBJ-NEXT:     Type: 0x0
+; OBJ-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; OBJ-NEXT:     NumberOfAuxEntries: 1
+; OBJ-NEXT:     CSECT Auxiliary Entry {
+; OBJ-NEXT:       Index: [[#INDX+1]]
+; OBJ-NEXT:       SectionLen: 0
+; OBJ-NEXT:       ParameterHashIndex: 0x0
+; OBJ-NEXT:       TypeChkSectNum: 0x0
+; OBJ-NEXT:       SymbolAlignmentLog2: 0
+; OBJ-NEXT:       SymbolType: XTY_SD (0x1)
+; OBJ-NEXT:       StorageMappingClass: XMC_PR (0x0)
+; OBJ-NEXT:       StabInfoIndex: 0x0
+; OBJ-NEXT:       StabSectNum: 0x0
+; OBJ-NEXT:     }
+; OBJ-NEXT:   }
+
+; OBJ:        Symbol {
+; OBJ-NEXT:     Index: [[#INDX+2]]
+; OBJ-NEXT:     Name: .data
+; OBJ-NEXT:     Value (RelocatableAddress): 0x0
+; OBJ-NEXT:     Section: .data
+; OBJ-NEXT:     Type: 0x0
+; OBJ-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; OBJ-NEXT:     NumberOfAuxEntries: 1
+; OBJ-NEXT:     CSECT Auxiliary Entry {
+; OBJ-NEXT:       Index: [[#INDX+3]]
+; OBJ-NEXT:       SectionLen: 80
+; OBJ-NEXT:       ParameterHashIndex: 0x0
+; OBJ-NEXT:       TypeChkSectNum: 0x0
+; OBJ-NEXT:       SymbolAlignmentLog2: 5
+; OBJ-NEXT:       SymbolType: XTY_SD (0x1)
+; OBJ-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; OBJ-NEXT:       StabInfoIndex: 0x0
+; OBJ-NEXT:       StabSectNum: 0x0
+; OBJ-NEXT:     }
+; OBJ-NEXT:   }
+
+; OBJ:        Symbol {
+; OBJ-NEXT:     Index: [[#INDX+4]]
+; OBJ-NEXT:     Name: ivar
+; OBJ-NEXT:     Value (RelocatableAddress): 0x0
+; OBJ-NEXT:     Section: .data
+; OBJ-NEXT:     Type: 0x0
+; OBJ-NEXT:     StorageClass: C_EXT (0x2)
+; OBJ-NEXT:     NumberOfAuxEntries: 1
+; OBJ-NEXT:     CSECT Auxiliary Entry {
+; OBJ-NEXT:       Index: [[#INDX+5]]
+; OBJ-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; OBJ-NEXT:       ParameterHashIndex: 0x0
+; OBJ-NEXT:       TypeChkSectNum: 0x0
+; OBJ-NEXT:       SymbolAlignmentLog2: 0
+; OBJ-NEXT:       SymbolType: XTY_LD (0x2)
+; OBJ-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; OBJ-NEXT:       StabInfoIndex: 0x0
+; OBJ-NEXT:       StabSectNum: 0x0
+; OBJ-NEXT:     }
+; OBJ-NEXT:   }
+
+; OBJ:        Symbol {
+; OBJ-NEXT:     Index: [[#INDX+6]]
+; OBJ-NEXT:     Name: llvar
+; OBJ-NEXT:     Value (RelocatableAddress): 0x8
+; OBJ-NEXT:     Section: .data
+; OBJ-NEXT:     Type: 0x0
+; OBJ-NEXT:     StorageClass: C_EXT (0x2)
+; OBJ-NEXT:     NumberOfAuxEntries: 1
+; OBJ-NEXT:     CSECT Auxiliary Entry {
+; OBJ-NEXT:       Index: [[#INDX+7]]
+; OBJ-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; OBJ-NEXT:       ParameterHashIndex: 0x0
+; OBJ-NEXT:       TypeChkSectNum: 0x0
+; OBJ-NEXT:       SymbolAlignmentLog2: 0
+; OBJ-NEXT:       SymbolType: XTY_LD (0x2)
+; OBJ-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; OBJ-NEXT:       StabInfoIndex: 0x0
+; OBJ-NEXT:       StabSectNum: 0x0
+; OBJ-NEXT:     }
+; OBJ-NEXT:   }
+
+; OBJ:        Symbol {
+; OBJ-NEXT:     Index: [[#INDX+8]]
+; OBJ-NEXT:     Name: svar
+; OBJ-NEXT:     Value (RelocatableAddress): 0x10
+; OBJ-NEXT:     Section: .data
+; OBJ-NEXT:     Type: 0x0
+; OBJ-NEXT:     StorageClass: C_EXT (0x2)
+; OBJ-NEXT:     NumberOfAuxEntries: 1
+; OBJ-NEXT:     CSECT Auxiliary Entry {
+; OBJ-NEXT:       Index: [[#INDX+9]]
+; OBJ-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; OBJ-NEXT:       ParameterHashIndex: 0x0
+; OBJ-NEXT:       TypeChkSectNum: 0x0
+; OBJ-NEXT:       SymbolAlignmentLog2: 0
+; OBJ-NEXT:       SymbolType: XTY_LD (0x2)
+; OBJ-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; OBJ-NEXT:       StabInfoIndex: 0x0
+; OBJ-NEXT:       StabSectNum: 0x0
+; OBJ-NEXT:     }
+; OBJ-NEXT:   }
+
+; OBJ:        Symbol {
+; OBJ-NEXT:     Index: [[#INDX+10]]
+; OBJ-NEXT:     Name: fvar
+; OBJ-NEXT:     Value (RelocatableAddress): 0x14
+; OBJ-NEXT:     Section: .data
+; OBJ-NEXT:     Type: 0x0
+; OBJ-NEXT:     StorageClass: C_EXT (0x2)
+; OBJ-NEXT:     NumberOfAuxEntries: 1
+; OBJ-NEXT:     CSECT Auxiliary Entry {
+; OBJ-NEXT:       Index: [[#INDX+11]]
+; OBJ-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; OBJ-NEXT:       ParameterHashIndex: 0x0
+; OBJ-NEXT:       TypeChkSectNum: 0x0
+; OBJ-NEXT:       SymbolAlignmentLog2: 0
+; OBJ-NEXT:       SymbolType: XTY_LD (0x2)
+; OBJ-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; OBJ-NEXT:       StabInfoIndex: 0x0
+; OBJ-NEXT:       StabSectNum: 0x0
+; OBJ-NEXT:     }
+; OBJ-NEXT:   }
+
+; OBJ:        Symbol {
+; OBJ-NEXT:     Index: [[#INDX+12]]
+; OBJ-NEXT:     Name: dvar
+; OBJ-NEXT:     Value (RelocatableAddress): 0x18
+; OBJ-NEXT:     Section: .data
+; OBJ-NEXT:     Type: 0x0
+; OBJ-NEXT:     StorageClass: C_EXT (0x2)
+; OBJ-NEXT:     NumberOfAuxEntries: 1
+; OBJ-NEXT:     CSECT Auxiliary Entry {
+; OBJ-NEXT:       Index: [[#INDX+13]]
+; OBJ-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; OBJ-NEXT:       ParameterHashIndex: 0x0
+; OBJ-NEXT:       TypeChkSectNum: 0x0
+; OBJ-NEXT:       SymbolAlignmentLog2: 0
+; OBJ-NEXT:       SymbolType: XTY_LD (0x2)
+; OBJ-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; OBJ-NEXT:       StabInfoIndex: 0x0
+; OBJ-NEXT:       StabSectNum: 0x0
+; OBJ-NEXT:     }
+; OBJ-NEXT:   }
+
+; OBJ:        Symbol {
+; OBJ-NEXT:     Index: [[#INDX+14]]
+; OBJ-NEXT:     Name: over_aligned
+; OBJ-NEXT:     Value (RelocatableAddress): 0x20
+; OBJ-NEXT:     Section: .data
+; OBJ-NEXT:     Type: 0x0
+; OBJ-NEXT:     StorageClass: C_EXT (0x2)
+; OBJ-NEXT:     NumberOfAuxEntries: 1
+; OBJ-NEXT:     CSECT Auxiliary Entry {
+; OBJ-NEXT:       Index: [[#INDX+15]]
+; OBJ-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; OBJ-NEXT:       ParameterHashIndex: 0x0
+; OBJ-NEXT:       TypeChkSectNum: 0x0
+; OBJ-NEXT:       SymbolAlignmentLog2: 0
+; OBJ-NEXT:       SymbolType: XTY_LD (0x2)
+; OBJ-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; OBJ-NEXT:       StabInfoIndex: 0x0
+; OBJ-NEXT:       StabSectNum: 0x0
+; OBJ-NEXT:     }
+; OBJ-NEXT:   }
+
+; OBJ:        Symbol {
+; OBJ-NEXT:     Index: [[#INDX+16]]
+; OBJ-NEXT:     Name: charr
+; OBJ-NEXT:     Value (RelocatableAddress): 0x28
+; OBJ-NEXT:     Section: .data
+; OBJ-NEXT:     Type: 0x0
+; OBJ-NEXT:     StorageClass: C_EXT (0x2)
+; OBJ-NEXT:     NumberOfAuxEntries: 1
+; OBJ-NEXT:     CSECT Auxiliary Entry {
+; OBJ-NEXT:       Index: [[#INDX+17]]
+; OBJ-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; OBJ-NEXT:       ParameterHashIndex: 0x0
+; OBJ-NEXT:       TypeChkSectNum: 0x0
+; OBJ-NEXT:       SymbolAlignmentLog2: 0
+; OBJ-NEXT:       SymbolType: XTY_LD (0x2)
+; OBJ-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; OBJ-NEXT:       StabInfoIndex: 0x0
+; OBJ-NEXT:       StabSectNum: 0x0
+; OBJ-NEXT:     }
+; OBJ-NEXT:   }
+
+; OBJ:        Symbol {
+; OBJ-NEXT:     Index: [[#INDX+18]]
+; OBJ-NEXT:     Name: dblarr
+; OBJ-NEXT:     Value (RelocatableAddress): 0x30
+; OBJ-NEXT:     Section: .data
+; OBJ-NEXT:     Type: 0x0
+; OBJ-NEXT:     StorageClass: C_EXT (0x2)
+; OBJ-NEXT:     NumberOfAuxEntries: 1
+; OBJ-NEXT:     CSECT Auxiliary Entry {
+; OBJ-NEXT:       Index: [[#INDX+19]]
+; OBJ-NEXT:       ContainingCsectSymbolIndex: [[#INDX+2]]
+; OBJ-NEXT:       ParameterHashIndex: 0x0
+; OBJ-NEXT:       TypeChkSectNum: 0x0
+; OBJ-NEXT:       SymbolAlignmentLog2: 0
+; OBJ-NEXT:       SymbolType: XTY_LD (0x2)
+; OBJ-NEXT:       StorageMappingClass: XMC_RW (0x5)
+; OBJ-NEXT:       StabInfoIndex: 0x0
+; OBJ-NEXT:       StabSectNum: 0x0
+; OBJ-NEXT:     }
+; OBJ-NEXT:   }
+; OBJ:      ]