add DWARF_LINE* macros to help diagnosis

Similarly to the previous commit, we modify the new safe_dwarf_line*()
functions so that they carry __FILE__ and __LINE__ information into the
error. This new information is filled in when using the new DWARF_LINE*
macros.

Before:

semantic error: libdw failure (dwarf_lineaddr): no error

After:

semantic error: libdw failure (dwarf_lineaddr): no error
   thrown from: ../systemtap/dwflpp.cxx:2242

diff --git a/dwarf_wrappers.h b/dwarf_wrappers.h
index c6f2782f2cd7c00a1703d08aa399bd3a19e31af7..10d1ad1f441dd0ed7c09ebe06041547331139cc7 100644 (file)
--- a/dwarf_wrappers.h
+++ b/dwarf_wrappers.h
@@ -73,41 +73,64 @@ dwarf_assert(const std::string& desc, const void* ptr,
     dwarf_assert(desc, -1, file, line);
 }
 
+#define DWARF_LINENO(line) \
+  safe_dwarf_lineno(line, __FILE__, __LINE__)
+
 inline int
-safe_dwarf_lineno(const Dwarf_Line* line)
+safe_dwarf_lineno(const Dwarf_Line* line,
+                  const std::string& errfile, int errline)
 {
   int lineno;
-  DWARF_ASSERT("dwarf_lineno",
-               dwarf_lineno(const_cast<Dwarf_Line*>(line), &lineno));
+  dwarf_assert("dwarf_lineno",
+               dwarf_lineno(const_cast<Dwarf_Line*>(line), &lineno),
+               errfile, errline);
   return lineno;
 }
 
+#define DWARF_LINEADDR(line) \
+  safe_dwarf_lineaddr(line, __FILE__, __LINE__)
+
 inline Dwarf_Addr
-safe_dwarf_lineaddr(const Dwarf_Line* line)
+safe_dwarf_lineaddr(const Dwarf_Line* line,
+                    const std::string& errfile, int errline)
 {
   Dwarf_Addr addr;
-  DWARF_ASSERT("dwarf_lineaddr",
-               dwarf_lineaddr(const_cast<Dwarf_Line*>(line), &addr));
+  dwarf_assert("dwarf_lineaddr",
+               dwarf_lineaddr(const_cast<Dwarf_Line*>(line), &addr),
+               errfile, errline);
   return addr;
 }
 
+#define DWARF_LINESRC(line) \
+  safe_dwarf_linesrc(line, NULL, NULL, __FILE__, __LINE__)
+#define DWARF_LINESRC2(line, mtime) \
+  safe_dwarf_linesrc(line, mtime, NULL, __FILE__, __LINE__)
+#define DWARF_LINESRC3(line, mtime, length) \
+  safe_dwarf_linesrc(line, mtime, length, __FILE__, __LINE__)
+
 inline const char*
 safe_dwarf_linesrc(const Dwarf_Line* line,
-                   Dwarf_Word* mtime = NULL,
-                   Dwarf_Word* length = NULL)
+                   Dwarf_Word* mtime,
+                   Dwarf_Word* length,
+                   const std::string& errfile, int errline)
 {
   const char* linesrc =
     dwarf_linesrc(const_cast<Dwarf_Line*>(line), mtime, length);
-  DWARF_ASSERT("dwarf_linesrc", linesrc);
+  dwarf_assert("dwarf_linesrc", linesrc, errfile, errline);
   return linesrc;
 }
 
+#define DWARF_LINEPROLOGUEEND(line) \
+  safe_dwarf_lineprologueend(line, __FILE__, __LINE__)
+
 inline bool
-safe_dwarf_lineprologueend(const Dwarf_Line* line)
+safe_dwarf_lineprologueend(const Dwarf_Line* line,
+                           const std::string& errfile, int errline)
 {
   bool flag;
-  DWARF_ASSERT("is_prologue_end",
-               dwarf_lineprologueend(const_cast<Dwarf_Line*>(line), &flag));
+  dwarf_assert("is_prologue_end",
+               dwarf_lineprologueend(const_cast<Dwarf_Line*>(line), &flag),
+               errfile, errline);
   return flag;
 }
 

diff --git a/dwflpp.cxx b/dwflpp.cxx
index 12f2baa9e433c8f7607c2dc622a95f75eb68b45e..c1da772a9b74c9a834b2b07220601d0a38207ed0 100644 (file)
--- a/dwflpp.cxx
+++ b/dwflpp.cxx
@@ -1493,10 +1493,10 @@ compare_lines(Dwarf_Line* a, Dwarf_Line* b)
   if (a == b)
     return false;
 
