Allow building heatmaps from basic sampled events with `-nl`.

[rahmanl]

Summary

I find that this is useful for finding event hotspots.

[rafauler]

bolt/lib/Profile/DataAggregator.cpp

1346

Missing ;

[rahmanl]

Update the doc.

[rahmanl]

Fixed the error.

[rahmanl]

change "simple events" to "basic events".

[rafauler]

Thanks! LGTM

bolt/docs/Heatmaps.md

 ```bash
 $ perf record -e cycles:u -j any,u -- <executable with args>
 ```
 or if you want to monitor the existing process(es):
 ```bash
 $ perf record -e cycles:u -j any,u [-p PID|-a] -- sleep <interval>
 ```
 
-Note that at the moment running with LBR (`-j any,u` or `-b`) is
-a requirement.
+Running with LBR (`-j any,u` or `-b`) is recommended. Heatmaps can be generated
+from simple events by using the llvm-bolt-heatmap option `-nl` (no LBR) but
+such heatmaps do not have the coverage provided by LBR and may only be useful
+for finding event hotspots at larger code block granularities.
 
 Once the run is complete, and `perf.data` is generated, run llvm-bolt-heatmap:
 
 ```bash
 $ llvm-bolt-heatmap -p perf.data <executable>
 ```
 
 By default the heatmap will be dumped to *stdout*. You can change it

bolt/lib/Profile/DataAggregator.cpp

if (opts::LinuxKernelMode) {
     opts::HeatmapMaxAddress = 0xffffffffffffffff;
     opts::HeatmapMinAddress = KernelBaseAddr;
   }
   Heatmap HM(opts::HeatmapBlock, opts::HeatmapMinAddress,
              opts::HeatmapMaxAddress);
   uint64_t NumTotalSamples = 0;
 
   while (hasData()) {
+    if (opts::BasicAggregation) {
+      ErrorOr<PerfBasicSample> SampleRes = parseBasicSample();
+      if (std::error_code EC = SampleRes.getError()) {
+        if (EC == errc::no_such_process)
+          continue;
+        return EC;
+      }
+      PerfBasicSample &Sample = SampleRes.get();
+      HM.registerAddress(Sample.PC);
+      NumTotalSamples++;
+    } else {
       ErrorOr<PerfBranchSample> SampleRes = parseBranchSample();
       if (std::error_code EC = SampleRes.getError()) {
         if (EC == errc::no_such_process)
           continue;
         return EC;
       }
 
       PerfBranchSample &Sample = SampleRes.get();
 
       // LBRs are stored in reverse execution order. NextLBR refers to the next
       // executed branch record.
       const LBREntry *NextLBR = nullptr;
       for (const LBREntry &LBR : Sample.LBR) {
         if (NextLBR) {
           // Record fall-through trace.
           const uint64_t TraceFrom = LBR.To;
           const uint64_t TraceTo = NextLBR->From;
           ++FallthroughLBRs[Trace(TraceFrom, TraceTo)].InternCount;
         }
         NextLBR = &LBR;
       }
       if (!Sample.LBR.empty()) {
         HM.registerAddress(Sample.LBR.front().To);
         HM.registerAddress(Sample.LBR.back().From);
       }
       NumTotalSamples += Sample.LBR.size();
     }
+  }
 
   if (!NumTotalSamples) {
+    if (!opts::BasicAggregation) {
       errs() << "HEATMAP-ERROR: no LBR traces detected in profile. "
-              "Cannot build heatmap.\n";
+                "Cannot build heatmap. Use -nl for building heatmap from "
+                "basic events.\n";
+    } else {
+      errs() << "HEATMAP-ERROR: no samples detected in profile. "
+                "Cannot build heatmap.";
+    }
     exit(1);
   }
 
   outs() << "HEATMAP: read " << NumTotalSamples << " LBR samples\n";
   outs() << "HEATMAP: " << FallthroughLBRs.size() << " unique traces\n";
 
   outs() << "HEATMAP: building heat map...\n";