Fix asm printing of associated sections

[eugenis]

Summary

Make MCSectionELF::AssociatedSection be a link to a symbol, because
that's how it works in the assembly, and use it in the asm printer.

[pcc]

lib/MC/MCSectionELF.cpp

157

(from D29104) Would AssociatedSymbol ever be null?

[eugenis]

lib/MC/MCSectionELF.cpp

157

should never happen

[pcc]

LGTM

[eugenis]

Rebased.
The parent revision has been submitted, this one is ready.
Rafael, are you OK with this?

[eugenis]

Friendly ping.

[eugenis]

Hi,

I'd really like to submit this some time soon. Any comments?

[eugenis]

ping

[eugenis]

address Rafael's comments

[eugenis]

Committed as r297769

include/llvm/MC/MCContext.h

private:
     MCSymbol *getOrCreateDirectionalLocalSymbol(unsigned LocalLabelVal,
                                                 unsigned Instance);
 
     MCSectionELF *createELFSectionImpl(StringRef Section, unsigned Type,
                                        unsigned Flags, SectionKind K,
                                        unsigned EntrySize,
                                        const MCSymbolELF *Group,
                                        unsigned UniqueID,
-                                       const MCSectionELF *Associated);
+                                       const MCSymbolELF *Associated);
 
   public:
     explicit MCContext(const MCAsmInfo *MAI, const MCRegisterInfo *MRI,
                        const MCObjectFileInfo *MOFI,
                        const SourceMgr *Mgr = nullptr, bool DoAutoReset = true);
     MCContext(const MCContext &) = delete;
     MCContext &operator=(const MCContext &) = delete;
     ~MCContext();
MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
                                 const Twine &Group, unsigned UniqueID) {
       return getELFSection(Section, Type, Flags, EntrySize, Group, UniqueID,
                            nullptr);
     }
 
     MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
                                 unsigned Flags, unsigned EntrySize,
                                 const Twine &Group, unsigned UniqueID,
-                                const MCSectionELF *Associated);
+                                const MCSymbolELF *Associated);
 
     MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
                                 unsigned Flags, unsigned EntrySize,
                                 const MCSymbolELF *Group, unsigned UniqueID,
-                                const MCSectionELF *Associated);
+                                const MCSymbolELF *Associated);
 
     /// Get a section with the provided group identifier. This section is
     /// named by concatenating \p Prefix with '.' then \p Suffix. The \p Type
     /// describes the type of the section and \p Flags are used to further
     /// configure this named section.
     MCSectionELF *getELFNamedSection(const Twine &Prefix, const Twine &Suffix,
                                      unsigned Type, unsigned Flags,
                                      unsigned EntrySize = 0);
 
     MCSectionELF *createELFRelSection(const Twine &Name, unsigned Type,
                                       unsigned Flags, unsigned EntrySize,
                                       const MCSymbolELF *Group,
-                                      const MCSectionELF *Associated);
+                                      const MCSectionELF *RelInfoSection);
 
     void renameELFSection(MCSectionELF *Section, StringRef Name);
 
     MCSectionELF *createELFGroupSection(const MCSymbolELF *Group);
 
     MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
                                   SectionKind Kind, StringRef COMDATSymName,
                                   int Selection,

include/llvm/MC/MCSectionELF.h

class MCSectionELF final : public MCSection {
 
   /// The size of each entry in this section. This size only makes sense for
   /// sections that contain fixed-sized entries. If a section does not contain
   /// fixed-sized entries 'EntrySize' will be 0.
   unsigned EntrySize;
 
   const MCSymbolELF *Group;
 
-  /// Depending on the type of the section this is sh_link or sh_info.
-  const MCSectionELF *Associated;
+  /// sh_link for REL and RELA sections.
+  const MCSectionELF *RelInfoSection;
+
+  /// sh_info for SHF_LINK_ORDER (can be null).
+  const MCSymbol *AssociatedSymbol;
 