-  int lineno_a = safe_dwarf_lineno(a);
-  int lineno_b = safe_dwarf_lineno(b);
+  int lineno_a = DWARF_LINENO(a);
+  int lineno_b = DWARF_LINENO(b);
   if (lineno_a == lineno_b)
-    return safe_dwarf_lineaddr(a) < safe_dwarf_lineaddr(b);
+    return DWARF_LINEADDR(a) < DWARF_LINEADDR(b);
   return lineno_a < lineno_b;
 }
 
@@ -1510,9 +1510,9 @@ struct lineno_comparator {
     {
       assert(a || b);
       if (a)
-        return safe_dwarf_lineno(a) < lineno;
+        return DWARF_LINENO(a) < lineno;
       else
-        return lineno < safe_dwarf_lineno(b);
+        return lineno < DWARF_LINENO(b);
     }
 };
 
@@ -1552,7 +1552,7 @@ dwflpp::get_cu_lines_sorted_by_lineno(const char *srcfile)
       for (size_t i = 0; i < nlines_cu; i++)
         {
           Dwarf_Line *line = dwarf_onesrcline(lines_cu, i);
-          const char *linesrc = safe_dwarf_linesrc(line);
+          const char *linesrc = DWARF_LINESRC(line);
           if (strcmp(srcfile, linesrc))
             continue;
           lines->push_back(line);
@@ -1566,8 +1566,8 @@ dwflpp::get_cu_lines_sorted_by_lineno(const char *srcfile)
           clog << "found the following lines for %s:" << endl;
           lines_t::iterator i;
           for (i  = lines->begin(); i != lines->end(); ++i)
-            cout << safe_dwarf_lineno(*i) << " = " << hex
-                 << safe_dwarf_lineaddr(*i) << dec << endl;
+            cout << DWARF_LINENO(*i) << " = " << hex
+                 << DWARF_LINEADDR(*i) << dec << endl;
         }
     }
   return lines;
@@ -1579,7 +1579,7 @@ get_func_first_line(Dwarf_Die *cu, base_func_info& func)
   // dwarf_getsrc_die() uses binary search to find the Dwarf_Line, but will
   // return the wrong line if not found.
   Dwarf_Line *line = dwarf_getsrc_die(cu, func.entrypc);
-  if (line && safe_dwarf_lineaddr(line) == func.entrypc)
+  if (line && DWARF_LINEADDR(line) == func.entrypc)
     return line;
 
   // Line not found (or line at wrong addr). We have to resort to a slower
@@ -1594,7 +1594,7 @@ get_func_first_line(Dwarf_Die *cu, base_func_info& func)
   for (size_t i = 0; i < nlines; i++)
     {
       line = dwarf_onesrcline(lines, i);
-      if (dwarf_haspc(&func.die, safe_dwarf_lineaddr(line)))
+      if (dwarf_haspc(&func.die, DWARF_LINEADDR(line)))
         return line;
     }
   return NULL;
@@ -1606,7 +1606,7 @@ collect_lines_in_die(lines_range_t range, Dwarf_Die *die)
   lines_t lines_in_die;
   for (lines_t::iterator line  = range.first;
                          line != range.second; ++line)
-    if (dwarf_haspc(die, safe_dwarf_lineaddr(*line)))
+    if (dwarf_haspc(die, DWARF_LINEADDR(*line)))
       lines_in_die.push_back(*line);
   return lines_in_die;
 }
