Movatterモバイル変換

Go to the documentation of this file.

1//===- SampleProfWriter.cpp - Write LLVM sample profile data --------------===//

2//

3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

4// See https://llvm.org/LICENSE.txt for license information.

5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

6//

7//===----------------------------------------------------------------------===//

8//

9// This file implements the class that writes LLVM sample profiles. It

10// supports two file formats: text and binary. The textual representation

11// is useful for debugging and testing purposes. The binary representation

12// is more compact, resulting in smaller file sizes. However, they can

13// both be used interchangeably.

14//

15// See lib/ProfileData/SampleProfReader.cpp for documentation on each of the

16// supported formats.

17//

18//===----------------------------------------------------------------------===//

20#include "llvm/ProfileData/SampleProfWriter.h"

21#include "llvm/ADT/StringRef.h"

22#include "llvm/ProfileData/ProfileCommon.h"

23#include "llvm/ProfileData/SampleProf.h"

24#include "llvm/Support/Compression.h"

25#include "llvm/Support/EndianStream.h"

26#include "llvm/Support/ErrorOr.h"

27#include "llvm/Support/FileSystem.h"

28#include "llvm/Support/LEB128.h"

29#include "llvm/Support/MD5.h"

30#include "llvm/Support/raw_ostream.h"

31#include <cmath>

32#include <cstdint>

33#include <memory>

34#include <set>

35#include <system_error>

36#include <utility>

37#include <vector>

39#define DEBUG_TYPE "llvm-profdata"

41using namespacellvm;

42using namespacesampleprof;

44namespacellvm {

45namespacesupport {

46namespaceendian {

47namespace{

49// Adapter class to llvm::support::endian::Writer for pwrite().

50structSeekableWriter {

51raw_pwrite_stream &OS;

52endianness Endian;

53 SeekableWriter(raw_pwrite_stream &OS,endianness Endian)

54 :OS(OS),Endian(Endian) {}

56template <typename ValueType>

57void pwrite(ValueType Val,size_tOffset) {

58 std::string StringBuf;

59raw_string_ostream SStream(StringBuf);

60 Writer(SStream, Endian).write(Val);

61OS.pwrite(StringBuf.data(), StringBuf.size(),Offset);

62 }

63};

65}// namespace

66}// namespace endian

67}// namespace support

68}// namespace llvm

70DefaultFunctionPruningStrategy::DefaultFunctionPruningStrategy(

71SampleProfileMap &ProfileMap,size_t OutputSizeLimit)

72 :FunctionPruningStrategy(ProfileMap, OutputSizeLimit) {

73sortFuncProfiles(ProfileMap, SortedFunctions);

74}

76voidDefaultFunctionPruningStrategy::Erase(size_t CurrentOutputSize) {

77doubleD = (double)OutputSizeLimit / CurrentOutputSize;

78size_t NewSize = (size_t)round(ProfileMap.size() *D *D);

79size_t NumToRemove =ProfileMap.size() - NewSize;

80if (NumToRemove < 1)

81 NumToRemove = 1;

83assert(NumToRemove <= SortedFunctions.size());

84for (constNameFunctionSamples &E :

85llvm::drop_begin(SortedFunctions, SortedFunctions.size() - NumToRemove))

86ProfileMap.erase(E.first);

87 SortedFunctions.resize(SortedFunctions.size() - NumToRemove);

88}

90std::error_codeSampleProfileWriter::writeWithSizeLimitInternal(

91SampleProfileMap &ProfileMap,size_t OutputSizeLimit,

92FunctionPruningStrategy *Strategy) {

93if (OutputSizeLimit == 0)

94returnwrite(ProfileMap);

96size_t OriginalFunctionCount = ProfileMap.size();

98 std::unique_ptr<raw_ostream> OriginalOutputStream;

99OutputStream.swap(OriginalOutputStream);

100

101size_t IterationCount = 0;

102size_t TotalSize;

103

104SmallVector<char> StringBuffer;

105do {

106 StringBuffer.clear();

107OutputStream.reset(newraw_svector_ostream(StringBuffer));

108if (std::error_code EC =write(ProfileMap))

109return EC;

110

111 TotalSize = StringBuffer.size();

112// On Windows every "\n" is actually written as "\r\n" to disk but not to

113// memory buffer, this difference should be added when considering the total

114// output size.

115#ifdef _WIN32

116if (Format ==SPF_Text)

117 TotalSize +=LineCount;

118#endif

119if (TotalSize <= OutputSizeLimit)

120break;

121

122 Strategy->Erase(TotalSize);

123 IterationCount++;

124 }while (ProfileMap.size() != 0);

125

126if (ProfileMap.size() == 0)

127returnsampleprof_error::too_large;

128

129OutputStream.swap(OriginalOutputStream);

130OutputStream->write(StringBuffer.data(), StringBuffer.size());

131LLVM_DEBUG(dbgs() <<"Profile originally has " << OriginalFunctionCount

132 <<" functions, reduced to " << ProfileMap.size() <<" in "

133 << IterationCount <<" iterations\n");

134// Silence warning on Release build.

135 (void)OriginalFunctionCount;

136 (void)IterationCount;

137returnsampleprof_error::success;

138}

139

140std::error_code

141SampleProfileWriter::writeFuncProfiles(constSampleProfileMap &ProfileMap) {

142 std::vector<NameFunctionSamples> V;

143sortFuncProfiles(ProfileMap, V);

144for (constauto &I : V) {

145if (std::error_code EC =writeSample(*I.second))

146return EC;

147 }

148returnsampleprof_error::success;

149}

150

151std::error_codeSampleProfileWriter::write(constSampleProfileMap &ProfileMap) {

152if (std::error_code EC =writeHeader(ProfileMap))

153return EC;

154

155if (std::error_code EC =writeFuncProfiles(ProfileMap))

156return EC;

157

158returnsampleprof_error::success;

159}

160

161/// Return the current position and prepare to use it as the start

162/// position of a section given the section type \p Type and its position

163/// \p LayoutIdx in SectionHdrLayout.

164uint64_t

165SampleProfileWriterExtBinaryBase::markSectionStart(SecType Type,

166uint32_t LayoutIdx) {

167uint64_t SectionStart =OutputStream->tell();

168assert(LayoutIdx <SectionHdrLayout.size() &&"LayoutIdx out of range");

169constauto &Entry =SectionHdrLayout[LayoutIdx];

170assert(Entry.Type ==Type &&"Unexpected section type");

171// Use LocalBuf as a temporary output for writting data.

172if (hasSecFlag(Entry,SecCommonFlags::SecFlagCompress))

173 LocalBufStream.swap(OutputStream);

174return SectionStart;

175}

176

177std::error_code SampleProfileWriterExtBinaryBase::compressAndOutput() {

178if (!llvm::compression::zlib::isAvailable())

179returnsampleprof_error::zlib_unavailable;

180 std::string &UncompressedStrings =

181static_cast<raw_string_ostream *>(LocalBufStream.get())->str();

182if (UncompressedStrings.size() == 0)

183returnsampleprof_error::success;

184auto &OS = *OutputStream;

185SmallVector<uint8_t, 128> CompressedStrings;

186compression::zlib::compress(arrayRefFromStringRef(UncompressedStrings),

187 CompressedStrings,

188compression::zlib::BestSizeCompression);

189encodeULEB128(UncompressedStrings.size(),OS);

190encodeULEB128(CompressedStrings.size(),OS);

191OS << toStringRef(CompressedStrings);

192 UncompressedStrings.clear();

193returnsampleprof_error::success;

194}

195

196/// Add a new section into section header table given the section type

197/// \p Type, its position \p LayoutIdx in SectionHdrLayout and the

198/// location \p SectionStart where the section should be written to.

