[NFC][XCOFF][AIX] Return function entry point symbol with dedicate function

[jasonliu]

Summary

Use getFunctionEntryPointSymbol whenever possible to enclose the implementation detail and reduce duplicate logic.

[DiggerLin]

llvm/include/llvm/Target/TargetLoweringObjectFile.h

249

the code should be never come to here. maybe report an fatal error maybe better.

[jasonliu]

llvm/include/llvm/Target/TargetLoweringObjectFile.h

249

Current code won't come here. But I think returning a nullptr have more benefit than just report_fatal_error. Sometimes, we could write code that relying on it being return nulltpr on Targets that does not support it (instead of relying on target query).

[DiggerLin]

LGTM

[hubert.reinterpretcast]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2152

I think getNameWithPrefix appends, meaning that NameStr.push_back('.') before calling it will do what we need without using operator+ below.

[jasonliu]

Use push_back instead of operator+.

[hubert.reinterpretcast]

LGTM.

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

public:
   /// csect.
   MCSection *
   getSectionForExternalReference(const GlobalObject *GO,
                                  const TargetMachine &TM) const override;
 
   /// For functions, this will always return a function descriptor symbol.
   MCSymbol *getTargetSymbol(const GlobalValue *GV,
                             const TargetMachine &TM) const override;
+
+  MCSymbol *getFunctionEntryPointSymbol(const Function *F,
+                                        const TargetMachine &TM) const override;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H

llvm/include/llvm/Target/TargetLoweringObjectFile.h

public:
 
   /// Targets that have a special convention for their symbols could use
   /// this hook to return a specialized symbol.
   virtual MCSymbol *getTargetSymbol(const GlobalValue *GV,
                                     const TargetMachine &TM) const {
     return nullptr;
   }
 
+  /// If supported, return the function entry point symbol.
+  /// Otherwise, returns nulltpr.
+  virtual MCSymbol *getFunctionEntryPointSymbol(const Function *F,
+                                                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/AsmPrinter/AsmPrinter.cpp

bool AsmPrinter::doFinalization(Module &M) {
 
   // Emit global variables.
   for (const auto &G : M.globals())
     emitGlobalVariable(&G);
 
   // Emit remaining GOT equivalent globals.
   emitGlobalGOTEquivs();
 
+  const TargetLoweringObjectFile &TLOF = getObjFileLowering();
+
   // Emit linkage(XCOFF) and visibility info for declarations
   for (const Function &F : M) {
     if (!F.isDeclarationForLinker())
       continue;
 
     MCSymbol *Name = getSymbol(&F);
     // Function getSymbol gives us the function descriptor symbol for XCOFF.
     if (TM.getTargetTriple().isOSBinFormatXCOFF() && !F.isIntrinsic()) {
 
       // Get the function entry point symbol.
-      MCSymbol *FnEntryPointSym = OutContext.getOrCreateSymbol(
-          "." + cast<MCSymbolXCOFF>(Name)->getUnqualifiedName());
+      MCSymbol *FnEntryPointSym = TLOF.getFunctionEntryPointSymbol(&F, TM);
       if (cast<MCSymbolXCOFF>(FnEntryPointSym)->hasRepresentedCsectSet())
         // Emit linkage for the function entry point.
         emitLinkage(&F, FnEntryPointSym);
 
       // Emit linkage for the function descriptor.
       emitLinkage(&F, Name);
     }
 
     GlobalValue::VisibilityTypes V = F.getVisibility();
     if (V == GlobalValue::DefaultVisibility)
       continue;
 
     emitVisibility(Name, V, false);
   }
 
   // Emit the remarks section contents.
   // FIXME: Figure out when is the safest time to emit this section. It should
   // not come after debug info.
   if (remarks::RemarkStreamer *RS = M.getContext().getMainRemarkStreamer())
     emitRemarksSection(*RS);
 
-  const TargetLoweringObjectFile &TLOF = getObjFileLowering();
-
   TLOF.emitModuleMetadata(*OutStreamer, M);
 
   if (TM.getTargetTriple().isOSBinFormatELF()) {
     MachineModuleInfoELF &MMIELF = MMI->getObjFileInfo<MachineModuleInfoELF>();
 
     // Output stubs for external and common global variables.
     MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList();
     if (!Stubs.empty()) {
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(
-        "." + cast<MCSymbolXCOFF>(CurrentFnDescSym)->getUnqualifiedName());
+    CurrentFnSym = getObjFileLowering().getFunctionEntryPointSymbol(&F, TM);
   }
 
   CurrentFnSymForSize = CurrentFnSym;
   CurrentFnBegin = nullptr;
   CurrentSectionBeginSym = nullptr;
   CurExceptionSym = nullptr;
   bool NeedsLocalForSize = MAI->needsLocalForSize();
   if (F.hasFnAttribute("patchable-function-entry") ||

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

report_fatal_error(
         "There is no mapping that implements AppendingLinkage for XCOFF.");
   case GlobalValue::AvailableExternallyLinkage:
     report_fatal_error("unhandled AvailableExternallyLinkage when mapping "
                        "linkage to StorageClass");
   }
   llvm_unreachable("Unknown linkage type!");
 }
 
+MCSymbol *TargetLoweringObjectFileXCOFF::getFunctionEntryPointSymbol(
+    const Function *F, const TargetMachine &TM) const {
+  SmallString<128> NameStr;
+  NameStr.push_back('.');
+  getNameWithPrefix(NameStr, F, TM);
+  return getContext().getOrCreateSymbol(NameStr);
+}
+
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForFunctionDescriptor(
     const Function *F, const TargetMachine &TM) const {
   SmallString<128> NameStr;
   getNameWithPrefix(NameStr, F, TM);
   return getContext().getXCOFFSection(NameStr, XCOFF::XMC_DS, XCOFF::XTY_SD,
                                       getStorageClassForGlobal(F),
                                       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());
 }