[XCOFF] Enable explicit sections on AIX

[jasonliu]

Summary

Implement mechanism to allow explicit sections to be generated on AIX.

[jasonliu]

llvm/lib/MC/MCContext.cpp

673

Maybe it's worth to discuss: is there a better way to detect and prevent this case from happening?

int b __attribute__((section("a"))) = 2;
int a = 3;

Right now, I have to add a new field to MCSectionXCOFF to see if the policy matches. Not sure if we could do it without this new field.

[DiggerLin]

llvm/include/llvm/MC/MCSectionXCOFF.h

39

Using MultiSymbolsAllowed to represent whether the section is generated for separate function or separated data variable when -function-section or -data-section .

what about to change the MultiSymbolsAllowed to IsSymbolNameAsSectionName ?

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2285

is there possible, something like ?

int b attribute((section("a"))) = 2;
void a(void) {
}
and compile with -function-section?

[jasonliu]

llvm/include/llvm/MC/MCSectionXCOFF.h

39

Anything wrong with the MultiSymbolsAllowed?
IsSymbolNameAsSectionName does not really convey what we want. As you could have
int a attribute((section("a"))) = 2;
And the symbol name is the same with section name, but I assume we don't want true here.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2285

I don't think that would be a problem as they still belongs to different sections.
b would belong to a[RW]
and function a would belong to a[PR]

[jasonliu]

Gentle ping.

[DiggerLin]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2088–2100

/// If this global does not have a custom section, this will be empty and the
 /// default object file section (.text, .data, etc) will be used.
 StringRef getSection() const {
   return hasSection() ? getSectionImpl() : StringRef();
 }

do we need to check whether the Section Name is empty ?

2285

thanks

[jasonliu]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2088–2100

This functionality seems already handled in its caller: TargetLoweringObjectFile::SectionForGlobal, where it would return the default section if hasSection returns false.

[jasonliu]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2088–2100

Checked that it's possible for the user to get here with a pragma clang section, so I will report a fatal error as a limitation for now.

[DiggerLin]

LGTM

llvm/include/llvm/MC/MCContext.h

MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
                                   const char *BeginSymName);
 
     MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
                                   const MCSymbolWasm *Group, unsigned UniqueID,
                                   const char *BeginSymName);
 
     MCSectionXCOFF *getXCOFFSection(StringRef Section,
                                     XCOFF::StorageMappingClass MappingClass,
-                                    XCOFF::SymbolType CSectType,
-                                    SectionKind K,
+                                    XCOFF::SymbolType CSectType, SectionKind K,
+                                    bool MultiSymbolsAllowed = false,
                                     const char *BeginSymName = nullptr);
 
     // Create and save a copy of STI and return a reference to the copy.
     MCSubtargetInfo &getSubtargetCopy(const MCSubtargetInfo &STI);
 
     /// @}
 
     /// \name Dwarf Management

llvm/include/llvm/MC/MCSectionXCOFF.h

 //    implemented yet.
 class MCSectionXCOFF final : public MCSection {
   friend class MCContext;
 
   XCOFF::StorageMappingClass MappingClass;
   XCOFF::SymbolType Type;
   MCSymbolXCOFF *const QualName;
   StringRef SymbolTableName;
+  bool MultiSymbolsAllowed;
   static constexpr unsigned DefaultAlignVal = 4;
 
   MCSectionXCOFF(StringRef Name, XCOFF::StorageMappingClass SMC,
                  XCOFF::SymbolType ST, SectionKind K, MCSymbolXCOFF *QualName,
-                 MCSymbol *Begin, StringRef SymbolTableName)
+                 MCSymbol *Begin, StringRef SymbolTableName,
+                 bool MultiSymbolsAllowed)
       : MCSection(SV_XCOFF, Name, K, Begin), MappingClass(SMC), Type(ST),
