[NFC][XCOFF] Refactor Csect creation into TargetLoweringObjectFile

[daltenty]

Summary

We create a number of standard types of control sections in multiple places for
things like the function descriptors, external references and the TOC anchor
among others, so it is possible for their properties to be defined
inconsistently in different places. This refactor moves their creation and
properties into functions in the TargetLoweringObjectFile class hierarchy, where
functions for retrieving various special types of sections typically seem
to reside.

Note: There is one case in PPCISelLowering which is specific to function entry
points which we don't address since we don't have access to the TLOF there.

[DiggerLin]

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

251

I think we can
getSectionForExternalReference(const MCSymbol *Sym). const override here ?

I search all the place where invoke getSectionForExternalReference , it can use the function define getSectionForExternalReference(const MCSymbol *Sym)

the benefit of using getSectionForExternalReference(const MCSymbol *Sym) , we save one parameter and have some function parameter as getSectionForFunctionDescriptor and getSectionForTOCEntry

[DiggerLin]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1803

If I understand correctly, I do not think we need to change the

if (!GV->hasInitializer())  to here .

the reason is if the extern variable is declared in the source code. but never be used, it the declare extern variable do not to show on the xcoff object file even in the symbol table or in the asm file.

if the extern variable is declared and be used as initiator , the MCSection will be created in the PPCAIXAsmPrinter::lowerConstant()

[jasonliu]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1982

Other getSection... function do not set the containing csect.
And I think for the design of the function, this extra convenient thing it does, did not reflect on anywhere (function name does not suggest it would do that). When developer see the call site only, they might actually want to find out why we do not set the containing csect (until they find it here).
So I suggest to move it out for both consistency and the design.

[daltenty]

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

251

I was original inclined to do this as well, but we need to query the GlobalObject to determine whether it is a function, so we can set the correct Storage Mapping Class.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1803

There are other cases than will be handled by lowerConstant(). We may refer to the external global in a function body, in which case we will need to setup the symbols containing CSect here.

[daltenty]

• Move set containing csect out of getSectionForTOCEntry

[daltenty]

• Avoid unneeded variable rename

[daltenty]

• And avoid comment change

[jasonliu]

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

251

Have we thought about passing an extra bool parameter to indicate whether it is a function or not? I don't like bool parameter either, but in this case, it might not be that bad, and we could avoid querying if we need to create a new name.

[daltenty]

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

251

Unfortunately functions are not the only special case of externals we will need to handle in the future (e.g. thread locals), so I think this interface creates a better abstraction for the future. The current parameter types are also fairly congruent with what we see for some of the other get*Section() members here.

[jasonliu]

Other than some minor nits. LGTM.

llvm/include/llvm/Target/TargetLoweringObjectFile.h

216

nit: it's -> its

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1981

nit: similar to the function above, we could return this TCEntry directly without creating a local variable.

[hubert.reinterpretcast]

llvm/include/llvm/Target/TargetLoweringObjectFile.h

215

This is for targets that use separate function descriptor symbols, not for targets that support function descriptors in general.

221

https://refspecs.linuxfoundation.org/ELF/ppc64/PPC-elf64abi-1.9.html mentions TOC entries. Did we implement this function for the corresponding LLVM implementation?

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1803

Please add this rationale to the comment about creating the containing csect.

[daltenty]

• Comment updates
• Just do a direct return in getSectionForTOCEntry

llvm/include/llvm/Target/TargetLoweringObjectFile.h

221

I can add the ELF change if we think it is in scope, though this will make this no longer an XCOFF only patch. Perhaps we better do that as a follow on patch?

[hubert.reinterpretcast]

llvm/include/llvm/Target/TargetLoweringObjectFile.h

221

The second this lands, having the interface here without a TODO comment suggests that it is already implemented for the existing targets for which it applies. The alternative consideration is whether the scope of the interface is correct. Should it be clearly more XCOFF specific and should it be a virtual function at this level of the class hierarchy at all?

[daltenty]

• Add todo

[hubert.reinterpretcast]

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

247

I am not sure there is anything about this interface that indicates that it is not suitable for retrieving the section for a function descriptor in the case where said section should be an external reference. In lowerConstant, the argument value needed to call this function is available even in the case where the function is undefined.

250

I am not sure there is anything about this interface that indicates that it is not suitable for retrieving the section for an external reference to a function entry point. Where getAIXFuncEntryPointSymbolSDNode is present in the codebase, the function is also handled as a GlobalObject.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1837

Add "a" before "defined global".

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1806

Assert !GV->isDeclaration() here to be sure that GVKind has been initialized.

[daltenty]

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

