1 //===- SampleProfWriter.cpp - Write LLVM sample profile data --------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the class that writes LLVM sample profiles. It 11 // supports two file formats: text and binary. The textual representation 12 // is useful for debugging and testing purposes. The binary representation 13 // is more compact, resulting in smaller file sizes. However, they can 14 // both be used interchangeably. 15 // 16 // See lib/ProfileData/SampleProfReader.cpp for documentation on each of the 17 // supported formats. 18 // 19 //===----------------------------------------------------------------------===// 20 21 #include "llvm/ProfileData/SampleProfWriter.h" 22 #include "llvm/Support/Debug.h" 23 #include "llvm/Support/ErrorOr.h" 24 #include "llvm/Support/LEB128.h" 25 #include "llvm/Support/LineIterator.h" 26 #include "llvm/Support/MemoryBuffer.h" 27 #include "llvm/Support/Regex.h" 28 29 using namespace llvm::sampleprof; 30 using namespace llvm; 31 32 /// \brief Write samples to a text file. 33 /// 34 /// Note: it may be tempting to implement this in terms of 35 /// FunctionSamples::print(). Please don't. The dump functionality is intended 36 /// for debugging and has no specified form. 37 /// 38 /// The format used here is more structured and deliberate because 39 /// it needs to be parsed by the SampleProfileReaderText class. 40 std::error_code SampleProfileWriterText::write(StringRef FName, 41 const FunctionSamples &S) { 42 auto &OS = *OutputStream; 43 44 OS << FName << ":" << S.getTotalSamples(); 45 if (Indent == 0) 46 OS << ":" << S.getHeadSamples(); 47 OS << "\n"; 48 49 SampleSorter<LineLocation, SampleRecord> SortedSamples(S.getBodySamples()); 50 for (const auto &I : SortedSamples.get()) { 51 LineLocation Loc = I->first; 52 const SampleRecord &Sample = I->second; 53 OS.indent(Indent + 1); 54 if (Loc.Discriminator == 0) 55 OS << Loc.LineOffset << ": "; 56 else 57 OS << Loc.LineOffset << "." << Loc.Discriminator << ": "; 58 59 OS << Sample.getSamples(); 60 61 for (const auto &J : Sample.getCallTargets()) 62 OS << " " << J.first() << ":" << J.second; 63 OS << "\n"; 64 } 65 66 SampleSorter<CallsiteLocation, FunctionSamples> SortedCallsiteSamples( 67 S.getCallsiteSamples()); 68 Indent += 1; 69 for (const auto &I : SortedCallsiteSamples.get()) { 70 CallsiteLocation Loc = I->first; 71 const FunctionSamples &CalleeSamples = I->second; 72 OS.indent(Indent); 73 if (Loc.Discriminator == 0) 74 OS << Loc.LineOffset << ": "; 75 else 76 OS << Loc.LineOffset << "." << Loc.Discriminator << ": "; 77 if (std::error_code EC = write(Loc.CalleeName, CalleeSamples)) 78 return EC; 79 } 80 Indent -= 1; 81 82 return sampleprof_error::success; 83 } 84 85 std::error_code SampleProfileWriterBinary::writeNameIdx(StringRef FName) { 86 const auto &ret = NameTable.find(FName); 87 if (ret == NameTable.end()) 88 return sampleprof_error::truncated_name_table; 89 encodeULEB128(ret->second, *OutputStream); 90 return sampleprof_error::success; 91 } 92 93 void SampleProfileWriterBinary::addName(StringRef FName) { 94 auto NextIdx = NameTable.size(); 95 NameTable.insert(std::make_pair(FName, NextIdx)); 96 } 97 98 void SampleProfileWriterBinary::addNames(const FunctionSamples &S) { 99 // Add all the names in indirect call targets. 100 for (const auto &I : S.getBodySamples()) { 101 const SampleRecord &Sample = I.second; 102 for (const auto &J : Sample.getCallTargets()) 103 addName(J.first()); 104 } 105 106 // Recursively add all the names for inlined callsites. 107 for (const auto &J : S.getCallsiteSamples()) { 108 CallsiteLocation Loc = J.first; 109 const FunctionSamples &CalleeSamples = J.second; 110 addName(Loc.CalleeName); 111 addNames(CalleeSamples); 112 } 113 } 114 115 std::error_code SampleProfileWriterBinary::writeHeader( 116 const StringMap<FunctionSamples> &ProfileMap) { 117 auto &OS = *OutputStream; 118 119 // Write file magic identifier. 120 encodeULEB128(SPMagic(), OS); 121 encodeULEB128(SPVersion(), OS); 122 123 // Generate the name table for all the functions referenced in the profile. 124 for (const auto &I : ProfileMap) { 125 addName(I.first()); 126 addNames(I.second); 127 } 128 129 // Write out the name table. 130 encodeULEB128(NameTable.size(), OS); 131 for (auto N : NameTable) { 132 OS << N.first; 133 encodeULEB128(0, OS); 134 } 135 136 return sampleprof_error::success; 137 } 138 139 std::error_code SampleProfileWriterBinary::writeBody(StringRef FName, 140 const FunctionSamples &S) { 141 auto &OS = *OutputStream; 142 143 if (std::error_code EC = writeNameIdx(FName)) 144 return EC; 145 146 encodeULEB128(S.getTotalSamples(), OS); 147 148 // Emit all the body samples. 149 encodeULEB128(S.getBodySamples().size(), OS); 150 for (const auto &I : S.getBodySamples()) { 151 LineLocation Loc = I.first; 152 const SampleRecord &Sample = I.second; 153 encodeULEB128(Loc.LineOffset, OS); 154 encodeULEB128(Loc.Discriminator, OS); 155 encodeULEB128(Sample.getSamples(), OS); 156 encodeULEB128(Sample.getCallTargets().size(), OS); 157 for (const auto &J : Sample.getCallTargets()) { 158 StringRef Callee = J.first(); 159 uint64_t CalleeSamples = J.second; 160 if (std::error_code EC = writeNameIdx(Callee)) 161 return EC; 162 encodeULEB128(CalleeSamples, OS); 163 } 164 } 165 166 // Recursively emit all the callsite samples. 167 encodeULEB128(S.getCallsiteSamples().size(), OS); 168 for (const auto &J : S.getCallsiteSamples()) { 169 CallsiteLocation Loc = J.first; 170 const FunctionSamples &CalleeSamples = J.second; 171 encodeULEB128(Loc.LineOffset, OS); 172 encodeULEB128(Loc.Discriminator, OS); 173 if (std::error_code EC = writeBody(Loc.CalleeName, CalleeSamples)) 174 return EC; 175 } 176 177 return sampleprof_error::success; 178 } 179 180 /// \brief Write samples of a top-level function to a binary file. 181 /// 182 /// \returns true if the samples were written successfully, false otherwise. 183 std::error_code SampleProfileWriterBinary::write(StringRef FName, 184 const FunctionSamples &S) { 185 encodeULEB128(S.getHeadSamples(), *OutputStream); 186 return writeBody(FName, S); 187 } 188 189 /// \brief Create a sample profile file writer based on the specified format. 190 /// 191 /// \param Filename The file to create. 192 /// 193 /// \param Writer The writer to instantiate according to the specified format. 194 /// 195 /// \param Format Encoding format for the profile file. 196 /// 197 /// \returns an error code indicating the status of the created writer. 198 ErrorOr<std::unique_ptr<SampleProfileWriter>> 199 SampleProfileWriter::create(StringRef Filename, SampleProfileFormat Format) { 200 std::error_code EC; 201 std::unique_ptr<raw_ostream> OS; 202 if (Format == SPF_Binary) 203 OS.reset(new raw_fd_ostream(Filename, EC, sys::fs::F_None)); 204 else 205 OS.reset(new raw_fd_ostream(Filename, EC, sys::fs::F_Text)); 206 if (EC) 207 return EC; 208 209 return create(OS, Format); 210 } 211 212 /// \brief Create a sample profile stream writer based on the specified format. 213 /// 214 /// \param OS The output stream to store the profile data to. 215 /// 216 /// \param Writer The writer to instantiate according to the specified format. 217 /// 218 /// \param Format Encoding format for the profile file. 219 /// 220 /// \returns an error code indicating the status of the created writer. 221 ErrorOr<std::unique_ptr<SampleProfileWriter>> 222 SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS, 223 SampleProfileFormat Format) { 224 std::error_code EC; 225 std::unique_ptr<SampleProfileWriter> Writer; 226 227 if (Format == SPF_Binary) 228 Writer.reset(new SampleProfileWriterBinary(OS)); 229 else if (Format == SPF_Text) 230 Writer.reset(new SampleProfileWriterText(OS)); 231 else if (Format == SPF_GCC) 232 EC = sampleprof_error::unsupported_writing_format; 233 else 234 EC = sampleprof_error::unrecognized_format; 235 236 if (EC) 237 return EC; 238 239 return std::move(Writer); 240 } 241