[LNT] Remove `nm` dependency, used `objdump –t` instead

[kpdev42]

Summary

It is necessary to use the correct nm and objdump for some targets (for example ARM thumb).
Wrong nm can provide an information but addresses may be wrong. The correct nm for ARM will report the address 0x1234 for a thumb binary, but system’s nm (x86) will report the address 0x1235.
It is very hard to investigate such issues. We suggest to remove nm dependency at all and use objdump -t instead.
Note objdump allows demangling too. It makes the profile page more human friendly.
Here is the objdump -t output format for reference https://github.com/llvm-mirror/llvm/blob/2c4ca6832fa6b306ee6a7010bfb80a3f2596f824/tools/llvm-objdump/llvm-objdump.cpp#L1850

OS Laboratory. Huawei Russian Research Institute. Saint-Petersburg

[thopre]

Adding Tamar to get an Arm person to review this.

[kpdev42]

Rebase

[tnfchris]

The code itself looks fine to me,

Wrong nm can provide an information but addresses may be wrong. The correct nm for ARM will report the address 0x1234 for a thumb binary, but system’s nm (x86) will report the address 0x1235.

Right since nm only reads the ELF header and doesn't need to understand the object format first, so it's unable to strip the Thumb bit as it has no concept of Thumb.
But objdump does need to understand it, for better or worse..

So by depending on objdump it does mean you can only really support one target at once (unless you have an objdump built with support for al bfd targets).
Looks like that's not a new change in this Diff. but something we might want to change in the future.

[tnfchris]

So by depending on objdump it does mean you can only really support one target at once (unless you have an objdump built with support for al bfd targets).
Looks like that's not a new change in this Diff. but something we might want to change in the future.

I just realized that this is only done so during the profile upgrade so this is fine. disregard :)

lnt/server/ui/profile_views.py

 from flask import abort
 from flask import request
 from sqlalchemy.orm.exc import NoResultFound
 
 from flask import render_template, current_app
 import os
 import json
+import urllib
 from lnt.server.ui.decorators import v4_route, frontend
 from lnt.server.ui.globals import v4_url_for
 from lnt.server.ui.views import ts_data
 
 
 def _get_sample(session, ts, run_id, test_id):
     return session.query(ts.Sample) \
                     .filter(ts.Sample.run_id == run_id) \

 
 
 @v4_route("/profile/ajax/getCodeForFunction")
 def v4_profile_ajax_getCodeForFunction():
     session = request.session
     ts = request.get_testsuite()
     runid = request.args.get('runid')
     testid = request.args.get('testid')
-    f = request.args.get('f')
+    f = urllib.parse.unquote(request.args.get('f'))
 
     profileDir = current_app.old_config.profileDir
 
     sample = _get_sample(session, ts, runid, testid)
     if not sample or not sample.profile:
         abort(404)
 
     p = sample.profile.load(profileDir)

lnt/server/ui/static/lnt_profile.js