-        QualName(QualName), SymbolTableName(SymbolTableName) {
+        QualName(QualName), SymbolTableName(SymbolTableName),
+        MultiSymbolsAllowed(MultiSymbolsAllowed) {
     assert((ST == XCOFF::XTY_SD || ST == XCOFF::XTY_CM || ST == XCOFF::XTY_ER) &&
            "Invalid or unhandled type for csect.");
     assert(QualName != nullptr && "QualName is needed.");
     QualName->setRepresentedCsect(this);
     QualName->setStorageClass(XCOFF::C_HIDEXT);
     // A csect is 4 byte aligned by default, except for undefined symbol csects.
     if (Type != XCOFF::XTY_ER)
       setAlignment(Align(DefaultAlignVal));
public:
   MCSymbolXCOFF *getQualNameSymbol() const { return QualName; }
 
   void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                             raw_ostream &OS,
                             const MCExpr *Subsection) const override;
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
   StringRef getSymbolTableName() const { return SymbolTableName; }
+  bool isMultiSymbolsAllowed() const { return MultiSymbolsAllowed; }
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

if (GO->isDeclarationForLinker())
       return cast<MCSectionXCOFF>(getSectionForExternalReference(GO, TM))
           ->getQualNameSymbol();
 
     SectionKind GOKind = getKindForGlobal(GO, TM);
     if (GOKind.isText())
       return cast<MCSectionXCOFF>(
                  getSectionForFunctionDescriptor(cast<Function>(GO), TM))
           ->getQualNameSymbol();
-    if (TM.getDataSections() || GOKind.isCommon() || GOKind.isBSSLocal())
+    if ((TM.getDataSections() && !GO->hasSection()) || GOKind.isCommon() ||
+        GOKind.isBSSLocal())
       return cast<MCSectionXCOFF>(SectionForGlobal(GO, GOKind, TM))
           ->getQualNameSymbol();
   }
 
   // For all other cases, fall back to getSymbol to return the unqualified name.
   return nullptr;
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getExplicitSectionGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
-  report_fatal_error("XCOFF explicit sections not yet implemented.");
+  StringRef SectionName = GO->getSection();
+  XCOFF::StorageMappingClass MappingClass;
+  if (Kind.isText())
+    MappingClass = XCOFF::XMC_PR;
+  else if (Kind.isData() || Kind.isReadOnlyWithRel() || Kind.isBSS())
+    MappingClass = XCOFF::XMC_RW;
+  else if (Kind.isReadOnly())
+    MappingClass = XCOFF::XMC_RO;
+  else
+    report_fatal_error("XCOFF other section types not yet implemented.");
+
+  return getContext().getXCOFFSection(SectionName, MappingClass, XCOFF::XTY_SD,
+                                      Kind, /* MultiSymbolsAllowed*/ true);
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForExternalReference(
     const GlobalObject *GO, const TargetMachine &TM) const {
   assert(GO->isDeclarationForLinker() &&
          "Tried to get ER section for a defined global.");
 
   SmallString<128> Name;
MCSection *TargetLoweringObjectFileXCOFF::SelectSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
   // Common symbols go into a csect with matching name which will get mapped
   // into the .bss section.
   if (Kind.isBSSLocal() || Kind.isCommon()) {
     SmallString<128> Name;
     getNameWithPrefix(Name, GO, TM);
     return getContext().getXCOFFSection(
         Name, Kind.isBSSLocal() ? XCOFF::XMC_BS : XCOFF::XMC_RW, XCOFF::XTY_CM,
-        Kind, /* BeginSymbolName */ nullptr);
+        Kind);
   }
 
   if (Kind.isMergeableCString()) {
     Align Alignment = GO->getParent()->getDataLayout().getPreferredAlign(
         cast<GlobalVariable>(GO));
 
     unsigned EntrySize = getEntrySizeForKind(Kind);
     std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
     SmallString<128> Name;
     Name = SizeSpec + utostr(Alignment.value());
 
     if (TM.getDataSections())
       getNameWithPrefix(Name, GO, TM);
 
-    return getContext().getXCOFFSection(Name, XCOFF::XMC_RO, XCOFF::XTY_SD,
-                                        Kind, /*BeginSymbolName*/ nullptr);
+    return getContext().getXCOFFSection(
+        Name, XCOFF::XMC_RO, XCOFF::XTY_SD, Kind,
+        /* MultiSymbolsAllowed*/ !TM.getDataSections());
   }
 
   if (Kind.isText()) {
     if (TM.getFunctionSections()) {
       return cast<MCSymbolXCOFF>(getFunctionEntryPointSymbol(GO, TM))
           ->getRepresentedCsect();
     }
     return TextSection;

 MCSymbol *TargetLoweringObjectFileXCOFF::getFunctionEntryPointSymbol(
     const GlobalValue *Func, const TargetMachine &TM) const {
   assert(
       (isa<Function>(Func) ||
        (isa<GlobalAlias>(Func) &&
         isa_and_nonnull<Function>(cast<GlobalAlias>(Func)->getBaseObject()))) &&
       "Func must be a function or an alias which has a function as base "
       "object.");
+
   SmallString<128> NameStr;
   NameStr.push_back('.');
   getNameWithPrefix(NameStr, Func, TM);
 
-  // When -function-sections is enabled, it's not necessary to emit
-  // function entry point label any more. We will use function entry
-  // point csect instead. And for function delcarations, the undefined symbols
-  // gets treated as csect with XTY_ER property.
-  if ((TM.getFunctionSections() || Func->isDeclaration()) &&
+  // When -function-sections is enabled and explicit section is not specified,
+  // it's not necessary to emit function entry point label any more. We will use
+  // function entry point csect instead. And for function delcarations, the
+  // undefined symbols gets treated as csect with XTY_ER property.
+  if (((TM.getFunctionSections() && !Func->hasSection()) ||
+       Func->isDeclaration()) &&
       isa<Function>(Func)) {
-    return cast<MCSectionXCOFF>(
-               getContext().getXCOFFSection(
-                   NameStr, XCOFF::XMC_PR,
+    return getContext()
+        .getXCOFFSection(NameStr, XCOFF::XMC_PR,
                          Func->isDeclaration() ? XCOFF::XTY_ER : XCOFF::XTY_SD,
-                   SectionKind::getText()))
+                         SectionKind::getText())
         ->getQualNameSymbol();
   }
 
   return getContext().getOrCreateSymbol(NameStr);
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForFunctionDescriptor(
     const Function *F, const TargetMachine &TM) const {

llvm/lib/MC/MCContext.cpp

MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind Kind,
   auto *F = new MCDataFragment();
   Result->getFragmentList().insert(Result->begin(), F);
   F->setParent(Result);
   Begin->setFragment(F);
 
   return Result;
 }
 
-MCSectionXCOFF *MCContext::getXCOFFSection(StringRef Section,
-                                           XCOFF::StorageMappingClass SMC,
-                                           XCOFF::SymbolType Type,
-                                           SectionKind Kind,
-                                           const char *BeginSymName) {
+MCSectionXCOFF *
+MCContext::getXCOFFSection(StringRef Section, XCOFF::StorageMappingClass SMC,
+                           XCOFF::SymbolType Type, SectionKind Kind,
+                           bool MultiSymbolsAllowed, const char *BeginSymName) {
   // Do the lookup. If we have a hit, return it.
   auto IterBool = XCOFFUniquingMap.insert(
       std::make_pair(XCOFFSectionKey{Section.str(), SMC}, nullptr));
   auto &Entry = *IterBool.first;
-  if (!IterBool.second)
-    return Entry.second;
+  if (!IterBool.second) {
+    MCSectionXCOFF *ExistedEntry = Entry.second;
+    if (ExistedEntry->isMultiSymbolsAllowed() != MultiSymbolsAllowed)
+      report_fatal_error("section's multiply symbols policy does not match");
+
+    return ExistedEntry;
+  }
 
   // Otherwise, return a new section.
   StringRef CachedName = Entry.first.SectionName;
   MCSymbolXCOFF *QualName = cast<MCSymbolXCOFF>(getOrCreateSymbol(
       CachedName + "[" + XCOFF::getMappingClassString(SMC) + "]"));
 
   MCSymbol *Begin = nullptr;
   if (BeginSymName)
     Begin = createTempSymbol(BeginSymName, false);
 
   // QualName->getUnqualifiedName() and CachedName are the same except when
   // CachedName contains invalid character(s) such as '$' for an XCOFF symbol.
   MCSectionXCOFF *Result = new (XCOFFAllocator.Allocate())
       MCSectionXCOFF(QualName->getUnqualifiedName(), SMC, Type, Kind, QualName,
-                     Begin, CachedName);
+                     Begin, CachedName, MultiSymbolsAllowed);
   Entry.second = Result;
 
   auto *F = new MCDataFragment();
   Result->getFragmentList().insert(Result->begin(), F);
   F->setParent(Result);
 
   if (Begin)
     Begin->setFragment(F);

llvm/lib/MC/MCObjectFileInfo.cpp

void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
   // TODO: Define more sections.
 }
 
 void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
   // The default csect for program code. Functions without a specified section
   // get placed into this csect. The choice of csect name is not a property of
   // the ABI or object file format. For example, the XL compiler uses an unnamed
   // csect for program code.
-  TextSection =
-      Ctx->getXCOFFSection(".text", XCOFF::StorageMappingClass::XMC_PR,
-                           XCOFF::XTY_SD, SectionKind::getText());
-
-  DataSection =
-      Ctx->getXCOFFSection(".data", XCOFF::StorageMappingClass::XMC_RW,
-                           XCOFF::XTY_SD, SectionKind::getData());
-
-  ReadOnlySection =
-      Ctx->getXCOFFSection(".rodata", XCOFF::StorageMappingClass::XMC_RO,
-                           XCOFF::XTY_SD, SectionKind::getReadOnly());
+  TextSection = Ctx->getXCOFFSection(
+      ".text", XCOFF::StorageMappingClass::XMC_PR, XCOFF::XTY_SD,
+      SectionKind::getText(), /* MultiSymbolsAllowed*/ true);
+
+  DataSection = Ctx->getXCOFFSection(
+      ".data", XCOFF::StorageMappingClass::XMC_RW, XCOFF::XTY_SD,
+      SectionKind::getData(), /* MultiSymbolsAllowed*/ true);
+
+  ReadOnlySection = Ctx->getXCOFFSection(
+      ".rodata", XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD,
+      SectionKind::getReadOnly(), /* MultiSymbolsAllowed*/ true);
 
   TOCBaseSection =
       Ctx->getXCOFFSection("TOC", XCOFF::StorageMappingClass::XMC_TC0,
                            XCOFF::XTY_SD, SectionKind::getData());
 
   // The TOC-base always has 0 size, but 4 byte alignment.
   TOCBaseSection->setAlignment(Align(4));
 

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <memory>
 #include <new>
 
+#include <iostream>
+
 using namespace llvm;
 
 #define DEBUG_TYPE "asmprinter"
 
 namespace {
 
 class PPCAsmPrinter : public AsmPrinter {
 protected:
void PPCAIXAsmPrinter::SetupMachineFunction(MachineFunction &MF) {
   return AsmPrinter::SetupMachineFunction(MF);
 }
 
 void PPCAIXAsmPrinter::ValidateGV(const GlobalVariable *GV) {
   // Early error checking limiting what is supported.
   if (GV->isThreadLocal())
     report_fatal_error("Thread local not yet supported on AIX.");
 
-  if (GV->hasSection())
-    report_fatal_error("Custom section for Data not yet supported.");
-
   if (GV->hasComdat())
     report_fatal_error("COMDAT not yet supported by AIX.");
 }
 
 static bool isSpecialLLVMGlobalArrayToSkip(const GlobalVariable *GV) {
   return GV->hasAppendingLinkage() &&
          StringSwitch<bool>(GV->getName())
              // TODO: Linker could still eliminate the GV if we just skip
if (GVKind.isCommon() || GVKind.isBSSLocal()) {
     else
       OutStreamer->emitCommonSymbol(GVSym, Size, Alignment.value());
     return;
   }
 
   MCSymbol *EmittedInitSym = GVSym;
   emitLinkage(GV, EmittedInitSym);
   emitAlignment(getGVAlignment(GV, DL), GV);
+
   // When -fdata-sections is enabled, every GlobalVariable will
   // be put into its own csect; therefore, label is not necessary here.
-  if (!TM.getDataSections())
+  if (!TM.getDataSections() || GV->hasSection()) {
     OutStreamer->emitLabel(EmittedInitSym);
+  }
 
   // Emit aliasing label for global variable.
   llvm::for_each(GOAliasMap[GV], [this](const GlobalAlias *Alias) {
     OutStreamer->emitLabel(getSymbol(Alias));
   });
 
   emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer());
 }

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

+; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff \
+; RUN:                 -mcpu=pwr4 -mattr=-altivec < %s 2>&1 | FileCheck %s
+; CHECK: LLVM ERROR: section's multiply symbols policy does not match
+
+@a = global i32 3, section "ab", align 4
+@ab = global i32 5, align 4

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

+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck %s
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff < %s | FileCheck %s
+; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc-ibm-aix-xcoff -filetype=obj -o %t.o < %s
+; RUN: llvm-objdump -D --symbol-description %t.o | FileCheck --check-prefix=CHECKOBJ %s
+; RUN: llvm-readobj -syms %t.o | FileCheck --check-prefix=CHECKSYM %s
+
+@ext_const = constant i32 1, section ".ext_const_sec", align 4
+@ext_var = global i32 1, section ".ext_var_sec", align 4
+@ext_zvar = global i32 0, section ".ext_zvar_sec", align 4
+
+define dso_local signext i32 @ext_fun() section ".ext_fun_sec" {
+entry:
+  %0 = load i32, i32* @ext_const, align 4
+  %1 = load i32, i32* @ext_var, align 4
+  %add = add nsw i32 %0, %1
+  %2 = load i32, i32* @ext_zvar, align 4
+  %add1 = add nsw i32 %add, %2
+  ret i32 %add1
+}
+
+; CHECK:              .globl  ext_fun[DS]                     # -- Begin function ext_fun
+; CHECK-NEXT:         .globl  .ext_fun
+; CHECK-NEXT:         .align  4
+; CHECK-NEXT:         .csect ext_fun[DS]
+; CHECK:              .csect .ext_fun_sec[PR],2
+; CHECK-NEXT: .ext_fun:
+; CHECK:              .csect .ext_const_sec[RO],2
+; CHECK-NEXT:         .globl  ext_const
+; CHECK-NEXT:         .align  2
+; CHECK-NEXT: ext_const:
+; CHECK-NEXT:         .vbyte  4, 1                            # 0x1
+; CHECK-NEXT:         .csect .ext_var_sec[RW],2
+; CHECK-NEXT:         .globl  ext_var
+; CHECK-NEXT:         .align  2
+; CHECK-NEXT: ext_var:
+; CHECK-NEXT:         .vbyte  4, 1                            # 0x1
+; CHECK-NEXT:         .csect .ext_zvar_sec[RW],2
+; CHECK-NEXT:         .globl  ext_zvar
+; CHECK-NEXT:         .align  2
+; CHECK-NEXT: ext_zvar:
+; CHECK-NEXT:         .vbyte  4, 0                            # 0x0
+; CHECK-NEXT:         .toc
+; CHECK-NEXT: L..C0:
+; CHECK-NEXT:         .tc ext_var[TC],ext_var
+; CHECK-NEXT: L..C1:
+; CHECK-NEXT:         .tc ext_zvar[TC],ext_zvar
+
+; CHECKOBJ:        00000000 (idx: 4) .ext_fun:
+; CHECKOBJ-NEXT:          0: 80 62 00 00   lwz 3, 0(2)
+; CHECKOBJ-NEXT:          4: 80 82 00 04   lwz 4, 4(2)
+; CHECKOBJ-NEXT:          8: 80 63 00 00   lwz 3, 0(3)
+; CHECKOBJ-NEXT:          c: 80 84 00 00   lwz 4, 0(4)
+; CHECKOBJ-NEXT:         10: 7c 63 22 14   add 3, 3, 4
+; 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: 8) ext_const:
+; CHECKOBJ-NEXT:         1c: 00 00 00 01   <unknown>
+; CHECKOBJ-EMPTY:   
+; CHECKOBJ-NEXT:   Disassembly of section .data:
+; CHECKOBJ-EMPTY:   
+; CHECKOBJ-NEXT:   00000020 (idx: 12) ext_var:
+; CHECKOBJ-NEXT:         20: 00 00 00 01   <unknown>
+; CHECKOBJ-EMPTY:   
+; CHECKOBJ-NEXT:   00000024 (idx: 16) ext_zvar:
+; CHECKOBJ-NEXT:         24: 00 00 00 00   <unknown>
+; CHECKOBJ-EMPTY:   
+; CHECKOBJ-NEXT:   00000028 (idx: 18) ext_fun[DS]:
+; 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-EMPTY:   
+; CHECKOBJ-NEXT:   00000034 (idx: 22) ext_var[TC]:
+; CHECKOBJ-NEXT:         34: 00 00 00 20   <unknown>
+; CHECKOBJ-EMPTY:   
+; CHECKOBJ-NEXT:   00000038 (idx: 24) ext_zvar[TC]:
+; CHECKOBJ-NEXT:         38: 00 00 00 24   <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:        Index: [[#INDX+1]]
+; CHECKSYM-NEXT:        SectionLen: 28
+; CHECKSYM-NEXT:        ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:        TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:        SymbolAlignmentLog2: 4
+; CHECKSYM-NEXT:        SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:        StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:        StabInfoIndex: 0x0
+; CHECKSYM-NEXT:        StabSectNum: 0x0
+; CHECKSYM-NEXT:      }
+; CHECKSYM-NEXT:    }
+; CHECKSYM-NEXT:    Symbol {
+; CHECKSYM-NEXT:      Index: [[#INDX+2]]
+; CHECKSYM-NEXT:      Name: .ext_fun
+; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:      Section: .text
+; CHECKSYM-NEXT:      Type: 0x0
+; CHECKSYM-NEXT:      StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:      NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:      CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:        Index: [[#INDX+3]]
+; CHECKSYM-NEXT:        ContainingCsectSymbolIndex: [[#INDX]]
+; CHECKSYM-NEXT:        ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:        TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:        SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:        SymbolType: XTY_LD (0x2)
+; CHECKSYM-NEXT:        StorageMappingClass: XMC_PR (0x0)
+; CHECKSYM-NEXT:        StabInfoIndex: 0x0
+; CHECKSYM-NEXT:        StabSectNum: 0x0
+; CHECKSYM-NEXT:      }
+; CHECKSYM-NEXT:    }
+; CHECKSYM-NEXT:    Symbol {
+; CHECKSYM-NEXT:      Index: [[#INDX+4]]
+; CHECKSYM-NEXT:      Name: .ext_const_sec
+; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x1C
+; CHECKSYM-NEXT:      Section: .text
+; CHECKSYM-NEXT:      Type: 0x0
+; CHECKSYM-NEXT:      StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:      NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:      CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:        Index: [[#INDX+5]]
+; 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_RO (0x1)
+; CHECKSYM-NEXT:        StabInfoIndex: 0x0
+; CHECKSYM-NEXT:        StabSectNum: 0x0
+; CHECKSYM-NEXT:      }
+; CHECKSYM-NEXT:    }
+; CHECKSYM-NEXT:    Symbol {
+; CHECKSYM-NEXT:      Index: [[#INDX+6]]
+; CHECKSYM-NEXT:      Name: ext_const
+; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x1C
+; CHECKSYM-NEXT:      Section: .text
+; CHECKSYM-NEXT:      Type: 0x0
+; CHECKSYM-NEXT:      StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:      NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:      CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:        Index: [[#INDX+7]]
+; CHECKSYM-NEXT:        ContainingCsectSymbolIndex: [[#INDX+4]]
+; CHECKSYM-NEXT:        ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:        TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:        SymbolAlignmentLog2: 0
+; 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:      Value (RelocatableAddress): 0x20
+; CHECKSYM-NEXT:      Section: .data
+; CHECKSYM-NEXT:      Type: 0x0
+; CHECKSYM-NEXT:      StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:      NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:      CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:        Index: [[#INDX+9]]
+; CHECKSYM-NEXT:        SectionLen: 4
+; CHECKSYM-NEXT:        ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:        TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:        SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:        SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:        StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM-NEXT:        StabInfoIndex: 0x0
+; CHECKSYM-NEXT:        StabSectNum: 0x0
+; CHECKSYM-NEXT:      }
+; CHECKSYM-NEXT:    }
+; CHECKSYM-NEXT:    Symbol {
+; CHECKSYM-NEXT:      Index: [[#INDX+10]]
+; CHECKSYM-NEXT:      Name: ext_var
+; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x20
+; 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+11]]
+; CHECKSYM-NEXT:        ContainingCsectSymbolIndex: [[#INDX+8]]
+; CHECKSYM-NEXT:        ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:        TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:        SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:        SymbolType: XTY_LD (0x2)
+; CHECKSYM-NEXT:        StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM-NEXT:        StabInfoIndex: 0x0
+; CHECKSYM-NEXT:        StabSectNum: 0x0
+; CHECKSYM-NEXT:      }
+; CHECKSYM-NEXT:    }
+; CHECKSYM-NEXT:    Symbol {
+; CHECKSYM-NEXT:      Index: [[#INDX+12]]
+; CHECKSYM-NEXT:      Name: .ext_zvar_sec
+; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x24
+; CHECKSYM-NEXT:      Section: .data
+; CHECKSYM-NEXT:      Type: 0x0
+; CHECKSYM-NEXT:      StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:      NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:      CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:        Index: [[#INDX+13]]
+; CHECKSYM-NEXT:        SectionLen: 4
+; CHECKSYM-NEXT:        ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:        TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:        SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:        SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:        StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM-NEXT:        StabInfoIndex: 0x0
+; CHECKSYM-NEXT:        StabSectNum: 0x0
+; CHECKSYM-NEXT:      }
+; CHECKSYM-NEXT:    }
+; CHECKSYM-NEXT:    Symbol {
+; CHECKSYM-NEXT:      Index: [[#INDX+14]]
+; CHECKSYM-NEXT:      Name: ext_zvar
+; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x24
+; 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+15]]
+; CHECKSYM-NEXT:        ContainingCsectSymbolIndex: [[#INDX+12]]
+; CHECKSYM-NEXT:        ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:        TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:        SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:        SymbolType: XTY_LD (0x2)
+; CHECKSYM-NEXT:        StorageMappingClass: XMC_RW (0x5)
+; CHECKSYM-NEXT:        StabInfoIndex: 0x0
+; CHECKSYM-NEXT:        StabSectNum: 0x0
+; CHECKSYM-NEXT:      }
+; CHECKSYM-NEXT:    }
+; CHECKSYM-NEXT:    Symbol {
+; CHECKSYM-NEXT:      Index: [[#INDX+16]]
+; CHECKSYM-NEXT:      Name: ext_fun
+; CHECKSYM-NEXT:      Value (RelocatableAddress): 0x28
+; 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:        ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:        TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:        SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:        SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:        StorageMappingClass: XMC_DS (0xA)
+; CHECKSYM-NEXT:        StabInfoIndex: 0x0
+; CHECKSYM-NEXT:        StabSectNum: 0x0
+; CHECKSYM-NEXT:      }
+; CHECKSYM-NEXT:    }