[XCOFF][AIX] Give symbol an internal name when desired symbol name contains invalid character(s)

[jasonliu]

Summary

When a desired symbol name contains invalid character that the system assembler could not process, we need to emit .rename directive in assembly path in order for that desired symbol name to appear in the symbol table.

[jasonliu]

Address clang-tidy comments.

[hubert.reinterpretcast]

llvm/test/CodeGen/PowerPC/aix-xcoff-symbol-rename.ll

79

Minor nit: Trailing whitespace at the end of line (multiple instances of OBJ-EMPTY exhibit this).

[daltenty]

llvm/lib/MC/MCAsmStreamer.cpp

820

Previously we avoided emitting this directive for some case where it wasn't strictly required (i.e. function descriptors). Why the change in behaviour? (at first glance seems somewhat orthogonal to this patch)

[jasonliu]

llvm/lib/MC/MCAsmStreamer.cpp

820

If we don't emit this directive for function descriptor, then we would not trigger the rename for that .lglobl function descriptor when needed. While not having rename for the HIDE_EXT function descriptor is not a huge problem, we would have inconsistency in the object file generation path (object file generation will use the original name when available.).

[jasonliu]

llvm/lib/MC/MCAsmStreamer.cpp

820

And I think previously we choose to skip emitting the .lglobl for function descriptor because we have it as a label, and we would get a unnecessary symbol in the symbol table because of that. But now we have function descriptor as csect, so emitting .lglobl for it is redundant but do not have real effect. So I think it might be just easier to emit it and keep everything consistent.

[jasonliu]

Remove trailling whitespace.

[DiggerLin]

llvm/include/llvm/MC/MCSymbolXCOFF.h

64

even if there is some Overhead, using hasRename() can let user know what the getSymbolTableName() do ?

llvm/lib/MC/MCAsmStreamer.cpp

865

I do not think print out rename directive here is a good idead, as the function name :emitCommonSymbol suggestion , it just print the .comm directive, and it is common function for all the target(not only for XCOFF).

I think it maybe better to put the code in the function emitGlobalVariable() before we call the OutStreamer->emitCommonSymbol(GVSym, Size, Align);

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1610

I think it maybe better to call emitSymbolAttribute(GVSym, MCSA_LGlobal) and then return directly,

Reason:

1. for the .lglobl do not have have visibility, it do not need to go to emitXCOFFSymbolLinkageWithVisibility() ,
2. we can move the code if (cast<MCSymbolXCOFF>(Symbol)->hasRename()) OutStreamer->emitXCOFFRenameDirective(Symbol, cast<MCSymbolXCOFF>(Symbol)->getSymbolTableName());

into this function.

3. if you call emitSymbolAttribute directly, we do not need to modify the function emitXCOFFSymbolLinkageWithVisibility() in this patch.

[jasonliu]

llvm/lib/MC/MCAsmStreamer.cpp

865

As I mentioned in the other comment, emitGlobalVariable() gets called on both assembly path and object file generation path as well. So we could not directly call emitXCOFFRenameDirective() there because we only wants to do it on the assembly generation path.
I understand it is common function for all the target, but it doesn't mean we could not do target specific staff in this function (See all the MAI calls).
I would argue for XCOFF specifically, emitCommonSymbol would need to tight together with this .rename everywhere (meaning if you need to emit a .comm directive, you need to check if the symbol used have a rename, if so emit .rename), so it kinda of make sense to do it here, as oppose to making sure every future use of emitCommonSymbol call on the assembly path accompany by a emitRename call below.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1610

We only want to emitXCOFFRenameDirective when it's emitting assembly though.
And emitLinkage is called on both assembly generating path and object generation path, so we can't move that call directly to here.
It's still possible to make it happen by wrapping emitXCOFFRenameDirective with another new function(something like handleXCOFFRename?), and have that function do emitXCOFFRenameDirective on the assembly generation side, but do nothing on the object file generation side.
But I don't find adding that new function to be particular appealing though (we need to add so many extra boilerplate to tell other target that this function is not meant for them, we already did it for emitXCOFFRenameDirective but that's necessary evil because that directive is indeed not supported by other target).

[jasonliu]

Use rename() when possible.

[Xiangling_L]

llvm/lib/MC/MCContext.cpp

311

s/have use/have or s/have use/use?

326

I think some comments here explaining the way we handle the name conflict may lead to entry point and function descriptor symbols rename mismatch may help.

[jasonliu]

Adjust comments.

[DiggerLin]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1610

If we change the function

void MCStreamer::emitXCOFFRenameDirective(const MCSymbol *Name,
                                          StringRef Rename) {
  llvm_unreachable("emitXCOFFRenameDirecitve is only supported on "
                   "XCOFF targets");
}

to

void MCStreamer::emitXCOFFRenameDirective(const MCSymbol *Name,
                                          StringRef Rename) {

}

and object generation path will do nothing for the emitXCOFFRenameDirective(), it just some overhead for object generation path but the logic will be more clear.

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1610

Object generation path will take the one in MCXCOFFStreamer.h, which currently doing report_fatal_error.
I'm doing report_fatal_error because we do not need to invoke that function for now. That function will need to set the symbol table name for a rename when we implement the AsmParser for XCOFF and it could not be an empty function that does nothing for that purpose.

[hubert.reinterpretcast]

llvm/lib/MC/MCContext.cpp

313

Although this encoding generates runs of underscores, it does make it less intrusive in terms of being able to use c++filt on the result. Note that collisions increase with non-Latin scripts (which could be reduced if we append the hex values of all the underscores, including the original ones, to the end of the string).

namespace ImplVerTags {

typedef struct
一世
{} A;
typedef struct
二世
{} B;

}

template <typename> void *implStaticDataUnsafe = nullptr;

template void *implStaticDataUnsafe<ImplVerTags::A>;
template void *implStaticDataUnsafe<ImplVerTags::B>;

[jasonliu]

llvm/lib/MC/MCContext.cpp

313

Just want to make sure I understand your suggestion:
so if I have a "f`!o" as symbol name, I would get back _Renamed..6021f__o back?
Do we want to consider just adding those hex values up? Like getting back _Renamed..81f__o for that?

[jasonliu]

llvm/lib/MC/MCContext.cpp

