[llvm-profgen] Filter out oversized LBR ranges.

[hoy]

Summary

As a follow up to D123271: [llvm-profgen] Filter out invalid LBR ranges., LBR ranges that are too big should also be considered as invalid.

For example, the last two pairs in the following trace form a range [0x0d7b02b0, 0x368ba706] that covers a ton of functions in the binary. Such oversized range should also be ignored.

0x0c74505f/0x368b99a0 **0x368ba706**/0x0c745040  0x0d7b1c3f/**0x0d7b02b0**

I'm using the size of the largest binary function range to define an oversized range, since there cannot be a linear execution range that spans over multiple function ranges.

[wenlei]

llvm/tools/llvm-profgen/PerfReader.h

225

While it has value to have such defensive checks in the tool, I'm wondering what has caused such bad input.

The range check seems hacky. If we have to go with it, we at least need some explanation why it's needed, and call out in comment that this is a workaround.

[hoy]

We don't seem to need this change at this point.

[hoy]

Updating D123361: [llvm-profgen] Filter out oversized LBR ranges.

[hoy]

Replaced by D125448: [llvm-profgen] Filter out oversized LBR ranges..

llvm/tools/llvm-profgen/PerfReader.h

 // into this counter. The key stores the sample data and the value is
 // the sample repeat times.
 using AggregatedCounter =
     std::unordered_map<Hashable<PerfSample>, uint64_t,
                        Hashable<PerfSample>::Hash, Hashable<PerfSample>::Equal>;
 
 using SampleVector = SmallVector<std::tuple<uint64_t, uint64_t, uint64_t>, 16>;
 
+
+inline bool isValidLBRRange(uint64_t Start, uint64_t End)
+{
+  // Start bigger than End is considered invalid.
+  // Larger LBR ranges are also assumed invalid.
+  return Start <= End && End <= Start +  (1 << 20);
+}
+
 // The state for the unwinder, it doesn't hold the data but only keep the
 // pointer/index of the data, While unwinding, the CallStack is changed
 // dynamicially and will be recorded as the context of the sample
 struct UnwindState {
   // Profiled binary that current frame address belongs to
   const ProfiledBinary *Binary;
   // Call stack trie node
   struct ProfiledFrame {

llvm/tools/llvm-profgen/PerfReader.cpp

void VirtualUnwinder::unwindCall(UnwindState &State) {
   }
   State.InstPtr.update(Source);
 }
 
 void VirtualUnwinder::unwindLinear(UnwindState &State, uint64_t Repeat) {
   InstructionPointer &IP = State.InstPtr;
   uint64_t Target = State.getCurrentLBRTarget();
   uint64_t End = IP.Address;
-  if (Target > End) {
+  if (!isValidLBRRange(Target, End)) {
     // Skip unwinding the rest of LBR trace when a bogus range is seen.
     State.setInvalid();
     return;
   }
   if (Binary->usePseudoProbes()) {
     // We don't need to top frame probe since it should be extracted
     // from the range.
     // The outcome of the virtual unwinding with pseudo probes is a
for (const LBREntry &LBR : Sample->LBRStack) {
     if (!LBR.IsArtificial && TargetOffset != ExternalAddr) {
       Counter.recordBranchCount(SourceOffset, TargetOffset, Repeat);
     }
 
     // If this not the first LBR, update the range count between TO of current
     // LBR and FROM of next LBR.
     uint64_t StartOffset = TargetOffset;
     if (EndOffeset != 0) {
-      if (StartOffset <= EndOffeset)
+      if (isValidLBRRange(StartOffset, EndOffeset))
         Counter.recordRangeCount(StartOffset, EndOffeset, Repeat);
     }
     EndOffeset = SourceOffset;
   }
 }
 
 void LBRPerfReader::parseSample(TraceStream &TraceIt, uint64_t Count) {
   std::shared_ptr<PerfSample> Sample = std::make_shared<PerfSample>();
void PerfScriptReader::warnInvalidRange() {
 
   const char *EndNotBoundaryMsg = "Range is not on instruction boundary, "
                                   "likely due to profile and binary mismatch.";
   const char *DanglingRangeMsg = "Range does not belong to any functions, "
                                  "likely from PLT, .init or .fini section.";
   const char *RangeCrossFuncMsg =
       "Fall through range should not cross function boundaries, likely due to "
       "profile and binary mismatch.";
-  const char *BogusRangeMsg = "Range start is after range end.";
+  const char *BogusRangeMsg = "Range start is after or too far from range end.";
 
   uint64_t TotalRangeNum = 0;
   uint64_t InstNotBoundary = 0;
   uint64_t UnmatchedRange = 0;
   uint64_t RangeCrossFunc = 0;
   uint64_t BogusRange = 0;
 
   for (auto &I : Ranges) {
if (!FRange) {
       continue;
     }
 
     if (EndOffset >= FRange->EndOffset) {
       RangeCrossFunc += I.second;
       WarnInvalidRange(StartOffset, EndOffset, RangeCrossFuncMsg);
     }
 
-    if (StartOffset > EndOffset) {
+    if (!isValidLBRRange(StartOffset, EndOffset)) {
       BogusRange += I.second;
       WarnInvalidRange(StartOffset, EndOffset, BogusRangeMsg);
     }
   }
 
   emitWarningSummary(
       InstNotBoundary, TotalRangeNum,
       "of samples are from ranges that are not on instruction boundary.");
   emitWarningSummary(
       UnmatchedRange, TotalRangeNum,
       "of samples are from ranges that do not belong to any functions.");
   emitWarningSummary(
       RangeCrossFunc, TotalRangeNum,
       "of samples are from ranges that do cross function boundaries.");
-  emitWarningSummary(
-      BogusRange, TotalRangeNum,
-      "of samples are from ranges that have range start after range end.");
+  emitWarningSummary(BogusRange, TotalRangeNum,
+                     "of samples are from ranges that have range start after "
+                     "or too far from range end.");
 }
 
 void PerfScriptReader::parsePerfTraces() {
   // Parse perf traces and do aggregation.
   parseAndAggregateTrace();
 
   emitWarningSummary(NumLeafExternalFrame, NumTotalSample,
                      "of samples have leaf external frame in call stack.");