199std::error_codeSampleProfileWriterExtBinaryBase::addNewSection(

200SecType Type,uint32_t LayoutIdx,uint64_t SectionStart) {

201assert(LayoutIdx <SectionHdrLayout.size() &&"LayoutIdx out of range");

202constauto &Entry =SectionHdrLayout[LayoutIdx];

203assert(Entry.Type ==Type &&"Unexpected section type");

204if (hasSecFlag(Entry,SecCommonFlags::SecFlagCompress)) {

205 LocalBufStream.swap(OutputStream);

206if (std::error_code EC = compressAndOutput())

207return EC;

208 }

209 SecHdrTable.push_back({Type, Entry.Flags, SectionStart - FileStart,

210OutputStream->tell() - SectionStart, LayoutIdx});

211returnsampleprof_error::success;

212}

213

214std::error_code

215SampleProfileWriterExtBinaryBase::write(constSampleProfileMap &ProfileMap) {

216// When calling write on a different profile map, existing states should be

217// cleared.

218NameTable.clear();

219 CSNameTable.clear();

220 SecHdrTable.clear();

221

222if (std::error_code EC = writeHeader(ProfileMap))

223return EC;

224

225 std::string LocalBuf;

226 LocalBufStream = std::make_unique<raw_string_ostream>(LocalBuf);

227if (std::error_code EC =writeSections(ProfileMap))

228return EC;

229

230if (std::error_code EC = writeSecHdrTable())

231return EC;

232

233returnsampleprof_error::success;

234}

235

236std::error_codeSampleProfileWriterExtBinaryBase::writeContextIdx(

237constSampleContext &Context) {

238if (Context.hasContext())

239returnwriteCSNameIdx(Context);

240else

241returnSampleProfileWriterBinary::writeNameIdx(Context.getFunction());

242}

243

244std::error_code

245SampleProfileWriterExtBinaryBase::writeCSNameIdx(constSampleContext &Context) {

246constauto &Ret = CSNameTable.find(Context);

247if (Ret == CSNameTable.end())

248returnsampleprof_error::truncated_name_table;

249encodeULEB128(Ret->second, *OutputStream);

250returnsampleprof_error::success;

251}

252

253std::error_code

254SampleProfileWriterExtBinaryBase::writeSample(constFunctionSamples &S) {

255uint64_t Offset =OutputStream->tell();

256auto &Context = S.getContext();

257 FuncOffsetTable[Context] =Offset -SecLBRProfileStart;

258encodeULEB128(S.getHeadSamples(), *OutputStream);

259returnwriteBody(S);

260}

261

262std::error_codeSampleProfileWriterExtBinaryBase::writeFuncOffsetTable() {

263auto &OS = *OutputStream;

264

265// Write out the table size.

266encodeULEB128(FuncOffsetTable.size(),OS);

267

268// Write out FuncOffsetTable.

269auto WriteItem = [&](constSampleContext &Context,uint64_t Offset) {

270if (std::error_code EC =writeContextIdx(Context))

271return EC;

272encodeULEB128(Offset,OS);

273return (std::error_code)sampleprof_error::success;

274 };

275

276if (FunctionSamples::ProfileIsCS) {

277// Sort the contexts before writing them out. This is to help fast load all

278// context profiles for a function as well as their callee contexts which

279// can help profile-guided importing for ThinLTO.

280 std::map<SampleContext, uint64_t> OrderedFuncOffsetTable(

281 FuncOffsetTable.begin(), FuncOffsetTable.end());

282for (constauto &Entry : OrderedFuncOffsetTable) {

283if (std::error_code EC = WriteItem(Entry.first, Entry.second))

284return EC;

285 }

286addSectionFlag(SecFuncOffsetTable,SecFuncOffsetFlags::SecFlagOrdered);

287 }else {

288for (constauto &Entry : FuncOffsetTable) {

289if (std::error_code EC = WriteItem(Entry.first, Entry.second))

290return EC;

291 }

292 }

293

294 FuncOffsetTable.clear();

295returnsampleprof_error::success;

296}

297

298std::error_codeSampleProfileWriterExtBinaryBase::writeFuncMetadata(

299constFunctionSamples &FunctionProfile) {

300auto &OS = *OutputStream;

301if (std::error_code EC =writeContextIdx(FunctionProfile.getContext()))

302return EC;

303

304if (FunctionSamples::ProfileIsProbeBased)

305encodeULEB128(FunctionProfile.getFunctionHash(),OS);

306if (FunctionSamples::ProfileIsCS ||FunctionSamples::ProfileIsPreInlined) {

307encodeULEB128(FunctionProfile.getContext().getAllAttributes(),OS);

308 }

309

310if (!FunctionSamples::ProfileIsCS) {

311// Recursively emit attributes for all callee samples.

312uint64_t NumCallsites = 0;

313for (constauto &J : FunctionProfile.getCallsiteSamples())

314 NumCallsites += J.second.size();

315encodeULEB128(NumCallsites,OS);

316for (constauto &J : FunctionProfile.getCallsiteSamples()) {

317for (constauto &FS : J.second) {

318LineLocation Loc = J.first;

319encodeULEB128(Loc.LineOffset,OS);

320encodeULEB128(Loc.Discriminator,OS);

321if (std::error_code EC =writeFuncMetadata(FS.second))

322return EC;

323 }

324 }

325 }

326

327returnsampleprof_error::success;

328}

329

330std::error_codeSampleProfileWriterExtBinaryBase::writeFuncMetadata(

331constSampleProfileMap &Profiles) {

332if (!FunctionSamples::ProfileIsProbeBased && !FunctionSamples::ProfileIsCS &&

333 !FunctionSamples::ProfileIsPreInlined)

334returnsampleprof_error::success;

335for (constauto &Entry : Profiles) {

336if (std::error_code EC =writeFuncMetadata(Entry.second))

337return EC;

338 }

339returnsampleprof_error::success;

340}

341

342std::error_codeSampleProfileWriterExtBinaryBase::writeNameTable() {

343if (!UseMD5)

344returnSampleProfileWriterBinary::writeNameTable();

345

346auto &OS = *OutputStream;

347 std::set<FunctionId> V;

348stablizeNameTable(NameTable, V);

349

350// Write out the MD5 name table. We wrote unencoded MD5 so reader can

351// retrieve the name using the name index without having to read the

352// whole name table.

353encodeULEB128(NameTable.size(),OS);

354support::endian::Writer Writer(OS,llvm::endianness::little);

355for (autoN : V)

356 Writer.write(N.getHashCode());

357returnsampleprof_error::success;

358}

359

360std::error_codeSampleProfileWriterExtBinaryBase::writeNameTableSection(

361constSampleProfileMap &ProfileMap) {

362for (constauto &I : ProfileMap) {

363addContext(I.second.getContext());

364addNames(I.second);

365 }

366

367// If NameTable contains ".__uniq." suffix, set SecFlagUniqSuffix flag

368// so compiler won't strip the suffix during profile matching after

369// seeing the flag in the profile.

370// Original names are unavailable if using MD5, so this option has no use.

371if (!UseMD5) {

372for (constauto &I :NameTable) {

373if (I.first.stringRef().contains(FunctionSamples::UniqSuffix)) {

374addSectionFlag(SecNameTable,SecNameTableFlags::SecFlagUniqSuffix);

375break;

376 }

377 }

378 }

379

380if (auto EC =writeNameTable())

381return EC;

382returnsampleprof_error::success;

383}

384

385std::error_codeSampleProfileWriterExtBinaryBase::writeCSNameTableSection() {

386// Sort the names to make CSNameTable deterministic.

387 std::set<SampleContext> OrderedContexts;

388for (constauto &I : CSNameTable)

389 OrderedContexts.insert(I.first);

390assert(OrderedContexts.size() == CSNameTable.size() &&

391"Unmatched ordered and unordered contexts");

392uint64_t I = 0;

393for (auto &Context : OrderedContexts)

394 CSNameTable[Context] =I++;

395

396auto &OS = *OutputStream;

397encodeULEB128(OrderedContexts.size(),OS);

398support::endian::Writer Writer(OS,llvm::endianness::little);

399for (auto Context : OrderedContexts) {

400auto Frames = Context.getContextFrames();

401encodeULEB128(Frames.size(),OS);

402for (auto &Callsite : Frames) {

403if (std::error_code EC =writeNameIdx(Callsite.Func))

404return EC;

405encodeULEB128(Callsite.Location.LineOffset,OS);

406encodeULEB128(Callsite.Location.Discriminator,OS);

407 }

408 }

409

410returnsampleprof_error::success;

411}