247

I will add a comment indicating this interface is for use only with defined functions.

250

Indeed, that is not a limitation of this interface, this is the case in PPCISelLowering mentioned in the patch description. It was my intention to handle that as a separate patch since it will require some further refactoring as it appears the TLOF is not available there.

[daltenty]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1806

The branch on !GV->hasInitializer() above guarantees this, GV->hasInitializer() is defined as !isDeclaration()

[daltenty]

• Address comments

[hubert.reinterpretcast]

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

250

The interface is ambiguous as it stands on whether the function descriptor or function entry point is meant.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1970

There should be an assertion that the function is defined.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1806

It is better not to rely on such a relationship between the two queries.

[daltenty]

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

250

I've added a comment to clarify this is the behaviour for XCOFF

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1970

That query is not safe to make on the symbol here, as it requires a fragment that we may not have.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1806

I will replace the branch condition above with 'isDeclaration()' so the relationship is explicit

[daltenty]

• Address comments

[hubert.reinterpretcast]

LGTM with minor comment.

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

250

I think this deserves to be a Doxygen comment.

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 *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/MC/MCObjectFileInfo.h

protected:
   /// COFF specific sections.
   MCSection *DrectveSection = nullptr;
   MCSection *PDataSection = nullptr;
   MCSection *XDataSection = nullptr;
   MCSection *SXDataSection = nullptr;
   MCSection *GFIDsSection = nullptr;
   MCSection *GLJMPSection = nullptr;
 
+  // XCOFF specific sections
+  MCSection *TOCBaseSection = nullptr;
+
 public:
   void InitMCObjectFileInfo(const Triple &TT, bool PIC, MCContext &ctx,
                             bool LargeCodeModel = false);
 
   bool getSupportsWeakOmittedEHFrame() const {
     return SupportsWeakOmittedEHFrame;
   }
   bool getSupportsCompactUnwindWithoutEHFrame() const {
public:
   // COFF specific sections.
   MCSection *getDrectveSection() const { return DrectveSection; }
   MCSection *getPDataSection() const { return PDataSection; }
   MCSection *getXDataSection() const { return XDataSection; }
   MCSection *getSXDataSection() const { return SXDataSection; }
   MCSection *getGFIDsSection() const { return GFIDsSection; }
   MCSection *getGLJMPSection() const { return GLJMPSection; }
 
+  // XCOFF specific sections
+  MCSection *getTOCBaseSection() const { return TOCBaseSection; }
+
   MCSection *getEHFrameSection() {
     return EHFrameSection;
   }
 
   enum Environment { IsMachO, IsELF, IsCOFF, IsWasm, IsXCOFF };
   Environment getObjectFileType() const { return Env; }
 
   bool isPositionIndependent() const { return PositionIndependent; }

llvm/include/llvm/Target/TargetLoweringObjectFile.h

virtual void emitLinkerFlagsForUsed(raw_ostream &OS,
                                       const GlobalValue *GV) const {}
 
   /// 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 {
+    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;
+  }
+
+  /// On targets that associate external references with a section, return such
+  /// a section for the given external global.
+  virtual MCSection *
+  getSectionForExternalReference(const GlobalObject *GO,
+                                 const TargetMachine &TM) const {
+    return nullptr;
+  }
+
 protected:
   virtual MCSection *SelectSectionForGlobal(const GlobalObject *GO,
                                             SectionKind Kind,
                                             const TargetMachine &TM) const = 0;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_TARGETLOWERINGOBJECTFILE_H

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

 //===----------------------------------------------------------------------===//
 //                                  XCOFF
 //===----------------------------------------------------------------------===//
 MCSection *TargetLoweringObjectFileXCOFF::getExplicitSectionGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
   report_fatal_error("XCOFF explicit sections not yet implemented.");
 }
 
+MCSection *TargetLoweringObjectFileXCOFF::getSectionForExternalReference(
+    const GlobalObject *GO, const TargetMachine &TM) const {
+  assert(GO->isDeclaration() &&
+         "Tried to get ER section for a defined global.");
+
+  SmallString<128> Name;
+  getNameWithPrefix(Name, GO, TM);
+  XCOFF::StorageClass SC =
+      TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GO);
+
+  // Externals go into a csect of type ER.
+  return getContext().getXCOFFSection(
+      Name, isa<Function>(GO) ? XCOFF::XMC_DS : XCOFF::XMC_UA, XCOFF::XTY_ER,
+      SC, SectionKind::getMetadata());
+}
+
 MCSection *TargetLoweringObjectFileXCOFF::SelectSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
   assert(!TM.getFunctionSections() && !TM.getDataSections() &&
          "XCOFF unique sections not yet implemented.");
 
   // Common symbols go into a csect with matching name which will get mapped
   // into the .bss section.
   if (Kind.isBSSLocal() || Kind.isCommon()) {
case GlobalValue::CommonLinkage:
     return XCOFF::C_EXT;
   case GlobalValue::ExternalWeakLinkage:
     return XCOFF::C_WEAKEXT;
   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());
