[llvm-readobj] Only print the real size of the note

[phosek]

Summary

Note payloads are padded to a multiple of 4 bytes in size, but the size of the string that should be print can be smaller e.g. the n_descsz field in gold's version note is 9, so that's the whole size of the string that should be printed. The padding is part of the format of a SHT_NOTE section or PT_NOTE segment, but it's not part of the note itself.

Printing the extra null bytes may confuse some tools, e.g. when the llvm-readobj is sent to grep, it treats the output as binary because it contains a null byte.

[mcgrathr]

LGTM.

This tool really should validate all its input's size fields, but that's a separate issue from this change and needs to be done here for n_namesz as well as n_descsz, and presumably lots of other places throughout the tool(s). binutils and elfutils have had volunteers doing input fuzzing that found many such holes. LLVM's ELF tools could use some of that too.

Neither binutils nor elfutils does anything about unprintable bytes in the contents of NT_GNU_GOLD_VERSION, but both do stop printing at the first '\0' (so if they'd had the printing-the-padding bug too it might have gone unnoticed since it wouldn't had affected the output when the first padding byte was zero, which in practice it always is). I'm willing to call it a feature to print the whole string rather than truncating it at the first '\0', but I'll point out the difference with other tools for the record.

tools/llvm-readobj/ELFDumper.cpp

static std::string getFreeBSDNoteTypeName(const uint32_t NT) {
   std::string string;
   raw_string_ostream OS(string);
   OS << format("Unknown note type (0x%08x)", NT);
   return string;
 }
 
 template <typename ELFT>
 static void printGNUNote(raw_ostream &OS, uint32_t NoteType,
-                         ArrayRef<typename ELFFile<ELFT>::Elf_Word> Words) {
+                         ArrayRef<typename ELFFile<ELFT>::Elf_Word> Words,
+                         size_t Size) {
   switch (NoteType) {
   default:
     return;
   case ELF::NT_GNU_ABI_TAG: {
     static const char *OSNames[] = {
         "Linux", "Hurd", "Solaris", "FreeBSD", "NetBSD", "Syllable", "NaCl",
     };
 
     StringRef OSName = "Unknown";
     if (Words[0] < array_lengthof(OSNames))
       OSName = OSNames[Words[0]];
     uint32_t Major = Words[1], Minor = Words[2], Patch = Words[3];
 
     if (Words.size() < 4)
       OS << "    <corrupt GNU_ABI_TAG>";
     else
       OS << "    OS: " << OSName << ", ABI: " << Major << "." << Minor << "."
          << Patch;
     break;
   }
   case ELF::NT_GNU_BUILD_ID: {
     OS << "    Build ID: ";
-    ArrayRef<uint8_t> ID(reinterpret_cast<const uint8_t *>(Words.data()),
-                         Words.size() * 4);
+    ArrayRef<uint8_t> ID(reinterpret_cast<const uint8_t *>(Words.data()), Size);
     for (const auto &B : ID)
       OS << format_hex_no_prefix(B, 2);
     break;
   }
   case ELF::NT_GNU_GOLD_VERSION:
     OS << "    Version: "
-       << StringRef(reinterpret_cast<const char *>(Words.data()),
-                    Words.size() * 4);
+       << StringRef(reinterpret_cast<const char *>(Words.data()), Size);
     break;
   }
 
   OS << '\n';
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) {
while (P < E) {
         Name =
             StringRef(reinterpret_cast<const char *>(&Words[3]), NameSize - 1);
 
       OS << "  " << Name << std::string(22 - NameSize, ' ')
          << format_hex(DescriptorSize, 10) << '\t';
 
       if (Name == "GNU") {
         OS << getGNUNoteTypeName(Type) << '\n';
-        printGNUNote<ELFT>(OS, Type, Descriptor);
+        printGNUNote<ELFT>(OS, Type, Descriptor, DescriptorSize);
       } else if (Name == "FreeBSD") {
         OS << getFreeBSDNoteTypeName(Type) << '\n';
       } else {
         OS << "Unknown note type: (" << format_hex(Type, 10) << ')';
       }
       OS << '\n';
 
       P = P + 3 * sizeof(Elf_Word) + alignTo<4>(NameSize) +