[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–1975

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

1549

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–1975

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

1549

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–1975

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

1549

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.

1562

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();

[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

1762

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

1762

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

1762

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

1563–1564

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

1568

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

1587

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

1568

thanks

1762

OK

[jasonliu]

There is a nit, otherwise LGTM.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1589

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

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1589

This comment is not addressed when you land the commit.

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1589

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

llvm/include/llvm/CodeGen/AsmPrinter.h

public:
 
   /// This emits visibility information about symbol, if this is supported by
   /// the target.
   void emitVisibility(MCSymbol *Sym, unsigned Visibility,
                       bool IsDefinition = true) const;
 
   /// This emits linkage information about \p GVSym based on \p GV, if this is
   /// supported by the target.
-  void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const;
+  virtual void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const;
 
   /// Return the alignment for the specified \p GV.
   static Align getGVAlignment(const GlobalValue *GV, const DataLayout &DL,
                               Align InAlign = Align(1));
 
 private:
   /// Private state for PrintSpecial()
   // Assign a unique ID to this machine instruction.

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 GlobalObject *GO,
+                                             const MCSymbol *) 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 GlobalObject *GO,
+                                                     const MCSymbol *S) 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/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 GlobalObject *GO, const MCSymbol *FuncSym) const {
+  return getContext().getXCOFFSection(
+      FuncSym->getName(), XCOFF::XMC_DS, XCOFF::XTY_SD,
+      getStorageClassForGlobal(GO), SectionKind::getData());
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForTOCEntry(
     const MCSymbol *Sym) const {
   return getContext().getXCOFFSection(
       cast<MCSymbolXCOFF>(Sym)->getUnqualifiedName(), XCOFF::XMC_TC,
       XCOFF::XTY_SD, XCOFF::C_HIDEXT, SectionKind::getData());
 }

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

public:
 
   const MCExpr *lowerConstant(const Constant *CV) override;
 
   void emitGlobalVariable(const GlobalVariable *GV) override;
 
   void emitFunctionDescriptor() override;
 
   void emitEndOfAsmFile(Module &) override;
+
+  void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const override;
 };
 
 } // end anonymous namespace
 
 void PPCAsmPrinter::PrintSymbolOperand(const MachineOperand &MO,
                                        raw_ostream &O) {
   // Computing the address of a global symbol, not calling it.
   const GlobalValue *GV = MO.getGlobal();
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::emitLinkage(const GlobalValue *GV,
+                                   MCSymbol *GVSym) const {
+
+  MCSymbolXCOFF *XCOFFSym = cast<MCSymbolXCOFF>(GVSym);
+
+  if (XCOFFSym->hasContainingCsect()) {
+    MCSymbolXCOFF *QualName =
+        XCOFFSym->getContainingCsect()->getQualNameSymbol();
+    if (GVSym->getName() == QualName->getUnqualifiedName() &&
+        XCOFFSym->getContainingCsect()->getMappingClass() != XCOFF::XMC_PR)
+      GVSym = QualName;
+
+    AsmPrinter::emitLinkage(GV, GVSym);
+  }
+}
+
 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));
+  MCSectionXCOFF *FnDescSec =
+      cast<MCSectionXCOFF>(getObjFileLowering().getSectionForFunctionDescriptor(
+          &MF.getFunction(), CurrentFnDescSym));
   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));
       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) {
 
   // 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(GO, XSym))
         ->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();
   }
 
   // Other global variables are refered to by labels inside of a single csect,

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