[WebAssembly] Merge producers section

[tlively]

This has a cyclic dependency on D56742, but phabricator won't let me express that.

[tlively]

• Change to getProducerInfo interface

[sbc100]

wasm/Writer.cpp

654

From brazed from these two single line blocks. That the lld style anyway.

657

Call this FieldCount ?

817

Add another newline here for visual consistency?

[tlively]

• Style fixes

wasm/InputFiles.h

public:
 
   uint32_t calcNewIndex(const WasmRelocation &Reloc) const;
   uint32_t calcNewValue(const WasmRelocation &Reloc) const;
   uint32_t calcNewAddend(const WasmRelocation &Reloc) const;
   uint32_t calcExpectedValue(const WasmRelocation &Reloc) const;
 
   const WasmSection *CodeSection = nullptr;
   const WasmSection *DataSection = nullptr;
+  const WasmSection *ProducersSection = nullptr;
 
   // Maps input type indices to output type indices
   std::vector<uint32_t> TypeMap;
   std::vector<bool> TypeIsUsed;
   // Maps function indices to table indices
   std::vector<uint32_t> TableEntries;
   std::vector<bool> UsedComdats;
   std::vector<InputSegment *> Segments;
public:
   explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
 
   void parse() override;
   std::unique_ptr<llvm::lto::InputFile> Obj;
 };
 
 // Will report a fatal() error if the input buffer is not a valid bitcode
-// or was object file.
+// or wasm object file.
 InputFile *createObjectFile(MemoryBufferRef MB);
 
 // Opens a given file.
 llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
 
 } // namespace wasm
 
 std::string toString(const wasm::InputFile *File);
 
 } // namespace lld
 
 #endif

wasm/InputFiles.cpp

for (const SectionRef &Sec : WasmObj->sections()) {
     if (Section.Type == WASM_SEC_CODE) {
       CodeSection = &Section;
     } else if (Section.Type == WASM_SEC_DATA) {
       DataSection = &Section;
     } else if (Section.Type == WASM_SEC_CUSTOM) {
       CustomSections.emplace_back(make<InputSection>(Section, this));
       CustomSections.back()->setRelocations(Section.Relocations);
       CustomSectionsByIndex[SectionIndex] = CustomSections.back();
+      if (Section.Name == "producers")
+        ProducersSection = &Section;
     }
     SectionIndex++;
   }
 
   TypeMap.resize(getWasmObj()->types().size());
   TypeIsUsed.resize(getWasmObj()->types().size(), false);
 
   ArrayRef<StringRef> Comdats = WasmObj->linkingData().Comdats;

wasm/Writer.cpp

 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/Threads.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/Object/WasmTraits.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/LEB128.h"
 
private:
   void createDataSection();
   void createCustomSections();
 
   // Custom sections
   void createDylinkSection();
   void createRelocSections();
   void createLinkingSection();
   void createNameSection();
+  void createProducersSection();
 
   void writeHeader();
   void writeSections();
 
   uint64_t FileSize = 0;
   uint32_t TableBase = 0;
   uint32_t NumMemoryPages = 0;
   uint32_t MaxMemoryPages = 0;

 void Writer::calculateCustomSections() {
   log("calculateCustomSections");
   bool StripDebug = Config->StripDebug || Config->StripAll;
   for (ObjFile *File : Symtab->ObjectFiles) {
     for (InputSection *Section : File->CustomSections) {
       StringRef Name = Section->getName();
       // These custom sections are known the linker and synthesized rather than
       // blindly copied
-      if (Name == "linking" || Name == "name" || Name.startswith("reloc."))
+      if (Name == "linking" || Name == "name" || Name == "producers" ||
+          Name.startswith("reloc."))
         continue;
       // .. or it is a debug section
       if (StripDebug && Name.startswith(".debug_"))
         continue;
       CustomSectionMapping[Name].push_back(Section);
     }
   }
 }
if (!F->getName().empty()) {
         writeStr(Sub.OS, maybeDemangleSymbol(F->getName()), "symbol name");
       }
     }
   }
 
   Sub.writeTo(Section->getStream());
 }
 
+void Writer::createProducersSection() {
+  SmallVector<std::pair<std::string, std::string>, 8> Languages;
+  SmallVector<std::pair<std::string, std::string>, 8> Tools;
+  SmallVector<std::pair<std::string, std::string>, 8> SDKs;
+  for (ObjFile *File : Symtab->ObjectFiles) {
+    const WasmObjectFile *Obj = File->getWasmObj();
+    for (auto &Producers : {std::make_pair(Obj->getLanguages(), &Languages),
+                            std::make_pair(Obj->getTools(), &Tools),
+                            std::make_pair(Obj->getSDKs(), &SDKs)}) {
+      llvm::SmallSet<StringRef, 8> SeenProducers;
+      for (auto &Producer : Producers.first) {
+        if (SeenProducers.insert(Producer.first).second) {
+          Producers.second->push_back(Producer);
+        }
+      }
+    }
+  }
+  int Fields =
+      int(!Languages.empty()) + int(!Tools.empty()) + int(!SDKs.empty());
+  if (Fields == 0)
+    return;
+  SyntheticSection *Section =
+      createSyntheticSection(WASM_SEC_CUSTOM, "producers");
+  auto &OS = Section->getStream();
+  writeUleb128(OS, Fields, "field count");
+  for (auto &Field : {std::make_pair(StringRef("language"), Languages),
+                      std::make_pair(StringRef("processed-by"), Tools),
+                      std::make_pair(StringRef("sdk"), SDKs)}) {
+    if (Field.second.empty())
+      continue;
+    writeStr(OS, Field.first, "field name");
+    writeUleb128(OS, Field.second.size(), "number of entries");
+    for (auto &Entry : Field.second) {
+      writeStr(OS, Entry.first, "producer name");
+      writeStr(OS, Entry.second, "producer version");
+    }
+  }
+}
+
 void Writer::writeHeader() {
   memcpy(Buffer->getBufferStart(), Header.data(), Header.size());
 }
 
 void Writer::writeSections() {
   uint8_t *Buf = Buffer->getBufferStart();
   parallelForEach(OutputSections, [Buf](OutputSection *S) { S->writeTo(Buf); });
 }
void Writer::createSections() {
   createCodeSection();
   createDataSection();
   createCustomSections();
 
   // Custom sections
   if (Config->Relocatable) {
     createLinkingSection();
     createRelocSections();
   }
   if (!Config->StripDebug && !Config->StripAll)
     createNameSection();
 
+  if (!Config->StripAll)
+    createProducersSection();
+
   for (OutputSection *S : OutputSections) {
     S->setOffset(FileSize);
     S->finalizeContents();
     FileSize += S->getSize();
   }
 }
 
 void Writer::calculateImports() {