Revert "[InstrProf] Make the IndexedInstrProf header backwards compatible."

This reverts commit 14cc41a020. [2/4]

llvm/include/llvm/ProfileData/InstrProf.h

@@ -1028,16 +1028,6 @@ struct Header {
   uint64_t Unused; // Becomes unused since version 4
   uint64_t HashType;
   uint64_t HashOffset;
-  // New fields should only be added at the end to ensure that the size
-  // computation is correct. The methods below need to be updated to ensure that
-  // the new field is read correctly.
-
-  // Reads a header struct from the buffer.
-  static Expected<Header> readFromBuffer(const unsigned char *Buffer);
-
-  // Returns the size of the header in bytes for all valid fields based on the
-  // version. I.e a older version header will return a smaller size.
-  size_t size() const;
 };
 
 // Profile summary data recorded in the profile data file in indexed

llvm/lib/ProfileData/InstrProf.cpp

@@ -51,7 +51,6 @@
 #include <memory>
 #include <string>
 #include <system_error>
-#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -1312,59 +1311,4 @@ void OverlapStats::dump(raw_fd_ostream &OS) const {
   }
 }
 
-namespace IndexedInstrProf {
-// A C++14 compatible version of the offsetof macro.
-template <typename T1, typename T2>
-inline size_t constexpr offsetOf(T1 T2::*Member) {
-  constexpr T2 Object{};
-  return size_t(&(Object.*Member)) - size_t(&Object);
-}
-
-static inline uint64_t read(const unsigned char *Buffer, size_t Offset) {
-  return *reinterpret_cast<const uint64_t *>(Buffer + Offset);
-}
-
-Expected<Header> Header::readFromBuffer(const unsigned char *Buffer) {
-  using namespace support;
-  static_assert(std::is_standard_layout<Header>::value,
-                "The header should be standard layout type since we use offset "
-                "of fields to read.");
-  Header H;
-
-  H.Magic = read(Buffer, offsetOf(&Header::Magic));
-  // Check the magic number.
-  uint64_t Magic = endian::byte_swap<uint64_t, little>(H.Magic);
-  if (Magic != IndexedInstrProf::Magic)
-    return make_error<InstrProfError>(instrprof_error::bad_magic);
-
-  // Read the version.
-  H.Version = read(Buffer, offsetOf(&Header::Version));
-  uint64_t FormatVersion = endian::byte_swap<uint64_t, little>(H.Version);
-  if (GET_VERSION(FormatVersion) >
-      IndexedInstrProf::ProfVersion::CurrentVersion)
-    return make_error<InstrProfError>(instrprof_error::unsupported_version);
-
-  switch (GET_VERSION(FormatVersion)) {
-  // When a new field is added in the header add a case statement here to
-  // populate it.
-  default:
-    H.HashType = read(Buffer, offsetOf(&Header::HashType));
-    H.HashOffset = read(Buffer, offsetOf(&Header::HashOffset));
-  }
-
-  return H;
-}
-
-size_t Header::size() const {
-  switch (GET_VERSION(Version)) {
-  // When a new field is added to the header add a case statement here to
-  // compute the size as offset of the new field + size of the new field. This
-  // relies on the field being added to the end of the list.
-  default:
-    return offsetOf(&Header::HashOffset) + sizeof(Header::HashOffset);
-  }
-}
-
-} // namespace IndexedInstrProf
-
 } // end namespace llvm

llvm/lib/ProfileData/InstrProfReader.cpp

@@ -934,17 +934,24 @@ Error IndexedInstrProfReader::readHeader() {
   if ((const unsigned char *)DataBuffer->getBufferEnd() - Cur < 24)
     return error(instrprof_error::truncated);
 
-  auto HeaderOr = IndexedInstrProf::Header::readFromBuffer(Start);
+  auto *Header = reinterpret_cast<const IndexedInstrProf::Header *>(Cur);
-  if (!HeaderOr)
+  Cur += sizeof(IndexedInstrProf::Header);
-    return HeaderOr.takeError();
 
-  const IndexedInstrProf::Header *Header = &HeaderOr.get();
+  // Check the magic number.
-  Cur += Header->size();
+  uint64_t Magic = endian::byte_swap<uint64_t, little>(Header->Magic);
+  if (Magic != IndexedInstrProf::Magic)
+    return error(instrprof_error::bad_magic);
 
-  Cur = readSummary((IndexedInstrProf::ProfVersion)Header->Version, Cur,
+  // Read the version.
+  uint64_t FormatVersion = endian::byte_swap<uint64_t, little>(Header->Version);
+  if (GET_VERSION(FormatVersion) >
+      IndexedInstrProf::ProfVersion::CurrentVersion)
+    return error(instrprof_error::unsupported_version);
+
+  Cur = readSummary((IndexedInstrProf::ProfVersion)FormatVersion, Cur,
                     /* UseCS */ false);
-  if (Header->Version & VARIANT_MASK_CSIR_PROF)
+  if (FormatVersion & VARIANT_MASK_CSIR_PROF)
-    Cur = readSummary((IndexedInstrProf::ProfVersion)Header->Version, Cur,
+    Cur = readSummary((IndexedInstrProf::ProfVersion)FormatVersion, Cur,
                       /* UseCS */ true);
 
   // Read the hash type and start offset.
@@ -956,8 +963,9 @@ Error IndexedInstrProfReader::readHeader() {
   uint64_t HashOffset = endian::byte_swap<uint64_t, little>(Header->HashOffset);
 
   // The rest of the file is an on disk hash table.
-  auto IndexPtr = std::make_unique<InstrProfReaderIndex<OnDiskHashTableImplV3>>(
+  auto IndexPtr =
-      Start + HashOffset, Cur, Start, HashType, Header->Version);
+      std::make_unique<InstrProfReaderIndex<OnDiskHashTableImplV3>>(
+          Start + HashOffset, Cur, Start, HashType, FormatVersion);
 
   // Load the remapping table now if requested.
   if (RemappingBuffer) {