[lib/ObjectYAML] - Cleanup the private interface of ELFState<ELFT>. NFCI.

[grimar]

Summary

In D62809 I accidentally added "ELFState<ELFT> &State" as the
first parameter to two methods. There is no reason for having that.
I removed this argument and also moved finalizeStrings declaration to
remove an excessive 'private:' tag.

[MaskRay]

I do not know why, but two methods accepted ELFState<ELFT> &State as

an argument, though they are not static. There is no visible reason for having that.

D62809 accidentally added ELFState<ELFT> &State as the first parameter to two methods. This patch removes them.

[grimar]

In D67157#1658940, @MaskRay wrote:

I do not know why, but two methods accepted ELFState<ELFT> &State as

an argument, though they are not static. There is no visible reason for having that.

D62809 accidentally added ELFState<ELFT> &State as the first parameter to two methods. This patch removes them.

Ah, it was me... :) Fine then.

lib/ObjectYAML/ELFEmitter.cpp

template <class ELFT> class ELFState {
   NameToIdxMap SymN2I;
   NameToIdxMap DynSymN2I;
   ELFYAML::Object &Doc;
 
   bool buildSectionIndex();
   bool buildSymbolIndexes();
   void initELFHeader(Elf_Ehdr &Header);
   void initProgramHeaders(std::vector<Elf_Phdr> &PHeaders);
-  bool initImplicitHeader(ELFState<ELFT> &State, ContiguousBlobAccumulator &CBA,
-                          Elf_Shdr &Header, StringRef SecName,
-                          ELFYAML::Section *YAMLSec);
-  bool initSectionHeaders(ELFState<ELFT> &State,
-                          std::vector<Elf_Shdr> &SHeaders,
+  bool initImplicitHeader(ContiguousBlobAccumulator &CBA, Elf_Shdr &Header,
+                          StringRef SecName, ELFYAML::Section *YAMLSec);
+  bool initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                           ContiguousBlobAccumulator &CBA);
   void initSymtabSectionHeader(Elf_Shdr &SHeader, SymtabType STType,
                                ContiguousBlobAccumulator &CBA,
                                ELFYAML::Section *YAMLSec);
   void initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                StringTableBuilder &STB,
                                ContiguousBlobAccumulator &CBA,
                                ELFYAML::Section *YAMLSec);
   void setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
                               std::vector<Elf_Shdr> &SHeaders);
+  void finalizeStrings();
   bool writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RawContentSection &Section,
                            ContiguousBlobAccumulator &CBA);
   bool writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RelocationSection &Section,
                            ContiguousBlobAccumulator &CBA);
   bool writeSectionContent(Elf_Shdr &SHeader, const ELFYAML::Group &Group,
                            ContiguousBlobAccumulator &CBA);
bool writeSectionContent(Elf_Shdr &SHeader,
                            ContiguousBlobAccumulator &CBA);
   bool writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::DynamicSection &Section,
                            ContiguousBlobAccumulator &CBA);
   ELFState(ELFYAML::Object &D);
 
 public:
   static int writeELF(raw_ostream &OS, ELFYAML::Object &Doc);
-
-private:
-  void finalizeStrings();
 };
 } // end anonymous namespace
 
 template <class T> static size_t arrayDataSize(ArrayRef<T> A) {
   return A.size() * sizeof(T);
 }
 
 template <class T> static void writeArrayData(raw_ostream &OS, ArrayRef<T> A) {
if (!SN2I.lookup(IndexSrc, IndexDest) && !to_integer(IndexSrc, IndexDest)) {
     WithColor::error() << "Unknown section referenced: '" << IndexSrc
                        << "' at YAML section '" << SecName << "'.\n";
     return false;
   }
   return true;
 }
 
 template <class ELFT>
