[MCContext] Use `const Twine &` in symbol creation methods. NFC

[paperchalice]

Summary

All of these methods will invoke getOrCreateSymbol(const Twine &Name), using Twine here makes these methods more flexible.

[paperchalice]

Could you submit this patch for me? I don't have the commit access. Thanks. @MaskRay

[paperchalice]

Ping @MaskRay

[MaskRay]

Do you have a use case for the more flexible function signature?

[paperchalice]

I recently worked on an assembler which allow user add prefix or set values to symbols, getOrCreateSymbol can create symbols with prefix in Twine, but if I want to set the value for the symbol with prefix, setSymbolValue no longer works because it expect StringRef rather than Twine like getOrCreateSymbol.

llvm/include/llvm/MC/MCContext.h

public:
   ///
   /// \param Name - The symbol name, which must be unique across all symbols.
   MCSymbol *getOrCreateSymbol(const Twine &Name);
 
   /// Gets a symbol that will be defined to the final stack offset of a local
   /// variable after codegen.
   ///
   /// \param Idx - The index of a local variable passed to \@llvm.localescape.
-  MCSymbol *getOrCreateFrameAllocSymbol(StringRef FuncName, unsigned Idx);
+  MCSymbol *getOrCreateFrameAllocSymbol(const Twine &FuncName, unsigned Idx);
 
-  MCSymbol *getOrCreateParentFrameOffsetSymbol(StringRef FuncName);
+  MCSymbol *getOrCreateParentFrameOffsetSymbol(const Twine &FuncName);
 
-  MCSymbol *getOrCreateLSDASymbol(StringRef FuncName);
+  MCSymbol *getOrCreateLSDASymbol(const Twine &FuncName);
 
   /// Get the symbol for \p Name, or null.
   MCSymbol *lookupSymbol(const Twine &Name) const;
 
   /// Set value for a symbol.
-  void setSymbolValue(MCStreamer &Streamer, StringRef Sym, uint64_t Val);
+  void setSymbolValue(MCStreamer &Streamer, const Twine &Sym, uint64_t Val);
 
   /// getSymbols - Get a reference for the symbol table for clients that
   /// want to, for example, iterate over all symbols. 'const' because we
   /// still want any modifications to the table itself to use the MCContext
   /// APIs.
   const SymbolTable &getSymbols() const { return Symbols; }
 
   /// isInlineAsmLabel - Return true if the name is a label referenced in
public:
 
   MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
                                 unsigned Flags, const Twine &Group,
                                 unsigned UniqueID, const char *BeginSymName);
 
   MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
                                 unsigned Flags, const MCSymbolWasm *Group,
                                 unsigned UniqueID, const char *BeginSymName);
-  
   /// Get the section for the provided Section name
   MCSectionDXContainer *getDXContainerSection(StringRef Section, SectionKind K);
 
   bool hasXCOFFSection(StringRef Section,
                        XCOFF::CsectProperties CsectProp) const;
 
   MCSectionXCOFF *getXCOFFSection(
       StringRef Section, SectionKind K,

llvm/lib/MC/MCContext.cpp

MCSymbol *MCContext::getOrCreateSymbol(const Twine &Name) {
 
   MCSymbol *&Sym = Symbols[NameRef];
   if (!Sym)
     Sym = createSymbol(NameRef, false, false);
 
   return Sym;
 }
 
-MCSymbol *MCContext::getOrCreateFrameAllocSymbol(StringRef FuncName,
+MCSymbol *MCContext::getOrCreateFrameAllocSymbol(const Twine &FuncName,
                                                  unsigned Idx) {
-  return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName +
+  return getOrCreateSymbol(MAI->getPrivateGlobalPrefix() + FuncName +
                            "$frame_escape_" + Twine(Idx));
 }
 
-MCSymbol *MCContext::getOrCreateParentFrameOffsetSymbol(StringRef FuncName) {
-  return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName +
+MCSymbol *MCContext::getOrCreateParentFrameOffsetSymbol(const Twine &FuncName) {
+  return getOrCreateSymbol(MAI->getPrivateGlobalPrefix() + FuncName +
                            "$parent_frame_offset");
 }
 
-MCSymbol *MCContext::getOrCreateLSDASymbol(StringRef FuncName) {
-  return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + "__ehtable$" +
+MCSymbol *MCContext::getOrCreateLSDASymbol(const Twine &FuncName) {
+  return getOrCreateSymbol(MAI->getPrivateGlobalPrefix() + "__ehtable$" +
                            FuncName);
 }
 
 MCSymbol *MCContext::createSymbolImpl(const StringMapEntry<bool> *Name,
                                       bool IsTemporary) {
   static_assert(std::is_trivially_destructible<MCSymbolCOFF>(),
                 "MCSymbol classes must be trivially destructible");
   static_assert(std::is_trivially_destructible<MCSymbolELF>(),
MCSymbol *MCContext::createSymbolImpl(const StringMapEntry<bool> *Name,
   case MCContext::IsXCOFF:
     return createXCOFFSymbolImpl(Name, IsTemporary);
   case MCContext::IsDXContainer:
     break;
   case MCContext::IsSPIRV:
     return new (Name, *this)
         MCSymbol(MCSymbol::SymbolKindUnset, Name, IsTemporary);
   }
-  return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name,
-                                    IsTemporary);
+  return new (Name, *this)
+      MCSymbol(MCSymbol::SymbolKindUnset, Name, IsTemporary);
 }
 
 MCSymbol *MCContext::createSymbol(StringRef Name, bool AlwaysAddSuffix,
                                   bool CanBeUnnamed) {
   if (CanBeUnnamed && !UseNamesOnTempLabels)
     return createSymbolImpl(nullptr, true);
 
   // Determine whether this is a user written assembler temporary or normal

 }
 
 MCSymbol *MCContext::lookupSymbol(const Twine &Name) const {
   SmallString<128> NameSV;
   StringRef NameRef = Name.toStringRef(NameSV);
   return Symbols.lookup(NameRef);
 }
 
-void MCContext::setSymbolValue(MCStreamer &Streamer,
-                              StringRef Sym,
+void MCContext::setSymbolValue(MCStreamer &Streamer, const Twine &Sym,
                                uint64_t Val) {
   auto Symbol = getOrCreateSymbol(Sym);
   Streamer.emitAssignment(Symbol, MCConstantExpr::create(Val, *this));
 }
 
 void MCContext::registerInlineAsmLabel(MCSymbol *Sym) {
   InlineAsmUsedLabelNames[Sym->getName()] = Sym;
 }
 
MCSectionELF *MCContext::createELFSectionImpl(StringRef Section, unsigned Type,
   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(const Twine &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.str(), true));
 
   return createELFSectionImpl(
       I->getKey(), Type, Flags, SectionKind::getReadOnly(), EntrySize, Group,
       true, true, cast<MCSymbolELF>(RelInfoSection->getBeginSymbol()));
 }
 
 MCSectionELF *MCContext::getELFNamedSection(const Twine &Prefix,
                                             const Twine &Suffix, unsigned Type,
MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
                                          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};
   auto IterBool = COFFUniquingMap.insert(std::make_pair(T, nullptr));
   auto Iter = IterBool.first;
   if (!IterBool.second)
     return Iter->second;
 
   MCSymbol *Begin = nullptr;