perf: Fix profile reading to correctly take segments into account.

[tnfchris]

Summary

LNT's perf parsing implementation has a very subtle bug horrible bug:

It's assuming that the text segment starts at the same address that
the program was loaded at.  Or rather, it assumes the text segment is
at address 0.

This is usually not the case (and indeed LLD itself puts many non-exec
Segments before the first exec one)

Because of this no event is matched for certain binaries.  Also the
code can wrongly try to attribute an event to the wrong MMAP because
it only checks the starting address.  This means that the order of the
MMAPs matters and again as of a few days ago the order coming out of
LLD places the binary itself after most SOs including ld.so.

By checking only the start address we can attribute an event to an SO
instead of to the program since trivially shared libraries are
loaded before the program itself in the virtual memory space.  This
would later fail to resolve but we'd lose the event.

This patch changes it to also check for the ending position.

[thopre]

LGTM with the following description change: very subtle bug horrible bug -> very subtle *but* horrible bug

[tnfchris]

Landed with dcf5fc3f60846b5d2e436befb934493f5132ffd9

lnt/testing/profile/cPerf.cpp

#else
   int P[2];
   pipe(P);
 
   FILE *Stream = fdopen(P[0], "r");
 
   if (fork() == 0) {
     dup2(P[1], 1);
     close(P[0]);
-    execl("/bin/sh", "sh", "-c", Cmd.c_str(), 0);
+    execl("/bin/sh", "sh", "-c", Cmd.c_str(), (char *)NULL);
   } else {
     close(P[1]);
   }
 #endif
   return Stream;
 }
 
 #ifdef _WIN32

 // Readers for objdump output
 //===----------------------------------------------------------------------===//
 
 struct Map {
   uint64_t Start, End, Adjust;
   const char *Filename;
 };
 
