[BOLT] Distinguish sections in heatmap

[FPar]

Summary

Output different letters for different sections in the heatmap to
visually separate sections.

[FPar]

Fix comment

[FPar]

Fix legend

[maksfb]

LGTM

bolt/lib/Profile/Heatmap.cpp

 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
+#include <cctype>
 #include <cmath>
 #include <vector>
 
 #define DEBUG_TYPE "bolt-heatmap"
 
 using namespace llvm;
 
 namespace llvm {
void Heatmap::print(raw_ostream &OS) const {
 
   uint64_t Range[NumRanges];
   for (uint64_t I = 0; I < NumRanges; ++I)
     Range[I] = std::max(I + 1, (uint64_t)std::pow((double)MaxValue,
                                                   (double)(I + 1) / NumRanges));
   Range[NumRanges - 1] = std::max((uint64_t)NumRanges, MaxValue);
 
   // Print scaled value
-  auto printValue = [&](uint64_t Value, bool ResetColor = false) {
+  auto printValue = [&](uint64_t Value, char Character, bool ResetColor) {
     assert(Value && "should only print positive values");
     for (unsigned I = 0; I < sizeof(Range) / sizeof(Range[0]); ++I) {
       if (Value <= Range[I]) {
         changeColor(Colors[I]);
         break;
       }
     }
     if (Value <= Range[0])
-      OS << 'o';
+      OS << static_cast<char>(std::tolower(Character));
     else
-      OS << 'O';
+      OS << static_cast<char>(std::toupper(Character));
 
     if (ResetColor)
       changeColor(DefaultColor);
   };
 
   // Print against black background
   OS.changeColor(raw_ostream::BLACK, /*Bold=*/false, /*Background=*/true);
   changeColor(DefaultColor);
 
   // Print map legend
   OS << "Legend:\n";
   uint64_t PrevValue = 0;
   for (unsigned I = 0; I < sizeof(Range) / sizeof(Range[0]); ++I) {
     const uint64_t Value = Range[I];
     OS << "  ";
-    printValue(Value, true);
+    printValue(Value, 'o', /*ResetColor=*/true);
     OS << " : (" << PrevValue << ", " << Value << "]\n";
     PrevValue = Value;
   }
 
   // Pos - character position from right in hex form.
   auto printHeader = [&](unsigned Pos) {
     OS << "            ";
     if (MaxAddress > 0xffffffff)
       OS << "        ";
     unsigned PrevValue = unsigned(-1);
     for (unsigned I = 0; I < BytesPerLine; I += BucketSize) {
       const unsigned Value = (I & ((1 << Pos * 4) - 1)) >> (Pos - 1) * 4;
       if (Value != PrevValue) {
         OS << Twine::utohexstr(Value);
         PrevValue = Value;
       } else {
         OS << ' ';
       }
     }
     OS << '\n';
   };
   for (unsigned I = 5; I > 0; --I)
     printHeader(I);
 
+  auto SectionStart = TextSections.begin();
   uint64_t PrevAddress = 0;
   for (auto MI = Map.begin(), ME = Map.end(); MI != ME; ++MI) {
     const std::pair<const uint64_t, uint64_t> &Entry = *MI;
     uint64_t Address = Entry.first * BucketSize;
+    char Character = 'o';
+
+    // Check if address is in the current or any later section.
+    auto Section = std::find_if(
+        SectionStart, TextSections.end(), [&](const SectionNameAndRange &S) {
+          return Address >= S.BeginAddress && Address < S.EndAddress;
+        });
+    if (Section != TextSections.end()) {
+      // Shift the section forward (if SectionStart is different from Section).
+      // This works, because TextSections is sorted by start address.
+      SectionStart = Section;
+      Character = 'a' + ((Section - TextSections.begin()) % 26);
+    }
 
     if (PrevAddress)
       fillRange(PrevAddress, Address);
     else
       startLine(Address);
 
-    printValue(Entry.second);
+    printValue(Entry.second, Character, /*ResetColor=*/false);
 
     PrevAddress = Address;
   }
 
   if (PrevAddress) {
     changeColor(DefaultColor);
     finishLine(PrevAddress);
   }