[AIX] discard the label in the csect of function description and use qualname for linkage

[DiggerLin]

Summary

In current llvm,

cat > test.c
void foo() {};

llc will generate assembly code as (assembly patch)

        .globl  foo
        .globl  .foo
        .csect foo[DS]
foo:
        .long   .foo
        .long   TOC[TC0]
        .long   0

and symbol table as (xcoff object file)
[4]     m   0x00000004     .data     1  unamex                    foo
[5]     a4  0x0000000c       0    0     SD       DS    0    0
[6]     m   0x00000004     .data     1  extern                    foo
[7]     a4  0x00000004       0    0     LD       DS    0    0


After first patch, the assembly will be as
```
     .globl  foo[DS]                 # -- Begin function foo
     .globl  .foo
     .align  2
     .csect foo[DS]
     .long   .foo
     .long   TOC[TC0]
     .long   0

    and symbol table will as 
   [6]     m   0x00000004     .data     1  extern                    foo
   [7]     a4  0x00000004       0    0     DS      DS    0    0

Change the code  for the assembly path and xcoff objectfile patch for llc.

[DiggerLin]

change .globl symbolName
to .globl qualSymbolName
in the test cases.

[jasonliu]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1972–1977

MCSymbolXCOFF already have a getStorageClass() function, I don't think we need to pass in GlobalObject to get it. If we need to, then we get the wrong FuncSym.

1974

FuncSym->getName() works means something is wrong here.
I assume FuncSym here is "foo", however FuncSym is supposed to be a "foo[DS]" name.
It's werid for us to have a symbol named "foo" here since we don't actually need that anywhere now after this patch.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1547

This is similar issues I saw above, I think we have the wrong MCSymbol here. If we have the correct one, we could just call emitLinkage without this if statement.

[DiggerLin]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1972–1977

we do not set StorageClass() for the FuncSym before we call the getSectionForFunctionDescriptor. We can not get getStorageClass() before set it.

1974

The FuncSym is symbol in the MCContext. not in the MCAssembler. it is foo[DS] in the MCAssembler (we put the foo[DS] into MCAssembler when we emiltLinkage ). we only care about MCAssembler in the XCOFFObjectWriter::executePostLayoutBinding()

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1547

when we do to the emitLinkage in the doFinalization()
there is function .llvm.StackProtector which do not have hasContainingCsect()

[jasonliu]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1972–1977

I think we should modify getSectionForFunctionDescriptor to only take const Function * as argument instead. You could get everything you need from that alone.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1542–1543

CurrentFnDescSym is foo here, which is wrong. It should be foo[DS].
You can achieve that by moving this after getting FnDescSec:
CurrentFnDescSym = FnDescSec->getQualNameSymbol();

1547

What I meant is, GVSym we received from function argument, should be foo[DS], or foo depending which one we need. We shouldn't try to get the correct one here. It's the caller's responsibility to pass in the correct MCSymbol. And in this patch, it's not even necessary to override emitLinkage for AIX.

[DiggerLin]

address comment

[jasonliu]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1974

Looking at what other XCOFF function is doing in this file, I think we should be consistent with them for easier maintenance which means we should call

getNameWithPrefix(Name, GO, TM);

instead.

1976

NameStr is good. I don't think you need to call .str().

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1740

Why do we use dyn_cast? Is there a chance GO is not a Function when we gets here?

[DiggerLin]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1974

TM is not a member of TargetLoweringObjectFile, do you want pass TM as parameter of getSectionForFunctionDescriptor() ? I do not think we need a TM as parameter of getSectionForFunctionDescriptor.

1976

thanks, there is function operator StringRef() const { return str(); }

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1740

getSectionForFunctionDescriptor(Function*) , but GO is GlobalObject.

[jasonliu]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1974

I think it makes sense to pass it in. I understand right now calling to getNameWithPrefix(Name, GO, TM) is the same as what you have which is getMangler()->getNameWithPrefix(OutName, GV, /*CannotUsePrivateLabel=*/false);. But if later we decide to override getNameWithPrefix(Name, GO, TM) for XCOFF, we will forget there is this one place called directly to getMangler()->getNameWithPrefix .

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1740

Let me rephrase my question, could you use cast instead of dyn_cast?

[DiggerLin]

address comment

[jasonliu]

Some last cleanups needed...

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1543–1544

We should modify the comment a bit to something like:
// Setup CurrentFnDescSym and its containing csect.

1548

This line could be removed, as the symbol returned from getQualNameSymbol() should already have its csect set.

1567

I think we could remove this FSym now, as it's not needed and it's better if we actually remove its existant from MCContext.
This if block could rewrite to:

if (const Function *F = dyn_cast<Function>(CV)) {
  const MCSectionXCOFF *Csect = cast<MCSectionXCOFF>(
          F->isDeclaration()
              ? getObjFileLowering().getSectionForExternalReference(F, TM)
              : getObjFileLowering().getSectionForFunctionDescriptor(F, TM));
   return MCSymbolRefExpr::create(Csect->getQualNameSymbol(), OutContext);
 }

[DiggerLin]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1548

thanks

1740

OK

[jasonliu]

There is a nit, otherwise LGTM.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1569

clang format this block, I don't think the spaces are aligned correctly.

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1569

This comment is not addressed when you land the commit.

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1569

Could we land a commit to address this before we all forget? Please comment if you landed this change. Thanks.

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

public:
   /// Given a constant with the SectionKind, return a section that it should be
   /// placed in.
   MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,
                                    const Constant *C,
                                    unsigned &Align) const override;
 
   static XCOFF::StorageClass getStorageClassForGlobal(const GlobalObject *GO);
 
-  MCSection *getSectionForFunctionDescriptor(const MCSymbol *) const override;
+  MCSection *getSectionForFunctionDescriptor(const Function *F) const override;
   MCSection *getSectionForTOCEntry(const MCSymbol *Sym) const override;
 
   /// For external functions, this will always return a function descriptor
   /// csect.
   MCSection *
   getSectionForExternalReference(const GlobalObject *GO,
                                  const TargetMachine &TM) const override;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H

llvm/include/llvm/Target/TargetLoweringObjectFile.h

public:
   /// If supported, return the section to use for the llvm.commandline
   /// metadata. Otherwise, return nullptr.
   virtual MCSection *getSectionForCommandLines() const {
     return nullptr;
   }
 
   /// On targets that use separate function descriptor symbols, return a section
   /// for the descriptor given its symbol. Use only with defined functions.
-  virtual MCSection *getSectionForFunctionDescriptor(const MCSymbol *S) const {
+  virtual MCSection *getSectionForFunctionDescriptor(const Function *F) const {
     return nullptr;
   }
 
   /// On targets that support TOC entries, return a section for the entry given
   /// the symbol it refers to.
   /// TODO: Implement this interface for existing ELF targets.
   virtual MCSection *getSectionForTOCEntry(const MCSymbol *S) const {
     return nullptr;

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

assert(TM.getTargetTriple().isOSAIX() &&
            "Only AIX uses the function descriptor hooks.");
     // AIX is unique here in that the name of the symbol emitted for the
     // function body does not have the same name as the source function's
     // C-linkage name.
     assert(CurrentFnDescSym && "The function descriptor symbol needs to be"
                                " initalized first.");
 
     // Get the function entry point symbol.
-    CurrentFnSym =
-        OutContext.getOrCreateSymbol("." + CurrentFnDescSym->getName());
+    CurrentFnSym = OutContext.getOrCreateSymbol(
+        "." + cast<MCSymbolXCOFF>(CurrentFnDescSym)->getUnqualifiedName());
 
     // Set the containing csect.
     MCSectionXCOFF *FnEntryPointSec =
         cast<MCSectionXCOFF>(getObjFileLowering().SectionForGlobal(&F, TM));
     cast<MCSymbolXCOFF>(CurrentFnSym)->setContainingCsect(FnEntryPointSec);
   }
 
   CurrentFnSymForSize = CurrentFnSym;

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

report_fatal_error(
         "There is no mapping that implements AppendingLinkage for XCOFF.");
   default:
     report_fatal_error(
         "Unhandled linkage when mapping linkage to StorageClass.");
   }
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForFunctionDescriptor(
-    const MCSymbol *FuncSym) const {
-  return getContext().getXCOFFSection(FuncSym->getName(), XCOFF::XMC_DS,
-                                      XCOFF::XTY_SD, XCOFF::C_HIDEXT,
-                                      SectionKind::getData());
+    const Function *F) const {
+  SmallString<128> NameStr;
+  getMangler().getNameWithPrefix(NameStr, F, /*CannotUsePrivateLabel=*/false);
+  return getContext().getXCOFFSection(
+      NameStr.str(), XCOFF::XMC_DS, XCOFF::XTY_SD, getStorageClassForGlobal(F),
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForTOCEntry(
     const MCSymbol *Sym) const {
   return getContext().getXCOFFSection(
       cast<MCSymbolXCOFF>(Sym)->getUnqualifiedName(), XCOFF::XMC_TC,
       XCOFF::XTY_SD, XCOFF::C_HIDEXT, SectionKind::getData());
 }

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

void PPCLinuxAsmPrinter::emitFunctionBodyEnd() {
   // the PPC64 ELF ABI (this is a low-priority item because GDB does not
   // currently make use of these fields).
   if (Subtarget->isPPC64()) {
     OutStreamer->emitIntValue(0, 4/*size*/);
     OutStreamer->emitIntValue(0, 8/*size*/);
   }
 }
 
 void PPCAIXAsmPrinter::SetupMachineFunction(MachineFunction &MF) {
-  // Get the function descriptor symbol.
-  CurrentFnDescSym = getSymbol(&MF.getFunction());
   // Set the alignment and the containing csect.
   MCSectionXCOFF *FnDescSec = cast<MCSectionXCOFF>(
-      getObjFileLowering().getSectionForFunctionDescriptor(CurrentFnDescSym));
+      getObjFileLowering().getSectionForFunctionDescriptor(&MF.getFunction()));
+  CurrentFnDescSym = FnDescSec->getQualNameSymbol();
   FnDescSec->setAlignment(Align(Subtarget->isPPC64() ? 8 : 4));
   cast<MCSymbolXCOFF>(CurrentFnDescSym)->setContainingCsect(FnDescSec);
 
   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.");
 }
 
 const MCExpr *PPCAIXAsmPrinter::lowerConstant(const Constant *CV) {
   if (const Function *F = dyn_cast<Function>(CV)) {
     MCSymbolXCOFF *FSym = cast<MCSymbolXCOFF>(getSymbol(F));
     if (!FSym->hasContainingCsect()) {
       MCSectionXCOFF *Csect = cast<MCSectionXCOFF>(
           F->isDeclaration()
               ? getObjFileLowering().getSectionForExternalReference(F, TM)
-              : getObjFileLowering().getSectionForFunctionDescriptor(FSym));
+              : getObjFileLowering().getSectionForFunctionDescriptor(F));
       FSym->setContainingCsect(Csect);
     }
     return MCSymbolRefExpr::create(
         FSym->getContainingCsect()->getQualNameSymbol(), OutContext);
   }
   return PPCAsmPrinter::lowerConstant(CV);
 }
 

 void PPCAIXAsmPrinter::emitFunctionDescriptor() {
   const DataLayout &DL = getDataLayout();
   const unsigned PointerSize = DL.getPointerSizeInBits() == 64 ? 8 : 4;
 
   MCSectionSubPair Current = OutStreamer->getCurrentSection();
   // Emit function descriptor.
   OutStreamer->SwitchSection(
       cast<MCSymbolXCOFF>(CurrentFnDescSym)->getContainingCsect());
-  OutStreamer->emitLabel(CurrentFnDescSym);
   // Emit function entry point address.
   OutStreamer->emitValue(MCSymbolRefExpr::create(CurrentFnSym, OutContext),
                          PointerSize);
   // Emit TOC base address.
   const MCSymbol *TOCBaseSym =
       cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
           ->getQualNameSymbol();
   OutStreamer->emitValue(MCSymbolRefExpr::create(TOCBaseSym, OutContext),
PPCAIXAsmPrinter::getMCSymbolForTOCPseudoMO(const MachineOperand &MO) {
 
   // Do an early error check for globals we don't support. This will go away
   // eventually.
   const auto *GV = dyn_cast<const GlobalVariable>(GO);
   if (GV) {
     ValidateGV(GV);
   }
 
-  MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(getSymbol(GO));
-
   // If the global object is a global variable without initializer or is a
   // declaration of a function, then XSym is an external referenced symbol.
   // Hence we may need to explictly create a MCSectionXCOFF for it so that we
   // can return its symbol later.
   if (GO->isDeclaration()) {
     return cast<MCSectionXCOFF>(
                getObjFileLowering().getSectionForExternalReference(GO, TM))
         ->getQualNameSymbol();
   }
 
   // Handle initialized global variables and defined functions.
   SectionKind GOKind = getObjFileLowering().getKindForGlobal(GO, TM);
 
   if (GOKind.isText()) {
     // If the MO is a function, we want to make sure to refer to the function
     // descriptor csect.
     return cast<MCSectionXCOFF>(
-               getObjFileLowering().getSectionForFunctionDescriptor(XSym))
+               getObjFileLowering().getSectionForFunctionDescriptor(
+                   dyn_cast<const Function>(GO)))
         ->getQualNameSymbol();
   } else if (GOKind.isCommon() || GOKind.isBSSLocal()) {
     // If the operand is a common then we should refer to the csect symbol.
     return cast<MCSectionXCOFF>(
                getObjFileLowering().SectionForGlobal(GO, GOKind, TM))
         ->getQualNameSymbol();
   }
 

llvm/test/CodeGen/PowerPC/aix-func-dsc-gen.ll

 ; CHECK-NEXT:     }
 ; CHECK-NEXT:   }
 ; CHECK-NEXT:   Symbol {
 ; CHECK-NEXT:     Index: [[#Index+4]]
 ; CHECK-NEXT:     Name: foo
 ; CHECK-NEXT:     Value (RelocatableAddress): 0x4
 ; CHECK-NEXT:     Section: .data
 ; CHECK-NEXT:     Type: 0x0
-; CHECK-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECK-NEXT:     StorageClass: C_EXT (0x2) 
 ; CHECK-NEXT:     NumberOfAuxEntries: 1
 ; CHECK-NEXT:     CSECT Auxiliary Entry {
 ; CHECK-NEXT:       Index: [[#Index+5]]
 ; CHECK-NEXT:       SectionLen: 12
 ; CHECK-NEXT:       ParameterHashIndex: 0x0
 ; CHECK-NEXT:       TypeChkSectNum: 0x0
 ; CHECK-NEXT:       SymbolAlignmentLog2: 2
 ; CHECK-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECK-NEXT:       StorageMappingClass: XMC_DS (0xA)
 ; CHECK-NEXT:       StabInfoIndex: 0x0
 ; CHECK-NEXT:       StabSectNum: 0x0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:   }
 ; CHECK-NEXT:   Symbol {
 ; CHECK-NEXT:     Index: [[#Index+6]]
-; CHECK-NEXT:     Name: foo
-; CHECK-NEXT:     Value (RelocatableAddress): 0x4
-; CHECK-NEXT:     Section: .data
-; CHECK-NEXT:     Type: 0x0
-; CHECK-NEXT:     StorageClass: C_EXT (0x2)
-; CHECK-NEXT:     NumberOfAuxEntries: 1
-; CHECK-NEXT:     CSECT Auxiliary Entry {
-; CHECK-NEXT:       Index: [[#Index+7]]
-; CHECK-NEXT:       ContainingCsectSymbolIndex: [[#Index+4]]
-; CHECK-NEXT:       ParameterHashIndex: 0x0
-; CHECK-NEXT:       TypeChkSectNum: 0x0
-; CHECK-NEXT:       SymbolAlignmentLog2: 0
-; CHECK-NEXT:       SymbolType: XTY_LD (0x2)
-; CHECK-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; CHECK-NEXT:       StabInfoIndex: 0x0
-; CHECK-NEXT:       StabSectNum: 0x0
-; CHECK-NEXT:     }
-; CHECK-NEXT:   }
-; CHECK-NEXT:   Symbol {
-; CHECK-NEXT:     Index: [[#Index+8]]
 ; CHECK-NEXT:     Name: TOC
 ; CHECK-NEXT:     Value (RelocatableAddress): 0x10
 ; CHECK-NEXT:     Section: .data
 ; CHECK-NEXT:     Type: 0x0
 ; CHECK-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECK-NEXT:     NumberOfAuxEntries: 1
 ; CHECK-NEXT:     CSECT Auxiliary Entry {
-; CHECK-NEXT:       Index: [[#Index+9]]
+; CHECK-NEXT:       Index: [[#Index+7]]
 ; CHECK-NEXT:       SectionLen: 0
 ; CHECK-NEXT:       ParameterHashIndex: 0x0
 ; CHECK-NEXT:       TypeChkSectNum: 0x0
 ; CHECK-NEXT:       SymbolAlignmentLog2: 2
 ; CHECK-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECK-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
 ; CHECK-NEXT:       StabInfoIndex: 0x0
 ; CHECK-NEXT:       StabSectNum: 0x0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:   }

llvm/test/CodeGen/PowerPC/aix-user-defined-memcpy.ll

 ; 32-REL-NEXT:    Symbol: .memcpy (2)
 ; 32-REL-NEXT:    IsSigned: No
 ; 32-REL-NEXT:    FixupBitValue: 0
 ; 32-REL-NEXT:    Length: 32
 ; 32-REL-NEXT:    Type: R_POS (0x0)
 ; 32-REL-NEXT:  }
 ; 32-REL-NEXT:  Relocation {
 ; 32-REL-NEXT:    Virtual Address: 0x38
-; 32-REL-NEXT:    Symbol: TOC (14)
+; 32-REL-NEXT:    Symbol: TOC (10)
 ; 32-REL-NEXT:    IsSigned: No
 ; 32-REL-NEXT:    FixupBitValue: 0
 ; 32-REL-NEXT:    Length: 32
 ; 32-REL-NEXT:    Type: R_POS (0x0)
 ; 32-REL-NEXT:  }
 ; 32-REL-NEXT:  Relocation {
 ; 32-REL-NEXT:    Virtual Address: 0x40
 ; 32-REL-NEXT:    Symbol: .call_memcpy (4)
 ; 32-REL-NEXT:    IsSigned: No
 ; 32-REL-NEXT:    FixupBitValue: 0
 ; 32-REL-NEXT:    Length: 32
 ; 32-REL-NEXT:    Type: R_POS (0x0)
 ; 32-REL-NEXT:  }
 ; 32-REL-NEXT:  Relocation {
 ; 32-REL-NEXT:    Virtual Address: 0x44
-; 32-REL-NEXT:    Symbol: TOC (14)
+; 32-REL-NEXT:    Symbol: TOC (10)
 ; 32-REL-NEXT:    IsSigned: No
 ; 32-REL-NEXT:    FixupBitValue: 0
 ; 32-REL-NEXT:    Length: 32
 ; 32-REL-NEXT:    Type: R_POS (0x0)
 ; 32-REL-NEXT:  }
 ; 32-REL-NEXT:  }
 ; 32-REL-NEXT: ]
 

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

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

 ; RELOC-NEXT:     Symbol: .bar (0)
 ; RELOC-NEXT:     IsSigned: Yes
 ; RELOC-NEXT:     FixupBitValue: 0
 ; RELOC-NEXT:     Length: 26
 ; RELOC-NEXT:     Type: R_RBR (0x1A)
 ; RELOC-NEXT:   }
 ; RELOC-NEXT:   Relocation {
 ; RELOC-NEXT:     Virtual Address: 0x1A
-; RELOC-NEXT:     Symbol: globalA (22)
+; RELOC-NEXT:     Symbol: globalA (20)
 ; RELOC-NEXT:     IsSigned: No
 ; RELOC-NEXT:     FixupBitValue: 0
 ; RELOC-NEXT:     Length: 16
 ; RELOC-NEXT:     Type: R_TOC (0x3)
 ; RELOC-NEXT:   }
 ; RELOC-NEXT:   Relocation {
 ; RELOC-NEXT:     Virtual Address: 0x1E
-; RELOC-NEXT:     Symbol: globalB (24)
+; RELOC-NEXT:     Symbol: globalB (22)
 ; 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:   Symbol: .foo (4)
 ; 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 (20)
+; RELOC-NEXT:   Symbol: TOC (18)
 ; RELOC-NEXT:   IsSigned: No
 ; RELOC-NEXT:   FixupBitValue: 0
 ; RELOC-NEXT:   Length: 32
 ; RELOC-NEXT:   Type: R_POS (0x0)
 ; RELOC-NEXT: }
 ; RELOC-NEXT: Relocation {
 ; RELOC-NEXT:   Virtual Address: 0x80
 ; RELOC-NEXT:   Symbol: globalA (8)

 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: 16
 ; SYM-NEXT:     Name: foo
 ; SYM-NEXT:     Value (RelocatableAddress): 0x74
 ; 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: 17
 ; SYM-NEXT:       SectionLen: 12
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 2
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: 18
-; SYM-NEXT:     Name: foo
-; SYM-NEXT:     Value (RelocatableAddress): 0x74
-; SYM-NEXT:     Section: .data
-; SYM-NEXT:     Type: 0x0
-; SYM-NEXT:     StorageClass: C_EXT (0x2)
-; SYM-NEXT:     NumberOfAuxEntries: 1
-; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 19
-; SYM-NEXT:       ContainingCsectSymbolIndex: 16
-; SYM-NEXT:       ParameterHashIndex: 0x0
-; SYM-NEXT:       TypeChkSectNum: 0x0
-; SYM-NEXT:       SymbolAlignmentLog2: 0
-; SYM-NEXT:       SymbolType: XTY_LD (0x2)
-; SYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
-; SYM-NEXT:       StabInfoIndex: 0x0
-; SYM-NEXT:       StabSectNum: 0x0
-; SYM-NEXT:     }
-; SYM-NEXT:   }
-; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: 20
 ; SYM-NEXT:     Name: TOC
 ; SYM-NEXT:     Value (RelocatableAddress): 0x80
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 21
+; SYM-NEXT:       Index: 19
 ; SYM-NEXT:       SectionLen: 0
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 2
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_TC0 (0xF)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: 22
+; SYM-NEXT:     Index: 20
 ; SYM-NEXT:     Name: globalA
 ; SYM-NEXT:     Value (RelocatableAddress): 0x80
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 23
+; SYM-NEXT:       Index: 21
 ; SYM-NEXT:       SectionLen: 4
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 2
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
-; SYM-NEXT:     Index: 24
+; SYM-NEXT:     Index: 22
 ; SYM-NEXT:     Name: globalB
 ; SYM-NEXT:     Value (RelocatableAddress): 0x84
 ; SYM-NEXT:     Section: .data
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
-; SYM-NEXT:       Index: 25
+; SYM-NEXT:       Index: 23
 ; SYM-NEXT:       SectionLen: 4
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
 ; SYM-NEXT:       SymbolAlignmentLog2: 2
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0

llvm/test/CodeGen/PowerPC/test_func_desc.ll

 
 declare i32 @extern_foo(...)
 
 define internal i32 @static_foo() {
 entry:
   ret i32 3
 }
 
-; CHECK: .globl foo
+; CHECK: .globl foo[DS]
 ; CHECK: .globl .foo
 ; CHECK: .csect foo[DS]
-; CHECK-NEXT: foo:
 ; 32BIT: .long .foo
 ; 32BIT-NEXT: .long TOC[TC0]
 ; 32BIT-NEXT: .long 0
 ; 64BIT: .llong .foo
 ; 64BIT-NEXT: .llong TOC[TC0]
 ; 64BIT-NEXT: .llong 0
 ; CHECK-NEXT: .csect .text[PR]
 ; CHECK-LABEL: .foo:
 
-; CHECK: .globl main
+; CHECK: .globl main[DS]
 ; CHECK: .globl .main
 ; CHECK: .csect main[DS]
-; CHECK-NEXT: main:
 ; 32BIT: .long .main
 ; 32BIT-NEXT: .long TOC[TC0]
 ; 32BIT-NEXT: .long 0
 ; 64BIT: .llong .main
 ; 64BIT-NEXT: .llong TOC[TC0]
 ; 64BIT-NEXT: .llong 0
 ; CHECK-NEXT: .csect .text[PR]
 ; CHECK-LABEL: .main:
 ; CHECK: bl .foo
 ; CHECK: bl .extern_foo
 ; CHECK: bl .static_foo
 
 ; CHECK: .lglobl .static_foo
 ; CHECK: .csect static_foo[DS]
-; CHECK-NEXT: static_foo:
 ; 32BIT: .long .static_foo
 ; 32BIT-NEXT: .long TOC[TC0]
 ; 32BIT-NEXT: .long 0
 ; 64BIT: .llong .static_foo
 ; 64BIT-NEXT: .llong TOC[TC0]
 ; 64BIT-NEXT: .llong 0
 ; CHECK-NEXT: .csect .text[PR]
 ; CHECK-LABEL: .static_foo:
 
 ; CHECK-NOT: .csect extern_foo
 
 ; CHECK: .toc
 ; CHECK-NOT: .tc