[BOLT][NFC] Handle "dynamic section sizes should match"

[Amir]

Summary

Address fuzzer crash on malformed input

[rafauler]

LGTM

bolt/include/bolt/Rewrite/RewriteInstance.h

private:
   /// Disassemble aarch64-specific .plt \p Section auxiliary function
   void disassemblePLTSectionAArch64(BinarySection &Section);
 
   /// Disassemble X86-specific .plt \p Section auxiliary function. \p EntrySize
   /// is the expected .plt \p Section entry function size.
   void disassemblePLTSectionX86(BinarySection &Section, uint64_t EntrySize);
 
   /// ELF-specific part. TODO: refactor into new class.
-#define ELF_FUNCTION(FUNC)                                                     \
-  template <typename ELFT> void FUNC(object::ELFObjectFile<ELFT> *Obj);        \
-  void FUNC() {                                                                \
+#define ELF_FUNCTION(TYPE, FUNC)                                               \
+  template <typename ELFT> TYPE FUNC(object::ELFObjectFile<ELFT> *Obj);        \
+  TYPE FUNC() {                                                                \
     if (auto *ELF32LE = dyn_cast<object::ELF32LEObjectFile>(InputFile))        \
       return FUNC(ELF32LE);                                                    \
     if (auto *ELF64LE = dyn_cast<object::ELF64LEObjectFile>(InputFile))        \
       return FUNC(ELF64LE);                                                    \
     if (auto *ELF32BE = dyn_cast<object::ELF32BEObjectFile>(InputFile))        \
       return FUNC(ELF32BE);                                                    \
     auto *ELF64BE = cast<object::ELF64BEObjectFile>(InputFile);                \
     return FUNC(ELF64BE);                                                      \
   }
 
   /// Patch ELF book-keeping info.
   void patchELFPHDRTable();
 
   /// Create section header table.
-  ELF_FUNCTION(patchELFSectionHeaderTable);
+  ELF_FUNCTION(void, patchELFSectionHeaderTable);
 
   /// Create the regular symbol table and patch dyn symbol tables.
-  ELF_FUNCTION(patchELFSymTabs);
+  ELF_FUNCTION(void, patchELFSymTabs);
 
   /// Read dynamic section/segment of ELF.
-  ELF_FUNCTION(readELFDynamic);
+  ELF_FUNCTION(Error, readELFDynamic);
 
   /// Patch dynamic section/segment of ELF.
-  ELF_FUNCTION(patchELFDynamic);
+  ELF_FUNCTION(void, patchELFDynamic);
 
   /// Patch .got
-  ELF_FUNCTION(patchELFGOT);
+  ELF_FUNCTION(void, patchELFGOT);
 
   /// Patch allocatable relocation sections.
-  ELF_FUNCTION(patchELFAllocatableRelaSections);
+  ELF_FUNCTION(void, patchELFAllocatableRelaSections);
 
   /// Finalize memory image of section header string table.
-  ELF_FUNCTION(finalizeSectionStringTable);
+  ELF_FUNCTION(void, finalizeSectionStringTable);
 
   /// Return a name of the input file section in the output file.
   template <typename ELFObjType, typename ELFShdrTy>
   std::string getOutputSectionName(const ELFObjType &Obj,
                                    const ELFShdrTy &Section);
 
   /// Return a list of all sections to include in the output binary.
   /// Populate \p NewSectionIndex with a map of input to output indices.

bolt/lib/Rewrite/RewriteInstance.cpp

Error RewriteInstance::readSpecialSections() {
   // Parse build-id
   parseBuildID();
   if (Optional<std::string> FileBuildID = getPrintableBuildID())
     BC->setFileBuildID(*FileBuildID);
 
   parseSDTNotes();
 
   // Read .dynamic/PT_DYNAMIC.
-  readELFDynamic();
-  return Error::success();
+  return readELFDynamic();
 }
 
 void RewriteInstance::adjustCommandLineOptions() {
   if (BC->isAArch64() && !BC->HasRelocations)
     errs() << "BOLT-WARNING: non-relocation mode for AArch64 is not fully "
               "supported\n";
 
   if (RuntimeLibrary *RtLibrary = BC->getRuntimeLibrary())
if (BC->RequiresZNow && !ZNowSet) {
     errs() << "BOLT-ERROR: output binary requires immediate relocation "
               "processing which depends on DT_FLAGS or DT_FLAGS_1 presence in "
               ".dynamic. Please re-link the binary with -znow.\n";
     exit(1);
   }
 }
 
 template <typename ELFT>
-void RewriteInstance::readELFDynamic(ELFObjectFile<ELFT> *File) {
+Error RewriteInstance::readELFDynamic(ELFObjectFile<ELFT> *File) {
   const ELFFile<ELFT> &Obj = File->getELFFile();
 
   using Elf_Phdr = typename ELFFile<ELFT>::Elf_Phdr;
   using Elf_Dyn = typename ELFFile<ELFT>::Elf_Dyn;
 
   // Locate DYNAMIC by looking through program headers.
   const Elf_Phdr *DynamicPhdr = 0;
   for (const Elf_Phdr &Phdr : cantFail(Obj.program_headers())) {
     if (Phdr.p_type == ELF::PT_DYNAMIC) {
       DynamicPhdr = &Phdr;
       break;
     }
   }
 
   if (!DynamicPhdr) {
     outs() << "BOLT-INFO: static input executable detected\n";
     // TODO: static PIE executable might have dynamic header
     BC->IsStaticExecutable = true;
-    return;
+    return Error::success();
   }
 
-  assert(DynamicPhdr->p_memsz == DynamicPhdr->p_filesz &&
+  if (DynamicPhdr->p_memsz != DynamicPhdr->p_filesz)
+    return createStringError(errc::executable_format_error,
                              "dynamic section sizes should match");
 
   // Go through all dynamic entries to locate entries of interest.
   typename ELFT::DynRange DynamicEntries =
       cantFail(Obj.dynamicEntries(), "error accessing dynamic table");
 
   for (const Elf_Dyn &Dyn : DynamicEntries) {
     switch (Dyn.d_tag) {
     case ELF::DT_INIT:
if (!DynamicRelocationsAddress || !DynamicRelocationsSize) {
     DynamicRelocationsAddress.reset();
     DynamicRelocationsSize = 0;
   }
 
   if (!PLTRelocationsAddress || !PLTRelocationsSize) {
     PLTRelocationsAddress.reset();
     PLTRelocationsSize = 0;
   }
+  return Error::success();
 }
 
 uint64_t RewriteInstance::getNewFunctionAddress(uint64_t OldAddress) {
   const BinaryFunction *Function = BC->getBinaryFunctionAtAddress(OldAddress);
   if (!Function)
     return 0;
 
   assert(!Function->isFragment() && "cannot get new address for a fragment");