[llvm-objcopy] Add --add-gnu-debuglink

[jakehehrlich]

Summary

This change adds support for --add-gnu-debuglink to llvm-objcopy

[jhenderson]

tools/llvm-objcopy/Object.cpp

359–360

"turns out to be fine" implies that you don't know the underlying code. I think it might be better to remove this first sentence and simply say "For sections not found in segments, OriginalOffset is only used to establish the order that sections should go in."

364

Why not use std::numeric_limits<uint64_t>::max()?

384

Could this also supply the appropriate error message, please, e.g. "file not found" or "access denied".

tools/llvm-objcopy/llvm-objcopy.cpp

121

Has this line been clang-formatted?

[jakehehrlich]

1. Used numeric limits max instead of a cast and bitwise hack
2. Modified comment
3. Clang formated add-gnu-debuglink
4. Updated error message to display the specific error not just the vague "could not be opened" message.

[jhenderson]

LGTM, with one change.

tools/llvm-objcopy/Object.h

362–363

Do you need this constructor? It's not called anywhere as far as I can see?

test/tools/llvm-objcopy/add-gnu-debuglink.test

+# RUN: yaml2obj %s > %t
+# RUN: printf 0000 > %t.blob
+# RUN: llvm-objcopy -add-gnu-debuglink=%t.blob %t %t2
+# RUN: llvm-readobj -sections -section-data %t2 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+
+# CHECK:       Name: .gnu_debuglink
+# CHECK-NEXT:  Type: SHT_PROGBITS (0x1)
+# CHECK-NEXT:  Flags [ (0x0)
+# CHECK-NEXT:  ]
+# CHECK-NEXT:  Address: 0x0
+# CHECK-NEXT:  Offset:
+# CHECK-NEXT:  Size: 32
+# CHECK-NEXT:  Link: 0
+# CHECK-NEXT:  Info: 0
+# CHECK-NEXT:  AddressAlignment: 4
+# CHECK-NEXT:  EntrySize: 0
+# CHECK-NEXT:  SectionData (
+# CHECK-NEXT:      0000: 6164642D 676E752D 64656275 676C696E  |add-gnu-debuglin|
+# CHECK-NEXT:      0010: 6B2E7465 73742E74 6D700000 72C49B0C  |k.test.tmp..r...|
+# CHECK-NEXT:  )

tools/llvm-objcopy/Object.h

 #define LLVM_TOOLS_OBJCOPY_OBJECT_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Support/JamCRC.h"
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <set>
 #include <vector>
 
 namespace llvm {
public:
 
   static bool classof(const SectionBase *S) {
     if (!(S->Flags & ELF::SHF_ALLOC))
       return false;
     return S->Type == ELF::SHT_REL || S->Type == ELF::SHT_RELA;
   }
 };
 
+template <class ELFT> class GnuDebugLinkSection : public SectionBase {
+private:
+  // Elf_Word is 4-bytes on every format but has the same endianess as the elf
+  // type ELFT. We'll need to write the CRC32 out in the proper endianess so
+  // we'll make sure to use this type.
+  using Elf_Word = typename ELFT::Word;
+
+  StringRef FileName;
+  uint32_t CRC32;
+
+  void init(StringRef File, StringRef Data);
+
+public:
+  // If we add this section from an internal source we can use this ctor.
+  GnuDebugLinkSection(StringRef File, StringRef Data);
+
+  // If we add this section from an external source we can use this ctor.
+  GnuDebugLinkSection(StringRef File);
+  void writeSection(FileOutputBuffer &Out) const override;
+};
+
 template <class ELFT> class Object {
 private:
   using SecPtr = std::unique_ptr<SectionBase>;
   using SegPtr = std::unique_ptr<Segment>;
 
   using Elf_Shdr = typename ELFT::Shdr;
   using Elf_Ehdr = typename ELFT::Ehdr;
   using Elf_Phdr = typename ELFT::Phdr;
public:
 
   Object(const object::ELFObjectFile<ELFT> &Obj);
   virtual ~Object() = default;
 
   SymbolTableSection *getSymTab() const { return SymbolTable; }
   const SectionBase *getSectionHeaderStrTab() const { return SectionNames; }
   void removeSections(std::function<bool(const SectionBase &)> ToRemove);
   void addSection(StringRef SecName, ArrayRef<uint8_t> Data);
+  void addGnuDebugLink(StringRef File);
   virtual size_t totalSize() const = 0;
   virtual void finalize() = 0;
   virtual void write(FileOutputBuffer &Out) const = 0;
 };
 
 template <class ELFT> class ELFObject : public Object<ELFT> {
 private:
   using SecPtr = std::unique_ptr<SectionBase>;

tools/llvm-objcopy/Object.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileOutputBuffer.h"
+#include "llvm/Support/Path.h"
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
if (StrTab->Type != SHT_STRTAB) {
     error("Link field value " + Twine(Link) + " in section " + Name +
           " is not a string table");
   }
   setStrTab(StrTab);
 }
 
 void SectionWithStrTab::finalize() { this->Link = StrTab->Index; }
 