412

413std::error_code

414SampleProfileWriterExtBinaryBase::writeProfileSymbolListSection() {

415if (ProfSymList && ProfSymList->size() > 0)

416if (std::error_code EC = ProfSymList->write(*OutputStream))

417return EC;

418

419returnsampleprof_error::success;

420}

421

422std::error_codeSampleProfileWriterExtBinaryBase::writeOneSection(

423SecType Type,uint32_t LayoutIdx,constSampleProfileMap &ProfileMap) {

424// The setting of SecFlagCompress should happen before markSectionStart.

425if (Type ==SecProfileSymbolList && ProfSymList && ProfSymList->toCompress())

426setToCompressSection(SecProfileSymbolList);

427if (Type ==SecFuncMetadata &&FunctionSamples::ProfileIsProbeBased)

428addSectionFlag(SecFuncMetadata,SecFuncMetadataFlags::SecFlagIsProbeBased);

429if (Type ==SecFuncMetadata &&

430 (FunctionSamples::ProfileIsCS ||FunctionSamples::ProfileIsPreInlined))

431addSectionFlag(SecFuncMetadata,SecFuncMetadataFlags::SecFlagHasAttribute);

432if (Type ==SecProfSummary &&FunctionSamples::ProfileIsCS)

433addSectionFlag(SecProfSummary,SecProfSummaryFlags::SecFlagFullContext);

434if (Type ==SecProfSummary &&FunctionSamples::ProfileIsPreInlined)

435addSectionFlag(SecProfSummary,SecProfSummaryFlags::SecFlagIsPreInlined);

436if (Type ==SecProfSummary &&FunctionSamples::ProfileIsFS)

437addSectionFlag(SecProfSummary,SecProfSummaryFlags::SecFlagFSDiscriminator);

438

439uint64_t SectionStart =markSectionStart(Type, LayoutIdx);

440switch (Type) {

441caseSecProfSummary:

442computeSummary(ProfileMap);

443if (auto EC =writeSummary())

444return EC;

445break;

446caseSecNameTable:

447if (auto EC =writeNameTableSection(ProfileMap))

448return EC;

449break;

450caseSecCSNameTable:

451if (auto EC =writeCSNameTableSection())

452return EC;

453break;

454caseSecLBRProfile:

455SecLBRProfileStart =OutputStream->tell();

456if (std::error_code EC =writeFuncProfiles(ProfileMap))

457return EC;

458break;

459caseSecFuncOffsetTable:

460if (auto EC =writeFuncOffsetTable())

461return EC;

462break;

463caseSecFuncMetadata:

464if (std::error_code EC =writeFuncMetadata(ProfileMap))

465return EC;

466break;

467caseSecProfileSymbolList:

468if (auto EC =writeProfileSymbolListSection())

469return EC;

470break;

471default:

472if (auto EC =writeCustomSection(Type))

473return EC;

474break;

475 }

476if (std::error_code EC =addNewSection(Type, LayoutIdx, SectionStart))

477return EC;

478returnsampleprof_error::success;

479}

480

481std::error_code SampleProfileWriterExtBinary::writeDefaultLayout(

482constSampleProfileMap &ProfileMap) {

483// The const indices passed to writeOneSection below are specifying the

484// positions of the sections in SectionHdrLayout. Look at

485// initSectionHdrLayout to find out where each section is located in

486// SectionHdrLayout.

487if (auto EC =writeOneSection(SecProfSummary, 0, ProfileMap))

488return EC;

489if (auto EC =writeOneSection(SecNameTable, 1, ProfileMap))

490return EC;

491if (auto EC =writeOneSection(SecCSNameTable, 2, ProfileMap))

492return EC;

493if (auto EC =writeOneSection(SecLBRProfile, 4, ProfileMap))

494return EC;

495if (auto EC =writeOneSection(SecProfileSymbolList, 5, ProfileMap))

496return EC;

497if (auto EC =writeOneSection(SecFuncOffsetTable, 3, ProfileMap))

498return EC;

499if (auto EC =writeOneSection(SecFuncMetadata, 6, ProfileMap))

500return EC;

501returnsampleprof_error::success;

502}

503

504staticvoidsplitProfileMapToTwo(constSampleProfileMap &ProfileMap,

505SampleProfileMap &ContextProfileMap,

506SampleProfileMap &NoContextProfileMap) {

507for (constauto &I : ProfileMap) {

508if (I.second.getCallsiteSamples().size())

509 ContextProfileMap.insert({I.first,I.second});

510else

511 NoContextProfileMap.insert({I.first,I.second});

512 }

513}

514

515std::error_code SampleProfileWriterExtBinary::writeCtxSplitLayout(

516constSampleProfileMap &ProfileMap) {

517SampleProfileMap ContextProfileMap, NoContextProfileMap;

518splitProfileMapToTwo(ProfileMap, ContextProfileMap, NoContextProfileMap);

519

520if (auto EC =writeOneSection(SecProfSummary, 0, ProfileMap))

521returnEC;

522if (auto EC =writeOneSection(SecNameTable, 1, ProfileMap))

523returnEC;

524if (auto EC =writeOneSection(SecLBRProfile, 3, ContextProfileMap))

525returnEC;

526if (auto EC =writeOneSection(SecFuncOffsetTable, 2, ContextProfileMap))

527returnEC;

528// Mark the section to have no context. Note section flag needs to be set

529// before writing the section.

530addSectionFlag(5,SecCommonFlags::SecFlagFlat);

531if (auto EC =writeOneSection(SecLBRProfile, 5, NoContextProfileMap))

532returnEC;

533// Mark the section to have no context. Note section flag needs to be set

534// before writing the section.

535addSectionFlag(4,SecCommonFlags::SecFlagFlat);

536if (auto EC =writeOneSection(SecFuncOffsetTable, 4, NoContextProfileMap))

537returnEC;

538if (auto EC =writeOneSection(SecProfileSymbolList, 6, ProfileMap))

539returnEC;

540if (auto EC =writeOneSection(SecFuncMetadata, 7, ProfileMap))

541returnEC;

542

543returnsampleprof_error::success;

544}

545

546std::error_code SampleProfileWriterExtBinary::writeSections(

547constSampleProfileMap &ProfileMap) {

548 std::error_codeEC;

549if (SecLayout ==DefaultLayout)

550EC = writeDefaultLayout(ProfileMap);

551elseif (SecLayout ==CtxSplitLayout)

552EC = writeCtxSplitLayout(ProfileMap);

553else

554llvm_unreachable("Unsupported layout");

555returnEC;

556}

557

558/// Write samples to a text file.

559///

560/// Note: it may be tempting to implement this in terms of

561/// FunctionSamples::print(). Please don't. The dump functionality is intended

562/// for debugging and has no specified form.

563///

564/// The format used here is more structured and deliberate because

565/// it needs to be parsed by the SampleProfileReaderText class.

566std::error_codeSampleProfileWriterText::writeSample(constFunctionSamples &S) {

567auto &OS = *OutputStream;

568if (FunctionSamples::ProfileIsCS)

569OS <<"[" << S.getContext().toString() <<"]:" << S.getTotalSamples();

570else

571OS << S.getFunction() <<":" << S.getTotalSamples();

572

573if (Indent == 0)

574OS <<":" << S.getHeadSamples();

575OS <<"\n";

576LineCount++;

577

578SampleSorter<LineLocation, SampleRecord> SortedSamples(S.getBodySamples());

579for (constauto &I : SortedSamples.get()) {

580LineLocation Loc =I->first;

581constSampleRecord &Sample =I->second;

582OS.indent(Indent + 1);

583if (Loc.Discriminator == 0)

584OS << Loc.LineOffset <<": ";

585else

586OS << Loc.LineOffset <<"." << Loc.Discriminator <<": ";

587

588OS << Sample.getSamples();

589

590for (constauto &J : Sample.getSortedCallTargets())

591OS <<" " << J.first <<":" << J.second;

592OS <<"\n";

593LineCount++;

594 }

595

596SampleSorter<LineLocation, FunctionSamplesMap> SortedCallsiteSamples(

597 S.getCallsiteSamples());

598 Indent += 1;

599for (constauto &I : SortedCallsiteSamples.get())

600for (constauto &FS :I->second) {

601LineLocation Loc =I->first;

602constFunctionSamples &CalleeSamples = FS.second;

603OS.indent(Indent);

604if (Loc.Discriminator == 0)

605OS << Loc.LineOffset <<": ";

606else

607OS << Loc.LineOffset <<"." << Loc.Discriminator <<": ";

608if (std::error_code EC =writeSample(CalleeSamples))

609return EC;

610 }

611 Indent -= 1;

612

613if (FunctionSamples::ProfileIsProbeBased) {

614OS.indent(Indent + 1);

615OS <<"!CFGChecksum: " << S.getFunctionHash() <<"\n";

616LineCount++;

617 }

618

619if (S.getContext().getAllAttributes()) {

620OS.indent(Indent + 1);

621OS <<"!Attributes: " << S.getContext().getAllAttributes() <<"\n";

622LineCount++;

623 }

624

625if (Indent == 0 && MarkFlatProfiles && S.getCallsiteSamples().size() == 0)

626OS <<" !Flat\n";

627

628returnsampleprof_error::success;

629}

630

631std::error_code

632SampleProfileWriterBinary::writeContextIdx(constSampleContext &Context) {

633assert(!Context.hasContext() &&"cs profile is not supported");

634returnwriteNameIdx(Context.getFunction());

635}

636

637std::error_codeSampleProfileWriterBinary::writeNameIdx(FunctionId FName) {

638auto &NTable =getNameTable();

639constauto &Ret = NTable.find(FName);

640if (Ret == NTable.end())

641returnsampleprof_error::truncated_name_table;

642encodeULEB128(Ret->second, *OutputStream);

643returnsampleprof_error::success;

644}

645

646voidSampleProfileWriterBinary::addName(FunctionId FName) {

647auto &NTable =getNameTable();

648 NTable.insert(std::make_pair(FName, 0));

649}

650

651voidSampleProfileWriterBinary::addContext(constSampleContext &Context) {

652addName(Context.getFunction());

653}

654

655voidSampleProfileWriterBinary::addNames(constFunctionSamples &S) {

656// Add all the names in indirect call targets.

657for (constauto &I : S.getBodySamples()) {

658constSampleRecord &Sample =I.second;

659for (constauto &J : Sample.getCallTargets())

660addName(J.first);

661 }

662

663// Recursively add all the names for inlined callsites.

664for (constauto &J : S.getCallsiteSamples())

665for (constauto &FS : J.second) {

666constFunctionSamples &CalleeSamples = FS.second;

667addName(CalleeSamples.getFunction());

668addNames(CalleeSamples);

669 }

670}

671

672voidSampleProfileWriterExtBinaryBase::addContext(

673constSampleContext &Context) {

674if (Context.hasContext()) {

675for (auto &Callsite : Context.getContextFrames())

676SampleProfileWriterBinary::addName(Callsite.Func);

677 CSNameTable.insert(std::make_pair(Context, 0));

678 }else {

679SampleProfileWriterBinary::addName(Context.getFunction());

680 }

681}

682

683voidSampleProfileWriterBinary::stablizeNameTable(

684MapVector<FunctionId, uint32_t> &NameTable, std::set<FunctionId> &V) {

685// Sort the names to make NameTable deterministic.

686for (constauto &I :NameTable)

687 V.insert(I.first);

688int i = 0;

689for (constFunctionId &N : V)

690NameTable[N] = i++;

691}

692

693std::error_codeSampleProfileWriterBinary::writeNameTable() {

694auto &OS = *OutputStream;

695 std::set<FunctionId> V;

696stablizeNameTable(NameTable, V);

697

698// Write out the name table.

699encodeULEB128(NameTable.size(),OS);

700for (autoN : V) {

701OS <<N;

702encodeULEB128(0,OS);

703 }

704returnsampleprof_error::success;

705}

706

707std::error_code

708SampleProfileWriterBinary::writeMagicIdent(SampleProfileFormat Format) {

709auto &OS = *OutputStream;

710// Write file magic identifier.

711encodeULEB128(SPMagic(Format),OS);

712encodeULEB128(SPVersion(),OS);

713returnsampleprof_error::success;

714}

715

716std::error_code

717SampleProfileWriterBinary::writeHeader(constSampleProfileMap &ProfileMap) {

718// When calling write on a different profile map, existing names should be

719// cleared.

720NameTable.clear();

721

722writeMagicIdent(Format);

723

724computeSummary(ProfileMap);

725if (auto EC =writeSummary())

726return EC;

727

728// Generate the name table for all the functions referenced in the profile.

729for (constauto &I : ProfileMap) {

730addContext(I.second.getContext());

731addNames(I.second);

732 }

733

734writeNameTable();

735returnsampleprof_error::success;

736}

737

738voidSampleProfileWriterExtBinaryBase::setToCompressAllSections() {

739for (auto &Entry :SectionHdrLayout)

740addSecFlag(Entry,SecCommonFlags::SecFlagCompress);

741}

742

743voidSampleProfileWriterExtBinaryBase::setToCompressSection(SecType Type) {

744addSectionFlag(Type,SecCommonFlags::SecFlagCompress);

745}

746

747void SampleProfileWriterExtBinaryBase::allocSecHdrTable() {

748support::endian::Writer Writer(*OutputStream,llvm::endianness::little);

749

750 Writer.write(static_cast<uint64_t>(SectionHdrLayout.size()));

751 SecHdrTableOffset =OutputStream->tell();

752for (uint32_t i = 0; i <SectionHdrLayout.size(); i++) {

753 Writer.write(static_cast<uint64_t>(-1));

754 Writer.write(static_cast<uint64_t>(-1));

755 Writer.write(static_cast<uint64_t>(-1));

756 Writer.write(static_cast<uint64_t>(-1));

757 }

758}

759

760std::error_code SampleProfileWriterExtBinaryBase::writeSecHdrTable() {

761assert(SecHdrTable.size() ==SectionHdrLayout.size() &&

762"SecHdrTable entries doesn't match SectionHdrLayout");

763SmallVector<uint32_t, 16> IndexMap(SecHdrTable.size(), -1);

764for (uint32_t TableIdx = 0; TableIdx < SecHdrTable.size(); TableIdx++) {

765 IndexMap[SecHdrTable[TableIdx].LayoutIndex] = TableIdx;

766 }

767

768// Write the section header table in the order specified in

769// SectionHdrLayout. SectionHdrLayout specifies the sections

770// order in which profile reader expect to read, so the section

771// header table should be written in the order in SectionHdrLayout.

772// Note that the section order in SecHdrTable may be different

773// from the order in SectionHdrLayout, for example, SecFuncOffsetTable

774// needs to be computed after SecLBRProfile (the order in SecHdrTable),

775// but it needs to be read before SecLBRProfile (the order in

776// SectionHdrLayout). So we use IndexMap above to switch the order.

777 support::endian::SeekableWriter Writer(

778static_cast<raw_pwrite_stream &>(*OutputStream),

779llvm::endianness::little);

780for (uint32_t LayoutIdx = 0; LayoutIdx <SectionHdrLayout.size();

781 LayoutIdx++) {

782assert(IndexMap[LayoutIdx] < SecHdrTable.size() &&

783"Incorrect LayoutIdx in SecHdrTable");

784autoEntry = SecHdrTable[IndexMap[LayoutIdx]];

785 Writer.pwrite(static_cast<uint64_t>(Entry.Type),

786 SecHdrTableOffset + 4 * LayoutIdx *sizeof(uint64_t));

787 Writer.pwrite(static_cast<uint64_t>(Entry.Flags),

788 SecHdrTableOffset + (4 * LayoutIdx + 1) *sizeof(uint64_t));

789 Writer.pwrite(static_cast<uint64_t>(Entry.Offset),

790 SecHdrTableOffset + (4 * LayoutIdx + 2) *sizeof(uint64_t));

791 Writer.pwrite(static_cast<uint64_t>(Entry.Size),

792 SecHdrTableOffset + (4 * LayoutIdx + 3) *sizeof(uint64_t));

793 }

794

795returnsampleprof_error::success;

796}

797

798std::error_code SampleProfileWriterExtBinaryBase::writeHeader(

799constSampleProfileMap &ProfileMap) {

800auto &OS = *OutputStream;

801 FileStart =OS.tell();

802writeMagicIdent(Format);

803

804 allocSecHdrTable();

805returnsampleprof_error::success;

806}

807

808std::error_codeSampleProfileWriterBinary::writeSummary() {

809auto &OS = *OutputStream;

810encodeULEB128(Summary->getTotalCount(),OS);

811encodeULEB128(Summary->getMaxCount(),OS);

812encodeULEB128(Summary->getMaxFunctionCount(),OS);

813encodeULEB128(Summary->getNumCounts(),OS);

814encodeULEB128(Summary->getNumFunctions(),OS);

815ArrayRef<ProfileSummaryEntry> Entries =Summary->getDetailedSummary();

816encodeULEB128(Entries.size(),OS);

817for (auto Entry : Entries) {

818encodeULEB128(Entry.Cutoff,OS);

819encodeULEB128(Entry.MinCount,OS);

820encodeULEB128(Entry.NumCounts,OS);

821 }

822returnsampleprof_error::success;

823}

824std::error_codeSampleProfileWriterBinary::writeBody(constFunctionSamples &S) {

825auto &OS = *OutputStream;

826if (std::error_code EC =writeContextIdx(S.getContext()))

827return EC;

828

829encodeULEB128(S.getTotalSamples(),OS);

830

831// Emit all the body samples.

832encodeULEB128(S.getBodySamples().size(),OS);

833for (constauto &I : S.getBodySamples()) {

834LineLocation Loc =I.first;

835constSampleRecord &Sample =I.second;

836encodeULEB128(Loc.LineOffset,OS);

837encodeULEB128(Loc.Discriminator,OS);

838encodeULEB128(Sample.getSamples(),OS);

839encodeULEB128(Sample.getCallTargets().size(),OS);

840for (constauto &J : Sample.getSortedCallTargets()) {

841FunctionId Callee = J.first;

842uint64_t CalleeSamples = J.second;

843if (std::error_code EC =writeNameIdx(Callee))

844return EC;

845encodeULEB128(CalleeSamples,OS);

846 }

847 }

848

849// Recursively emit all the callsite samples.

850uint64_t NumCallsites = 0;

851for (constauto &J : S.getCallsiteSamples())

852 NumCallsites += J.second.size();

853encodeULEB128(NumCallsites,OS);

854for (constauto &J : S.getCallsiteSamples())

855for (constauto &FS : J.second) {

856LineLocation Loc = J.first;

857constFunctionSamples &CalleeSamples = FS.second;

858encodeULEB128(Loc.LineOffset,OS);

859encodeULEB128(Loc.Discriminator,OS);

860if (std::error_code EC =writeBody(CalleeSamples))

861return EC;

862 }

863

864returnsampleprof_error::success;

865}

866

867/// Write samples of a top-level function to a binary file.

868///

869/// \returns true if the samples were written successfully, false otherwise.

870std::error_code

871SampleProfileWriterBinary::writeSample(constFunctionSamples &S) {

872encodeULEB128(S.getHeadSamples(), *OutputStream);

873returnwriteBody(S);

874}

875

876/// Create a sample profile file writer based on the specified format.

877///

878/// \param Filename The file to create.

879///

880/// \param Format Encoding format for the profile file.

881///

882/// \returns an error code indicating the status of the created writer.

883ErrorOr<std::unique_ptr<SampleProfileWriter>>

884SampleProfileWriter::create(StringRef Filename,SampleProfileFormat Format) {

885 std::error_code EC;

886 std::unique_ptr<raw_ostream>OS;

887if (Format ==SPF_Binary ||Format ==SPF_Ext_Binary)

888OS.reset(newraw_fd_ostream(Filename, EC,sys::fs::OF_None));

889else

890OS.reset(newraw_fd_ostream(Filename, EC,sys::fs::OF_TextWithCRLF));

891if (EC)

892return EC;

893

894returncreate(OS,Format);

895}

896

897/// Create a sample profile stream writer based on the specified format.

898///

899/// \param OS The output stream to store the profile data to.

900///

901/// \param Format Encoding format for the profile file.

902///

903/// \returns an error code indicating the status of the created writer.

904ErrorOr<std::unique_ptr<SampleProfileWriter>>

905SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,

906SampleProfileFormat Format) {

907 std::error_code EC;

908 std::unique_ptr<SampleProfileWriter> Writer;

909

910// Currently only Text and Extended Binary format are supported for CSSPGO.

911if ((FunctionSamples::ProfileIsCS ||FunctionSamples::ProfileIsProbeBased) &&

912Format ==SPF_Binary)

913returnsampleprof_error::unsupported_writing_format;

914

915if (Format ==SPF_Binary)

916 Writer.reset(newSampleProfileWriterRawBinary(OS));

917elseif (Format ==SPF_Ext_Binary)

918 Writer.reset(newSampleProfileWriterExtBinary(OS));

919elseif (Format ==SPF_Text)

920 Writer.reset(newSampleProfileWriterText(OS));

921elseif (Format ==SPF_GCC)

922 EC =sampleprof_error::unsupported_writing_format;

923else

924 EC =sampleprof_error::unrecognized_format;

925

926if (EC)

927return EC;

928

929 Writer->Format =Format;

930return std::move(Writer);

931}

932

933voidSampleProfileWriter::computeSummary(constSampleProfileMap &ProfileMap) {

934SampleProfileSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);

935Summary = Builder.computeSummaryForProfiles(ProfileMap);

936}

static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")

Compression.h

LLVM_DEBUG

#define LLVM_DEBUG(...)

Definition:Debug.h:106

EndianStream.h

ErrorOr.h

Provides ErrorOr<T> smart pointer.

FileSystem.h

LEB128.h

#define I(x, y, z)

Definition:MD5.cpp:58

MD5.h

ProfileCommon.h

assert

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

Endian

endianness Endian

Definition:SampleProfWriter.cpp:52

splitProfileMapToTwo

static void splitProfileMapToTwo(const SampleProfileMap &ProfileMap, SampleProfileMap &ContextProfileMap, SampleProfileMap &NoContextProfileMap)

Definition:SampleProfWriter.cpp:504

raw_pwrite_stream & OS

Definition:SampleProfWriter.cpp:51

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

Definition:ArrayRef.h:41

llvm::ErrorOr

Represents either an error or a value T.

Definition:ErrorOr.h:56

llvm::MapVector

This class implements a map that also provides access to all stored values in a deterministic order.

Definition:MapVector.h:36

llvm::PointerUnion< const Value *, const PseudoSourceValue * >

llvm::ProfileSummaryBuilder::DefaultCutoffs

static const ArrayRef< uint32_t > DefaultCutoffs

A vector of useful cutoff values for detailed summary.

Definition:ProfileCommon.h:70

llvm::SampleProfileSummaryBuilder

Definition:ProfileCommon.h:93

llvm::SampleProfileSummaryBuilder::computeSummaryForProfiles

std::unique_ptr< ProfileSummary > computeSummaryForProfiles(const sampleprof::SampleProfileMap &Profiles)

Definition:ProfileSummaryBuilder.cpp:193

llvm::SmallVectorBase::size

size_t size() const

Definition:SmallVector.h:78

llvm::SmallVectorImpl::clear

void clear()

Definition:SmallVector.h:610

llvm::SmallVectorTemplateCommon::data

pointer data()

Return a pointer to the vector's buffer, even if empty().

Definition:SmallVector.h:286

llvm::SmallVector

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

Definition:SmallVector.h:1196

llvm::StringRef

StringRef - Represent a constant reference to a string, i.e.

Definition:StringRef.h:51

llvm::Type

The instances of the Type class are immutable: once they are created, they are never changed.

Definition:Type.h:45

llvm::raw_fd_ostream

A raw_ostream that writes to a file descriptor.

Definition:raw_ostream.h:460

llvm::raw_ostream::tell

uint64_t tell() const

tell - Return the current offset with the file.

Definition:raw_ostream.h:147

llvm::raw_ostream::indent

raw_ostream & indent(unsigned NumSpaces)

indent - Insert 'NumSpaces' spaces.

Definition:raw_ostream.cpp:495

llvm::raw_pwrite_stream

An abstract base class for streams implementations that also support a pwrite operation.

Definition:raw_ostream.h:434

llvm::raw_pwrite_stream::pwrite

void pwrite(const char *Ptr, size_t Size, uint64_t Offset)

Definition:raw_ostream.h:442

llvm::raw_string_ostream

A raw_ostream that writes to an std::string.

Definition:raw_ostream.h:661

llvm::raw_svector_ostream

A raw_ostream that writes to an SmallVector or SmallString.

Definition:raw_ostream.h:691

llvm::sampleprof::DefaultFunctionPruningStrategy::DefaultFunctionPruningStrategy

DefaultFunctionPruningStrategy(SampleProfileMap &ProfileMap, size_t OutputSizeLimit)

Definition:SampleProfWriter.cpp:70

llvm::sampleprof::DefaultFunctionPruningStrategy::Erase

void Erase(size_t CurrentOutputSize) override

In this default implementation, functions with fewest samples are dropped first.

Definition:SampleProfWriter.cpp:76

llvm::sampleprof::FunctionId

This class represents a function that is read from a sample profile.

Definition:FunctionId.h:36

llvm::sampleprof::FunctionPruningStrategy

When writing a profile with size limit, user may want to use a different strategy to reduce function ...

Definition:SampleProfWriter.h:42

llvm::sampleprof::FunctionPruningStrategy::Erase

virtual void Erase(size_t CurrentOutputSize)=0

SampleProfileWriter::writeWithSizeLimit() calls this after every write iteration if the output size s...

llvm::sampleprof::FunctionPruningStrategy::ProfileMap

SampleProfileMap & ProfileMap

Definition:SampleProfWriter.h:44

llvm::sampleprof::FunctionPruningStrategy::OutputSizeLimit

size_t OutputSizeLimit

Definition:SampleProfWriter.h:45

llvm::sampleprof::FunctionSamples

Representation of the samples collected for a function.

Definition:SampleProf.h:745

llvm::sampleprof::FunctionSamples::ProfileIsPreInlined

static bool ProfileIsPreInlined

Definition:SampleProf.h:1190

llvm::sampleprof::FunctionSamples::UniqSuffix

static constexpr const char * UniqSuffix

Definition:SampleProf.h:1100

llvm::sampleprof::FunctionSamples::getHeadSamples

uint64_t getHeadSamples() const

For top-level functions, return the total number of branch samples that have the function as the bran...

Definition:SampleProf.h:942

llvm::sampleprof::FunctionSamples::ProfileIsCS

static bool ProfileIsCS

Definition:SampleProf.h:1188

llvm::sampleprof::FunctionSamples::getFunction

FunctionId getFunction() const

Return the function name.

Definition:SampleProf.h:1074

llvm::sampleprof::FunctionSamples::getFunctionHash

uint64_t getFunctionHash() const

Definition:SampleProf.h:1081

llvm::sampleprof::FunctionSamples::ProfileIsProbeBased

static bool ProfileIsProbeBased

Definition:SampleProf.h:1186

llvm::sampleprof::FunctionSamples::ProfileIsFS

static bool ProfileIsFS

If this profile uses flow sensitive discriminators.

Definition:SampleProf.h:1203

llvm::sampleprof::FunctionSamples::getContext

SampleContext & getContext() const

Definition:SampleProf.h:1192

llvm::sampleprof::FunctionSamples::getTotalSamples

uint64_t getTotalSamples() const

Return the total number of samples collected inside the function.

Definition:SampleProf.h:934

llvm::sampleprof::FunctionSamples::getCallsiteSamples

const CallsiteSampleMap & getCallsiteSamples() const

Return all the callsite samples collected in the body of the function.

Definition:SampleProf.h:976

llvm::sampleprof::FunctionSamples::getBodySamples

const BodySampleMap & getBodySamples() const

Return all the samples collected in the body of the function.

Definition:SampleProf.h:973

llvm::sampleprof::ProfileSymbolList::toCompress

bool toCompress()

Definition:SampleProf.h:1535

llvm::sampleprof::ProfileSymbolList::write

std::error_code write(raw_ostream &OS)

Definition:SampleProf.cpp:404

llvm::sampleprof::ProfileSymbolList::size

unsigned size()

Definition:SampleProf.h:1532

llvm::sampleprof::SampleContext

Definition:SampleProf.h:523

llvm::sampleprof::SampleContext::hasContext

bool hasContext() const

Definition:SampleProf.h:615

llvm::sampleprof::SampleContext::getContextFrames

SampleContextFrames getContextFrames() const

Definition:SampleProf.h:618

llvm::sampleprof::SampleContext::getFunction

FunctionId getFunction() const

Definition:SampleProf.h:617

llvm::sampleprof::SampleContext::getAllAttributes

uint32_t getAllAttributes()

Definition:SampleProf.h:610

llvm::sampleprof::SampleContext::toString

std::string toString() const

Definition:SampleProf.h:633

llvm::sampleprof::SampleProfileMap

This class provides operator overloads to the map container using MD5 as the key type,...

Definition:SampleProf.h:1313

llvm::sampleprof::SampleProfileMap::erase

size_t erase(const SampleContext &Ctx)

Definition:SampleProf.h:1334

llvm::sampleprof::SampleProfileWriterBinary::stablizeNameTable

void stablizeNameTable(MapVector< FunctionId, uint32_t > &NameTable, std::set< FunctionId > &V)

Definition:SampleProfWriter.cpp:683

llvm::sampleprof::SampleProfileWriterBinary::addContext

virtual void addContext(const SampleContext &Context)

Definition:SampleProfWriter.cpp:651

llvm::sampleprof::SampleProfileWriterBinary::writeNameTable

virtual std::error_code writeNameTable()

Definition:SampleProfWriter.cpp:693

llvm::sampleprof::SampleProfileWriterBinary::writeMagicIdent

virtual std::error_code writeMagicIdent(SampleProfileFormat Format)

Definition:SampleProfWriter.cpp:708

llvm::sampleprof::SampleProfileWriterBinary::writeSummary

std::error_code writeSummary()

Definition:SampleProfWriter.cpp:808

llvm::sampleprof::SampleProfileWriterBinary::NameTable

MapVector< FunctionId, uint32_t > NameTable

Definition:SampleProfWriter.h:220

llvm::sampleprof::SampleProfileWriterBinary::addNames

void addNames(const FunctionSamples &S)

Definition:SampleProfWriter.cpp:655

llvm::sampleprof::SampleProfileWriterBinary::writeContextIdx

virtual std::error_code writeContextIdx(const SampleContext &Context)

Definition:SampleProfWriter.cpp:632

llvm::sampleprof::SampleProfileWriterBinary::writeSample

std::error_code writeSample(const FunctionSamples &S) override

Write samples of a top-level function to a binary file.

Definition:SampleProfWriter.cpp:871

llvm::sampleprof::SampleProfileWriterBinary::writeHeader

std::error_code writeHeader(const SampleProfileMap &ProfileMap) override

Write a file header for the profile file.

Definition:SampleProfWriter.cpp:717

llvm::sampleprof::SampleProfileWriterBinary::getNameTable

virtual MapVector< FunctionId, uint32_t > & getNameTable()

Definition:SampleProfWriter.h:209

llvm::sampleprof::SampleProfileWriterBinary::writeBody

std::error_code writeBody(const FunctionSamples &S)

Definition:SampleProfWriter.cpp:824

llvm::sampleprof::SampleProfileWriterBinary::writeNameIdx

std::error_code writeNameIdx(FunctionId FName)

Definition:SampleProfWriter.cpp:637

llvm::sampleprof::SampleProfileWriterBinary::addName

void addName(FunctionId FName)

Definition:SampleProfWriter.cpp:646

llvm::sampleprof::SampleProfileWriterExtBinaryBase::writeNameTableSection

std::error_code writeNameTableSection(const SampleProfileMap &ProfileMap)

Definition:SampleProfWriter.cpp:360

llvm::sampleprof::SampleProfileWriterExtBinaryBase::SectionHdrLayout

SmallVector< SecHdrTableEntry, 8 > SectionHdrLayout

Definition:SampleProfWriter.h:363

llvm::sampleprof::SampleProfileWriterExtBinaryBase::writeFuncMetadata

std::error_code writeFuncMetadata(const SampleProfileMap &Profiles)

Definition:SampleProfWriter.cpp:330

llvm::sampleprof::SampleProfileWriterExtBinaryBase::setToCompressSection

void setToCompressSection(SecType Type)

Definition:SampleProfWriter.cpp:743

llvm::sampleprof::SampleProfileWriterExtBinaryBase::writeCustomSection

virtual std::error_code writeCustomSection(SecType Type)=0

llvm::sampleprof::SampleProfileWriterExtBinaryBase::writeOneSection

virtual std::error_code writeOneSection(SecType Type, uint32_t LayoutIdx, const SampleProfileMap &ProfileMap)

Definition:SampleProfWriter.cpp:422

llvm::sampleprof::SampleProfileWriterExtBinaryBase::writeFuncOffsetTable

std::error_code writeFuncOffsetTable()

Definition:SampleProfWriter.cpp:262

llvm::sampleprof::SampleProfileWriterExtBinaryBase::writeCSNameTableSection

std::error_code writeCSNameTableSection()

Definition:SampleProfWriter.cpp:385

llvm::sampleprof::SampleProfileWriterExtBinaryBase::writeCSNameIdx

std::error_code writeCSNameIdx(const SampleContext &Context)

Definition:SampleProfWriter.cpp:245

llvm::sampleprof::SampleProfileWriterExtBinaryBase::writeSections

virtual std::error_code writeSections(const SampleProfileMap &ProfileMap)=0

llvm::sampleprof::SampleProfileWriterExtBinaryBase::writeNameTable

std::error_code writeNameTable() override

Definition:SampleProfWriter.cpp:342

llvm::sampleprof::SampleProfileWriterExtBinaryBase::addSectionFlag

void addSectionFlag(SecType Type, SecFlagType Flag)

Definition:SampleProfWriter.h:318

llvm::sampleprof::SampleProfileWriterExtBinaryBase::writeProfileSymbolListSection

std::error_code writeProfileSymbolListSection()

Definition:SampleProfWriter.cpp:414

llvm::sampleprof::SampleProfileWriterExtBinaryBase::markSectionStart

uint64_t markSectionStart(SecType Type, uint32_t LayoutIdx)

Return the current position and prepare to use it as the start position of a section given the sectio...

Definition:SampleProfWriter.cpp:165

llvm::sampleprof::SampleProfileWriterExtBinaryBase::addContext

void addContext(const SampleContext &Context) override

Definition:SampleProfWriter.cpp:672

llvm::sampleprof::SampleProfileWriterExtBinaryBase::addNewSection

std::error_code addNewSection(SecType Sec, uint32_t LayoutIdx, uint64_t SectionStart)

Add a new section into section header table given the section type Type, its position LayoutIdx in Se...

Definition:SampleProfWriter.cpp:199

llvm::sampleprof::SampleProfileWriterExtBinaryBase::SecLayout

SectionLayout SecLayout

Definition:SampleProfWriter.h:358

llvm::sampleprof::SampleProfileWriterExtBinaryBase::setToCompressAllSections

void setToCompressAllSections() override

Definition:SampleProfWriter.cpp:738

llvm::sampleprof::SampleProfileWriterExtBinaryBase::SecLBRProfileStart

uint64_t SecLBRProfileStart

Definition:SampleProfWriter.h:369

llvm::sampleprof::SampleProfileWriterExtBinaryBase::write

std::error_code write(const SampleProfileMap &ProfileMap) override

Write all the sample profiles in the given map of samples.

Definition:SampleProfWriter.cpp:215

llvm::sampleprof::SampleProfileWriterExtBinaryBase::writeContextIdx

std::error_code writeContextIdx(const SampleContext &Context) override

Definition:SampleProfWriter.cpp:236

llvm::sampleprof::SampleProfileWriterExtBinaryBase::writeSample

std::error_code writeSample(const FunctionSamples &S) override

Write samples of a top-level function to a binary file.

Definition:SampleProfWriter.cpp:254

llvm::sampleprof::SampleProfileWriterExtBinary

Definition:SampleProfWriter.h:410

llvm::sampleprof::SampleProfileWriterRawBinary

Definition:SampleProfWriter.h:232

llvm::sampleprof::SampleProfileWriterText

Sample-based profile writer (text format).

Definition:SampleProfWriter.h:166

llvm::sampleprof::SampleProfileWriterText::writeSample

std::error_code writeSample(const FunctionSamples &S) override

Write samples to a text file.

Definition:SampleProfWriter.cpp:566

llvm::sampleprof::SampleProfileWriter::Summary

std::unique_ptr< ProfileSummary > Summary

Profile summary.

Definition:SampleProfWriter.h:156

llvm::sampleprof::SampleProfileWriter::writeSample

virtual std::error_code writeSample(const FunctionSamples &S)=0

Write sample profiles in S.

llvm::sampleprof::SampleProfileWriter::Format

SampleProfileFormat Format

Profile format.

Definition:SampleProfWriter.h:162

llvm::sampleprof::SampleProfileWriter::writeWithSizeLimitInternal

std::error_code writeWithSizeLimitInternal(SampleProfileMap &ProfileMap, size_t OutputSizeLimit, FunctionPruningStrategy *Strategy)

Definition:SampleProfWriter.cpp:90

llvm::sampleprof::SampleProfileWriter::computeSummary

void computeSummary(const SampleProfileMap &ProfileMap)

Compute summary for this profile.

Definition:SampleProfWriter.cpp:933

llvm::sampleprof::SampleProfileWriter::writeFuncProfiles

virtual std::error_code writeFuncProfiles(const SampleProfileMap &ProfileMap)

Definition:SampleProfWriter.cpp:141

llvm::sampleprof::SampleProfileWriter::OutputStream

std::unique_ptr< raw_ostream > OutputStream

Output stream where to emit the profile to.

Definition:SampleProfWriter.h:153

llvm::sampleprof::SampleProfileWriter::LineCount

size_t LineCount

For writeWithSizeLimit in text mode, each newline takes 1 additional byte on Windows when actually wr...

Definition:SampleProfWriter.h:150

llvm::sampleprof::SampleProfileWriter::create

static ErrorOr< std::unique_ptr< SampleProfileWriter > > create(StringRef Filename, SampleProfileFormat Format)

Profile writer factory.

Definition:SampleProfWriter.cpp:884

llvm::sampleprof::SampleProfileWriter::writeHeader

virtual std::error_code writeHeader(const SampleProfileMap &ProfileMap)=0

Write a file header for the profile file.

llvm::sampleprof::SampleProfileWriter::write

virtual std::error_code write(const SampleProfileMap &ProfileMap)

Write all the sample profiles in the given map of samples.

Definition:SampleProfWriter.cpp:151

llvm::sampleprof::SampleRecord

Representation of a single sample record.

Definition:SampleProf.h:325

llvm::sampleprof::SampleRecord::getCallTargets

const CallTargetMap & getCallTargets() const

Definition:SampleProf.h:393

llvm::sampleprof::SampleRecord::getSamples

uint64_t getSamples() const

Definition:SampleProf.h:392

llvm::sampleprof::SampleRecord::getSortedCallTargets

const SortedCallTargetSet getSortedCallTargets() const

Definition:SampleProf.h:394

llvm::sampleprof::SampleSorter

Sort a LocationT->SampleT map by LocationT.

Definition:SampleProf.h:1353

llvm::sampleprof::SampleSorter::get

const SamplesWithLocList & get() const

Definition:SampleProf.h:1366

uint32_t

uint64_t

llvm_unreachable

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

Definition:ErrorHandling.h:143

llvm::COFF::Entry

@ Entry

Definition:COFF.h:844

llvm::codeview::CompileSym2Flags::EC

@ EC

llvm::compression::zlib::compress

void compress(ArrayRef< uint8_t > Input, SmallVectorImpl< uint8_t > &CompressedBuffer, int Level=DefaultCompression)

Definition:Compression.cpp:147

llvm::compression::zlib::isAvailable

bool isAvailable()

Definition:Compression.cpp:146

llvm::compression::zlib::BestSizeCompression

constexpr int BestSizeCompression

Definition:Compression.h:39

llvm::sampleprof::sortFuncProfiles

void sortFuncProfiles(const SampleProfileMap &ProfileMap, std::vector< NameFunctionSamples > &SortedProfiles)

Definition:SampleProf.cpp:202

llvm::sampleprof::SPMagic

static uint64_t SPMagic(SampleProfileFormat Format=SPF_Binary)

Definition:SampleProf.h:106

llvm::sampleprof::SecCommonFlags::SecFlagCompress

@ SecFlagCompress

llvm::sampleprof::SecCommonFlags::SecFlagFlat

@ SecFlagFlat

llvm::sampleprof::NameFunctionSamples

std::pair< hash_code, const FunctionSamples * > NameFunctionSamples

Definition:SampleProf.h:1344

llvm::sampleprof::SampleProfileFormat

SampleProfileFormat

Definition:SampleProf.h:91

llvm::sampleprof::SPF_Binary

@ SPF_Binary

Definition:SampleProf.h:97

llvm::sampleprof::SPF_Ext_Binary

@ SPF_Ext_Binary

Definition:SampleProf.h:96

llvm::sampleprof::SPF_GCC

@ SPF_GCC

Definition:SampleProf.h:95

llvm::sampleprof::SPF_Text

@ SPF_Text

Definition:SampleProf.h:93

llvm::sampleprof::addSecFlag

static void addSecFlag(SecHdrTableEntry &Entry, SecFlagType Flag)

Definition:SampleProf.h:248

llvm::sampleprof::hasSecFlag

static bool hasSecFlag(const SecHdrTableEntry &Entry, SecFlagType Flag)

Definition:SampleProf.h:264

llvm::sampleprof::SecNameTableFlags::SecFlagUniqSuffix

@ SecFlagUniqSuffix

llvm::sampleprof::SecProfSummaryFlags::SecFlagIsPreInlined

@ SecFlagIsPreInlined

SecFlagIsPreInlined means this profile contains ShouldBeInlined contexts thus this is CS preinliner c...

llvm::sampleprof::SecProfSummaryFlags::SecFlagFSDiscriminator

@ SecFlagFSDiscriminator

SecFlagFSDiscriminator means this profile uses flow-sensitive discriminators.

llvm::sampleprof::SecProfSummaryFlags::SecFlagFullContext

@ SecFlagFullContext

SecFlagContext means this is context-sensitive flat profile for CSSPGO.

llvm::sampleprof::SecFuncOffsetFlags::SecFlagOrdered

@ SecFlagOrdered

llvm::sampleprof::SecFuncMetadataFlags::SecFlagHasAttribute

@ SecFlagHasAttribute

llvm::sampleprof::SecFuncMetadataFlags::SecFlagIsProbeBased

@ SecFlagIsProbeBased

llvm::sampleprof::CtxSplitLayout

@ CtxSplitLayout

Definition:SampleProfWriter.h:34

llvm::sampleprof::DefaultLayout

@ DefaultLayout

Definition:SampleProfWriter.h:30

llvm::sampleprof::SPVersion

static uint64_t SPVersion()

Definition:SampleProf.h:113

llvm::sampleprof::SecType

SecType

Definition:SampleProf.h:118

llvm::sampleprof::SecNameTable

@ SecNameTable

Definition:SampleProf.h:121

llvm::sampleprof::SecLBRProfile

@ SecLBRProfile

Definition:SampleProf.h:128

llvm::sampleprof::SecProfSummary

@ SecProfSummary

Definition:SampleProf.h:120

llvm::sampleprof::SecCSNameTable

@ SecCSNameTable

Definition:SampleProf.h:125

llvm::sampleprof::SecFuncMetadata

@ SecFuncMetadata

Definition:SampleProf.h:124

llvm::sampleprof::SecProfileSymbolList

@ SecProfileSymbolList

Definition:SampleProf.h:122

llvm::sampleprof::SecFuncOffsetTable

@ SecFuncOffsetTable

Definition:SampleProf.h:123

llvm::support::endian

Definition:Endian.h:41

llvm::sys::fs::OF_None

@ OF_None

Definition:FileSystem.h:750

llvm::sys::fs::OF_TextWithCRLF

@ OF_TextWithCRLF

The file should be opened in text mode and use a carriage linefeed '\r '.

Definition:FileSystem.h:763

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::drop_begin

auto drop_begin(T &&RangeOrContainer, size_t N=1)

Return a range covering RangeOrContainer with the first N elements excluded.

Definition:STLExtras.h:329

llvm::Offset

@ Offset

Definition:DWP.cpp:480

llvm::sampleprof_error::zlib_unavailable

@ zlib_unavailable

llvm::sampleprof_error::success

@ success

llvm::sampleprof_error::too_large

@ too_large

llvm::sampleprof_error::unsupported_writing_format

@ unsupported_writing_format

llvm::sampleprof_error::truncated_name_table

@ truncated_name_table

llvm::sampleprof_error::unrecognized_format

@ unrecognized_format

llvm::dbgs

raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

Definition:Debug.cpp:163

llvm::ReplacementType::Format

@ Format

llvm::encodeULEB128

unsigned encodeULEB128(uint64_t Value, raw_ostream &OS, unsigned PadTo=0)

Utility function to encode a ULEB128 value to an output stream.

Definition:LEB128.h:80

llvm::endianness

endianness

Definition:bit.h:70

llvm::endianness::little

@ little

raw_ostream.h

#define N

llvm::sampleprof::LineLocation

Represents the relative location of an instruction.

Definition:SampleProf.h:280

llvm::sampleprof::LineLocation::LineOffset

uint32_t LineOffset

Definition:SampleProf.h:303

llvm::sampleprof::LineLocation::Discriminator

uint32_t Discriminator

Definition:SampleProf.h:304

llvm::support::endian::Writer

Adapter to write values to a stream in a particular byte order.

Definition:EndianStream.h:67

llvm::support::endian::Writer::write

void write(ArrayRef< value_type > Val)

Definition:EndianStream.h:71

round

static uint64_t round(uint64_t Acc, uint64_t Input)

Definition:xxhash.cpp:80