[memprof] Fix frame deserialization on big endian systems.

[snehasish]

Summary

We write the memprof internal call frame data in little endian format.
However when reading the frame information we were casting it directly
to a MemProfRecord::Frame pointer. In this change we add a separate
deserialization method which uses an endian reader to read the bytes as
little endian.

This fixes https://lab.llvm.org/buildbot/#/builders/100/builds/12940

[davidxl]

llvm/include/llvm/ProfileData/MemProf.h

183

add comment on each field arg?

[snehasish]

Add comments for each field.

[snehasish]

PTAL, thanks for the quick review.

[snehasish]

Minor formatting fix.

[davidxl]

lgtm

[dyung]

Hi Snehasish, your change is likely causing 3 test failures on the PS4 linux buildbot, can you take a look?

https://lab.llvm.org/buildbot/#/builders/139/builds/17235

[snehasish]

In D120093#3331018, @dyung wrote:

Hi Snehasish, your change is likely causing 3 test failures on the PS4 linux buildbot, can you take a look?

https://lab.llvm.org/buildbot/#/builders/139/builds/17235

Yup, reverted the change while I look into it.

llvm/include/llvm/ProfileData/MemProf.h

PACKED(struct Frame {
     bool operator==(const Frame &Other) const {
       return Other.Function == Function && Other.LineOffset == LineOffset &&
              Other.Column == Column && Other.IsInlineFrame == IsInlineFrame;
     }
 
     bool operator!=(const Frame &Other) const { return !operator==(Other); }
 
     // Write the contents of the frame to the ostream \p OS.
-    void write(raw_ostream & OS) const {
+    void serialize(raw_ostream & OS) const {
       using namespace support;
 
       endian::Writer LE(OS, little);
 
       // If the type of the GlobalValue::GUID changes, then we need to update
       // the reader and the writer.
       static_assert(std::is_same<GlobalValue::GUID, uint64_t>::value,
                     "Expect GUID to be uint64_t.");
       LE.write<uint64_t>(Function);
 
       LE.write<uint32_t>(LineOffset);
       LE.write<uint32_t>(Column);
       LE.write<bool>(IsInlineFrame);
     }
+
+    // Read a frame from char data which has been serialized as little endian.
+    static Frame deserialize(const unsigned char *Ptr) {
+      using namespace support;
+      return Frame(
+          /*Function=*/endian::readNext<uint64_t, little, unaligned>(Ptr),
+          /*LineOffset=*/endian::readNext<uint32_t, little, unaligned>(Ptr),
+          /*Column=*/endian::readNext<uint32_t, little, unaligned>(Ptr),
+          /*IsInlineFrame=*/endian::readNext<bool, little, unaligned>(Ptr));
+    }
+
+    // Returns the size of the frame information.
+    static constexpr size_t serializedSize() {
+      return sizeof(Frame::Function) + sizeof(Frame::LineOffset) +
+             sizeof(Frame::Column) + sizeof(Frame::IsInlineFrame);
+    }
   });
 
   // The dynamic calling context for the allocation.
   std::vector<Frame> CallStack;
   // The statistics obtained from the runtime for the allocation.
   PortableMemInfoBlock Info;
 
   void clear() {

llvm/lib/ProfileData/MemProf.cpp

void serializeRecords(const ArrayRef<MemProfRecord> Records,
   using namespace support;
 
   endian::Writer LE(OS, little);
 
   LE.write<uint64_t>(Records.size());
   for (const MemProfRecord &MR : Records) {
     LE.write<uint64_t>(MR.CallStack.size());
     for (const MemProfRecord::Frame &F : MR.CallStack) {
-      F.write(OS);
+      F.serialize(OS);
     }
     MR.Info.serialize(Schema, OS);
   }
 }
 
 SmallVector<MemProfRecord, 4> deserializeRecords(const MemProfSchema &Schema,
                                                  const unsigned char *Ptr) {
   using namespace support;
 
   SmallVector<MemProfRecord, 4> Records;
   const uint64_t NumRecords =
       endian::readNext<uint64_t, little, unaligned>(Ptr);
   for (uint64_t I = 0; I < NumRecords; I++) {
     MemProfRecord MR;
     const uint64_t NumFrames =
         endian::readNext<uint64_t, little, unaligned>(Ptr);
     for (uint64_t J = 0; J < NumFrames; J++) {
-      const auto F = *reinterpret_cast<const MemProfRecord::Frame *>(Ptr);
-      Ptr += sizeof(MemProfRecord::Frame);
+      const auto F = MemProfRecord::Frame::deserialize(Ptr);
+      Ptr += MemProfRecord::Frame::serializedSize();
       MR.CallStack.push_back(F);
     }
     MR.Info.deserialize(Schema, Ptr);
     Ptr += PortableMemInfoBlock::serializedSize();
     Records.push_back(MR);
   }
   return Records;
 }