@@ -1621,7 +1621,7 @@ add_matching_lines_in_func(Dwarf_Die *cu,
   if (!start_line)
     return;
 
-  for (int lineno = safe_dwarf_lineno(start_line);;)
+  for (int lineno = DWARF_LINENO(start_line);;)
     {
       lines_range_t range = lineno_equal_range(cu_lines, lineno);
 
@@ -1639,7 +1639,7 @@ add_matching_lines_in_func(Dwarf_Die *cu,
       // break out if there are no more lines, otherwise, go to the next lineno
       if (range.second == cu_lines->end())
         break;
-      lineno = safe_dwarf_lineno(*range.second);
+      lineno = DWARF_LINENO(*range.second);
     }
 }
 
@@ -1823,8 +1823,8 @@ dwflpp::iterate_over_srcfile_lines<void>(char const * srcfile,
       for (lines_t::iterator line  = matching_lines.begin();
                              line != matching_lines.end(); ++line)
         {
-          int lineno = safe_dwarf_lineno(*line);
-          Dwarf_Addr addr = safe_dwarf_lineaddr(*line);
+          int lineno = DWARF_LINENO(*line);
+          Dwarf_Addr addr = DWARF_LINEADDR(*line);
           bool is_new_addr = probed_addrs.insert(addr).second;
           if (is_new_addr)
             callback(addr, lineno, data);
@@ -2239,7 +2239,7 @@ dwflpp::resolve_prologue_endings (func_info_map_t & funcs)
           {
             entrypc_srcline_idx = (l + h) / 2;
             Dwarf_Line* lr = dwarf_onesrcline(lines, entrypc_srcline_idx);
-            Dwarf_Addr addr = safe_dwarf_lineaddr(lr);
+            Dwarf_Addr addr = DWARF_LINEADDR(lr);
             if (addr == entrypc) { entrypc_srcline = lr; break; }
             else if (l + 1 == h) { break; } // ran off bottom of tree
             else if (addr < entrypc) { l = entrypc_srcline_idx; }
@@ -2283,7 +2283,7 @@ dwflpp::resolve_prologue_endings (func_info_map_t & funcs)
       // the entrypc maps to a statement in the body rather than the
       // declaration.
 
-      int entrypc_srcline_lineno = safe_dwarf_lineno(entrypc_srcline);
+      int entrypc_srcline_lineno = DWARF_LINENO(entrypc_srcline);
       unsigned postprologue_srcline_idx = entrypc_srcline_idx;
       Dwarf_Line *postprologue_srcline = entrypc_srcline;
 
@@ -2291,10 +2291,10 @@ dwflpp::resolve_prologue_endings (func_info_map_t & funcs)
         {
           postprologue_srcline = dwarf_onesrcline(lines,
                                                   postprologue_srcline_idx);
-          Dwarf_Addr lineaddr   = safe_dwarf_lineaddr(postprologue_srcline);
-          const char* linesrc   = safe_dwarf_linesrc(postprologue_srcline);
-          int lineno            = safe_dwarf_lineno(postprologue_srcline);
-          bool lineprologue_end = safe_dwarf_lineprologueend(postprologue_srcline);
+          Dwarf_Addr lineaddr   = DWARF_LINEADDR(postprologue_srcline);
+          const char* linesrc   = DWARF_LINESRC(postprologue_srcline);
+          int lineno            = DWARF_LINENO(postprologue_srcline);
+          bool lineprologue_end = DWARF_LINEPROLOGUEEND(postprologue_srcline);
 
           if (sess.verbose>2)
             clog << _F("checking line record %#" PRIx64 "@%s:%d%s\n", lineaddr,
@@ -2326,12 +2326,12 @@ dwflpp::resolve_prologue_endings (func_info_map_t & funcs)
         } // loop over srclines
 
 
-      Dwarf_Addr postprologue_addr = safe_dwarf_lineaddr(postprologue_srcline);
+      Dwarf_Addr postprologue_addr = DWARF_LINEADDR(postprologue_srcline);
       if (postprologue_addr >= highpc)
         {
           // pick addr of previous line record
           Dwarf_Line *lr = dwarf_onesrcline(lines, postprologue_srcline_idx-1);
-          postprologue_addr = safe_dwarf_lineaddr(lr);
+          postprologue_addr = DWARF_LINEADDR(lr);
         }
 
       it->prologue_end = postprologue_addr;
@@ -2344,10 +2344,10 @@ dwflpp::resolve_prologue_endings (func_info_map_t & funcs)
           if (postprologue_addr == entrypc)
             clog << _(" (naked)");
           //TRANSLATORS: Here we're adding some classification datum (ie we went over)
-          if (safe_dwarf_lineaddr(postprologue_srcline) >= highpc)
+          if (DWARF_LINEADDR(postprologue_srcline) >= highpc)
             clog << _(" (tail-call?)");
           //TRANSLATORS: Here we're adding some classification datum (ie it was marked)
-          if (safe_dwarf_lineprologueend(postprologue_srcline))
+          if (DWARF_LINEPROLOGUEEND(postprologue_srcline))
             clog << _(" (marked)");
 
           clog << " = 0x" << hex << postprologue_addr << dec << "\n";

diff --git a/tapsets.cxx b/tapsets.cxx
index b4ebc1f238a9c1848de363dd3c7f93160f81d43c..71f3de2eae0d53d2c99b3a4433462c751b1f77b6 100644 (file)
--- a/tapsets.cxx
+++ b/tapsets.cxx
@@ -1510,9 +1510,9 @@ query_addr(Dwarf_Addr addr, dwarf_query *q)
       Dwarf_Addr address_line_addr = addr;
       if (address_line)
         {
-          file = safe_dwarf_linesrc(address_line);
-          line = safe_dwarf_lineno(address_line);
-          address_line_addr = safe_dwarf_lineaddr(address_line);
+          file = DWARF_LINESRC(address_line);
+          line = DWARF_LINENO(address_line);
+          address_line_addr = DWARF_LINEADDR(address_line);
         }
 
       // Verify that a raw address matches the beginning of a