1 //===- SampleProfReader.h - Read LLVM sample profile data -----------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains definitions needed for reading sample profiles.
12 //===----------------------------------------------------------------------===//
13 #ifndef LLVM_PROFILEDATA_SAMPLEPROFREADER_H
14 #define LLVM_PROFILEDATA_SAMPLEPROFREADER_H
16 #include "llvm/ADT/DenseMap.h"
17 #include "llvm/ADT/StringMap.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/ADT/Twine.h"
20 #include "llvm/IR/DiagnosticInfo.h"
21 #include "llvm/IR/Function.h"
22 #include "llvm/IR/LLVMContext.h"
23 #include "llvm/ProfileData/SampleProf.h"
24 #include "llvm/Support/Debug.h"
25 #include "llvm/Support/ErrorHandling.h"
26 #include "llvm/Support/ErrorOr.h"
27 #include "llvm/Support/MemoryBuffer.h"
28 #include "llvm/Support/raw_ostream.h"
32 namespace sampleprof {
34 /// \brief Sample-based profile reader.
36 /// Each profile contains sample counts for all the functions
37 /// executed. Inside each function, statements are annotated with the
38 /// collected samples on all the instructions associated with that
41 /// For this to produce meaningful data, the program needs to be
42 /// compiled with some debug information (at minimum, line numbers:
43 /// -gline-tables-only). Otherwise, it will be impossible to match IR
44 /// instructions to the line numbers collected by the profiler.
46 /// From the profile file, we are interested in collecting the
47 /// following information:
49 /// * A list of functions included in the profile (mangled names).
51 /// * For each function F:
52 /// 1. The total number of samples collected in F.
54 /// 2. The samples collected at each line in F. To provide some
55 /// protection against source code shuffling, line numbers should
56 /// be relative to the start of the function.
58 /// The reader supports two file formats: text and binary. The text format
59 /// is useful for debugging and testing, while the binary format is more
60 /// compact. They can both be used interchangeably.
61 class SampleProfileReader {
63 SampleProfileReader(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
64 : Profiles(0), Ctx(C), Buffer(std::move(B)) {}
66 virtual ~SampleProfileReader() {}
68 /// \brief Read and validate the file header.
69 virtual std::error_code readHeader() = 0;
71 /// \brief Read sample profiles from the associated file.
72 virtual std::error_code read() = 0;
74 /// \brief Print the profile for \p FName on stream \p OS.
75 void dumpFunctionProfile(StringRef FName, raw_ostream &OS = dbgs());
77 /// \brief Print all the profiles on stream \p OS.
78 void dump(raw_ostream &OS = dbgs());
80 /// \brief Return the samples collected for function \p F.
81 FunctionSamples *getSamplesFor(const Function &F) {
82 return &Profiles[F.getName()];
85 /// \brief Return all the profiles.
86 StringMap<FunctionSamples> &getProfiles() { return Profiles; }
88 /// \brief Report a parse error message.
89 void reportParseError(int64_t LineNumber, Twine Msg) const {
90 Ctx.diagnose(DiagnosticInfoSampleProfile(Buffer->getBufferIdentifier(),
94 /// \brief Create a sample profile reader appropriate to the file format.
95 static ErrorOr<std::unique_ptr<SampleProfileReader>>
96 create(StringRef Filename, LLVMContext &C);
99 /// \brief Map every function to its associated profile.
101 /// The profile of every function executed at runtime is collected
102 /// in the structure FunctionSamples. This maps function objects
103 /// to their corresponding profiles.
104 StringMap<FunctionSamples> Profiles;
106 /// \brief LLVM context used to emit diagnostics.
109 /// \brief Memory buffer holding the profile file.
110 std::unique_ptr<MemoryBuffer> Buffer;
113 class SampleProfileReaderText : public SampleProfileReader {
115 SampleProfileReaderText(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
116 : SampleProfileReader(std::move(B), C) {}
118 /// \brief Read and validate the file header.
119 std::error_code readHeader() override { return sampleprof_error::success; }
121 /// \brief Read sample profiles from the associated file.
122 std::error_code read() override;
125 class SampleProfileReaderBinary : public SampleProfileReader {
127 SampleProfileReaderBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
128 : SampleProfileReader(std::move(B), C), Data(nullptr), End(nullptr) {}
130 /// \brief Read and validate the file header.
131 std::error_code readHeader() override;
133 /// \brief Read sample profiles from the associated file.
134 std::error_code read() override;
136 /// \brief Return true if \p Buffer is in the format supported by this class.
137 static bool hasFormat(const MemoryBuffer &Buffer);
140 /// \brief Read a numeric value of type T from the profile.
142 /// If an error occurs during decoding, a diagnostic message is emitted and
145 /// \returns the read value.
146 template <typename T> ErrorOr<T> readNumber();
148 /// \brief Read a string from the profile.
150 /// If an error occurs during decoding, a diagnostic message is emitted and
153 /// \returns the read value.
154 ErrorOr<StringRef> readString();
156 /// \brief Return true if we've reached the end of file.
157 bool at_eof() const { return Data >= End; }
159 /// \brief Points to the current location in the buffer.
162 /// \brief Points to the end of the buffer.
166 } // End namespace sampleprof
168 } // End namespace llvm
170 #endif // LLVM_PROFILEDATA_SAMPLEPROFREADER_H