+}
+
+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/MC/MCObjectFileInfo.cpp

void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
 
   DataSection = Ctx->getXCOFFSection(
       ".data", XCOFF::StorageMappingClass::XMC_RW, XCOFF::XTY_SD,
       XCOFF::C_HIDEXT, SectionKind::getData());
 
   ReadOnlySection = Ctx->getXCOFFSection(
       ".rodata", XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD,
       XCOFF::C_HIDEXT, SectionKind::getReadOnly());
+
+  TOCBaseSection = Ctx->getXCOFFSection(
+      "TOC", XCOFF::StorageMappingClass::XMC_TC0, XCOFF::XTY_SD,
+      XCOFF::C_HIDEXT, SectionKind::getData());
+
+  // The TOC-base always has 0 size, but 4 byte alignment.
+  TOCBaseSection->setAlignment(Align(4));
 }
 
 void MCObjectFileInfo::InitMCObjectFileInfo(const Triple &TheTriple, bool PIC,
                                             MCContext &ctx,
                                             bool LargeCodeModel) {
   PositionIndependent = PIC;
   Ctx = &ctx;
 

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
 
   return AsmPrinter::doFinalization(M);
 }
 
 void PPCAIXAsmPrinter::SetupMachineFunction(MachineFunction &MF) {
   // Get the function descriptor symbol.
   CurrentFnDescSym = getSymbol(&MF.getFunction());
   // Set the containing csect.
-  MCSectionXCOFF *FnDescSec = OutStreamer->getContext().getXCOFFSection(
-      CurrentFnDescSym->getName(), XCOFF::XMC_DS, XCOFF::XTY_SD,
-      XCOFF::C_HIDEXT, SectionKind::getData());
+  MCSectionXCOFF *FnDescSec = cast<MCSectionXCOFF>(
+      getObjFileLowering().getSectionForFunctionDescriptor(CurrentFnDescSym));
   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()) {
-      const XCOFF::StorageClass SC =
+      MCSectionXCOFF *Csect = cast<MCSectionXCOFF>(
           F->isDeclaration()
-              ? TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(F)
-              : XCOFF::C_HIDEXT;
-      MCSectionXCOFF *Csect = OutStreamer->getContext().getXCOFFSection(
-          FSym->getName(), XCOFF::XMC_DS,
-          F->isDeclaration() ? XCOFF::XTY_ER : XCOFF::XTY_SD, SC,
-          SectionKind::getData());
+              ? getObjFileLowering().getSectionForExternalReference(F, TM)
+              : getObjFileLowering().getSectionForFunctionDescriptor(FSym));
       FSym->setContainingCsect(Csect);
     }
     return MCSymbolRefExpr::create(
         FSym->getContainingCsect()->getQualNameSymbol(), OutContext);
   }
   return PPCAsmPrinter::lowerConstant(CV);
 }
 
 void PPCAIXAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
   ValidateGV(GV);
 
-  // External global variables are already handled.
-  if (!GV->hasInitializer())
-    return;
-
   // Create the symbol, set its storage class.
   MCSymbolXCOFF *GVSym = cast<MCSymbolXCOFF>(getSymbol(GV));
   GVSym->setStorageClass(
       TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GV));
 
-  SectionKind GVKind = getObjFileLowering().getKindForGlobal(GV, TM);
+  SectionKind GVKind;
+
+  // Create the containing csect and set it. We set it for externals as well,
+  // since this may not have been set elsewhere depending on how they are used.
+  MCSectionXCOFF *Csect = cast<MCSectionXCOFF>(
+      GV->isDeclaration()
+          ? getObjFileLowering().getSectionForExternalReference(GV, TM)
+          : getObjFileLowering().SectionForGlobal(
+                GV, GVKind = getObjFileLowering().getKindForGlobal(GV, TM),
+                TM));
+  GVSym->setContainingCsect(Csect);
+
+  // External global variables are already handled.
+  if (GV->isDeclaration())
+    return;
+
   if ((!GVKind.isCommon() && !GVKind.isBSS() && !GVKind.isData() &&
        !GVKind.isReadOnly()) ||
       GVKind.isMergeable2ByteCString() || GVKind.isMergeable4ByteCString())
     report_fatal_error("Encountered a global variable kind that is "
                        "not supported yet.");
 