313

If we choose to get the results like _Renamed..6021f__o, in what way I could trigger a collision? Do we need to have a collision handling mechanism then?

[hubert.reinterpretcast]

llvm/lib/MC/MCContext.cpp

313

Hmm, I suggested appending but adding to the front does seem to make it easier to eyeball the split (in addition to making the more relevant part show up first for C identifiers in non-Latin scripts). I like it. Also, yes, I meant that f_$ would become (with the prefix) _Renamed..5f24f__.

We shouldn't end up with collisions in that case. The transformation is completely reversible by identifying the number of underscores to determine the prefix length and then replacing each underscore with the encoded value.

346

Moot point if we're going with the encoding change, but the collision handling mechanism needs to check that the output name is not also going to collide:

void f_$o() { }
void f$_o() { }
void f_$o1() { }

llvm/test/CodeGen/PowerPC/aix-xcoff-symbol-rename.ll

3

Can't help but notice that none of the renamed entities are referenced via the TOC.

For example:

int f$o();
int (*bar())() { return f$o; }

[jasonliu]

llvm/lib/MC/MCContext.cpp

346

Thanks. Now I like the not-collidable renaming mechanism much more when I know I avoided a while loop to check if the ouput name is going to collide.

llvm/test/CodeGen/PowerPC/aix-xcoff-symbol-rename.ll

3

Thanks for pointing it out. Indeed I missed handling TOC entry renaming in this patch.

[jasonliu]

Change encoding mechanism for symbol renaming.

[jasonliu]

llvm/lib/MC/MCContext.cpp

313

Thanks for the clarification. Changed the renaming encoding using the idea in our discussion.

[DiggerLin]

LGTM ,but it need other person to approve it before landing.

llvm/test/CodeGen/PowerPC/aix-xcoff-symbol-rename.ll

162

minor: I do not think we need the line .

[jasonliu]

llvm/test/CodeGen/PowerPC/aix-xcoff-symbol-rename.ll

162

I would prefer to keep that line to show the whole picture of a common symbol.

[hubert.reinterpretcast]

llvm/include/llvm/MC/MCStreamer.h

580

I would suggest not to capitalize "Internal" if there is no clear special definition of that word that this is referencing.

Suggestion:
The name used internally in the assembly for references to the symbol.

581

s/at end/at the end/;

[hubert.reinterpretcast]

llvm/lib/MC/MCAsmInfoXCOFF.cpp

49

Please call isAlnum.

llvm/lib/MC/MCAsmStreamer.cpp

803

See other comment about missing space before left parenthesis.

848

