ELF: Implement --build-id=md5.

[ruiu]

Summary

ELF: Implement --build-id=md5.

ELF/Config.h

 //===- Config.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_CONFIG_H
 #define LLD_ELF_CONFIG_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ELF.h"
 
 #include <vector>
 
 namespace lld {
 namespace elf {
 
 class InputFile;
 class SymbolBody;
 
 enum ELFKind {
   ELFNoneKind,
   ELF32LEKind,
   ELF32BEKind,
   ELF64LEKind,
   ELF64BEKind
 };
 
+struct BuildIdBuilder {
+  void (*write)(uint8_t *Buf, std::vector<llvm::ArrayRef<uint8_t>> &Inputs);
+  size_t Size;
+};
+
 // This struct contains the global configuration for the linker.
 // Most fields are direct mapping from the command line options
 // and such fields have the same name as the corresponding options.
 // Most fields are initialized by the driver.
 struct Configuration {
   SymbolBody *EntrySym = nullptr;
   SymbolBody *MipsGpDisp = nullptr;
   SymbolBody *MipsLocalGp = nullptr;
   InputFile *FirstElf = nullptr;
   llvm::StringRef DynamicLinker;
   llvm::StringRef Entry;
   llvm::StringRef Emulation;
   llvm::StringRef Fini;
   llvm::StringRef Init;
   llvm::StringRef OutputFile;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   std::string RPath;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> Undefined;
   bool AllowMultipleDefinition;
   bool AsNeeded = false;
   bool Bsymbolic;
   bool BsymbolicFunctions;
-  bool BuildId;
   bool Demangle = true;
   bool DiscardAll;
   bool DiscardLocals;
   bool DiscardNone;
   bool EhFrameHdr;
   bool EnableNewDtags;
   bool ExportDynamic;
   bool GcSections;
struct Configuration {
   bool SysvHash = true;
   bool Threads;
   bool Verbose;
   bool ZExecStack;
   bool ZNodelete;
   bool ZNow;
   bool ZOrigin;
   bool ZRelro;
+  BuildIdBuilder *BuildId = nullptr;
   ELFKind EKind = ELFNoneKind;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   uint64_t EntryAddr = -1;
   unsigned Optimize = 0;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/Driver.h

 
 void printHelp(const char *Argv0);
 void printVersion();
 
 std::string findFromSearchPaths(StringRef Path);
 std::string searchLibrary(StringRef Path);
 std::string buildSysrootedPath(llvm::StringRef Dir, llvm::StringRef File);
 
+extern BuildIdBuilder BuildIdFnv1;
+extern BuildIdBuilder BuildIdMd5;
+
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/Driver.cpp

if (auto *Arg = Args.getLastArg(OPT_m)) {
     StringRef S = Arg->getValue();
     std::tie(Config->EKind, Config->EMachine) = parseEmulation(S);
     Config->Emulation = S;
   }
 
   Config->AllowMultipleDefinition = Args.hasArg(OPT_allow_multiple_definition);
   Config->Bsymbolic = Args.hasArg(OPT_Bsymbolic);
   Config->BsymbolicFunctions = Args.hasArg(OPT_Bsymbolic_functions);
-  Config->BuildId = Args.hasArg(OPT_build_id);
   Config->Demangle = !Args.hasArg(OPT_no_demangle);
   Config->DiscardAll = Args.hasArg(OPT_discard_all);
   Config->DiscardLocals = Args.hasArg(OPT_discard_locals);
   Config->DiscardNone = Args.hasArg(OPT_discard_none);
   Config->EhFrameHdr = Args.hasArg(OPT_eh_frame_hdr);
   Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);
   Config->GcSections = Args.hasArg(OPT_gc_sections);
if (S == "gnu") {
       Config->GnuHash = true;
       Config->SysvHash = false;
     } else if (S == "both") {
       Config->GnuHash = true;
     } else if (S != "sysv")
       error("Unknown hash style: " + S);
   }
 
+  // Parse --build-id or --build-id=<style>.
+  if (Args.hasArg(OPT_build_id))
+    Config->BuildId = &BuildIdFnv1;
+  if (auto *Arg = Args.getLastArg(OPT_build_id_eq)) {
+    StringRef S = Arg->getValue();
+    if (S == "md5") {
+      Config->BuildId = &BuildIdMd5;
+    } else
+      error("unknown --build-id style: " + S);
+  }
+
   for (auto *Arg : Args.filtered(OPT_undefined))
     Config->Undefined.push_back(Arg->getValue());
 }
 
 void LinkerDriver::createFiles(opt::InputArgList &Args) {
   for (auto *Arg : Args) {
     switch (Arg->getOption().getID()) {
     case OPT_l:

ELF/DriverUtils.cpp

 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 #include "Error.h"
 #include "lld/Config/Version.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/MD5.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/StringSaver.h"
 
 using namespace llvm;
 
 using namespace lld;
 using namespace lld::elf;
+using namespace llvm::support::endian;
 
 // Create OptTable
 
 // Create prefix string literals used in Options.td
 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
 #include "Options.inc"
 #undef PREFIX
 

 std::string elf::buildSysrootedPath(StringRef Dir, StringRef File) {
   SmallString<128> Path;
   if (Dir.startswith("="))
     sys::path::append(Path, Config->Sysroot, Dir.substr(1), File);
   else
     sys::path::append(Path, Dir, File);
   return Path.str();
 }
+
+static void writeFnv1(uint8_t *Buf, std::vector<ArrayRef<uint8_t>> &V) {
+  // Compute the 64-bit FNV-1 hash for V and write it to Buf.
+  uint64_t Hash = 0xcbf29ce484222325;
+  for (ArrayRef<uint8_t> Arr : V) {
+    for (uint8_t B : Arr) {
+      Hash *= 0x100000001b3;
+      Hash ^= B;
+    }
+  }
+  write64le(Buf, Hash);
+}
+
+static void writeMd5(uint8_t *Buf, std::vector<ArrayRef<uint8_t>> &V) {
+  MD5 Hash;
+  for (ArrayRef<uint8_t> Arr : V)
+    Hash.update(Arr);
+  MD5::MD5Result Res;
+  Hash.final(Res);
+  memcpy(Buf, Res, 16);
+}
+
+BuildIdBuilder elf::BuildIdFnv1 = {writeFnv1, 8};
+BuildIdBuilder elf::BuildIdMd5 = {writeMd5, 16};

ELF/Options.td

def Bdynamic: Flag<["-"], "Bdynamic">,
   HelpText<"Link against shared libraries">;
 
 def Bstatic: Flag<["-"], "Bstatic">,
   HelpText<"Do not link against shared libraries">;
 
 def build_id : Flag<["--", "-"], "build-id">,
   HelpText<"Generate build ID note">;
 
+def build_id_eq : Joined<["--", "-"], "build-id=">;
+
 def L : JoinedOrSeparate<["-"], "L">, MetaVarName<"<dir>">,
   HelpText<"Directory to search for libraries">;
 
 def O : Joined<["-"], "O">, HelpText<"Optimize">;
 
 def allow_multiple_definition: Flag<["--"], "allow-multiple-definition">,
   HelpText<"Allow multiple definitions">;
 

ELF/OutputSections.h

 class BuildIdSection final : public OutputSectionBase<ELFT> {
 public:
   BuildIdSection();
   void writeTo(uint8_t *Buf) override;
   void update(ArrayRef<uint8_t> Buf);
   void writeBuildId();
 
 private:
-  uint64_t Hash = 0xcbf29ce484222325; // FNV1 hash basis
+  std::vector<ArrayRef<uint8_t>> Inputs;
   uint8_t *HashBuf;
 };
 
 // All output sections that are hadnled by the linker specially are
 // globally accessible. Writer initializes them, so don't use them
 // until Writer is initialized.
 template <class ELFT> struct Out {
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;

ELF/OutputSections.cpp

uint8_t SymbolTableSection<ELFT>::getSymbolBinding(SymbolBody *Body) {
   if (isa<DefinedSynthetic<ELFT>>(Body))
     return STB_LOCAL;
   return Body->isWeak() ? STB_WEAK : STB_GLOBAL;
 }
 
 template <class ELFT>
 BuildIdSection<ELFT>::BuildIdSection()
     : OutputSectionBase<ELFT>(".note.gnu.build-id", SHT_NOTE, SHF_ALLOC) {
-  // 16 bytes for the note section header and 8 bytes for FNV1 hash.
-  this->Header.sh_size = 24;
+  // 16 bytes for the note section header.
+  this->Header.sh_size = 16 + Config->BuildId->Size;
 }
 
 template <class ELFT> void BuildIdSection<ELFT>::writeTo(uint8_t *Buf) {
   const endianness E = ELFT::TargetEndianness;
-  write32<E>(Buf, 4);                   // Name size
-  write32<E>(Buf + 4, sizeof(Hash));    // Content size
-  write32<E>(Buf + 8, NT_GNU_BUILD_ID); // Type
-  memcpy(Buf + 12, "GNU", 4);           // Name string
+  write32<E>(Buf, 4);                         // Name size
+  write32<E>(Buf + 4, Config->BuildId->Size); // Content size
+  write32<E>(Buf + 8, NT_GNU_BUILD_ID);       // Type
+  memcpy(Buf + 12, "GNU", 4);                 // Name string
   HashBuf = Buf + 16;
 }
 
 template <class ELFT> void BuildIdSection<ELFT>::update(ArrayRef<uint8_t> Buf) {
-  // 64-bit FNV1 hash
-  const uint64_t Prime = 0x100000001b3;
-  for (uint8_t B : Buf) {
-    Hash *= Prime;
-    Hash ^= B;
-  }
+  Inputs.push_back(Buf);
 }
 
 template <class ELFT> void BuildIdSection<ELFT>::writeBuildId() {
-  const endianness E = ELFT::TargetEndianness;
-  write64<E>(HashBuf, Hash);
+  Config->BuildId->write(HashBuf, Inputs);
 }
 
 template <class ELFT>
 MipsReginfoOutputSection<ELFT>::MipsReginfoOutputSection()
     : OutputSectionBase<ELFT>(".reginfo", SHT_MIPS_REGINFO, SHF_ALLOC) {
   this->Header.sh_addralign = 4;
   this->Header.sh_entsize = sizeof(Elf_Mips_RegInfo);
   this->Header.sh_size = sizeof(Elf_Mips_RegInfo);

test/ELF/build-id.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: ld.lld --build-id %t -o %t2
-# RUN: llvm-objdump -s %t2 | FileCheck -check-prefix=BUILDID %s
+# RUN: llvm-objdump -s %t2 | FileCheck -check-prefix=DEFAULT %s
+# RUN: ld.lld --build-id=md5 %t -o %t2
+# RUN: llvm-objdump -s %t2 | FileCheck -check-prefix=MD5 %s
 # RUN: ld.lld %t -o %t2
-# RUN: llvm-objdump -s %t2 | FileCheck -check-prefix=NO-BUILDID %s
+# RUN: llvm-objdump -s %t2 | FileCheck -check-prefix=NONE %s
 
 .globl _start;
 _start:
   nop
 
-# BUILDID:      Contents of section .note.gnu.build-id:
-# BUILDID-NEXT: 04000000 08000000 03000000 474e5500  ............GNU.
+# DEFAULT:      Contents of section .note.gnu.build-id:
+# DEFAULT-NEXT: 04000000 08000000 03000000 474e5500  ............GNU.
 
-# NO-BUILDID-NOT: Contents of section .note.gnu.build-id:
+# MD5:      Contents of section .note.gnu.build-id:
+# MD5-NEXT: 04000000 10000000 03000000 474e5500  ............GNU.
+
+# NONE-NOT: Contents of section .note.gnu.build-id: