From badd989bbae2521dd13085efe58ffb4eccab074d Mon Sep 17 00:00:00 2001 From: Dehao Chen Date: Wed, 30 Sep 2015 00:42:46 +0000 Subject: [PATCH] http://reviews.llvm.org/D13145 Support hierarachical sample profile format. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@248865 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/ProfileData/SampleProf.h | 69 +++++- lib/ProfileData/SampleProfReader.cpp | 233 +++++++++++++----- lib/Transforms/IPO/SampleProfile.cpp | 126 +++++++++- .../Inputs/bad_discriminator_value.prof | 2 +- .../SampleProfile/Inputs/bad_fn_header.prof | 4 +- .../SampleProfile/Inputs/bad_mangle.prof | 4 +- .../SampleProfile/Inputs/bad_sample_line.prof | 4 +- .../SampleProfile/Inputs/bad_samples.prof | 2 +- .../SampleProfile/Inputs/branch.prof | 14 +- .../SampleProfile/Inputs/calls.prof | 16 +- .../SampleProfile/Inputs/discriminator.prof | 14 +- .../SampleProfile/Inputs/entry_counts.prof | 4 +- .../SampleProfile/Inputs/fnptr.prof | 18 +- .../SampleProfile/Inputs/propagate.prof | 32 +-- .../SampleProfile/Inputs/syntax.prof | 4 +- .../Inputs/sample-profile.proftext | 18 +- 16 files changed, 429 insertions(+), 135 deletions(-) diff --git a/include/llvm/ProfileData/SampleProf.h b/include/llvm/ProfileData/SampleProf.h index bd4ec052bb1..0f1f4ed9a92 100644 --- a/include/llvm/ProfileData/SampleProf.h +++ b/include/llvm/ProfileData/SampleProf.h @@ -76,6 +76,18 @@ struct LineLocation { unsigned Discriminator; }; +/// Represents the relative location of a callsite. +/// +/// Callsite locations are specified by the line offset from the +/// beginning of the function (marked by the line where the function +/// head is), the discriminator value within that line, and the callee +/// function name. +struct CallsiteLocation : public LineLocation { + CallsiteLocation(int L, unsigned D, StringRef N) + : LineLocation(L, D), CalleeName(N) {} + StringRef CalleeName; +}; + } // End namespace sampleprof template <> struct DenseMapInfo { @@ -100,6 +112,31 @@ template <> struct DenseMapInfo { } }; +template <> struct DenseMapInfo { + typedef DenseMapInfo OffsetInfo; + typedef DenseMapInfo DiscriminatorInfo; + typedef DenseMapInfo CalleeNameInfo; + static inline sampleprof::CallsiteLocation getEmptyKey() { + return sampleprof::CallsiteLocation(OffsetInfo::getEmptyKey(), + DiscriminatorInfo::getEmptyKey(), ""); + } + static inline sampleprof::CallsiteLocation getTombstoneKey() { + return sampleprof::CallsiteLocation(OffsetInfo::getTombstoneKey(), + DiscriminatorInfo::getTombstoneKey(), + ""); + } + static inline unsigned getHashValue(sampleprof::CallsiteLocation Val) { + return DenseMapInfo>::getHashValue( + std::pair(Val.LineOffset, Val.Discriminator)); + } + static inline bool isEqual(sampleprof::CallsiteLocation LHS, + sampleprof::CallsiteLocation RHS) { + return LHS.LineOffset == RHS.LineOffset && + LHS.Discriminator == RHS.Discriminator && + LHS.CalleeName.equals(RHS.CalleeName); + } +}; + namespace sampleprof { /// Representation of a single sample record. @@ -160,6 +197,8 @@ private: }; typedef DenseMap BodySampleMap; +class FunctionSamples; +typedef DenseMap CallsiteSampleMap; /// Representation of the samples collected for a function. /// @@ -201,7 +240,23 @@ public: return ret->second.getSamples(); } - bool empty() const { return BodySamples.empty(); } + /// Return the function samples at the given callsite location. + FunctionSamples &functionSamplesAt(const CallsiteLocation &Loc) { + return CallsiteSamples[Loc]; + } + + /// Return a pointer to function samples at the given callsite location. + const FunctionSamples * + findFunctionSamplesAt(const CallsiteLocation &Loc) const { + auto iter = CallsiteSamples.find(Loc); + if (iter == CallsiteSamples.end()) { + return NULL; + } else { + return &iter->second; + } + } + + bool empty() const { return TotalSamples == 0; } /// Return the total number of samples collected inside the function. unsigned getTotalSamples() const { return TotalSamples; } @@ -213,6 +268,11 @@ public: /// Return all the samples collected in the body of the function. const BodySampleMap &getBodySamples() const { return BodySamples; } + /// Return all the callsite samples collected in the body of the function. + const CallsiteSampleMap &getCallsiteSamples() const { + return CallsiteSamples; + } + /// Merge the samples in \p Other into this one. void merge(const FunctionSamples &Other) { addTotalSamples(Other.getTotalSamples()); @@ -222,6 +282,11 @@ public: const SampleRecord &Rec = I.second; BodySamples[Loc].merge(Rec); } + for (const auto &I : Other.getCallsiteSamples()) { + const CallsiteLocation &Loc = I.first; + const FunctionSamples &Rec = I.second; + functionSamplesAt(Loc).merge(Rec); + } } private: @@ -242,6 +307,8 @@ private: /// collected at the corresponding line offset. All line locations /// are an offset from the start of the function. BodySampleMap BodySamples; + + CallsiteSampleMap CallsiteSamples; }; } // End namespace sampleprof diff --git a/lib/ProfileData/SampleProfReader.cpp b/lib/ProfileData/SampleProfReader.cpp index 70964cb27e1..9b579e6319d 100644 --- a/lib/ProfileData/SampleProfReader.cpp +++ b/lib/ProfileData/SampleProfReader.cpp @@ -25,14 +25,22 @@ // Each section has the following format // // function1:total_samples:total_head_samples -// offset1[.discriminator]: number_of_samples [fn1:num fn2:num ... ] -// offset2[.discriminator]: number_of_samples [fn3:num fn4:num ... ] -// ... -// offsetN[.discriminator]: number_of_samples [fn5:num fn6:num ... ] +// offset1[.discriminator]: number_of_samples [fn1:num fn2:num ... ] +// offset2[.discriminator]: number_of_samples [fn3:num fn4:num ... ] +// ... +// offsetN[.discriminator]: number_of_samples [fn5:num fn6:num ... ] +// offsetA[.discriminator]: fnA:num_of_total_samples +// offsetA1[.discriminator]: number_of_samples [fn7:num fn8:num ... ] +// ... // -// The file may contain blank lines between sections and within a -// section. However, the spacing within a single line is fixed. Additional -// spaces will result in an error while reading the file. +// This is a nested tree in which the identation represent the nest level +// of the inline stack. There is no blank line in the file. And the spacing +// within a single line is fixed. Additional spaces will result in an error +// while reading the file. +// +// Inline stack is a stack of source locations in which the top of the stack +// represents the leaf function, and the bottom of the stack represents the +// actual symbol in which the instruction belongs. // // Function names must be mangled in order for the profile loader to // match them in the current translation unit. The two numbers in the @@ -41,6 +49,11 @@ // in the prologue of the function (second number). This head sample // count provides an indicator of how frequently the function is invoked. // +// There are two types of lines in the function body. +// +// * Sampled line represents the profile information of a source location. +// * Callsite line represents the profile inofrmation of a callsite. +// // Each sampled line may contain several items. Some are optional (marked // below): // @@ -92,6 +105,16 @@ // instruction that calls one of ``foo()``, ``bar()`` and ``baz()``, // with ``baz()`` being the relatively more frequently called target. // +// Each callsite line may contain several items. Some are optional. +// +// a. Source line offset. This number represents the line number of the +// callsite that is inlined in the profiled binary. +// +// b. [OPTIONAL] Discriminator. Same as the discriminator for sampled line. +// +// c. Number of samples. This is an integer quantity representing the +// total number of samples collected for the inlined instance at this +// callsite //===----------------------------------------------------------------------===// #include "llvm/ProfileData/SampleProfReader.h" @@ -100,7 +123,8 @@ #include "llvm/Support/LEB128.h" #include "llvm/Support/LineIterator.h" #include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/Regex.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/SmallVector.h" using namespace llvm::sampleprof; using namespace llvm; @@ -143,6 +167,96 @@ void SampleProfileReader::dump(raw_ostream &OS) { dumpFunctionProfile(I.getKey(), OS); } +/// \brief Parse \p Input as function head. +/// +/// Parse one line of \p Input, and update function name in \p FName, +/// function's total sample count in \p NumSamples, function's entry +/// count in \p NumHeadSamples. +/// +/// \returns true if parsing is successful. +static bool ParseHead(const StringRef &Input, StringRef &FName, + unsigned &NumSamples, unsigned &NumHeadSamples) { + if (Input[0] == ' ') + return false; + size_t n2 = Input.rfind(':'); + size_t n1 = Input.rfind(':', n2 - 1); + FName = Input.substr(0, n1); + if (Input.substr(n1 + 1, n2 - n1 - 1).getAsInteger(10, NumSamples)) + return false; + if (Input.substr(n2 + 1).getAsInteger(10, NumHeadSamples)) + return false; + return true; +} + +/// \brief Parse \p Input as line sample. +/// +/// \param Input input line. +/// \param IsCallsite true if the line represents an inlined callsite. +/// \param Depth the depth of the inline stack. +/// \param NumSamples total samples of the line/inlined callsite. +/// \param LineOffset line offset to the start of the function. +/// \param Discriminator discriminator of the line. +/// \param TargetCountMap map from indirect call target to count. +/// +/// returns true if parsing is successful. +static bool ParseLine(const StringRef &Input, bool &IsCallsite, unsigned &Depth, + unsigned &NumSamples, unsigned &LineOffset, + unsigned &Discriminator, StringRef &CalleeName, + DenseMap &TargetCountMap) { + for (Depth = 0; Input[Depth] == ' '; Depth++) + ; + if (Depth == 0) + return false; + + size_t n1 = Input.find(':'); + StringRef Loc = Input.substr(Depth, n1 - Depth); + size_t n2 = Loc.find('.'); + if (n2 == StringRef::npos) { + if (Loc.getAsInteger(10, LineOffset)) + return false; + Discriminator = 0; + } else { + if (Loc.substr(0, n2).getAsInteger(10, LineOffset)) + return false; + if (Loc.substr(n2 + 1).getAsInteger(10, Discriminator)) + return false; + } + + StringRef Rest = Input.substr(n1 + 2); + if (Rest[0] >= '0' && Rest[0] <= '9') { + IsCallsite = false; + size_t n3 = Rest.find(' '); + if (n3 == StringRef::npos) { + if (Rest.getAsInteger(10, NumSamples)) + return false; + } else { + if (Rest.substr(0, n3).getAsInteger(10, NumSamples)) + return false; + } + while (n3 != StringRef::npos) { + n3 += Rest.substr(n3).find_first_not_of(' '); + Rest = Rest.substr(n3); + n3 = Rest.find(' '); + StringRef pair = Rest; + if (n3 != StringRef::npos) { + pair = Rest.substr(0, n3); + } + int n4 = pair.find(':'); + unsigned count; + if (pair.substr(n4 + 1).getAsInteger(10, count)) + return false; + TargetCountMap[pair.substr(0, n4)] = count; + } + } else { + IsCallsite = true; + int n3 = Rest.find_last_of(':'); + CalleeName = Rest.substr(0, n3); + if (Rest.substr(n3 + 1).getAsInteger(10, NumSamples)) + return false; + } + return true; +} + /// \brief Load samples from a text file. /// /// See the documentation at the top of the file for an explanation of @@ -152,13 +266,11 @@ void SampleProfileReader::dump(raw_ostream &OS) { std::error_code SampleProfileReaderText::read() { line_iterator LineIt(*Buffer, /*SkipBlanks=*/true, '#'); - // Read the profile of each function. Since each function may be - // mentioned more than once, and we are collecting flat profiles, - // accumulate samples as we parse them. - Regex HeadRE("^([^0-9].*):([0-9]+):([0-9]+)$"); - Regex LineSampleRE("^([0-9]+)\\.?([0-9]+)?: ([0-9]+)(.*)$"); - Regex CallSampleRE(" +([^0-9 ][^ ]*):([0-9]+)"); - while (!LineIt.is_at_eof()) { + SmallVector InlineStack; + + for (; !LineIt.is_at_eof(); ++LineIt) { + if ((*LineIt)[(*LineIt).find_first_not_of(' ')] == '#') + continue; // Read the header of each function. // // Note that for function identifiers we are actually expecting @@ -171,59 +283,52 @@ std::error_code SampleProfileReaderText::read() { // // The only requirement we place on the identifier, then, is that it // should not begin with a number. - SmallVector Matches; - if (!HeadRE.match(*LineIt, &Matches)) { - reportError(LineIt.line_number(), - "Expected 'mangled_name:NUM:NUM', found " + *LineIt); - return sampleprof_error::malformed; - } - assert(Matches.size() == 4); - StringRef FName = Matches[1]; - unsigned NumSamples, NumHeadSamples; - Matches[2].getAsInteger(10, NumSamples); - Matches[3].getAsInteger(10, NumHeadSamples); - Profiles[FName] = FunctionSamples(); - FunctionSamples &FProfile = Profiles[FName]; - FProfile.addTotalSamples(NumSamples); - FProfile.addHeadSamples(NumHeadSamples); - ++LineIt; - - // Now read the body. The body of the function ends when we reach - // EOF or when we see the start of the next function. - while (!LineIt.is_at_eof() && isdigit((*LineIt)[0])) { - if (!LineSampleRE.match(*LineIt, &Matches)) { + if ((*LineIt)[0] != ' ') { + unsigned NumSamples, NumHeadSamples; + StringRef FName; + if (!ParseHead(*LineIt, FName, NumSamples, NumHeadSamples)) { + reportError(LineIt.line_number(), + "Expected 'mangled_name:NUM:NUM', found " + *LineIt); + return sampleprof_error::malformed; + } + Profiles[FName] = FunctionSamples(); + FunctionSamples &FProfile = Profiles[FName]; + FProfile.addTotalSamples(NumSamples); + FProfile.addHeadSamples(NumHeadSamples); + InlineStack.clear(); + InlineStack.push_back(&FProfile); + } else { + unsigned NumSamples; + StringRef FName; + DenseMap TargetCountMap; + bool IsCallsite; + unsigned Depth, LineOffset, Discriminator; + if (!ParseLine(*LineIt, IsCallsite, Depth, NumSamples, LineOffset, + Discriminator, FName, TargetCountMap)) { reportError(LineIt.line_number(), "Expected 'NUM[.NUM]: NUM[ mangled_name:NUM]*', found " + *LineIt); return sampleprof_error::malformed; } - assert(Matches.size() == 5); - unsigned LineOffset, NumSamples, Discriminator = 0; - Matches[1].getAsInteger(10, LineOffset); - if (Matches[2] != "") - Matches[2].getAsInteger(10, Discriminator); - Matches[3].getAsInteger(10, NumSamples); - - // If there are function calls in this line, generate a call sample - // entry for each call. - std::string CallsLine(Matches[4]); - while (CallsLine != "") { - SmallVector CallSample; - if (!CallSampleRE.match(CallsLine, &CallSample)) { - reportError(LineIt.line_number(), - "Expected 'mangled_name:NUM', found " + CallsLine); - return sampleprof_error::malformed; + if (IsCallsite) { + while (InlineStack.size() > Depth) { + InlineStack.pop_back(); + } + FunctionSamples &FSamples = InlineStack.back()->functionSamplesAt( + CallsiteLocation(LineOffset, Discriminator, FName)); + FSamples.addTotalSamples(NumSamples); + InlineStack.push_back(&FSamples); + } else { + while (InlineStack.size() > Depth) { + InlineStack.pop_back(); + } + FunctionSamples &FProfile = *InlineStack.back(); + for (const auto &name_count : TargetCountMap) { + FProfile.addCalledTargetSamples(LineOffset, Discriminator, + name_count.first, name_count.second); } - StringRef CalledFunction = CallSample[1]; - unsigned CalledFunctionSamples; - CallSample[2].getAsInteger(10, CalledFunctionSamples); - FProfile.addCalledTargetSamples(LineOffset, Discriminator, - CalledFunction, CalledFunctionSamples); - CallsLine = CallSampleRE.sub("", CallsLine); + FProfile.addBodySamples(LineOffset, Discriminator, NumSamples); } - - FProfile.addBodySamples(LineOffset, Discriminator, NumSamples); - ++LineIt; } } @@ -474,7 +579,6 @@ std::error_code SampleProfileReaderGCC::addSourceCount(StringRef Name, return sampleprof_error::success; } - std::error_code SampleProfileReaderGCC::readOneFunctionProfile(const SourceStack &Stack, bool Update) { @@ -577,7 +681,6 @@ std::error_code SampleProfileReaderGCC::readWorkingSet() { return sampleprof_error::not_implemented; } - /// \brief Read a GCC AutoFDO profile. /// /// This format is generated by the Linux Perf conversion tool at @@ -591,8 +694,8 @@ std::error_code SampleProfileReaderGCC::read() { if (std::error_code EC = readFunctionProfiles()) return EC; - // FIXME(dnovillo) - Module groups and working set support are not - // yet implemented. +// FIXME(dnovillo) - Module groups and working set support are not +// yet implemented. #if 0 // Read the module group file. if (std::error_code EC = readModuleGroup()) diff --git a/lib/Transforms/IPO/SampleProfile.cpp b/lib/Transforms/IPO/SampleProfile.cpp index 3e931f77112..4d6ed522774 100644 --- a/lib/Transforms/IPO/SampleProfile.cpp +++ b/lib/Transforms/IPO/SampleProfile.cpp @@ -46,6 +46,7 @@ #include "llvm/Support/ErrorOr.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Transforms/IPO.h" +#include "llvm/Transforms/Utils/Cloning.h" #include using namespace llvm; @@ -105,6 +106,9 @@ protected: bool emitAnnotations(Function &F); ErrorOr getInstWeight(const Instruction &I) const; ErrorOr getBlockWeight(const BasicBlock *BB) const; + const FunctionSamples *findCalleeFunctionSamples(const CallInst &I) const; + const FunctionSamples *findFunctionSamples(const Instruction &I) const; + bool inlineHotFunctions(Function &F); void printEdgeWeight(raw_ostream &OS, Edge E); void printBlockWeight(raw_ostream &OS, const BasicBlock *BB) const; void printBlockEquivalence(raw_ostream &OS, const BasicBlock *BB); @@ -227,8 +231,11 @@ SampleProfileLoader::getInstWeight(const Instruction &Inst) const { return std::error_code(); const DILocation *DIL = DLoc; + const FunctionSamples *FS = findFunctionSamples(Inst); + if (!FS) + return std::error_code(); ErrorOr R = - Samples->findSamplesAt(Lineno - HeaderLineno, DIL->getDiscriminator()); + FS->findSamplesAt(Lineno - HeaderLineno, DIL->getDiscriminator()); if (R) DEBUG(dbgs() << " " << Lineno << "." << DIL->getDiscriminator() << ":" << Inst << " (line offset: " << Lineno - HeaderLineno << "." @@ -283,6 +290,121 @@ bool SampleProfileLoader::computeBlockWeights(Function &F) { return Changed; } +/// \brief Get the FunctionSamples for a call instruction. +/// +/// The FunctionSamples of a call instruction \p Inst is the inlined +/// instance in which that call instruction is calling to. It contains +/// all samples that resides in the inlined instance. We first find the +/// inlined instance in which the call instruction is from, then we +/// traverse its children to find the callsite with the matching +/// location and callee function name. +/// +/// \param Inst Call instruction to query. +/// +/// \returns The FunctionSamples pointer to the inlined instance. +const FunctionSamples * +SampleProfileLoader::findCalleeFunctionSamples(const CallInst &Inst) const { + const DILocation *DIL = Inst.getDebugLoc(); + if (!DIL) { + return nullptr; + } + DISubprogram *SP = DIL->getScope()->getSubprogram(); + if (!SP || DIL->getLine() < SP->getLine()) + return nullptr; + + Function *CalleeFunc = Inst.getCalledFunction(); + if (!CalleeFunc) { + return nullptr; + } + + StringRef CalleeName = CalleeFunc->getName(); + const FunctionSamples *FS = findFunctionSamples(Inst); + if (FS == nullptr) + return nullptr; + + return FS->findFunctionSamplesAt(CallsiteLocation( + DIL->getLine() - SP->getLine(), DIL->getDiscriminator(), CalleeName)); +} + +/// \brief Get the FunctionSamples for an instruction. +/// +/// The FunctionSamples of an instruction \p Inst is the inlined instance +/// in which that instruction is coming from. We traverse the inline stack +/// of that instruction, and match it with the tree nodes in the profile. +/// +/// \param Inst Instruction to query. +/// +/// \returns the FunctionSamples pointer to the inlined instance. +const FunctionSamples * +SampleProfileLoader::findFunctionSamples(const Instruction &Inst) const { + SmallVector S; + const DILocation *DIL = Inst.getDebugLoc(); + if (!DIL) { + return Samples; + } + StringRef CalleeName; + for (const DILocation *DIL = Inst.getDebugLoc(); DIL; + DIL = DIL->getInlinedAt()) { + DISubprogram *SP = DIL->getScope()->getSubprogram(); + if (!SP || DIL->getLine() < SP->getLine()) + return nullptr; + if (!CalleeName.empty()) { + S.push_back(CallsiteLocation(DIL->getLine() - SP->getLine(), + DIL->getDiscriminator(), CalleeName)); + } + CalleeName = SP->getLinkageName(); + } + if (S.size() == 0) + return Samples; + const FunctionSamples *FS = Samples; + for (int i = S.size() - 1; i >= 0 && FS != nullptr; i--) { + FS = FS->findFunctionSamplesAt(S[i]); + } + return FS; +} + +/// \brief Iteratively inline hot callsites of a function. +/// +/// Iteratively traverse all callsites of the function \p F, and find if +/// the corresponding inlined instance exists and is hot in profile. If +/// it is hot enough, inline the callsites and adds new callsites of the +/// callee into the caller. +/// +/// TODO: investigate the possibility of not invoking InlineFunction directly. +/// +/// \param F function to perform iterative inlining. +/// +/// \returns True if there is any inline happened. +bool SampleProfileLoader::inlineHotFunctions(Function &F) { + bool Changed = false; + while (true) { + bool LocalChanged = false; + SmallVector CIS; + for (auto &BB : F) { + for (auto &I : BB.getInstList()) { + CallInst *CI = dyn_cast(&I); + if (CI) { + const FunctionSamples *FS = findCalleeFunctionSamples(*CI); + if (FS && FS->getTotalSamples() > 0) { + CIS.push_back(CI); + } + } + } + } + for (auto CI : CIS) { + InlineFunctionInfo IFI; + if (InlineFunction(CI, IFI)) + LocalChanged = true; + } + if (LocalChanged) { + Changed = true; + } else { + break; + } + } + return Changed; +} + /// \brief Find equivalence classes for the given block. /// /// This finds all the blocks that are guaranteed to execute the same @@ -733,6 +855,8 @@ bool SampleProfileLoader::emitAnnotations(Function &F) { DEBUG(dbgs() << "Line number for the first instruction in " << F.getName() << ": " << HeaderLineno << "\n"); + Changed |= inlineHotFunctions(F); + // Compute basic block weights. Changed |= computeBlockWeights(F); diff --git a/test/Transforms/SampleProfile/Inputs/bad_discriminator_value.prof b/test/Transforms/SampleProfile/Inputs/bad_discriminator_value.prof index cc7f0d4f277..30e26cc8184 100644 --- a/test/Transforms/SampleProfile/Inputs/bad_discriminator_value.prof +++ b/test/Transforms/SampleProfile/Inputs/bad_discriminator_value.prof @@ -1,2 +1,2 @@ empty:100:0 -1.-3: 10 + 1.-3: 10 diff --git a/test/Transforms/SampleProfile/Inputs/bad_fn_header.prof b/test/Transforms/SampleProfile/Inputs/bad_fn_header.prof index abcb0ba3841..62227746655 100644 --- a/test/Transforms/SampleProfile/Inputs/bad_fn_header.prof +++ b/test/Transforms/SampleProfile/Inputs/bad_fn_header.prof @@ -1,3 +1,3 @@ 3empty:100:BAD -0: 0 -1: 100 + 0: 0 + 1: 100 diff --git a/test/Transforms/SampleProfile/Inputs/bad_mangle.prof b/test/Transforms/SampleProfile/Inputs/bad_mangle.prof index 50fe86119b7..33b4c42cab4 100644 --- a/test/Transforms/SampleProfile/Inputs/bad_mangle.prof +++ b/test/Transforms/SampleProfile/Inputs/bad_mangle.prof @@ -1,3 +1,3 @@ double convert(float):2909472:181842 -0: 181842 -1: 181842 + 0: 181842 + 1: 181842 diff --git a/test/Transforms/SampleProfile/Inputs/bad_sample_line.prof b/test/Transforms/SampleProfile/Inputs/bad_sample_line.prof index 038c45f77e3..608affa3ff9 100644 --- a/test/Transforms/SampleProfile/Inputs/bad_sample_line.prof +++ b/test/Transforms/SampleProfile/Inputs/bad_sample_line.prof @@ -1,3 +1,3 @@ empty:100:0 -0: 0 -1: BAD + 0: 0 + 1: BAD diff --git a/test/Transforms/SampleProfile/Inputs/bad_samples.prof b/test/Transforms/SampleProfile/Inputs/bad_samples.prof index a121d8c1ac4..bce7db9708d 100644 --- a/test/Transforms/SampleProfile/Inputs/bad_samples.prof +++ b/test/Transforms/SampleProfile/Inputs/bad_samples.prof @@ -1,2 +1,2 @@ empty:100:0 -1.3: -10 + 1.3: -10 diff --git a/test/Transforms/SampleProfile/Inputs/branch.prof b/test/Transforms/SampleProfile/Inputs/branch.prof index cd1cb5b1f16..5977a386c7e 100644 --- a/test/Transforms/SampleProfile/Inputs/branch.prof +++ b/test/Transforms/SampleProfile/Inputs/branch.prof @@ -1,8 +1,8 @@ main:15680:0 -0: 0 -4: 0 -7: 0 -9: 10226 -10: 2243 -16: 0 -18: 0 + 0: 0 + 4: 0 + 7: 0 + 9: 10226 + 10: 2243 + 16: 0 + 18: 0 diff --git a/test/Transforms/SampleProfile/Inputs/calls.prof b/test/Transforms/SampleProfile/Inputs/calls.prof index 57d3887dfb6..be64a1ead42 100644 --- a/test/Transforms/SampleProfile/Inputs/calls.prof +++ b/test/Transforms/SampleProfile/Inputs/calls.prof @@ -1,10 +1,10 @@ _Z3sumii:105580:5279 -0: 5279 -1: 5279 -2: 5279 + 0: 5279 + 1: 5279 + 2: 5279 main:225715:0 -2.1: 5553 -3: 5391 -# This indicates that at line 3 of this function, the 'then' branch -# of the conditional is taken (discriminator '1'). -3.1: 5752 _Z3sumii:5860 + 2.1: 5553 + 3: 5391 + # This indicates that at line 3 of this function, the 'then' branch + # of the conditional is taken (discriminator '1'). + 3.1: 5752 _Z3sumii:5860 diff --git a/test/Transforms/SampleProfile/Inputs/discriminator.prof b/test/Transforms/SampleProfile/Inputs/discriminator.prof index a6bcbc511a1..0c2561d725c 100644 --- a/test/Transforms/SampleProfile/Inputs/discriminator.prof +++ b/test/Transforms/SampleProfile/Inputs/discriminator.prof @@ -1,8 +1,8 @@ foo:1000:0 -1: 1 -2: 1 -2.1: 100 -3: 100 -3.1: 5 -4: 100 -5: 1 + 1: 1 + 2: 1 + 2.1: 100 + 3: 100 + 3.1: 5 + 4: 100 + 5: 1 diff --git a/test/Transforms/SampleProfile/Inputs/entry_counts.prof b/test/Transforms/SampleProfile/Inputs/entry_counts.prof index 5c2172b5a4d..95addc9f7a1 100644 --- a/test/Transforms/SampleProfile/Inputs/entry_counts.prof +++ b/test/Transforms/SampleProfile/Inputs/entry_counts.prof @@ -1,3 +1,3 @@ empty:100:13293 -0: 0 -1: 100 + 0: 0 + 1: 100 diff --git a/test/Transforms/SampleProfile/Inputs/fnptr.prof b/test/Transforms/SampleProfile/Inputs/fnptr.prof index 6a3b4e2315b..2491c427393 100644 --- a/test/Transforms/SampleProfile/Inputs/fnptr.prof +++ b/test/Transforms/SampleProfile/Inputs/fnptr.prof @@ -1,12 +1,12 @@ _Z3fooi:7711:610 -1: 610 + 1: 610 _Z3bari:20301:1437 -1: 1437 + 1: 1437 main:184019:0 -4: 534 -6: 2080 -9: 2064 _Z3bari:1471 _Z3fooi:631 -5.1: 1075 -5: 1075 -7: 534 -4.2: 534 + 4: 534 + 6: 2080 + 9: 2064 _Z3bari:1471 _Z3fooi:631 + 5.1: 1075 + 5: 1075 + 7: 534 + 4.2: 534 diff --git a/test/Transforms/SampleProfile/Inputs/propagate.prof b/test/Transforms/SampleProfile/Inputs/propagate.prof index b28609be66c..715321a4611 100644 --- a/test/Transforms/SampleProfile/Inputs/propagate.prof +++ b/test/Transforms/SampleProfile/Inputs/propagate.prof @@ -1,17 +1,17 @@ _Z3fooiil:58139:0 -0: 0 -1: 0 -2: 0 -4: 1 -5: 10 -6: 0 -7: 5 -8: 3 -9: 0 -10: 0 -11: 6339 -12: 16191 -13: 8141 -16: 1 -18: 0 -19: 0 + 0: 0 + 1: 0 + 2: 0 + 4: 1 + 5: 10 + 6: 0 + 7: 5 + 8: 3 + 9: 0 + 10: 0 + 11: 6339 + 12: 16191 + 13: 8141 + 16: 1 + 18: 0 + 19: 0 diff --git a/test/Transforms/SampleProfile/Inputs/syntax.prof b/test/Transforms/SampleProfile/Inputs/syntax.prof index f3738912a9d..465212d86e8 100644 --- a/test/Transforms/SampleProfile/Inputs/syntax.prof +++ b/test/Transforms/SampleProfile/Inputs/syntax.prof @@ -1,3 +1,3 @@ empty:100:0 -0: 0 -1: 100 + 0: 0 + 1: 100 diff --git a/test/tools/llvm-profdata/Inputs/sample-profile.proftext b/test/tools/llvm-profdata/Inputs/sample-profile.proftext index 9dc6d4310da..54c821243af 100644 --- a/test/tools/llvm-profdata/Inputs/sample-profile.proftext +++ b/test/tools/llvm-profdata/Inputs/sample-profile.proftext @@ -1,12 +1,12 @@ _Z3bari:20301:1437 -1: 1437 + 1: 1437 _Z3fooi:7711:610 -1: 610 + 1: 610 main:184019:0 -4: 534 -4.2: 534 -5: 1075 -5.1: 1075 -6: 2080 -7: 534 -9: 2064 _Z3bari:1471 _Z3fooi:631 + 4: 534 + 4.2: 534 + 5: 1075 + 5.1: 1075 + 6: 2080 + 7: 534 + 9: 2064 _Z3bari:1471 _Z3fooi:631 -- 2.34.1