To escape double quote (") characters, the character should be doubled. Unlike with names that start with digits, Clang does manage to handle quotes in names.

863

Minor nit: The space is missing before the first opening parenthesis.

865

We're performing the same cast/type check multiple times here...

Suggestion:

MCSymbolXCOFF *XSym = dyn_cast<MCSymbolXCOFF>(Symbol);
if (XSym && XSym->hasRename()) {

llvm/lib/MC/MCContext.cpp

317

Don't try to access the first character without locally ensuring that the string is non-empty. For example, ICC produces an "internal error" (https://godbolt.org/z/zLiJqb). It seems Clang avoids generating such by diagnosing empty string literals used as __asm__ names.

321

Replace the comma at the end of the line with a semicolon.

llvm/lib/MC/MCStreamer.cpp

1076

s/emitXCOFFRenameDirecitve/emitXCOFFRenameDirective/;

llvm/lib/MC/MCSymbolXCOFF.cpp

22

s/representatation/representation/;

37

s/representatation/representation/;

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

123 ↗

(On Diff #274163)

if (MCSymbolXCOFF *XSym = dyn_cast<MCSymbolXCOFF>(S)) {

llvm/test/CodeGen/PowerPC/aix-xcoff-symbol-rename.ll

2

s/symbol contains/symbols containing/;
s/invalid character/invalid characters/;

3

s/XCOFF platform/an XCOFF platform/;

4

s/32 bit/32-bit/;
s/64 bit/64-bit/;

5

s/test/tests/;
s/64 bit/64-bit/;
s/is/are/;

[jasonliu]

Address comments.

[jasonliu]

llvm/lib/MC/MCContext.cpp

317

Thanks for the example and also trying it out with Clang.

[hubert.reinterpretcast]

LGTM with minor nit; thanks.

llvm/lib/MC/MCAsmStreamer.cpp

851

Add "a" before "double quote".
s/chacacter/character/;

llvm/include/llvm/MC/MCContext.h

namespace llvm {
   class MCSectionELF;
   class MCSectionMachO;
   class MCSectionWasm;
   class MCSectionXCOFF;
   class MCStreamer;
   class MCSymbol;
   class MCSymbolELF;
   class MCSymbolWasm;
+  class MCSymbolXCOFF;
   class SMLoc;
   class SourceMgr;
 
   /// Context object for machine code objects.  This class owns all of the
   /// sections that it creates.
   ///
   class MCContext {
   public:
private:
     /// non-section symbol (there can be at most one of those, plus an unlimited
     /// number of section symbols with the same name).
     StringMap<bool, BumpPtrAllocator &> UsedNames;
 
     /// Keeps track of labels that are used in inline assembly.
     SymbolTable InlineAsmUsedLabelNames;
 
     /// The next ID to dole out to an unnamed assembler temporary symbol with
-    /// a given prefix.
+    /// a given prefix or an XCOFF symbol containing invalid character(s).
     StringMap<unsigned> NextID;
 
     /// Instances of directional local labels.
     DenseMap<unsigned, MCLabel *> Instances;
     /// NextInstance() creates the next instance of the directional local label
     /// for the LocalLabelVal and adds it to the map if needed.
     unsigned NextInstance(unsigned LocalLabelVal);
     /// GetInstance() gets the current instance of the directional local label
private:
 
     MCSectionELF *createELFSectionImpl(StringRef Section, unsigned Type,
                                        unsigned Flags, SectionKind K,
                                        unsigned EntrySize,
                                        const MCSymbolELF *Group,
                                        unsigned UniqueID,
                                        const MCSymbolELF *LinkedToSym);
 
+    MCSymbolXCOFF *createXCOFFSymbolImpl(const StringMapEntry<bool> *Name,
+                                         bool IsTemporary);
+
     /// Map of currently defined macros.
     StringMap<MCAsmMacro> MacroMap;
 
     struct ELFEntrySizeKey {
       std::string SectionName;
       unsigned Flags;
       unsigned EntrySize;
 

llvm/include/llvm/MC/MCSectionXCOFF.h

 //    implemented yet.
 class MCSectionXCOFF final : public MCSection {
   friend class MCContext;
 
   XCOFF::StorageMappingClass MappingClass;
   XCOFF::SymbolType Type;
   XCOFF::StorageClass StorageClass;
   MCSymbolXCOFF *const QualName;
+  StringRef SymbolTableName;
   static constexpr unsigned DefaultAlignVal = 4;
 
   MCSectionXCOFF(StringRef Name, XCOFF::StorageMappingClass SMC,
                  XCOFF::SymbolType ST, XCOFF::StorageClass SC, SectionKind K,
-                 MCSymbolXCOFF *QualName, MCSymbol *Begin)
+                 MCSymbolXCOFF *QualName, MCSymbol *Begin,
+                 StringRef SymbolTableName)
       : MCSection(SV_XCOFF, Name, K, Begin), MappingClass(SMC), Type(ST),
-        StorageClass(SC), QualName(QualName) {
+        StorageClass(SC), QualName(QualName), SymbolTableName(SymbolTableName) {
     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->setStorageClass(SC);
     QualName->setRepresentedCsect(this);
     // A csect is 4 byte aligned by default, except for undefined symbol csects.
     if (Type != XCOFF::XTY_ER)
       setAlignment(Align(DefaultAlignVal));
public:
   XCOFF::SymbolType getCSectType() const { return Type; }
   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; }
 };
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/MC/MCStreamer.h

public:
   ///
   /// \param Symbol - The symbol to emit.
   /// \param Linkage - The linkage of the symbol to emit.
   /// \param Visibility - The visibility of the symbol to emit or MCSA_Invalid
   /// if the symbol does not have an explicit visibility.
   virtual void emitXCOFFSymbolLinkageWithVisibility(MCSymbol *Symbol,
                                                     MCSymbolAttr Linkage,
                                                     MCSymbolAttr Visibility);
+  /// Emit a XCOFF .rename directive which creates a synonym for an illegal or
+  /// undesirable name.
+  ///
+  /// \param Name - The Internal reference to the symbol.
+  /// \param Rename - The value to which the Name parameter is changed at end of
+  /// assembly.
+  virtual void emitXCOFFRenameDirective(const MCSymbol *Name, StringRef Rename);
+
   /// Emit an ELF .size directive.
   ///
   /// This corresponds to an assembler statement such as:
   ///  .size symbol, expression
   virtual void emitELFSize(MCSymbol *Symbol, const MCExpr *Value);
 
   /// Emit an ELF .symver directive.
   ///

llvm/include/llvm/MC/MCSymbolXCOFF.h

 
 class MCSymbolXCOFF : public MCSymbol {
 public:
   MCSymbolXCOFF(const StringMapEntry<bool> *Name, bool isTemporary)
       : MCSymbol(SymbolKindXCOFF, Name, isTemporary) {}
 
   static bool classof(const MCSymbol *S) { return S->isXCOFF(); }
 
+  static StringRef getUnqualifiedName(StringRef Name) {
+    if (Name.back() == ']') {
+      StringRef Lhs, Rhs;
+      std::tie(Lhs, Rhs) = Name.rsplit('[');
+      assert(!Rhs.empty() && "Invalid SMC format in XCOFF symbol.");
+      return Lhs;
+    }
+    return Name;
+  }
+
   void setStorageClass(XCOFF::StorageClass SC) {
     assert((!StorageClass.hasValue() || StorageClass.getValue() == SC) &&
            "Redefining StorageClass of XCOFF MCSymbol.");
     StorageClass = SC;
   };
 
   XCOFF::StorageClass getStorageClass() const {
     assert(StorageClass.hasValue() &&
            "StorageClass not set on XCOFF MCSymbol.");
     return StorageClass.getValue();
   }
 
-  StringRef getUnqualifiedName() const {
-    const StringRef name = getName();
-    if (name.back() == ']') {
-      StringRef lhs, rhs;
-      std::tie(lhs, rhs) = name.rsplit('[');
-      assert(!rhs.empty() && "Invalid SMC format in XCOFF symbol.");
-      return lhs;
-    }
-    return name;
-  }
+  StringRef getUnqualifiedName() const { return getUnqualifiedName(getName()); }
 
   bool hasRepresentedCsectSet() const { return RepresentedCsect != nullptr; }
 
   MCSectionXCOFF *getRepresentedCsect() const;
 
   void setRepresentedCsect(MCSectionXCOFF *C);
 
   void setVisibilityType(XCOFF::VisibilityType SVT) { VisibilityType = SVT; };
 
   XCOFF::VisibilityType getVisibilityType() const { return VisibilityType; }
 
+  bool hasRename() const { return !SymbolTableName.empty(); }
+
+  void setSymbolTableName(StringRef STN) { SymbolTableName = STN; }
+
+  StringRef getSymbolTableName() const {
+    if (hasRename())
+      return SymbolTableName;
+    return getUnqualifiedName();
+  }
+
 private:
   Optional<XCOFF::StorageClass> StorageClass;
   MCSectionXCOFF *RepresentedCsect = nullptr;
   XCOFF::VisibilityType VisibilityType = XCOFF::SYM_V_UNSPECIFIED;
+  StringRef SymbolTableName;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSYMBOLXCOFF_H

llvm/include/llvm/MC/MCXCOFFStreamer.h

void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
                     SMLoc Loc = SMLoc()) override;
   void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
   void emitXCOFFLocalCommonSymbol(MCSymbol *LabelSym, uint64_t Size,
                                   MCSymbol *CsectSym,
                                   unsigned ByteAlign) override;
   void emitXCOFFSymbolLinkageWithVisibility(MCSymbol *Symbol,
                                             MCSymbolAttr Linkage,
                                             MCSymbolAttr Visibility) override;
+  void emitXCOFFRenameDirective(const MCSymbol *Name,
+                                StringRef Rename) override {
+    report_fatal_error("emitXCOFFRenameDirective is not implemented yet on "
+                       "object generation path");
+  }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCXCOFFSTREAMER_H

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

void AsmPrinter::emitFunctionHeader() {
 
   // Print the 'header' of function.
   MF->setSection(getObjFileLowering().SectionForGlobal(&F, TM));
   OutStreamer->SwitchSection(MF->getSection());
 
   if (!MAI->hasVisibilityOnlyWithLinkage())
     emitVisibility(CurrentFnSym, F.getVisibility());
 
-  if (MAI->needsFunctionDescriptors() &&
-      F.getLinkage() != GlobalValue::InternalLinkage)
+  if (MAI->needsFunctionDescriptors())
     emitLinkage(&F, CurrentFnDescSym);
 
   emitLinkage(&F, CurrentFnSym);
   if (MAI->hasFunctionAlignment())
     emitAlignment(MF->getAlignment(), &F);
 
   if (MAI->hasDotTypeDotSizeDirective())
     OutStreamer->emitSymbolAttribute(CurrentFnSym, MCSA_ELF_TypeFunction);

llvm/lib/MC/MCAsmInfoXCOFF.cpp

 }
 
 bool MCAsmInfoXCOFF::isAcceptableChar(char C) const {
   // QualName is allowed for a MCSymbolXCOFF, and
   // QualName contains '[' and ']'.
   if (C == '[' || C == ']')
     return true;
 
-  return MCAsmInfo::isAcceptableChar(C);
+  // For AIX assembler, symbols may consist of numeric digits,
+  // underscores, periods, uppercase or lowercase letters, or
+  // any combination of these.
+  return (C >= 'a' && C <= 'z') || (C >= 'A' && C <= 'Z') ||
+         (C >= '0' && C <= '9') || C == '_' || C == '.';
 }

llvm/lib/MC/MCAsmStreamer.cpp

 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCRegister.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSymbolXCOFF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TargetRegistry.h"
 #include <cctype>
public:
   void EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) override;
   void EmitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset) override;
   void emitXCOFFLocalCommonSymbol(MCSymbol *LabelSym, uint64_t Size,
                                   MCSymbol *CsectSym,
                                   unsigned ByteAlign) override;
   void emitXCOFFSymbolLinkageWithVisibility(MCSymbol *Symbol,
                                             MCSymbolAttr Linakge,
                                             MCSymbolAttr Visibility) override;
+  void emitXCOFFRenameDirective(const MCSymbol *Name,
+                                StringRef Rename) override;
 
   void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override;
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
 
   /// Emit a local common (.lcomm) symbol.
   ///
   /// @param Symbol - The common symbol to emit.
void MCAsmStreamer::emitXCOFFLocalCommonSymbol(MCSymbol *LabelSym,
   CsectSym->print(OS, MAI);
   OS << ',' << Log2_32(ByteAlignment);
 
   EmitEOL();
 }
 
 void MCAsmStreamer::emitXCOFFSymbolLinkageWithVisibility(
     MCSymbol *Symbol, MCSymbolAttr Linkage, MCSymbolAttr Visibility) {
+  // Print symbol's rename(original name contains invalid character(s)) if there
+  // is one.
+  if (cast<MCSymbolXCOFF>(Symbol)->hasRename())
+    emitXCOFFRenameDirective(Symbol,
+                             cast<MCSymbolXCOFF>(Symbol)->getSymbolTableName());
 
   switch (Linkage) {
   case MCSA_Global:
     OS << MAI->getGlobalDirective();
     break;
   case MCSA_Weak:
     OS << MAI->getWeakDirective();
     break;
   case MCSA_Extern:
     OS << "\t.extern\t";
     break;
+  case MCSA_LGlobal:
+    OS << "\t.lglobl\t";
+    break;
   default:
     report_fatal_error("unhandled linkage type");
   }
 
   Symbol->print(OS, MAI);
 
   switch (Visibility) {
   case MCSA_Invalid:
     // Nothing to do.
     break;
   case MCSA_Hidden:
     OS << ",hidden";
     break;
   case MCSA_Protected:
     OS << ",protected";
     break;
   default:
     report_fatal_error("unexpected value for Visibility type");
   }
   EmitEOL();
 }
 
+void MCAsmStreamer::emitXCOFFRenameDirective(const MCSymbol *Name,
+                                             StringRef Rename) {
+  OS << "\t.rename\t";
+  Name->print(OS, MAI);
+  OS << ',' << '"' << Rename << '"';
+  EmitEOL();
+}
+
 void MCAsmStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
   assert(MAI->hasDotTypeDotSizeDirective());
   OS << "\t.size\t";
   Symbol->print(OS, MAI);
   OS << ", ";
   Value->print(OS, MAI);
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                      unsigned ByteAlignment) {
+  // Print symbol's rename(original name contains invalid character(s)) if there
+  // is one.
+  if (Symbol->isXCOFF() && cast<MCSymbolXCOFF>(Symbol)->hasRename())
+    emitXCOFFRenameDirective(Symbol,
+                             cast<MCSymbolXCOFF>(Symbol)->getSymbolTableName());
+
   OS << "\t.comm\t";
   Symbol->print(OS, MAI);
   OS << ',' << Size;
 
   if (ByteAlignment != 0) {
     if (MAI->getCOMMDirectiveAlignmentIsInBytes())
       OS << ',' << ByteAlignment;
     else

llvm/lib/MC/MCContext.cpp

case MCObjectFileInfo::IsCOFF:
       return new (Name, *this) MCSymbolCOFF(Name, IsTemporary);
     case MCObjectFileInfo::IsELF:
       return new (Name, *this) MCSymbolELF(Name, IsTemporary);
     case MCObjectFileInfo::IsMachO:
       return new (Name, *this) MCSymbolMachO(Name, IsTemporary);
     case MCObjectFileInfo::IsWasm:
       return new (Name, *this) MCSymbolWasm(Name, IsTemporary);
     case MCObjectFileInfo::IsXCOFF:
-      return new (Name, *this) MCSymbolXCOFF(Name, IsTemporary);
+      return createXCOFFSymbolImpl(Name, IsTemporary);
     }
   }
   return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name,
                                     IsTemporary);
 }
 
 MCSymbol *MCContext::createSymbol(StringRef Name, bool AlwaysAddSuffix,
                                   bool CanBeUnnamed) {
void MCContext::setSymbolValue(MCStreamer &Streamer,
   auto Symbol = getOrCreateSymbol(Sym);
   Streamer.emitAssignment(Symbol, MCConstantExpr::create(Val, *this));
 }
 
 void MCContext::registerInlineAsmLabel(MCSymbol *Sym) {
   InlineAsmUsedLabelNames[Sym->getName()] = Sym;
 }
 
+MCSymbolXCOFF *
+MCContext::createXCOFFSymbolImpl(const StringMapEntry<bool> *Name,
+                                 bool IsTemporary) {
+  if (!Name)
+    return new (nullptr, *this) MCSymbolXCOFF(nullptr, IsTemporary);
+
+  StringRef OriginalName = Name->first();
+  if (OriginalName.startswith("._Renamed..") ||
+      OriginalName.startswith("_Renamed.."))
+    reportError(SMLoc(), "invalid symbol name from source");
+
+  if (MAI->isValidUnquotedName(OriginalName))
+    return new (Name, *this) MCSymbolXCOFF(Name, IsTemporary);
+
+  // We have a name that contains invalid character(s) for XCOFF symbol.
+  // Let's replace with something valid, but save the original name so that
+  // we could still have use the original name in the symbol table.
+  SmallString<128> InvalidName(OriginalName);
+  // Replace the invalid character with '_'.
+  for (size_t I = 0; I < InvalidName.size(); ++I) {
+    if (!MAI->isAcceptableChar(InvalidName[I]))
+      InvalidName[I] = '_';
+  }
+
+  SmallString<128> ValidName;
+  // If it's an entry point symbol, we will keep the '.'
+  // in front for the convention purpose. Otherwise, add "_Renamed.."
+  // as prefix to signal this is an renamed symbol.
+  ((InvalidName[0] == '.' ? "._Renamed." : "_Renamed..") + InvalidName)
+      .toStringRef(ValidName);
+
+  unsigned &NextUniqueID = NextID[ValidName];
+  if (NextUniqueID) {
+    if (ValidName.back() == ']') {
+      StringRef Lhs, Rhs;
+      std::tie(Lhs, Rhs) = ValidName.str().rsplit('[');
+      SmallString<128> LhsTemp(Lhs);
+      raw_svector_ostream(LhsTemp) << NextUniqueID << '[' << Rhs;
+      ValidName = LhsTemp;
+    } else {
+      raw_svector_ostream(ValidName) << NextUniqueID;
+    }
+  }
+  ++NextUniqueID;
+
+  auto NameEntry = UsedNames.insert(std::make_pair(ValidName, true));
+  assert((NameEntry.second || !NameEntry.first->second) &&
+         "This name is used somewhere else.");
+  // Mark the name as used for a non-section symbol.
+  NameEntry.first->second = true;
+  // Have the MCSymbol object itself refer to the copy of the string
+  // that is embedded in the UsedNames entry.
+  MCSymbolXCOFF *XSym = new (&*NameEntry.first, *this)
+      MCSymbolXCOFF(&*NameEntry.first, IsTemporary);
+  XSym->setSymbolTableName(MCSymbolXCOFF::getUnqualifiedName(OriginalName));
+  return XSym;
+}
+
 //===----------------------------------------------------------------------===//
 // Section Management
 //===----------------------------------------------------------------------===//
 
 MCSectionMachO *MCContext::getMachOSection(StringRef Segment, StringRef Section,
                                            unsigned TypeAndAttributes,
                                            unsigned Reserved2, SectionKind Kind,
                                            const char *BeginSymName) {
MCSectionXCOFF *MCContext::getXCOFFSection(StringRef Section,
   auto IterBool = XCOFFUniquingMap.insert(
       std::make_pair(XCOFFSectionKey{Section.str(), SMC}, nullptr));
   auto &Entry = *IterBool.first;
   if (!IterBool.second)
     return Entry.second;
 
   // Otherwise, return a new section.
   StringRef CachedName = Entry.first.SectionName;
-  MCSymbol *QualName = getOrCreateSymbol(
-      CachedName + "[" + XCOFF::getMappingClassString(SMC) + "]");
+  MCSymbolXCOFF *QualName = cast<MCSymbolXCOFF>(getOrCreateSymbol(
+      CachedName + "[" + XCOFF::getMappingClassString(SMC) + "]"));
 
   MCSymbol *Begin = nullptr;
   if (BeginSymName)
     Begin = createTempSymbol(BeginSymName, false);
 
-  MCSectionXCOFF *Result = new (XCOFFAllocator.Allocate()) MCSectionXCOFF(
-      CachedName, SMC, Type, SC, Kind, cast<MCSymbolXCOFF>(QualName), Begin);
+  // 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, SC, Kind,
+                     QualName, Begin, CachedName);
   Entry.second = Result;
 
   auto *F = new MCDataFragment();
   Result->getFragmentList().insert(Result->begin(), F);
   F->setParent(Result);
 
   if (Begin)
     Begin->setFragment(F);

llvm/lib/MC/MCStreamer.cpp

 
 void MCStreamer::emitXCOFFSymbolLinkageWithVisibility(MCSymbol *Symbol,
                                                       MCSymbolAttr Linkage,
                                                       MCSymbolAttr Visibility) {
   llvm_unreachable("emitXCOFFSymbolLinkageWithVisibility is only supported on "
                    "XCOFF targets");
 }
 
+void MCStreamer::emitXCOFFRenameDirective(const MCSymbol *Name,
+                                          StringRef Rename) {
+  llvm_unreachable("emitXCOFFRenameDirecitve is only supported on "
+                   "XCOFF targets");
+}
+
 void MCStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {}
 void MCStreamer::emitELFSymverDirective(StringRef AliasName,
                                         const MCSymbol *Aliasee) {}
 void MCStreamer::emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                        unsigned ByteAlignment) {}
 void MCStreamer::emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
                                 uint64_t Size, unsigned ByteAlignment) {}
 void MCStreamer::changeSection(MCSection *, const MCExpr *) {}

llvm/lib/MC/MCSymbolXCOFF.cpp

 
 MCSectionXCOFF *MCSymbolXCOFF::getRepresentedCsect() const {
   assert(RepresentedCsect &&
          "Trying to get csect representation of this symbol but none was set.");
   assert((!getName().equals(getUnqualifiedName()) ||
           RepresentedCsect->getCSectType() == XCOFF::XTY_ER) &&
          "Symbol does not represent a csect; MCSectionXCOFF that represents "
          "the symbol should not be (but is) set.");
+  assert(getSymbolTableName().equals(RepresentedCsect->getSymbolTableName()) &&
+         "SymbolTableNames need to be the same for this symbol and its csect "
+         "representatation.");
   return RepresentedCsect;
 }
 
 void MCSymbolXCOFF::setRepresentedCsect(MCSectionXCOFF *C) {
   assert(C && "Assigned csect should not be null.");
   assert((!RepresentedCsect || RepresentedCsect == C) &&
          "Trying to set a csect that doesn't match the one that"
          "this symbol is already mapped to.");
   assert((!getName().equals(getUnqualifiedName()) ||
           C->getCSectType() == XCOFF::XTY_ER) &&
          "Symbol does not represent a csect; can only set a MCSectionXCOFF "
          "representation for a csect.");
+  assert(getSymbolTableName().equals(C->getSymbolTableName()) &&
+         "SymbolTableNames need to be the same for this symbol and its csect "
+         "representatation.");
   RepresentedCsect = C;
 }

llvm/lib/MC/XCOFFObjectWriter.cpp

 // Wrapper around an MCSymbolXCOFF.
 struct Symbol {
   const MCSymbolXCOFF *const MCSym;
   uint32_t SymbolTableIndex;
 
   XCOFF::StorageClass getStorageClass() const {
     return MCSym->getStorageClass();
   }
-  StringRef getName() const { return MCSym->getName(); }
+  StringRef getSymbolTableName() const { return MCSym->getSymbolTableName(); }
   Symbol(const MCSymbolXCOFF *MCSym) : MCSym(MCSym), SymbolTableIndex(-1) {}
 };
 
 // Wrapper for an MCSectionXCOFF.
 struct ControlSection {
   const MCSectionXCOFF *const MCCsect;
   uint32_t SymbolTableIndex;
   uint32_t Address;
   uint32_t Size;
 
   SmallVector<Symbol, 1> Syms;
   SmallVector<XCOFFRelocation, 1> Relocations;
-  StringRef getName() const { return MCCsect->getName(); }
+  StringRef getSymbolTableName() const { return MCCsect->getSymbolTableName(); }
   ControlSection(const MCSectionXCOFF *MCSec)
       : MCCsect(MCSec), SymbolTableIndex(-1), Address(-1), Size(0) {}
 };
 
 // Type to be used for a container representing a set of csects with
 // (approximately) the same storage mapping class. For example all the csects
 // with a storage mapping class of `xmc_pr` will get placed into the same
 // container.
for (const auto &S : Asm) {
     const auto *MCSec = cast<const MCSectionXCOFF>(&S);
     assert(SectionMap.find(MCSec) == SectionMap.end() &&
            "Cannot add a csect twice.");
     assert(XCOFF::XTY_ER != MCSec->getCSectType() &&
            "An undefined csect should not get registered.");
 
     // If the name does not fit in the storage provided in the symbol table
     // entry, add it to the string table.
-    if (nameShouldBeInStringTable(MCSec->getName()))
-      Strings.add(MCSec->getName());
+    if (nameShouldBeInStringTable(MCSec->getSymbolTableName()))
+      Strings.add(MCSec->getSymbolTableName());
 
     CsectGroup &Group = getCsectGroup(MCSec);
     Group.emplace_back(MCSec);
     SectionMap[MCSec] = &Group.back();
   }
 
   for (const MCSymbol &S : Asm.symbols()) {
     // Nothing to do for temporary symbols.
     if (S.isTemporary())
       continue;
 
     const MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(&S);
     const MCSectionXCOFF *ContainingCsect = getContainingCsect(XSym);
 
     if (ContainingCsect->getCSectType() == XCOFF::XTY_ER) {
       // Handle undefined symbol.
       UndefinedCsects.emplace_back(ContainingCsect);
       SectionMap[ContainingCsect] = &UndefinedCsects.back();
-      if (nameShouldBeInStringTable(ContainingCsect->getName()))
-        Strings.add(ContainingCsect->getName());
+      if (nameShouldBeInStringTable(ContainingCsect->getSymbolTableName()))
+        Strings.add(ContainingCsect->getSymbolTableName());
       continue;
     }
 
     // If the symbol is the csect itself, we don't need to put the symbol
     // into csect's Syms.
     if (XSym == ContainingCsect->getQualNameSymbol())
       continue;
 
     // Only put a label into the symbol table when it is an external label.
     if (!XSym->isExternal())
       continue;
 
     assert(SectionMap.find(ContainingCsect) != SectionMap.end() &&
            "Expected containing csect to exist in map");
     // Lookup the containing csect and add the symbol to it.
     SectionMap[ContainingCsect]->Syms.emplace_back(XSym);
 
     // If the name does not fit in the storage provided in the symbol table
     // entry, add it to the string table.
-    if (nameShouldBeInStringTable(XSym->getName()))
-      Strings.add(XSym->getName());
+    if (nameShouldBeInStringTable(XSym->getSymbolTableName()))
+      Strings.add(XSym->getSymbolTableName());
   }
 
   Strings.finalize();
   assignAddressesAndIndices(Layout);
 }
 
 void XCOFFObjectWriter::recordRelocation(MCAssembler &Asm,
                                          const MCAsmLayout &Layout,
if (nameShouldBeInStringTable(SymbolName)) {
     W.write(NameRef);
   }
 }
 
 void XCOFFObjectWriter::writeSymbolTableEntryForCsectMemberLabel(
     const Symbol &SymbolRef, const ControlSection &CSectionRef,
     int16_t SectionIndex, uint64_t SymbolOffset) {
   // Name or Zeros and string table offset
-  writeSymbolName(SymbolRef.getName());
+  writeSymbolName(SymbolRef.getSymbolTableName());
   assert(SymbolOffset <= UINT32_MAX - CSectionRef.Address &&
          "Symbol address overflows.");
   W.write<uint32_t>(CSectionRef.Address + SymbolOffset);
   W.write<int16_t>(SectionIndex);
   // Basic/Derived type. See the description of the n_type field for symbol
   // table entries for a detailed description. Since we don't yet support
   // visibility, and all other bits are either optionally set or reserved, this
   // is always zero.
void XCOFFObjectWriter::writeSymbolTableEntryForCsectMemberLabel(
   // Reserved (x_snstab).
   W.write<uint16_t>(0);
 }
 
 void XCOFFObjectWriter::writeSymbolTableEntryForControlSection(
     const ControlSection &CSectionRef, int16_t SectionIndex,
     XCOFF::StorageClass StorageClass) {
   // n_name, n_zeros, n_offset
-  writeSymbolName(CSectionRef.getName());
+  writeSymbolName(CSectionRef.getSymbolTableName());
   // n_value
   W.write<uint32_t>(CSectionRef.Address);
   // n_scnum
   W.write<int16_t>(SectionIndex);
   // Basic/Derived type. See the description of the n_type field for symbol
   // table entries for a detailed description. Since we don't yet support
   // visibility, and all other bits are either optionally set or reserved, this
   // is always zero.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

case GlobalValue::ExternalWeakLinkage:
     LinkageAttr = MCSA_Weak;
     break;
   case GlobalValue::AvailableExternallyLinkage:
     LinkageAttr = MCSA_Extern;
     break;
   case GlobalValue::PrivateLinkage:
     return;
   case GlobalValue::InternalLinkage:
-    OutStreamer->emitSymbolAttribute(GVSym, MCSA_LGlobal);
-    return;
+    assert(GV->getVisibility() == GlobalValue::DefaultVisibility &&
+           "InternalLinkage should not have other visibility setting.");
+    LinkageAttr = MCSA_LGlobal;
+    break;
   case GlobalValue::AppendingLinkage:
     llvm_unreachable("Should never emit this");
   case GlobalValue::CommonLinkage:
     llvm_unreachable("CommonLinkage of XCOFF should not come to this path");
   }
 
   assert(LinkageAttr != MCSA_Invalid && "LinkageAttr should not MCSA_Invalid.");
 
   MCSymbolAttr VisibilityAttr = MCSA_Invalid;
   switch (GV->getVisibility()) {
 
-    // TODO: "exported" and "internal" Visibility needs to go here.
-
   case GlobalValue::DefaultVisibility:
     break;
   case GlobalValue::HiddenVisibility:
     VisibilityAttr = MAI->getHiddenVisibilityAttr();
     break;
   case GlobalValue::ProtectedVisibility:
     VisibilityAttr = MAI->getProtectedVisibilityAttr();
     break;

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

const auto getAIXFuncEntryPointSymbolSDNode =
         MCSymbolXCOFF *S = cast<MCSymbolXCOFF>(
             Context.getOrCreateSymbol(Twine(".") + Twine(FuncName)));
 
         if (IsDeclaration && !S->hasRepresentedCsectSet()) {
           // On AIX, an undefined symbol needs to be associated with a
           // MCSectionXCOFF to get the correct storage mapping class.
           // In this case, XCOFF::XMC_PR.
           MCSectionXCOFF *Sec = Context.getXCOFFSection(
-              S->getName(), XCOFF::XMC_PR, XCOFF::XTY_ER, SC,
+              S->getSymbolTableName(), XCOFF::XMC_PR, XCOFF::XTY_ER, SC,
               SectionKind::getMetadata());
           S->setRepresentedCsect(Sec);
         }
 
         MVT PtrVT =
             DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout());
         return DAG.getMCSymbol(S, PtrVT);
       };

llvm/test/CodeGen/PowerPC/aix-xcoff-symbol-rename.ll

+;; This file tests how llc handles symbol contains invalid character on XCOFF
+;; platform.
+;; Since symbol name resolution is the same between 32 bit and 64 bit,
+;; test for 64 bit mode is omitted.
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec < %s | \
+; RUN:   FileCheck --check-prefix=ASM %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec -filetype=obj -o %t.o < %s
+; RUN: llvm-objdump -D -r --symbol-description %t.o | \
+; RUN:   FileCheck --check-prefix=OBJ %s
+
+; This is f`o
+@"f\60o" = global i32 10, align 4
+
+; This is f!o
+@"f\21o" = common global i32 0, align 4
+
+define internal i32 @f$o() {
+entry:
+  %call = call i32 bitcast (i32 (...)* @"f\40o" to i32 ()*)()
+  ret i32 %call
+}
+
+; This is f&o
+define i32 @"f\26o"() {
+entry:
+  %call = call i32 @f$o()
+  ret i32 %call
+}
+
+; This is f@o
+declare i32 @"f\40o"(...)
+
+; ASM:               .rename _Renamed..f_o[DS],"f$o" # -- Begin function f$o
+; ASM-NEXT:          .lglobl _Renamed..f_o[DS]
+; ASM-NEXT:          .rename ._Renamed..f_o1,".f$o"
+; ASM-NEXT:          .lglobl ._Renamed..f_o1
+; ASM-NEXT:          .align  4
+; ASM-NEXT:          .csect _Renamed..f_o[DS],2
+; ASM-NEXT:          .vbyte  4, ._Renamed..f_o1      # @"f$o"
+; ASM-NEXT:          .vbyte  4, TOC[TC0]
+; ASM-NEXT:          .vbyte  4, 0
+; ASM-NEXT:          .csect .text[PR],2
+; ASM-NEXT:  ._Renamed..f_o1:
+; ASM:               bl ._Renamed..f_o
+; ASM-NEXT:          nop
+; ASM:                                                # -- End function
+; ASM-NEXT:          .rename _Renamed..f_o1[DS],"f&o" # -- Begin function f&o
+; ASM-NEXT:          .globl  _Renamed..f_o1[DS]
+; ASM-NEXT:          .rename ._Renamed..f_o2,".f&o"
+; ASM-NEXT:          .globl  ._Renamed..f_o2
+; ASM-NEXT:          .align  4
+; ASM-NEXT:          .csect _Renamed..f_o1[DS],2
+; ASM-NEXT:          .vbyte  4, ._Renamed..f_o2      # @"f&o"
+; ASM-NEXT:          .vbyte  4, TOC[TC0]
+; ASM-NEXT:          .vbyte  4, 0
+; ASM-NEXT:          .csect .text[PR],2
+; ASM-NEXT:  ._Renamed..f_o2:
+; ASM:               bl ._Renamed..f_o1
+; ASM:                                               # -- End function
+; ASM-NEXT:          .csect .data[RW],2
+; ASM-NEXT:          .rename _Renamed..f_o,"f`o"
+; ASM-NEXT:          .globl  _Renamed..f_o
+; ASM-NEXT:          .align  2
+; ASM-NEXT:  _Renamed..f_o:
+; ASM-NEXT:          .vbyte  4, 10                   # 0xa
+; ASM-NEXT:          .rename _Renamed..f_o[RW],"f!o"
+; ASM-NEXT:          .comm   _Renamed..f_o[RW],4,2
+; ASM-NEXT:          .rename ._Renamed..f_o,".f@o"
+; ASM-NEXT:          .extern ._Renamed..f_o
+; ASM-NEXT:          .rename _Renamed..f_o2[DS],"f@o"
+; ASM-NEXT:          .extern _Renamed..f_o2[DS]
+
+; OBJ:       Disassembly of section .text:
+; OBJ-EMPTY:
+; OBJ-NEXT:  00000000 (idx: 6) .f$o:
+; OBJ-NEXT:         0: 7c 08 02 a6   mflr 0
+; OBJ-NEXT:         4: 90 01 00 08   stw 0, 8(1)
+; OBJ-NEXT:         8: 94 21 ff c0   stwu 1, -64(1)
+; OBJ-NEXT:         c: 4b ff ff f5   bl 0x0
+; OBJ-NEXT:                          0000000c:  R_RBR        (idx: 0) .f@o[PR]
+; OBJ-NEXT:        10: 60 00 00 00   nop
+; OBJ-NEXT:        14: 38 21 00 40   addi 1, 1, 64
+; OBJ-NEXT:        18: 80 01 00 08   lwz 0, 8(1)
+; OBJ-NEXT:        1c: 7c 08 03 a6   mtlr 0
+; OBJ-NEXT:        20: 4e 80 00 20   blr
+; OBJ-NEXT:        24: 60 00 00 00   nop
+; OBJ-NEXT:        28: 60 00 00 00   nop
+; OBJ-NEXT:        2c: 60 00 00 00   nop
+; OBJ-EMPTY:
+; OBJ-NEXT:  00000030 (idx: 8) .f&o:
+; OBJ-NEXT:        30: 7c 08 02 a6   mflr 0
+; OBJ-NEXT:        34: 90 01 00 08   stw 0, 8(1)
+; OBJ-NEXT:        38: 94 21 ff c0   stwu 1, -64(1)
+; OBJ-NEXT:        3c: 4b ff ff c5   bl 0x0
+; OBJ-NEXT:        40: 38 21 00 40   addi 1, 1, 64
+; OBJ-NEXT:        44: 80 01 00 08   lwz 0, 8(1)
+; OBJ-NEXT:        48: 7c 08 03 a6   mtlr 0
+; OBJ-NEXT:        4c: 4e 80 00 20   blr
+; OBJ-EMPTY:
+; OBJ-NEXT:  Disassembly of section .data:
+; OBJ-EMPTY:  
+; OBJ-NEXT:  00000050 (idx: 12) f`o:
+; OBJ-NEXT:        50: 00 00 00 0a   <unknown>
+; OBJ-EMPTY:
+; OBJ-NEXT:  00000054 (idx: 14) f$o[DS]:
+; OBJ-NEXT:        54: 00 00 00 00   <unknown>
+; OBJ-NEXT:                          00000054:  R_POS        (idx: 6) .f$o
+; OBJ-NEXT:        58: 00 00 00 6c   <unknown>
+; OBJ-NEXT:                          00000058:  R_POS        (idx: 18) TOC[TC0]
+; OBJ-NEXT:        5c: 00 00 00 00   <unknown>
+; OBJ-EMPTY:
+; OBJ-NEXT:  00000060 (idx: 16) f&o[DS]:
+; OBJ-NEXT:        60: 00 00 00 30   <unknown>
+; OBJ-NEXT:                          00000060:  R_POS        (idx: 8) .f&o
+; OBJ-NEXT:        64: 00 00 00 6c   <unknown>
+; OBJ-NEXT:                          00000064:  R_POS        (idx: 18) TOC[TC0]
+; OBJ-NEXT:        68: 00 00 00 00   <unknown>
+; OBJ-EMPTY:
+; OBJ-NEXT:  Disassembly of section .bss:
+; OBJ-EMPTY:
+; OBJ-NEXT:  0000006c (idx: 20) f!o[RW]:
+; OBJ-NEXT:  ...

llvm/test/CodeGen/PowerPC/test_func_desc.ll

 ; 64BIT-NEXT: .vbyte  8, TOC[TC0]
 ; 64BIT-NEXT: .vbyte  8, 0
 ; CHECK-NEXT: .csect .text[PR],2
 ; CHECK-LABEL: .main:
 ; CHECK: bl .foo
 ; CHECK: bl .extern_foo
 ; CHECK: bl .static_foo
 
+; CHECK: .lglobl static_foo[DS]
 ; CHECK: .lglobl .static_foo
 ; 32BIT: .csect static_foo[DS],2
 ; 32BIT-NEXT: .vbyte  4, .static_foo
 ; 32BIT-NEXT: .vbyte  4, TOC[TC0]
 ; 32BIT-NEXT: .vbyte  4, 0
 ; 64BIT: .csect static_foo[DS],3
 ; 64BIT-NEXT: .vbyte  8, .static_foo
 ; 64BIT-NEXT: .vbyte  8, TOC[TC0]
 ; 64BIT-NEXT: .vbyte  8, 0
 ; CHECK-NEXT: .csect .text[PR],2
 ; CHECK-LABEL: .static_foo:
 
 ; CHECK-NOT: .csect extern_foo
 
 ; CHECK: .toc
 ; CHECK-NOT: .tc