 private:
   friend class MCContext;
 
   MCSectionELF(StringRef Section, unsigned type, unsigned flags, SectionKind K,
                unsigned entrySize, const MCSymbolELF *group, unsigned UniqueID,
-               MCSymbol *Begin, const MCSectionELF *Associated)
+               MCSymbol *Begin, const MCSymbolELF *AssociatedSymbol)
       : MCSection(SV_ELF, K, Begin), SectionName(Section), Type(type),
         Flags(flags), UniqueID(UniqueID), EntrySize(entrySize), Group(group),
-        Associated(Associated) {
+        RelInfoSection(nullptr), AssociatedSymbol(AssociatedSymbol) {
     if (Group)
       Group->setIsSignature();
   }
 
   void setSectionName(StringRef Name) { SectionName = Name; }
 
 public:
   ~MCSectionELF();
void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                             raw_ostream &OS,
                             const MCExpr *Subsection) const override;
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
 
   bool isUnique() const { return UniqueID != ~0U; }
   unsigned getUniqueID() const { return UniqueID; }
 
-  const MCSectionELF *getAssociatedSection() const { return Associated; }
+  const MCSectionELF *getRelInfoSection() const { return RelInfoSection; }
+  void setRelInfoSection(const MCSectionELF* S) { RelInfoSection = S; }
+
+  const MCSymbol *getAssociatedSymbol() const { return AssociatedSymbol; }
 
   static bool classof(const MCSection *S) {
     return S->getVariant() == SV_ELF;
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSECTIONELF_H

lib/MC/ELFObjectWriter.cpp

void ELFObjectWriter::writeSection(const SectionIndexMapTy &SectionIndexMap,
 
   case ELF::SHT_DYNAMIC:
     llvm_unreachable("SHT_DYNAMIC in a relocatable object");
 
   case ELF::SHT_REL:
   case ELF::SHT_RELA: {
     sh_link = SymbolTableIndex;
     assert(sh_link && ".symtab not found");
-    const MCSectionELF *InfoSection = Section.getAssociatedSection();
+    const MCSectionELF *InfoSection = Section.getRelInfoSection();
     sh_info = SectionIndexMap.lookup(InfoSection);
     break;
   }
 
   case ELF::SHT_SYMTAB:
   case ELF::SHT_DYNSYM:
     sh_link = StringTableIndex;
     sh_info = LastLocalSymbolIndex;
     break;
 
   case ELF::SHT_SYMTAB_SHNDX:
     sh_link = SymbolTableIndex;
     break;
 
   case ELF::SHT_GROUP:
     sh_link = SymbolTableIndex;
     sh_info = GroupSymbolIndex;
     break;
   }
 
-  if (Section.getFlags() & ELF::SHF_LINK_ORDER)
-    sh_link = SectionIndexMap.lookup(Section.getAssociatedSection());
+  if (Section.getFlags() & ELF::SHF_LINK_ORDER) {
+    const MCSymbol *Sym = Section.getAssociatedSymbol();
+    assert(Sym && Sym->isInSection());
+    const MCSectionELF *Sec = dyn_cast<MCSectionELF>(&Sym->getSection());
+    sh_link = SectionIndexMap.lookup(Sec);
+  }
 
   WriteSecHdrEntry(StrTabBuilder.getOffset(Section.getSectionName()),
                    Section.getType(), Section.getFlags(), 0, Offset, Size,
                    sh_link, sh_info, Section.getAlignment(),
                    Section.getEntrySize());
 }
 
 void ELFObjectWriter::writeSectionHeader(
void ELFObjectWriter::writeObject(MCAssembler &Asm,
   computeSymbolTable(Asm, Layout, SectionIndexMap, RevGroupMap, SectionOffsets);
 
   for (MCSectionELF *RelSection : Relocations) {
     align(RelSection->getAlignment());
 
     // Remember the offset into the file for this section.
     uint64_t SecStart = getStream().tell();
 
-    writeRelocations(Asm, *RelSection->getAssociatedSection());
+    writeRelocations(Asm, *RelSection->getRelInfoSection());
 
     uint64_t SecEnd = getStream().tell();
     SectionOffsets[RelSection] = std::make_pair(SecStart, SecEnd);
   }
 
   {
     uint64_t SecStart = getStream().tell();
     const MCSectionELF *Sec = createStringTable(Ctx);

lib/MC/MCContext.cpp

void MCContext::renameELFSection(MCSectionELF *Section, StringRef Name) {
   const_cast<MCSectionELF *>(Section)->setSectionName(CachedName);
 }
 
 MCSectionELF *MCContext::createELFSectionImpl(StringRef Section, unsigned Type,
                                               unsigned Flags, SectionKind K,
                                               unsigned EntrySize,
                                               const MCSymbolELF *Group,
                                               unsigned UniqueID,
-                                              const MCSectionELF *Associated) {
+                                              const MCSymbolELF *Associated) {
   MCSymbolELF *R;
   MCSymbol *&Sym = Symbols[Section];
   if (Sym && Sym->isUndefined()) {
     R = cast<MCSymbolELF>(Sym);
   } else {
     auto NameIter = UsedNames.insert(std::make_pair(Section, false)).first;
     R = new (&*NameIter, *this) MCSymbolELF(&*NameIter, /*isTemporary*/ false);
     if (!Sym)
MCSectionELF *MCContext::createELFSectionImpl(StringRef Section, unsigned Type,
   R->setFragment(F);
 
   return Ret;
 }
 
 MCSectionELF *MCContext::createELFRelSection(const Twine &Name, unsigned Type,
                                              unsigned Flags, unsigned EntrySize,
                                              const MCSymbolELF *Group,
-                                             const MCSectionELF *Associated) {
+                                             const MCSectionELF *RelInfoSection) {
   StringMap<bool>::iterator I;
   bool Inserted;
   std::tie(I, Inserted) =
       ELFRelSecNames.insert(std::make_pair(Name.str(), true));
 
-  return createELFSectionImpl(I->getKey(), Type, Flags,
-                              SectionKind::getReadOnly(), EntrySize, Group,
-                              true, Associated);
+  MCSectionELF *Section =
+      createELFSectionImpl(I->getKey(), Type, Flags, SectionKind::getReadOnly(),
+                           EntrySize, Group, true, nullptr);
+  Section->setRelInfoSection(RelInfoSection);
+  return Section;
 }
 
 MCSectionELF *MCContext::getELFNamedSection(const Twine &Prefix,
                                             const Twine &Suffix, unsigned Type,
                                             unsigned Flags,
                                             unsigned EntrySize) {
   return getELFSection(Prefix + "." + Suffix, Type, Flags, EntrySize, Suffix);
 }
 
 MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
                                        unsigned Flags, unsigned EntrySize,
                                        const Twine &Group, unsigned UniqueID,
-                                       const MCSectionELF *Associated) {
+                                       const MCSymbolELF *Associated) {
   MCSymbolELF *GroupSym = nullptr;
   if (!Group.isTriviallyEmpty() && !Group.str().empty())
     GroupSym = cast<MCSymbolELF>(getOrCreateSymbol(Group));
 
   return getELFSection(Section, Type, Flags, EntrySize, GroupSym, UniqueID,
                        Associated);
 }
 
 MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
                                        unsigned Flags, unsigned EntrySize,
                                        const MCSymbolELF *GroupSym,
                                        unsigned UniqueID,
-                                       const MCSectionELF *Associated) {
+                                       const MCSymbolELF *Associated) {
   StringRef Group = "";
   if (GroupSym)
     Group = GroupSym->getName();
   // Do the lookup, if we have a hit, return it.
   auto IterBool = ELFUniquingMap.insert(
       std::make_pair(ELFSectionKey{Section.str(), Group, UniqueID}, nullptr));
   auto &Entry = *IterBool.first;
   if (!IterBool.second)

lib/MC/MCParser/ELFAsmParser.cpp

 
 private:
   bool ParseSectionName(StringRef &SectionName);
   bool ParseSectionArguments(bool IsPush, SMLoc loc);
   unsigned parseSunStyleSectionFlags();
   bool maybeParseSectionType(StringRef &TypeName);
   bool parseMergeSize(int64_t &Size);
   bool parseGroup(StringRef &GroupName);
-  bool parseMetadataSym(MCSectionELF *&Associated);
+  bool parseMetadataSym(MCSymbolELF *&Associated);
   bool maybeParseUniqueID(int64_t &UniqueID);
 };
 
 } // end anonymous namespace
 
 /// ParseDirectiveSymbolAttribute
 ///  ::= { ".local", ".weak", ... } [ identifier ( , identifier )* ]
 bool ELFAsmParser::ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
if (L.is(AsmToken::Comma)) {
     if (getParser().parseIdentifier(Linkage))
       return true;
     if (Linkage != "comdat")
       return TokError("Linkage must be 'comdat'");
   }
   return false;
 }
 
-bool ELFAsmParser::parseMetadataSym(MCSectionELF *&Associated) {
+bool ELFAsmParser::parseMetadataSym(MCSymbolELF *&Associated) {
   MCAsmLexer &L = getLexer();
   if (L.isNot(AsmToken::Comma))
     return TokError("expected metadata symbol");
   Lex();
   StringRef Name;
   if (getParser().parseIdentifier(Name))
     return true;
-  MCSymbol *Sym = getContext().lookupSymbol(Name);
-  if (!Sym || !Sym->isInSection())
+  Associated = dyn_cast_or_null<MCSymbolELF>(getContext().lookupSymbol(Name));
+  if (!Associated || !Associated->isInSection())
     return TokError("symbol is not in a section: " + Name);
-  Associated = cast<MCSectionELF>(&Sym->getSection());
   return false;
 }
 
 bool ELFAsmParser::maybeParseUniqueID(int64_t &UniqueID) {
   MCAsmLexer &L = getLexer();
   if (L.isNot(AsmToken::Comma))
     return false;
   Lex();
bool ELFAsmParser::ParseSectionArguments(bool IsPush, SMLoc loc) {
 
   StringRef TypeName;
   int64_t Size = 0;
   StringRef GroupName;
   unsigned Flags = 0;
   const MCExpr *Subsection = nullptr;
   bool UseLastGroup = false;
   StringRef UniqueStr;
-  MCSectionELF *Associated = nullptr;
+  MCSymbolELF *Associated = nullptr;
   int64_t UniqueID = ~0;
 
   // Set the defaults first.
   if (SectionName == ".fini" || SectionName == ".init" ||
       SectionName == ".rodata")
     Flags |= ELF::SHF_ALLOC;
   if (SectionName == ".fini" || SectionName == ".init")
     Flags |= ELF::SHF_EXECINSTR;
if (UseLastGroup) {
     if (const MCSectionELF *Section =
             cast_or_null<MCSectionELF>(CurrentSection.first))
       if (const MCSymbol *Group = Section->getGroup()) {
         GroupName = Group->getName();
         Flags |= ELF::SHF_GROUP;
       }
   }
 
-  MCSection *ELFSection = getContext().getELFSection(
-      SectionName, Type, Flags, Size, GroupName, UniqueID, Associated);
+  MCSection *ELFSection =
+      getContext().getELFSection(SectionName, Type, Flags, Size, GroupName,
+                                 UniqueID, Associated);
   getStreamer().SwitchSection(ELFSection, Subsection);
 
   if (getContext().getGenDwarfForAssembly()) {
     bool InsertResult = getContext().addGenDwarfSection(ELFSection);
     if (InsertResult) {
       if (getContext().getDwarfVersion() <= 2)
         Warning(loc, "DWARF2 only supports one section per compilation unit");
 

lib/MC/MCSectionELF.cpp

void MCSectionELF::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
   if (Flags & ELF::SHF_WRITE)
     OS << 'w';
   if (Flags & ELF::SHF_MERGE)
     OS << 'M';
   if (Flags & ELF::SHF_STRINGS)
     OS << 'S';
   if (Flags & ELF::SHF_TLS)
     OS << 'T';
+  if (Flags & ELF::SHF_LINK_ORDER)
+    OS << 'm';
 
   // If there are target-specific flags, print them.
   Triple::ArchType Arch = T.getArch();
   if (Arch == Triple::xcore) {
     if (Flags & ELF::XCORE_SHF_CP_SECTION)
       OS << 'c';
     if (Flags & ELF::XCORE_SHF_DP_SECTION)
       OS << 'd';
void MCSectionELF::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
   }
 
   if (Flags & ELF::SHF_GROUP) {
     OS << ",";
     printName(OS, Group->getName());
     OS << ",comdat";
   }
 
+  if (Flags & ELF::SHF_LINK_ORDER) {
+    OS << ",";
+    printName(OS, AssociatedSymbol->getName());
+  }
+
   if (isUnique())
     OS << ",unique," << UniqueID;
 
   OS << '\n';
 
   if (Subsection) {
     OS << "\t.subsection\t";
     Subsection->print(OS, &MAI);

lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

if (FnSecName != ".text") {
     EHSecName += FnSecName;
   }
 
   // Get .ARM.extab or .ARM.exidx section
   const MCSymbolELF *Group = FnSection.getGroup();
   if (Group)
     Flags |= ELF::SHF_GROUP;
   MCSectionELF *EHSection = getContext().getELFSection(
-      EHSecName, Type, Flags, 0, Group, FnSection.getUniqueID(), &FnSection);
+      EHSecName, Type, Flags, 0, Group, FnSection.getUniqueID(),
+      dyn_cast<MCSymbolELF>(&Fn));
 
   assert(EHSection && "Failed to get the required EH section");
 
   // Switch to .ARM.extab or .ARM.exidx section
   SwitchSection(EHSection);
   EmitCodeAlignment(4);
 }
 

test/MC/ELF/section.s

 // RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o - | llvm-readobj -s | FileCheck %s
+// RUN: llvm-mc -filetype=asm -triple x86_64-pc-linux-gnu %s -o - |  FileCheck %s --check-prefix=ASM
 
 // Test that these names are accepted.
 
 .section  .note.GNU-stack,"",@progbits
 .section  .note.GNU-stack2,"",%progbits
 .section  .note.GNU-,"",@progbits
 .section  -.note.GNU,"","progbits"
 .section  src/stack.c,"",@progbits
.Lshf_metadata_target2_1:
         .quad 0
 .section .shf_metadata_target2, "a", @progbits, unique, 2
 .Lshf_metadata_target2_2:
         .quad 0
 
 .section .shf_metadata1,"am",@progbits,.Lshf_metadata_target2_1
 .section .shf_metadata2,"am",@progbits,.Lshf_metadata_target2_2
 .section .shf_metadata3,"am",@progbits,.shf_metadata_target1
+// ASM: .section .shf_metadata1,"am",@progbits,.Lshf_metadata_target2_1
+// ASM: .section .shf_metadata2,"am",@progbits,.Lshf_metadata_target2_2
+// ASM: .section .shf_metadata3,"am",@progbits,.shf_metadata_target1
 
 // CHECK:      Section {
 // CHECK:        Index: 22
 // CHECK-NEXT:   Name: .shf_metadata_target1
 
 // CHECK:      Section {
 // CHECK:        Index: 23
 // CHECK-NEXT:   Name: .shf_metadata_target2