[MC] Make first argument to MCContext::getXXXSection consistent

[sbc100]

Summary

StringRef Name seems to make the most sense here.

[sbc100]

• clang-format

include/llvm/MC/MCContext.h

public:
 
     MCSectionMachO *getMachOSection(StringRef Segment, StringRef Section,
                                     unsigned TypeAndAttributes, SectionKind K,
                                     const char *BeginSymName = nullptr) {
       return getMachOSection(Segment, Section, TypeAndAttributes, 0, K,
                              BeginSymName);
     }
 
-    MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
-                                unsigned Flags) {
-      return getELFSection(Section, Type, Flags, 0, "");
+    MCSectionELF *getELFSection(StringRef Name, unsigned Type, unsigned Flags) {
+      return getELFSection(Name, Type, Flags, 0, "");
     }
 
-    MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
-                                unsigned Flags, unsigned EntrySize,
-                                const Twine &Group) {
-      return getELFSection(Section, Type, Flags, EntrySize, Group, ~0);
+    MCSectionELF *getELFSection(StringRef Name, unsigned Type, unsigned Flags,
+                                unsigned EntrySize, const Twine &Group) {
+      return getELFSection(Name, Type, Flags, EntrySize, Group, ~0);
     }
 
-    MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
-                                unsigned Flags, unsigned EntrySize,
-                                const Twine &Group, unsigned UniqueID) {
-      return getELFSection(Section, Type, Flags, EntrySize, Group, UniqueID,
+    MCSectionELF *getELFSection(StringRef Name, unsigned Type, unsigned Flags,
+                                unsigned EntrySize, const Twine &Group,
+                                unsigned UniqueID) {
+      return getELFSection(Name, Type, Flags, EntrySize, Group, UniqueID,
                            nullptr);
     }
 
-    MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
-                                unsigned Flags, unsigned EntrySize,
-                                const Twine &Group, unsigned UniqueID,
+    MCSectionELF *getELFSection(StringRef Name, unsigned Type, unsigned Flags,
+                                unsigned EntrySize, const Twine &Group,
+                                unsigned UniqueID,
                                 const MCSymbolELF *Associated);
 
-    MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
-                                unsigned Flags, unsigned EntrySize,
-                                const MCSymbolELF *Group, unsigned UniqueID,
+    MCSectionELF *getELFSection(StringRef Name, unsigned Type, unsigned Flags,
+                                unsigned EntrySize, const MCSymbolELF *Group,
+                                unsigned UniqueID,
                                 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,
+    MCSectionELF *getELFNamedSection(StringRef Prefix, StringRef Suffix,
                                      unsigned Type, unsigned Flags,
                                      unsigned EntrySize = 0);
 
-    MCSectionELF *createELFRelSection(const Twine &Name, unsigned Type,
+    MCSectionELF *createELFRelSection(StringRef Name, unsigned Type,
                                       unsigned Flags, unsigned EntrySize,
                                       const MCSymbolELF *Group,
                                       const MCSectionELF *RelInfoSection);
 
     void renameELFSection(MCSectionELF *Section, StringRef Name);
 
     MCSectionELF *createELFGroupSection(const MCSymbolELF *Group);
 
-    MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
+    MCSectionCOFF *getCOFFSection(StringRef Name, unsigned Characteristics,
                                   SectionKind Kind, StringRef COMDATSymName,
                                   int Selection,
                                   unsigned UniqueID = GenericSectionID,
                                   const char *BeginSymName = nullptr);
 
-    MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
+    MCSectionCOFF *getCOFFSection(StringRef Name, unsigned Characteristics,
                                   SectionKind Kind,
                                   const char *BeginSymName = nullptr);
 
-    MCSectionCOFF *getCOFFSection(StringRef Section);
+    MCSectionCOFF *getCOFFSection(StringRef Name);
 
     /// Gets or creates a section equivalent to Sec that is associated with the
     /// section containing KeySym. For example, to create a debug info section
     /// associated with an inline function, pass the normal debug info section
     /// as Sec and the function symbol as KeySym.
     MCSectionCOFF *
     getAssociativeCOFFSection(MCSectionCOFF *Sec, const MCSymbol *KeySym,
                               unsigned UniqueID = GenericSectionID);
 
-    MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K) {
-      return getWasmSection(Section, K, nullptr);
+    MCSectionWasm *getWasmSection(StringRef Name, SectionKind K) {
+      return getWasmSection(Name, K, nullptr);
     }
 
-    MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
+    MCSectionWasm *getWasmSection(StringRef Name, SectionKind K,
                                   const char *BeginSymName) {
-      return getWasmSection(Section, K, "", ~0, BeginSymName);
+      return getWasmSection(Name, K, "", ~0, BeginSymName);
     }
 
-    MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
+    MCSectionWasm *getWasmSection(StringRef Name, SectionKind K,
                                   const Twine &Group, unsigned UniqueID) {
-      return getWasmSection(Section, K, Group, UniqueID, nullptr);
+      return getWasmSection(Name, K, Group, UniqueID, nullptr);
     }
 
-    MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
+    MCSectionWasm *getWasmSection(StringRef Name, SectionKind K,
                                   const Twine &Group, unsigned UniqueID,
                                   const char *BeginSymName);
 
-    MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
+    MCSectionWasm *getWasmSection(StringRef Name, SectionKind K,
                                   const MCSymbolWasm *Group, unsigned UniqueID,
                                   const char *BeginSymName);
 
     // Create and save a copy of STI and return a reference to the copy.
     MCSubtargetInfo &getSubtargetCopy(const MCSubtargetInfo &STI);
 
     /// @}
 

lib/MC/MCContext.cpp

void MCContext::renameELFSection(MCSectionELF *Section, StringRef Name) {
   auto I = ELFUniquingMap.insert(std::make_pair(
                                      ELFSectionKey{Name, GroupName, UniqueID},
                                      Section))
                .first;
   StringRef CachedName = I->first.SectionName;
   const_cast<MCSectionELF *>(Section)->setSectionName(CachedName);
 }
 
-MCSectionELF *MCContext::createELFSectionImpl(StringRef Section, unsigned Type,
+MCSectionELF *MCContext::createELFSectionImpl(StringRef Name, unsigned Type,
                                               unsigned Flags, SectionKind K,
                                               unsigned EntrySize,
                                               const MCSymbolELF *Group,
                                               unsigned UniqueID,
                                               const MCSymbolELF *Associated) {
   MCSymbolELF *R;
-  MCSymbol *&Sym = Symbols[Section];
+  MCSymbol *&Sym = Symbols[Name];
   // A section symbol can not redefine regular symbols. There may be multiple
   // sections with the same name, in which case the first such section wins.
   if (Sym && Sym->isDefined() &&
       (!Sym->isInSection() || Sym->getSection().getBeginSymbol() != Sym))
     reportError(SMLoc(), "invalid symbol redefinition");
   if (Sym && Sym->isUndefined()) {
     R = cast<MCSymbolELF>(Sym);
   } else {
-    auto NameIter = UsedNames.insert(std::make_pair(Section, false)).first;
+    auto NameIter = UsedNames.insert(std::make_pair(Name, false)).first;
     R = new (&*NameIter, *this) MCSymbolELF(&*NameIter, /*isTemporary*/ false);
     if (!Sym)
       Sym = R;
   }
   R->setBinding(ELF::STB_LOCAL);
   R->setType(ELF::STT_SECTION);
 
   auto *Ret = new (ELFAllocator.Allocate()) MCSectionELF(
-      Section, Type, Flags, K, EntrySize, Group, UniqueID, R, Associated);
+      Name, Type, Flags, K, EntrySize, Group, UniqueID, R, Associated);
 
   auto *F = new MCDataFragment();
   Ret->getFragmentList().insert(Ret->begin(), F);
   F->setParent(Ret);
   R->setFragment(F);
 
   return Ret;
 }
 
-MCSectionELF *MCContext::createELFRelSection(const Twine &Name, unsigned Type,
-                                             unsigned Flags, unsigned EntrySize,
-                                             const MCSymbolELF *Group,
-                                             const MCSectionELF *RelInfoSection) {
+MCSectionELF *
+MCContext::createELFRelSection(StringRef Name, unsigned Type, unsigned Flags,
+                               unsigned EntrySize, const MCSymbolELF *Group,
   StringMap<bool>::iterator I;
   bool Inserted;
-  std::tie(I, Inserted) =
-      RelSecNames.insert(std::make_pair(Name.str(), true));
+  std::tie(I, Inserted) = RelSecNames.insert(std::make_pair(Name, true));
 
   return createELFSectionImpl(
       I->getKey(), Type, Flags, SectionKind::getReadOnly(), EntrySize, Group,
       true, cast<MCSymbolELF>(RelInfoSection->getBeginSymbol()));
 }
 
-MCSectionELF *MCContext::getELFNamedSection(const Twine &Prefix,
-                                            const Twine &Suffix, unsigned Type,
-                                            unsigned Flags,
+MCSectionELF *MCContext::getELFNamedSection(StringRef Prefix, StringRef Suffix,
+                                            unsigned Type, unsigned Flags,
                                             unsigned EntrySize) {
-  return getELFSection(Prefix + "." + Suffix, Type, Flags, EntrySize, Suffix);
+  return getELFSection((Prefix + "." + Suffix).str(), Type, Flags, EntrySize,
+                       Suffix);
 }
 
-MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
+MCSectionELF *MCContext::getELFSection(StringRef Name, unsigned Type,
                                        unsigned Flags, unsigned EntrySize,
                                        const Twine &Group, unsigned UniqueID,
                                        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,
+  return getELFSection(Name, Type, Flags, EntrySize, GroupSym, UniqueID,
                        Associated);
 }
 
-MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
+MCSectionELF *MCContext::getELFSection(StringRef Name, unsigned Type,
                                        unsigned Flags, unsigned EntrySize,
                                        const MCSymbolELF *GroupSym,
                                        unsigned UniqueID,
                                        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));
+      std::make_pair(ELFSectionKey{Name, Group, UniqueID}, nullptr));
   auto &Entry = *IterBool.first;
   if (!IterBool.second)
     return Entry.second;
 
   StringRef CachedName = Entry.first.SectionName;
 
   SectionKind Kind;
   if (Flags & ELF::SHF_ARM_PURECODE)

 }
 
 MCSectionELF *MCContext::createELFGroupSection(const MCSymbolELF *Group) {
   return createELFSectionImpl(".group", ELF::SHT_GROUP, 0,
                               SectionKind::getReadOnly(), 4, Group, ~0,
                               nullptr);
 }
 
-MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
+MCSectionCOFF *MCContext::getCOFFSection(StringRef Name,
                                          unsigned Characteristics,
                                          SectionKind Kind,
                                          StringRef COMDATSymName, int Selection,
                                          unsigned UniqueID,
                                          const char *BeginSymName) {
   MCSymbol *COMDATSymbol = nullptr;
   if (!COMDATSymName.empty()) {
     COMDATSymbol = getOrCreateSymbol(COMDATSymName);
     COMDATSymName = COMDATSymbol->getName();
   }
 
 
   // Do the lookup, if we have a hit, return it.
-  COFFSectionKey T{Section, COMDATSymName, Selection, UniqueID};
+  COFFSectionKey T{Name, COMDATSymName, Selection, UniqueID};
   auto IterBool = COFFUniquingMap.insert(std::make_pair(T, nullptr));
   auto Iter = IterBool.first;
   if (!IterBool.second)
     return Iter->second;
 
   MCSymbol *Begin = nullptr;
   if (BeginSymName)
     Begin = createTempSymbol(BeginSymName, false);
return getCOFFSection(Sec->getSectionName(), Characteristics,
                           Sec->getKind(), KeySym->getName(),
                           COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
   }
 
   return getCOFFSection(Sec->getSectionName(), Characteristics, Sec->getKind(),
                         "", 0, UniqueID);
 }
 
-MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind K,
+MCSectionWasm *MCContext::getWasmSection(StringRef Name, SectionKind K,
                                          const Twine &Group, unsigned UniqueID,
                                          const char *BeginSymName) {
   MCSymbolWasm *GroupSym = nullptr;
   if (!Group.isTriviallyEmpty() && !Group.str().empty()) {
     GroupSym = cast<MCSymbolWasm>(getOrCreateSymbol(Group));
     GroupSym->setComdat(true);
   }
 
-  return getWasmSection(Section, K, GroupSym, UniqueID, BeginSymName);
+  return getWasmSection(Name, K, GroupSym, UniqueID, BeginSymName);
 }
 
-MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind Kind,
+MCSectionWasm *MCContext::getWasmSection(StringRef Name, SectionKind Kind,
                                          const MCSymbolWasm *GroupSym,
                                          unsigned UniqueID,
                                          const char *BeginSymName) {
   StringRef Group = "";
   if (GroupSym)
     Group = GroupSym->getName();
   // Do the lookup, if we have a hit, return it.
   auto IterBool = WasmUniquingMap.insert(
-      std::make_pair(WasmSectionKey{Section.str(), Group, UniqueID}, nullptr));
+      std::make_pair(WasmSectionKey{Name, Group, UniqueID}, nullptr));
   auto &Entry = *IterBool.first;
   if (!IterBool.second)
     return Entry.second;
 
   StringRef CachedName = Entry.first.SectionName;
 
   MCSymbol *Begin = nullptr;
   if (BeginSymName) {