[yaml2obj] - Convert `ELFState<ELFT>::addSymbols` method to `toELFSymbols` helper.

[grimar]

Summary

ELFState<ELFT>::addSymbols method looks a bit strange.
User code have to create the destination symbols vector outside,
add a null symbol and then pass it to addSymbols when it seems
the more natural logic is to isolate all work with symbols inside some
function, build the list right there and return it.

[jhenderson]

tools/yaml2obj/yaml2elf.cpp

383 ↗

(On Diff #205327)

Do you need this? I think the vector resize will do this automatically, if I'm not mistaken.

[grimar]

tools/yaml2obj/yaml2elf.cpp

383 ↗

(On Diff #205327)

Yes, I think you're right. I'll remove this.

[grimar]

• Removed memset.

James, are you happy with that version?

[jhenderson]

Yes, LGTM.

llvm/trunk/tools/yaml2obj/yaml2elf.cpp

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 addSymbols(ArrayRef<ELFYAML::Symbol> Symbols, std::vector<Elf_Sym> &Syms,
-                  const StringTableBuilder &Strtab);
   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);
static uint64_t writeRawSectionData(raw_ostream &OS,
   if (!RawSec.Size)
     return ContentSize;
 
   OS.write_zeros(*RawSec.Size - ContentSize);
   return *RawSec.Size;
 }
 
 template <class ELFT>
+static std::vector<typename ELFT::Sym>
+toELFSymbols(NameToIdxMap &SN2I, ArrayRef<ELFYAML::Symbol> Symbols,
+             const StringTableBuilder &Strtab) {
+  using Elf_Sym = typename ELFT::Sym;
+
+  std::vector<Elf_Sym> Ret;
+  Ret.resize(Symbols.size() + 1);
+
+  size_t I = 0;
+  for (const auto &Sym : Symbols) {
+    Elf_Sym &Symbol = Ret[++I];
+
+    // If NameIndex, which contains the name offset, is explicitly specified, we
+    // use it. This is useful for preparing broken objects. Otherwise, we add
+    // the specified Name to the string table builder to get its offset.
+    if (Sym.NameIndex)
+      Symbol.st_name = *Sym.NameIndex;
+    else if (!Sym.Name.empty())
+      Symbol.st_name = Strtab.getOffset(Sym.Name);
+
+    Symbol.setBindingAndType(Sym.Binding, Sym.Type);
+    if (!Sym.Section.empty()) {
+      unsigned Index;
+      if (!SN2I.lookup(Sym.Section, Index)) {
+        WithColor::error() << "Unknown section referenced: '" << Sym.Section
+                           << "' by YAML symbol " << Sym.Name << ".\n";
+        exit(1);
+      }
+      Symbol.st_shndx = Index;
+    } else if (Sym.Index) {
+      Symbol.st_shndx = *Sym.Index;
+    }
+    // else Symbol.st_shndex == SHN_UNDEF (== 0), since it was zero'd earlier.
+    Symbol.st_value = Sym.Value;
+    Symbol.st_other = Sym.Other;
+    Symbol.st_size = Sym.Size;
+  }
+
+  return Ret;
+}
+
+template <class ELFT>
 void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
                                              SymtabType STType,
                                              ContiguousBlobAccumulator &CBA,
                                              ELFYAML::Section *YAMLSec) {
 
   bool IsStatic = STType == SymtabType::Static;
   const auto &Symbols = IsStatic ? Doc.Symbols : Doc.DynamicSymbols;
 
void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
 
   auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
   if (RawSec && (RawSec->Content || RawSec->Size)) {
     assert(Symbols.empty());
     SHeader.sh_size = writeRawSectionData(OS, *RawSec);
     return;
   }
 
-  std::vector<Elf_Sym> Syms;
-  {
-    // Ensure STN_UNDEF is present
-    Elf_Sym Sym;
-    zero(Sym);
-    Syms.push_back(Sym);
-  }
-
-  addSymbols(Symbols, Syms, IsStatic ? DotStrtab : DotDynstr);
+  std::vector<Elf_Sym> Syms =
+      toELFSymbols<ELFT>(SN2I, Symbols, IsStatic ? DotStrtab : DotDynstr);
   writeArrayData(OS, makeArrayRef(Syms));
   SHeader.sh_size = arrayDataSize(makeArrayRef(Syms));
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                              StringTableBuilder &STB,
                                              ContiguousBlobAccumulator &CBA,
if (YamlPhdr.Align) {
       for (Elf_Shdr *SHeader : Sections)
         if (SHeader->sh_offset == PHeader.p_offset)
           PHeader.p_align = std::max(PHeader.p_align, SHeader->sh_addralign);
     }
   }
 }
 
 template <class ELFT>
-void ELFState<ELFT>::addSymbols(ArrayRef<ELFYAML::Symbol> Symbols,
-                                std::vector<Elf_Sym> &Syms,
-                                const StringTableBuilder &Strtab) {
-  for (const auto &Sym : Symbols) {
-    Elf_Sym Symbol;
-    zero(Symbol);
-
-    // If NameIndex, which contains the name offset, is explicitly specified, we
-    // use it. This is useful for preparing broken objects. Otherwise, we add
-    // the specified Name to the string table builder to get its offset.
-    if (Sym.NameIndex)
-      Symbol.st_name = *Sym.NameIndex;
-    else if (!Sym.Name.empty())
-      Symbol.st_name = Strtab.getOffset(Sym.Name);
-
-    Symbol.setBindingAndType(Sym.Binding, Sym.Type);
-    if (!Sym.Section.empty()) {
-      unsigned Index;
-      if (!SN2I.lookup(Sym.Section, Index)) {
-        WithColor::error() << "Unknown section referenced: '" << Sym.Section
-                           << "' by YAML symbol " << Sym.Name << ".\n";
-        exit(1);
-      }
-      Symbol.st_shndx = Index;
-    } else if (Sym.Index) {
-      Symbol.st_shndx = *Sym.Index;
-    }
-    // else Symbol.st_shndex == SHN_UNDEF (== 0), since it was zero'd earlier.
-    Symbol.st_value = Sym.Value;
-    Symbol.st_other = Sym.Other;
-    Symbol.st_size = Sym.Size;
-    Syms.push_back(Symbol);
-  }
-}
-
-template <class ELFT>
 bool ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::RawContentSection &Section,
     ContiguousBlobAccumulator &CBA) {
   raw_ostream &OS =
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
   SHeader.sh_size = writeRawSectionData(OS, Section);
 
   if (Section.EntSize)