[Object][COFF] Add table ptr checks but don't hard-error

[alvinhochun]

Summary

When loading split debug files for PE/COFF executables (produced with
objcopy --only-keep-debug), the tables or directories in such files
may not exist. COFFObjectFile shall check the pointers to make sure they
are not out of bounds. One such check already exists for
initImportTablePtr. However, this check forces an error and prevents
the object file from being loaded, which means the file could not be
used as debug info in LLDB. To fix this, it is sufficient to just hide
the error and pretend the import table does not exist for the object
file.

In the same way, other functions which load the pointers for other
tables should also contain similar pointer checks, but none of these
functions actually have the check in place. This commit adds these
missing checks.

Fixes https://github.com/mstorsjo/llvm-mingw/issues/284

[mstorsjo]

This needs a testcase - maybe one for llvm-readobj or llvm-objdump, to make sure it doesn't error out on such an object file. I believe you're familiar with the obj2yaml/yaml2obj kind of test object files used (based on some other patch of yours) - I guess it should be kinda doable to pick an existing minimal-ish yaml for e.g. an executable, and modify it to reach the state where the import tables point out of bounds, to trigger the issue (producing a case that didn't use to work before but now works).

llvm/lib/Object/COFFObjectFile.cpp

608

The // ! comments should be left out when upstreaming the patch.

[alvinhochun]

Replacing with https://reviews.llvm.org/D126898

llvm/lib/Object/COFFObjectFile.cpp

Error COFFObjectFile::initImportTablePtr() {
 
   uint32_t ImportTableRva = DataEntry->RelativeVirtualAddress;
 
   // Find the section that contains the RVA. This is needed because the RVA is
   // the import table's memory address which is different from its file offset.
   uintptr_t IntPtr = 0;
   if (Error E = getRvaPtr(ImportTableRva, IntPtr, "import table"))
     return E;
-  if (Error E = checkOffset(Data, IntPtr, DataEntry->Size))
-    return E;
+  if (Error E = checkOffset(Data, IntPtr, DataEntry->Size)) {
+    consumeError(std::move(E));
+    return Error::success();
+  }
+
   ImportDirectory = reinterpret_cast<
       const coff_import_directory_table_entry *>(IntPtr);
   return Error::success();
 }
 
 // Initializes DelayImportDirectory and NumberOfDelayImportDirectory.
 Error COFFObjectFile::initDelayImportTablePtr() {
   const data_directory *DataEntry =
       getDataDirectory(COFF::DELAY_IMPORT_DESCRIPTOR);
   if (!DataEntry)
     return Error::success();
   if (DataEntry->RelativeVirtualAddress == 0)
     return Error::success();
 
   uint32_t RVA = DataEntry->RelativeVirtualAddress;
   NumberOfDelayImportDirectory = DataEntry->Size /
       sizeof(delay_import_directory_table_entry) - 1;
 
   uintptr_t IntPtr = 0;
   if (Error E = getRvaPtr(RVA, IntPtr, "delay import table"))
     return E;
+  if (Error E = checkOffset(Data, IntPtr, DataEntry->Size)) { // !
+    consumeError(std::move(E));
+    return Error::success();
+  }
+
   DelayImportDirectory = reinterpret_cast<
       const delay_import_directory_table_entry *>(IntPtr);
   return Error::success();
 }
 
 // Find the export table.
 Error COFFObjectFile::initExportTablePtr() {
   // First, we get the RVA of the export table. If the file lacks a pointer to
   // the export table, do nothing.
   const data_directory *DataEntry = getDataDirectory(COFF::EXPORT_TABLE);
   if (!DataEntry)
     return Error::success();
 
   // Do nothing if the pointer to export table is NULL.
   if (DataEntry->RelativeVirtualAddress == 0)
     return Error::success();
 
   uint32_t ExportTableRva = DataEntry->RelativeVirtualAddress;
   uintptr_t IntPtr = 0;
   if (Error E = getRvaPtr(ExportTableRva, IntPtr, "export table"))
     return E;
+  if (Error E = checkOffset(Data, IntPtr, DataEntry->Size)) { // !
+    consumeError(std::move(E));
+    return Error::success();
+  }
+
   ExportDirectory =
       reinterpret_cast<const export_directory_table_entry *>(IntPtr);
   return Error::success();
 }
 
 Error COFFObjectFile::initBaseRelocPtr() {
   const data_directory *DataEntry =
       getDataDirectory(COFF::BASE_RELOCATION_TABLE);
   if (!DataEntry)
     return Error::success();
   if (DataEntry->RelativeVirtualAddress == 0)
     return Error::success();
 
   uintptr_t IntPtr = 0;
   if (Error E = getRvaPtr(DataEntry->RelativeVirtualAddress, IntPtr,
                           "base reloc table"))
     return E;
+  if (Error E = checkOffset(Data, IntPtr, DataEntry->Size)) { // !
+    consumeError(std::move(E));
+    return Error::success();
+  }
+
   BaseRelocHeader = reinterpret_cast<const coff_base_reloc_block_header *>(
       IntPtr);
   BaseRelocEnd = reinterpret_cast<coff_base_reloc_block_header *>(
       IntPtr + DataEntry->Size);
   // FIXME: Verify the section containing BaseRelocHeader has at least
   // DataEntry->Size bytes after DataEntry->RelativeVirtualAddress.
   return Error::success();
 }
Error COFFObjectFile::initDebugDirectoryPtr() {
   if (DataEntry->Size % sizeof(debug_directory) != 0)
     return createStringError(object_error::parse_failed,
                              "debug directory has uneven size");
 
   uintptr_t IntPtr = 0;
   if (Error E = getRvaPtr(DataEntry->RelativeVirtualAddress, IntPtr,
                           "debug directory"))
     return E;
+  if (Error E = checkOffset(Data, IntPtr, DataEntry->Size)) { // !
+    consumeError(std::move(E));
+    return Error::success();
+  }
+
   DebugDirectoryBegin = reinterpret_cast<const debug_directory *>(IntPtr);
   DebugDirectoryEnd = reinterpret_cast<const debug_directory *>(
       IntPtr + DataEntry->Size);
   // FIXME: Verify the section containing DebugDirectoryBegin has at least
   // DataEntry->Size bytes after DataEntry->RelativeVirtualAddress.
   return Error::success();
 }
 
return createStringError(
         object_error::parse_failed,
         "TLS Directory size (%u) is not the expected size (%" PRIu64 ").",
         static_cast<uint32_t>(DataEntry->Size), DirSize);
 
   uintptr_t IntPtr = 0;
   if (Error E =
           getRvaPtr(DataEntry->RelativeVirtualAddress, IntPtr, "TLS directory"))
     return E;
+  if (Error E = checkOffset(Data, IntPtr, DataEntry->Size)) {
+    consumeError(std::move(E));
+    return Error::success();
+  }
 
   if (is64())
     TLSDirectory64 = reinterpret_cast<const coff_tls_directory64 *>(IntPtr);
   else
     TLSDirectory32 = reinterpret_cast<const coff_tls_directory32 *>(IntPtr);
 
   return Error::success();
 }
 
 Error COFFObjectFile::initLoadConfigPtr() {
   // Get the RVA of the debug directory. Do nothing if it does not exist.
   const data_directory *DataEntry = getDataDirectory(COFF::LOAD_CONFIG_TABLE);
   if (!DataEntry)
     return Error::success();
 
   // Do nothing if the RVA is NULL.
   if (DataEntry->RelativeVirtualAddress == 0)
     return Error::success();
   uintptr_t IntPtr = 0;
   if (Error E = getRvaPtr(DataEntry->RelativeVirtualAddress, IntPtr,
                           "load config table"))
     return E;
+  if (Error E = checkOffset(Data, IntPtr, DataEntry->Size)) { // !
+    consumeError(std::move(E));
+    return Error::success();
+  }
 
   LoadConfig = (const void *)IntPtr;
   return Error::success();
 }
 
 Expected<std::unique_ptr<COFFObjectFile>>
 COFFObjectFile::create(MemoryBufferRef Object) {
   std::unique_ptr<COFFObjectFile> Obj(new COFFObjectFile(std::move(Object)));