+template <class ELFT>
+void GnuDebugLinkSection<ELFT>::init(StringRef File, StringRef Data) {
+  FileName = sys::path::stem(File);
+  // The format for the .gnu_debuglink starts with the stemmed file name and is
+  // followed by a null terminator and then the CRC32 of the file. The CRC32
+  // should be 4 byte aligned. So we add the FileName size, a 1 for the null
+  // byte, and then finally push the size to alignment and add 4.
+  Size = alignTo(FileName.size() + 1, 4) + 4;
+  // The CRC32 will only be aligned if we align the whole section.
+  Align = 4;
+  Type = ELF::SHT_PROGBITS;
+  Name = ".gnu_debuglink";
+  // For sections not found in segments, OriginalOffset is only used to
+  // establish the order that sections should go in. By using the maximum
+  // possible offset we cause this section to wind up at the end.
+  OriginalOffset = std::numeric_limits<uint64_t>::max();
+  JamCRC crc;
+  crc.update(ArrayRef<char>(Data.data(), Data.size()));
+  // The CRC32 value needs to be complemented because the JamCRC dosn't
+  // finalize the CRC32 value. It also dosn't negate the initial CRC32 value
+  // but it starts by default at 0xFFFFFFFF which is the complement of zero.
+  CRC32 = ~crc.getCRC();
+}
+
+template <class ELFT>
+GnuDebugLinkSection<ELFT>::GnuDebugLinkSection(StringRef File, StringRef Data) {
+  init(File, Data);
+}
+
+template <class ELFT>
+GnuDebugLinkSection<ELFT>::GnuDebugLinkSection(StringRef File)
+    : FileName(File) {
+  // Read in the file to compute the CRC of it.
+  auto DebugOrErr = MemoryBuffer::getFile(File);
+  if (!DebugOrErr)
+    error("'" + File + "': " + DebugOrErr.getError().message());
+  auto Debug = std::move(*DebugOrErr);
+  init(File, Debug->getBuffer());
+}
+
+template <class ELFT>
+void GnuDebugLinkSection<ELFT>::writeSection(FileOutputBuffer &Out) const {
+  auto Buf = Out.getBufferStart() + Offset;
+  char *File = reinterpret_cast<char *>(Buf);
+  Elf_Word *CRC = reinterpret_cast<Elf_Word *>(Buf + Size - sizeof(Elf_Word));
+  *CRC = CRC32;
+  std::copy(std::begin(FileName), std::end(FileName), File);
+}
+
 // Returns true IFF a section is wholly inside the range of a segment
 static bool sectionWithinSegment(const SectionBase &Section,
                                  const Segment &Segment) {
   // If a section is empty it should be treated like it has a size of 1. This is
   // to clarify the case when an empty section lies on a boundary between two
   // segments and ensures that the section "belongs" to the second segment and
   // not the first.
   uint64_t SecSize = Section.Size ? Section.Size : 1;

 
 template <class ELFT>
 void Object<ELFT>::addSection(StringRef SecName, ArrayRef<uint8_t> Data) {
   auto Sec = llvm::make_unique<OwnedDataSection>(SecName, Data);
   Sec->OriginalOffset = ~0ULL;
   Sections.push_back(std::move(Sec));
 }
 
+template <class ELFT> void Object<ELFT>::addGnuDebugLink(StringRef File) {
+  Sections.emplace_back(llvm::make_unique<GnuDebugLinkSection<ELFT>>(File));
+}
+
 template <class ELFT> void ELFObject<ELFT>::sortSections() {
   // Put all sections in offset order. Maintain the ordering as closely as
   // possible while meeting that demand however.
   auto CompareSections = [](const SecPtr &A, const SecPtr &B) {
     return A->OriginalOffset < B->OriginalOffset;
   };
   std::stable_sort(std::begin(this->Sections), std::end(this->Sections),
                    CompareSections);

tools/llvm-objcopy/llvm-objcopy.cpp

SplitDWO("split-dwo",
              cl::desc("Equivalent to extract-dwo on the input file to "
                       "<dwo-file>, then strip-dwo on the input file"),
              cl::value_desc("dwo-file"));
 static cl::list<std::string> AddSection(
     "add-section",
     cl::desc("Make a section named <section> with the contents of <file>."),
     cl::value_desc("section=file"));
 static cl::opt<bool> LocalizeHidden(
     "localize-hidden",
     cl::desc(
         "Mark all symbols that have hidden or internal visibility as local"));
+static cl::opt<std::string>
+    AddGnuDebugLink("add-gnu-debuglink",
+                    cl::desc("adds a .gnu_debuglink for <debug-file>"),
+                    cl::value_desc("debug-file"));
 
 using SectionPred = std::function<bool(const SectionBase &Sec)>;
 
 bool IsDWOSection(const SectionBase &Sec) { return Sec.Name.endswith(".dwo"); }
 
 template <class ELFT>
 bool OnlyKeepDWOPred(const Object<ELFT> &Obj, const SectionBase &Sec) {
   // We can't remove the section header string table.
for (const auto &Flag : AddSection) {
         reportError(File, BufOrErr.getError());
       auto Buf = std::move(*BufOrErr);
       auto BufPtr = reinterpret_cast<const uint8_t *>(Buf->getBufferStart());
       auto BufSize = Buf->getBufferSize();
       Obj->addSection(SecName, ArrayRef<uint8_t>(BufPtr, BufSize));
     }
   }
 
+  if (!AddGnuDebugLink.empty()) {
+    Obj->addGnuDebugLink(AddGnuDebugLink);
+  }
+
   Obj->finalize();
   WriteObjectFile(*Obj, OutputFilename.getValue());
 }
 
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);