+struct EventDesc {
+  uint64_t Start;
+  uint64_t End;
+  size_t MapId;
+};
+
 struct Symbol {
   uint64_t Start;
   uint64_t End;
   std::string Name;
 
   bool operator<(const Symbol &Other) const { return Start < Other.Start; }
   bool operator==(const Symbol &Other) const {
     return Start == Other.Start && End == Other.End && Name == Other.Name;
   }
 };
 
 class SymTabOutput : public std::vector<Symbol> {
 public:
   std::string Objdump, BinaryCacheRoot;
 
   SymTabOutput(std::string Objdump, std::string BinaryCacheRoot)
     : Objdump(Objdump), BinaryCacheRoot(BinaryCacheRoot) {}
 
+  uint64_t fetchExecSegment(Map *M) {
+    std::string Cmd = Objdump + " -p -C " +
+                      BinaryCacheRoot + std::string(M->Filename) +
+#ifdef _WIN32
+                      " 2> NUL";
+#else
+                      " 2>/dev/null";
+#endif
+    auto Stream = ForkAndExec(Cmd);
+
+    char *Line = nullptr, *PrevLine = nullptr;
+    size_t LineLen = 0;
+    uint64_t offset = 0;
+    while (true) {
+      if (PrevLine)
+        free (PrevLine);
+      if (Line)
+        PrevLine = strdup (Line);
+      ssize_t Len = getline(&Line, &LineLen, Stream);
+      if (Len == -1)
+        break;
+
+      char* pos;
+      if ((pos = strstr (Line, "flags r-x")) == NULL
+          && (pos = strstr (Line, "flags rwx")) == NULL)
+        continue;
+
+      /* Format is weird.. but we did find the section so punt.  */
+      if ((pos = strstr (PrevLine, "vaddr ")) == NULL)
+        break;
+
+      pos += 6;
+      offset = strtoull (pos, NULL, 16);
+      break;
+    }
+    if (Line)
+      free(Line);
+    if (PrevLine)
+      free(PrevLine);
+
+#ifdef _WIN32
+    _pclose(Stream);
+#else
+    fclose(Stream);
+    wait(NULL);
+#endif
+    return offset;
+  }
+
   void fetchSymbols(Map *M) {
     std::string Cmd = Objdump + " -t -T -C " +
                       BinaryCacheRoot + std::string(M->Filename) +
 #ifdef _WIN32
                       " 2> NUL";
 #else
                       " 2>/dev/null";
 #endif
#else
     fclose(Stream);
     wait(NULL);
 #endif
   }
 
   void reset(Map *M) {
     clear();
     // Fetch both dynamic and static symbols, sort and unique them.
+    uint64_t segmentStart = fetchExecSegment (M);
+    /* Adjust the symbol to a value relative to the start of the load address
+    to match up with registerNewMapping.  */
+    M->Adjust -= segmentStart;
     fetchSymbols(M);
 
     std::sort(begin(), end());
     auto NewEnd = std::unique(begin(), end());
     erase(NewEnd, end());
   }
 
 protected:
#endif
 
   perf_header *Header;
   std::map<uint64_t, const char *> EventIDs;
   std::map<uint64_t, uint64_t> EventLayouts;
   std::map<size_t, std::map<uint64_t, std::map<const char *, uint64_t>>> Events;
   std::map<const char *, uint64_t> TotalEvents;
   std::map<uint64_t, std::map<const char *, uint64_t>> TotalEventsPerMap;
   std::vector<Map> Maps;
-  std::map<uint64_t, std::map<uint64_t, size_t>> CurrentMaps;
+  std::map<uint64_t, std::map<uint64_t, EventDesc>> CurrentMaps;
 
   PyObject *Functions, *TopLevelCounters;
   std::vector<PyObject*> Lines;
   std::string Objdump, BinaryCacheRoot;
   double Threshold;
 };
 
 PerfReader::PerfReader(const std::string &Filename, std::string Objdump,
void PerfReader::registerNewMapping(unsigned char *Buf, const char *Filename) {
   uint64_t Adjust = IsSO ? E->start - E->pgoff : 0;
   Maps.push_back({E->start, End, Adjust, Filename});
 
   unsigned char *EndOfEvent = Buf + E->header.size;
   // FIXME: The first EventID is used for every event.
   // FIXME: The code assumes perf_event_attr.sample_id_all is set.
   uint64_t Time = getTimeFromSampleId(EndOfEvent, EventLayouts.begin()->second);
   auto &CurrentMap = CurrentMaps[Time];
-  CurrentMap.insert({E->start, MapID});
+  CurrentMap.insert({E->start, { E->start, End, MapID}});
 }
 
 unsigned char *PerfReader::readEvent(unsigned char *Buf) {
   perf_event_header *E = (perf_event_header *)Buf;
   switch (E->type) {
   case PERF_RECORD_MMAP:
   {
     perf_event_mmap *E = (perf_event_mmap *)Buf;
for (auto I = CurrentMaps.rbegin(), E = CurrentMaps.rend();
       if (I->first > NewE.time)
         continue;
 
       auto NewI = I->second.upper_bound(PC);
       if (NewI == I->second.begin())
         continue;
       --NewI;
 
-      if (NewI->first > PC)
+      if (NewI->second.Start > PC || NewI->second.End < PC)
         continue;
-      MapID = NewI->second;
+      MapID = NewI->second.MapId;
       break;
     }
     if (MapID != ~0ULL) {
       assert(EventIDs.count(EventID));
       Events[MapID][PC][EventIDs[EventID]] += NewE.period;
 
       TotalEvents[EventIDs[EventID]] += NewE.period;
       TotalEventsPerMap[MapID][EventIDs[EventID]] += NewE.period;
for (auto &I : TotalEventsPerMap[MapID]) {
       if ((float)I.second / (float)Total > 0.01f) {
         AllUnderThreshold = false;
         break;
       }
     }
     if (AllUnderThreshold)
       continue;
 
-    uint64_t Adjust = Maps[MapID].Adjust;
-
     SymTabOutput Syms(Objdump, BinaryCacheRoot);
     Syms.reset(&Maps[MapID]);
 
+    uint64_t Adjust = Maps[MapID].Adjust;
+
     // Accumulate the event totals for each symbol
     auto Sym = Syms.begin();
     auto Event = MapEvents.begin();
     std::map<uint64_t, std::map<const char*, uint64_t>> SymToEventTotals;
     while (Event != MapEvents.end() && Sym != Syms.end()) {
       // Skip events until we find one after the start of Sym
       auto PC = Event->first - Adjust;
       if (PC < Sym->Start) {