-  // Create the containing csect and switch to it.
-  MCSectionXCOFF *Csect = cast<MCSectionXCOFF>(
-      getObjFileLowering().SectionForGlobal(GV, GVKind, TM));
+  // Switch to the containing csect.
   OutStreamer->SwitchSection(Csect);
-  GVSym->setContainingCsect(Csect);
 
   const DataLayout &DL = GV->getParent()->getDataLayout();
 
   // Handle common symbols.
   if (GVKind.isCommon() || GVKind.isBSSLocal()) {
     unsigned Align =
       GV->getAlignment() ? GV->getAlignment() : DL.getPreferredAlignment(GV);
     uint64_t Size = DL.getTypeAllocSize(GV->getType()->getElementType());
void PPCAIXAsmPrinter::EmitFunctionDescriptor() {
   // 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 MCSectionXCOFF *TOCBaseSec = OutStreamer->getContext().getXCOFFSection(
-      StringRef("TOC"), XCOFF::XMC_TC0, XCOFF::XTY_SD, XCOFF::C_HIDEXT,
-      SectionKind::getData());
-  const MCSymbol *TOCBaseSym = TOCBaseSec->getQualNameSymbol();
+  const MCSymbol *TOCBaseSym =
+      cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
+          ->getQualNameSymbol();
   OutStreamer->EmitValue(MCSymbolRefExpr::create(TOCBaseSym, OutContext),
                          PointerSize);
   // Emit a null environment pointer.
   OutStreamer->EmitIntValue(0, PointerSize);
 
   OutStreamer->SwitchSection(Current.first, Current.second);
 }
 
 void PPCAIXAsmPrinter::EmitEndOfAsmFile(Module &M) {
   // If there are no functions in this module, we will never need to reference
   // the TOC base.
   if (M.empty())
     return;
 
-  // Emit TOC base.
-  MCSectionXCOFF *TOCBaseSection = OutStreamer->getContext().getXCOFFSection(
-      StringRef("TOC"), XCOFF::XMC_TC0, XCOFF::XTY_SD, XCOFF::C_HIDEXT,
-      SectionKind::getData());
-  // The TOC-base always has 0 size, but 4 byte alignment.
-  TOCBaseSection->setAlignment(Align(4));
   // Switch to section to emit TOC base.
-  OutStreamer->SwitchSection(TOCBaseSection);
+  OutStreamer->SwitchSection(getObjFileLowering().getTOCBaseSection());
 
   PPCTargetStreamer &TS =
       static_cast<PPCTargetStreamer &>(*OutStreamer->getTargetStreamer());
 
   for (auto &I : TOC) {
     // Setup the csect for the current TC entry.
-    MCSectionXCOFF *TCEntry = OutStreamer->getContext().getXCOFFSection(
-        cast<MCSymbolXCOFF>(I.first)->getUnqualifiedName(), XCOFF::XMC_TC,
-        XCOFF::XTY_SD, XCOFF::C_HIDEXT, SectionKind::getData());
+    MCSectionXCOFF *TCEntry = cast<MCSectionXCOFF>(
+        getObjFileLowering().getSectionForTOCEntry(I.first));
     cast<MCSymbolXCOFF>(I.second)->setContainingCsect(TCEntry);
     OutStreamer->SwitchSection(TCEntry);
 
     OutStreamer->EmitLabel(I.second);
     TS.emitTCEntry(*I.first);
   }
 }
 
PPCAIXAsmPrinter::getMCSymbolForTOCPseudoMO(const MachineOperand &MO) {
 
   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()) {
-    if (!XSym->hasContainingCsect()) {
-      // Make sure the storage class is set.
-      const XCOFF::StorageClass SC =
-          TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GO);
-      XSym->setStorageClass(SC);
-
-      MCSectionXCOFF *Csect = OutStreamer->getContext().getXCOFFSection(
-          XSym->getName(), isa<Function>(GO) ? XCOFF::XMC_DS : XCOFF::XMC_UA,
-          XCOFF::XTY_ER, SC, SectionKind::getMetadata());
-      XSym->setContainingCsect(Csect);
-    }
-
-    return XSym->getContainingCsect()->getQualNameSymbol();
+    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 OutStreamer->getContext()
-        .getXCOFFSection(XSym->getName(), XCOFF::XMC_DS, XCOFF::XTY_SD,
-                         XCOFF::C_HIDEXT, SectionKind::getData())
+    return cast<MCSectionXCOFF>(
+               getObjFileLowering().getSectionForFunctionDescriptor(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();
   }