-bool ELFState<ELFT>::initImplicitHeader(ELFState<ELFT> &State,
-                                        ContiguousBlobAccumulator &CBA,
+bool ELFState<ELFT>::initImplicitHeader(ContiguousBlobAccumulator &CBA,
                                         Elf_Shdr &Header, StringRef SecName,
                                         ELFYAML::Section *YAMLSec) {
   // Check if the header was already initialized.
   if (Header.sh_offset)
     return false;
 
   if (SecName == ".symtab")
-    State.initSymtabSectionHeader(Header, SymtabType::Static, CBA, YAMLSec);
+    initSymtabSectionHeader(Header, SymtabType::Static, CBA, YAMLSec);
   else if (SecName == ".strtab")
-    State.initStrtabSectionHeader(Header, SecName, State.DotStrtab, CBA,
-                                  YAMLSec);
+    initStrtabSectionHeader(Header, SecName, DotStrtab, CBA, YAMLSec);
   else if (SecName == ".shstrtab")
-    State.initStrtabSectionHeader(Header, SecName, State.DotShStrtab, CBA,
-                                  YAMLSec);
-
+    initStrtabSectionHeader(Header, SecName, DotShStrtab, CBA, YAMLSec);
   else if (SecName == ".dynsym")
-    State.initSymtabSectionHeader(Header, SymtabType::Dynamic, CBA, YAMLSec);
+    initSymtabSectionHeader(Header, SymtabType::Dynamic, CBA, YAMLSec);
   else if (SecName == ".dynstr")
-    State.initStrtabSectionHeader(Header, SecName, State.DotDynstr, CBA,
-                                  YAMLSec);
+    initStrtabSectionHeader(Header, SecName, DotDynstr, CBA, YAMLSec);
   else
     return false;
 
   // Override the fields if requested.
   if (YAMLSec) {
     if (YAMLSec->ShName)
       Header.sh_name = *YAMLSec->ShName;
     if (YAMLSec->ShOffset)
       Header.sh_offset = *YAMLSec->ShOffset;
     if (YAMLSec->ShSize)
       Header.sh_size = *YAMLSec->ShSize;
   }
 
   return true;
 }
 
 static StringRef dropUniqueSuffix(StringRef S) {
   size_t SuffixPos = S.rfind(" [");
   if (SuffixPos == StringRef::npos)
     return S;
   return S.substr(0, SuffixPos);
 }
 
 template <class ELFT>
-bool ELFState<ELFT>::initSectionHeaders(ELFState<ELFT> &State,
-                                        std::vector<Elf_Shdr> &SHeaders,
+bool ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                                         ContiguousBlobAccumulator &CBA) {
   // Ensure SHN_UNDEF entry is present. An all-zero section header is a
   // valid SHN_UNDEF entry since SHT_NULL == 0.
   SHeaders.resize(Doc.Sections.size());
 
   for (size_t I = 0; I < Doc.Sections.size(); ++I) {
     ELFYAML::Section *Sec = Doc.Sections[I].get();
     if (I == 0 && Sec->IsImplicit)
       continue;
 
     // We have a few sections like string or symbol tables that are usually
     // added implicitly to the end. However, if they are explicitly specified
     // in the YAML, we need to write them here. This ensures the file offset
     // remains correct.
     Elf_Shdr &SHeader = SHeaders[I];
-    if (initImplicitHeader(State, CBA, SHeader, Sec->Name,
+    if (initImplicitHeader(CBA, SHeader, Sec->Name,
                            Sec->IsImplicit ? nullptr : Sec))
       continue;
 
     assert(Sec && "It can't be null unless it is an implicit section. But all "
                   "implicit sections should already have been handled above.");
 
     SHeader.sh_name = DotShStrtab.getOffset(dropUniqueSuffix(Sec->Name));
     SHeader.sh_type = Sec->Type;
int ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc) {
   // XXX: This offset is tightly coupled with the order that we write
   // things to `OS`.
   const size_t SectionContentBeginOffset = Header.e_ehsize +
                                            Header.e_phentsize * Header.e_phnum +
                                            Header.e_shentsize * Header.e_shnum;
   ContiguousBlobAccumulator CBA(SectionContentBeginOffset);
 
   std::vector<Elf_Shdr> SHeaders;
-  if (!State.initSectionHeaders(State, SHeaders, CBA))
+  if (!State.initSectionHeaders(SHeaders, CBA))
     return 1;
 
   // Now we can decide segment offsets
   State.setProgramHeaderLayout(PHeaders, SHeaders);
 
   OS.write((const char *)&Header, sizeof(Header));
   writeArrayData(OS, makeArrayRef(PHeaders));
   writeArrayData(OS, makeArrayRef(SHeaders));