1#include "llvm/ProfileData/MemProf.h"
2#include "llvm/ADT/SmallVector.h"
3#include "llvm/IR/Function.h"
4#include "llvm/ProfileData/InstrProf.h"
5#include "llvm/ProfileData/SampleProf.h"
6#include "llvm/Support/Endian.h"
7#include "llvm/Support/EndianStream.h"
8
9namespace llvm {
10namespace memprof {
11
12void IndexedMemProfRecord::serialize(const MemProfSchema &Schema,
13                                     raw_ostream &OS) {
14  using namespace support;
15
16  endian::Writer LE(OS, llvm::endianness::little);
17
18  LE.write<uint64_t>(AllocSites.size());
19  for (const IndexedAllocationInfo &N : AllocSites) {
20    LE.write<uint64_t>(N.CallStack.size());
21    for (const FrameId &Id : N.CallStack)
22      LE.write<FrameId>(Id);
23    N.Info.serialize(Schema, OS);
24  }
25
26  // Related contexts.
27  LE.write<uint64_t>(CallSites.size());
28  for (const auto &Frames : CallSites) {
29    LE.write<uint64_t>(Frames.size());
30    for (const FrameId &Id : Frames)
31      LE.write<FrameId>(Id);
32  }
33}
34
35IndexedMemProfRecord
36IndexedMemProfRecord::deserialize(const MemProfSchema &Schema,
37                                  const unsigned char *Ptr) {
38  using namespace support;
39
40  IndexedMemProfRecord Record;
41
42  // Read the meminfo nodes.
43  const uint64_t NumNodes =
44      endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
45  for (uint64_t I = 0; I < NumNodes; I++) {
46    IndexedAllocationInfo Node;
47    const uint64_t NumFrames =
48        endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
49    for (uint64_t J = 0; J < NumFrames; J++) {
50      const FrameId Id =
51          endian::readNext<FrameId, llvm::endianness::little, unaligned>(Ptr);
52      Node.CallStack.push_back(Id);
53    }
54    Node.Info.deserialize(Schema, Ptr);
55    Ptr += PortableMemInfoBlock::serializedSize();
56    Record.AllocSites.push_back(Node);
57  }
58
59  // Read the callsite information.
60  const uint64_t NumCtxs =
61      endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
62  for (uint64_t J = 0; J < NumCtxs; J++) {
63    const uint64_t NumFrames =
64        endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
65    llvm::SmallVector<FrameId> Frames;
66    Frames.reserve(NumFrames);
67    for (uint64_t K = 0; K < NumFrames; K++) {
68      const FrameId Id =
69          endian::readNext<FrameId, llvm::endianness::little, unaligned>(Ptr);
70      Frames.push_back(Id);
71    }
72    Record.CallSites.push_back(Frames);
73  }
74
75  return Record;
76}
77
78GlobalValue::GUID IndexedMemProfRecord::getGUID(const StringRef FunctionName) {
79  // Canonicalize the function name to drop suffixes such as ".llvm.". Note
80  // we do not drop any ".__uniq." suffixes, as getCanonicalFnName does not drop
81  // those by default. This is by design to differentiate internal linkage
82  // functions during matching. By dropping the other suffixes we can then match
83  // functions in the profile use phase prior to their addition. Note that this
84  // applies to both instrumented and sampled function names.
85  StringRef CanonicalName =
86      sampleprof::FunctionSamples::getCanonicalFnName(FunctionName);
87
88  // We use the function guid which we expect to be a uint64_t. At
89  // this time, it is the lower 64 bits of the md5 of the canonical
90  // function name.
91  return Function::getGUID(CanonicalName);
92}
93
94Expected<MemProfSchema> readMemProfSchema(const unsigned char *&Buffer) {
95  using namespace support;
96
97  const unsigned char *Ptr = Buffer;
98  const uint64_t NumSchemaIds =
99      endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
100  if (NumSchemaIds > static_cast<uint64_t>(Meta::Size)) {
101    return make_error<InstrProfError>(instrprof_error::malformed,
102                                      "memprof schema invalid");
103  }
104
105  MemProfSchema Result;
106  for (size_t I = 0; I < NumSchemaIds; I++) {
107    const uint64_t Tag =
108        endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Ptr);
109    if (Tag >= static_cast<uint64_t>(Meta::Size)) {
110      return make_error<InstrProfError>(instrprof_error::malformed,
111                                        "memprof schema invalid");
112    }
113    Result.push_back(static_cast<Meta>(Tag));
114  }
115  // Advace the buffer to one past the schema if we succeeded.
116  Buffer = Ptr;
117  return Result;
118}
119
120} // namespace memprof
121} // namespace llvm
122