Profile.prototype = {
     },
 
     _fetch_and_display: function(fname, then) {
         this.function_name = fname;
         var this_ = this;
         $.ajax(g_urls.getCodeForFunction, {
             dataType: "json",
             data: {'runid': this.runid, 'testid': this.testid,
-                   'f': fname},
+                   'f': encodeURIComponent(fname)},
             success: function(data) {
                 this_.data = data;
                 this_._display();
             },
             error: function(xhr, textStatus, errorThrown) {
                 pf_flash_error('accessing URL ' + g_urls.getCodeForFunction +
                                '; ' + errorThrown);
             }
element.typeahead({
                     bval = b[1].counters[c];
                 }
                 return bval - aval;
             });
             return items;
         },
         updater: function(item) {
             // FIXME: the item isn't passed in as json any more, it's
-            // been rendered. Lame. Hack around this by splitting apart
-            // the ','-concatenated 2-tuple again.
-            fname = item.split(',')[0];
+            // been rendered ("fname,[object Object]"). Lame. Hack around
+            // this by splitting apart the ','-concatenated 2-tuple again.
+            var splitIndex = item.lastIndexOf(',');
+            fname = item.substr(0, splitIndex);
 
             options.updated(fname);
             return fname;
         },
         highlighter: function(item) {
             // Highlighting functions is a bit arduous - do it in
             // a helper function instead.
             return _this._renderItem(item, this.query);

lnt/testing/profile/cPerf.cpp

 // and the perf_events manpage.
 //
 // Once the aggregation is done, we do a single pass through the event data:
 //
 //   for each mmap:
 //       if the mmap's event total is < 1% of the total in all counters,
 //         then discard the mmap [1].
 //
-//       load symbol data by calling "nm" and parsing the result.
+//       load symbol data by calling "objdump -t" and parsing the result.
 //       for all PCs we have events for, in sorted order:
 //           find the symbol this PC is part of -> Sym
 //           look up all PCs between Sym.Start and Sym.End and emit data
 //
 // The output of this module (cPerf.importPerf) is a dictionary in (almost)
 // ProfileV1 form (see profile.py and profilev1impl.py). The only difference is
 // that all counters are absolute.
 //
 // [1]: Perf will start sampling from the moment the perf wrapper tool is
 // invoked, and its samples will continue until the perf wrapper tool exits.
 // This means that it will often take one or two samples in intermediate
 // binaries like "perf", "bash", or libaries such as libdl. We don't care about
-// these, and these binaries and libraries are very large to nm and objdump.
+// these, and these binaries and libraries are very large to objdump.
 //
 // So we have a threshold - if a binary contains < 1% of all samples, don't
 // bother importing it.
 //
 //===----------------------------------------------------------------------===//
 
 #ifdef _WIN32
 #define WIN32_LEAN_AND_MEAN
static const char* sw_event_names[PERF_COUNT_SW_MAX] = {
   "cpu-migrations",
   "minor-faults",
   "major-faults",
   "alignment-faults",
   "emulation-faults"
 };
 
 //===----------------------------------------------------------------------===//
-// Readers for nm and objdump output
+// Readers for objdump output
 //===----------------------------------------------------------------------===//
 
 struct Map {
   uint64_t Start, End, Adjust;
   const char *Filename;
 };
 
 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 NmOutput : public std::vector<Symbol> {
+class SymTabOutput : public std::vector<Symbol> {
 public:
-  std::string Nm, BinaryCacheRoot;
+  std::string Objdump, BinaryCacheRoot;
 
-  NmOutput(std::string Nm, std::string BinaryCacheRoot)
-    : Nm(Nm), BinaryCacheRoot(BinaryCacheRoot) {}
+  SymTabOutput(std::string Objdump, std::string BinaryCacheRoot)
+    : Objdump(Objdump), BinaryCacheRoot(BinaryCacheRoot) {}
 
-  void fetchSymbols(Map *M, bool Dynamic) {
-    std::string D = "-D";
-    if (!Dynamic)
-      // Don't fetch the dynamic symbols - instead fetch static ones.
-      D = "";
-    std::string Cmd = Nm + " " + D + " -S --defined-only " +
+  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
     auto Stream = ForkAndExec(Cmd);
 
     char *Line = nullptr;
     size_t LineLen = 0;
     while (true) {
       ssize_t Len = getline(&Line, &LineLen, Stream);
       if (Len == -1)
         break;
 
-      std::vector<std::string> SplittedLine;
-      if (splitLine(std::string(Line), SplittedLine) < 4)
-        continue; 
+      std::stringstream SS(Line);
+
+      std::string Start;
+      if (!std::getline(SS, Start, ' '))
+        continue;
+      char* EndPtr = NULL;
+      uint64_t NStart = strtoull(Start.c_str(), &EndPtr, 16);
+      if (EndPtr == Start.c_str())
+        continue;
 
-      const std::string& One = SplittedLine[0];
-      const std::string& Two = SplittedLine[1];
-      const std::string& Three = SplittedLine[2];
-      std::string& Four = SplittedLine[3];
+      char GlobLoc;          // Local -> 'l', Global -> 'g', Neither -> ' '
+      if (!SS.get(GlobLoc))
+        continue;
+      char Weak;             // Weak?
+      if (!SS.get(Weak))
+        continue;
+      char Space;
+      if (!SS.get(Space))    // Constructor. Not supported yet.
+        continue;
+      if (!SS.get(Space))    // Warning. Not supported yet.
+        continue;
+      char IFunc;            // Indirect reference to another symbol.
+      if (!SS.get(IFunc))
+        continue;
+      char Debug;            // Debugging (d) or dynamic (D) symbol.
+      if (!SS.get(Debug))
+        continue;
+      char FileFunc;         // Name of function (F), file (f) or object (O).
+      if (!SS.get(FileFunc))
+        continue;
+      if (FileFunc != 'F')
+        continue;
+      if (!SS.get(Space))
+        continue;
 
-      char *EndPtr = NULL;
-      uint64_t Start = strtoull(One.c_str(), &EndPtr, 16);
-      if (EndPtr == One.c_str())
+      std::string Section;
+      if (!std::getline(SS, Section, '\t'))
         continue;
-      uint64_t Extent = strtoull(Two.c_str(), &EndPtr, 16);
-      if (EndPtr == Two.c_str())
+      if (Section != ".text")
         continue;
-      if (Three.length() != 1)
+
+      std::string Extent;
+      if (!std::getline(SS, Extent, ' '))
         continue;
-      switch (Three.front()) {
-      default:
-        continue;
-      case 'T':
-      case 't': // Text section
-      case 'V':
-      case 'v': // Weak object
-      case 'W':
-      case 'w': // Weak object (not tagged as such)
-        break;
-      }
-      if (Four.back() == '\n')
-        Four.pop_back();
-      push_back({Start, Start + Extent, Four});
+      uint64_t NExtent = strtoull(Extent.c_str(), &EndPtr, 16);
+      if (EndPtr == Extent.c_str())
+        continue;
+
+      std::string Func;
+      while (std::getline(SS, Func, ' ') && Func.empty());  // Skip spaces.
+      if (Func.empty())
+        continue;
+      // Note Func includes the symbol table visibility if any.
+      std::string FuncRest;
+      if (std::getline(SS, FuncRest)) // Read the rest line if any.
+        Func += std::string(" ") + FuncRest;
+      if (Func.back() == '\n')
+        Func.pop_back();
+      push_back({NStart, NStart + NExtent, Func});
     }
     if (Line)
       free(Line);
 
 #ifdef _WIN32
     _pclose(Stream);
 #else
     fclose(Stream);
     wait(NULL);
 #endif
   }
 
   void reset(Map *M) {
     clear();
     // Fetch both dynamic and static symbols, sort and unique them.
-    fetchSymbols(M, true);
-    fetchSymbols(M, false);
+    fetchSymbols(M);
     
     std::sort(begin(), end());
     auto NewEnd = std::unique(begin(), end());
     erase(NewEnd, end());
   }
 
 protected:
   int splitLine(const std::string& line, std::vector<std::string>& output, char delim = ' ') {

 };
 
 //===----------------------------------------------------------------------===//
 // PerfReader
 //===----------------------------------------------------------------------===//
 
 class PerfReader {
 public:
-  PerfReader(const std::string &Filename, std::string Nm,
-             std::string Objdump, std::string BinaryCacheRoot);
+  PerfReader(const std::string &Filename, std::string Objdump,
+             std::string BinaryCacheRoot);
   ~PerfReader();
 
   void readHeader();
   void readAttrs();
   void readEventDesc();
   void readDataStream();
   unsigned char *readEvent(unsigned char *);
   perf_event_sample parseEvent(unsigned char *Buf, uint64_t Layout);
#endif
   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;
 
   PyObject *Functions, *TopLevelCounters;
   std::vector<PyObject*> Lines;
   
-  std::string Nm, Objdump, BinaryCacheRoot;
+  std::string Objdump, BinaryCacheRoot;
 };
 
-PerfReader::PerfReader(const std::string &Filename,
-                       std::string Nm, std::string Objdump,
+PerfReader::PerfReader(const std::string &Filename, std::string Objdump,
                        std::string BinaryCacheRoot)
-    : Nm(Nm), Objdump(Objdump), BinaryCacheRoot(BinaryCacheRoot) {
+    : Objdump(Objdump), BinaryCacheRoot(BinaryCacheRoot) {
   TopLevelCounters = PyDict_New();
   Functions = PyDict_New();
 #ifdef _WIN32
   Buffer = nullptr;
   hMapFile = nullptr;
   hFile = ::CreateFileA(Filename.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL,
                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
   assert(hFile != INVALID_HANDLE_VALUE);
for (auto &I : TotalEventsPerMap[MapID]) {
         break;
       }
     }
     if (AllUnderThreshold)
       continue;
 
     uint64_t Adjust = Maps[MapID].Adjust;
 
-    NmOutput Syms(Nm, BinaryCacheRoot);
+    SymTabOutput Syms(Objdump, BinaryCacheRoot);
     Syms.reset(&Maps[MapID]);
 
     // 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
PyObject *PerfReader::complete() {
   PyDict_SetItemString(Obj, "counters", TopLevelCounters);
   PyDict_SetItemString(Obj, "functions", Functions);
   return Obj;
 }
 
 #ifndef STANDALONE
 static PyObject *cPerf_importPerf(PyObject *self, PyObject *args) {
   const char *Fname;
-  const char *Nm = "nm";
   const char *Objdump = "objdump";
   const char *BinaryCacheRoot = "";
-  if (!PyArg_ParseTuple(args, "s|sss", &Fname, &Nm, &Objdump, &BinaryCacheRoot))
+  if (!PyArg_ParseTuple(args, "s|ss", &Fname, &Objdump, &BinaryCacheRoot))
     return NULL;
 
   try {
-    PerfReader P(Fname, Nm, Objdump, BinaryCacheRoot);
+    PerfReader P(Fname, Objdump, BinaryCacheRoot);
     P.readHeader();
     P.readAttrs();
     P.readDataStream();
     P.emitTopLevelCounters();
     P.emitMaps();
     return P.complete();
   } catch (std::logic_error &E) {
     PyErr_SetString(PyExc_AssertionError, E.what());

 }
 #endif
 
 #else // STANDALONE
 
 int main(int argc, char **argv) {
   Py_Initialize();
   if (argc < 2)  return -1;
-  PerfReader P(argv[1], "nm", "objdump", "");
+  PerfReader P(argv[1], "objdump", "");
   P.readHeader();
   P.readAttrs();
   P.readDataStream();
   P.emitTopLevelCounters();
   P.emitMaps();
   PyObject_Print(P.complete(), stdout, Py_PRINT_RAW);
   Py_FinalizeEx();
   return 0;
 }
 
 #endif

lnt/testing/profile/perf.py

def __init__(self):
         pass
 
     @staticmethod
     def checkFile(fn):
         with open(fn, 'rb') as f:
             return f.read(8) == b'PERFILE2'
 
     @staticmethod
-    def deserialize(f, nm='nm', objdump='objdump', propagateExceptions=False,
+    def deserialize(f, objdump='objdump', propagateExceptions=False,
                     binaryCacheRoot=''):
         f = f.name
 
         if os.path.getsize(f) == 0:
             # Empty file - exit early.
             return None
 
         try:
-            data = cPerf.importPerf(f, nm, objdump)
+            data = cPerf.importPerf(f, objdump, binaryCacheRoot)
 
             # Go through the data and convert counter values to percentages.
             for f in data['functions'].values():
                 fc = f['counters']
                 for inst_info in f['data']:
                     for k, v in inst_info[0].items():
                         inst_info[0][k] = 100.0 * float(v) / fc[k]
                 for k, v in fc.items():

lnt/testing/profile/profile.py

def fromFile(f):
         """
         for impl in lnt.testing.profile.IMPLEMENTATIONS.values():
             if impl.checkFile(f):
                 ret = None
                 with open(f, 'rb') as fd:
                     if impl is lnt.testing.profile.perf.LinuxPerfProfile:
                         ret = impl.deserialize(
                             fd,
-                            nm=os.getenv('CMAKE_NM', 'nm'),
                             objdump=os.getenv('CMAKE_OBJDUMP', 'objdump'),
                             binaryCacheRoot=os.getenv('LNT_BINARY_CACHE_ROOT', ''))
                     else:
                         ret = impl.deserialize(fd)
                 if ret:
                     return Profile(ret)
                 else:
                     return None