* dwarf_reader.cc (Sized_dwarf_line_info): Include all lines,

	but mark earlier ones as non-canonical
	(offset_to_iterator): Update search target and example
	(do_addr2line): Return extra lines in a vector*
	(format_file_lineno): Extract from do_addr2line
	(one_addr2line): Add vector* out-param
	* dwarf_reader.h (Offset_to_lineno_entry): New field recording
	when a lineno entry appeared last for its instruction
	(Dwarf_line_info): Add vector* out-param
	* object.cc (Relocate_info): Pass NULL for the vector* out-param
	* symtab.cc (Odr_violation_compare): Include the lineno in the
	comparison again.
	(linenos_from_loc): New. Combine the canonical line for an
	address with its other lines.
	(True_if_intersect): New. Helper functor to make
	std::set_intersection a query.
	(detect_odr_violations): Compare sets of lines instead of just
	one line for each function. This became less deterministic, but
	has fewer false positives.
	* symtab.h: Declarations.
	* testsuite/Makefile.am (odr_violation2.o): Compile with -O2 to
	mix an optimized and non-optimized object in the same binary
	(odr_violation2.so): Same.
	* testsuite/Makefile.in: Regenerate from Makefile.am.
	* testsuite/debug_msg.cc (main): Make OdrDerived classes.
	* testsuite/debug_msg.sh: Update line numbers and add
	assertions.
	* testsuite/odr_violation1.cc: Use OdrDerived, in a
	non-optimized context.
	* testsuite/odr_violation2.cc: Make sure Ordering::operator()
	isn't inlined, and use OdrDerived in an optimized context.
	* testsuite/odr_header1.h: Defines OdrDerived, where
	optimization will change the
	first-instruction-in-the-destructor's file and line number.
	* testsuite/odr_header2.h: Defines OdrBase.

1 files changed, 78 insertions, 52 deletions

diff --git a/gold/dwarf_reader.cc b/gold/dwarf_reader.cc
index 8110f38..e8fe04e 100644
--- a/gold/dwarf_reader.cc
+++ b/gold/dwarf_reader.cc
@@ -492,19 +492,18 @@ Sized_dwarf_line_info<size, big_endian>::read_lines(unsigned const char* lineptr
             {
               Offset_to_lineno_entry entry
                   = { lsm.address, this->current_header_index_,
-                      lsm.file_num, lsm.line_num };
+                      lsm.file_num, true, lsm.line_num };
 	      std::vector<Offset_to_lineno_entry>&
 		map(this->line_number_map_[lsm.shndx]);
 	      // If we see two consecutive entries with the same
-	      // offset and a real line number, then always use the
-	      // second one.
+	      // offset and a real line number, then mark the first
+	      // one as non-canonical.
 	      if (!map.empty()
 		  && (map.back().offset == static_cast<off_t>(lsm.address))
 		  && lsm.line_num != -1
 		  && map.back().line_num != -1)
-		map.back() = entry;
-	      else
-		map.push_back(entry);
+		map.back().last_line_for_offset = false;
+	      map.push_back(entry);
             }
           lineptr += oplength;
         }
@@ -612,7 +611,7 @@ static std::vector<Offset_to_lineno_entry>::const_iterator
 offset_to_iterator(const std::vector<Offset_to_lineno_entry>* offsets,
                    off_t offset)
 {
-  const Offset_to_lineno_entry lookup_key = { offset, 0, 0, 0 };
+  const Offset_to_lineno_entry lookup_key = { offset, 0, 0, true, 0 };
 
   // lower_bound() returns the smallest offset which is >= lookup_key.
   // If no offset in offsets is >= lookup_key, returns end().
@@ -621,25 +620,27 @@ offset_to_iterator(const std::vector<Offset_to_lineno_entry>* offsets,
 
   // This code is easiest to understand with a concrete example.
   // Here's a possible offsets array:
-  // {{offset = 3211, header_num = 0, file_num = 1, line_num = 16},  // 0
-  //  {offset = 3224, header_num = 0, file_num = 1, line_num = 20},  // 1
-  //  {offset = 3226, header_num = 0, file_num = 1, line_num = 22},  // 2
-  //  {offset = 3231, header_num = 0, file_num = 1, line_num = 25},  // 3
-  //  {offset = 3232, header_num = 0, file_num = 1, line_num = -1},  // 4
-  //  {offset = 3232, header_num = 0, file_num = 1, line_num = 65},  // 5
-  //  {offset = 3235, header_num = 0, file_num = 1, line_num = 66},  // 6
-  //  {offset = 3236, header_num = 0, file_num = 1, line_num = -1},  // 7
-  //  {offset = 5764, header_num = 0, file_num = 1, line_num = 47},  // 8
-  //  {offset = 5765, header_num = 0, file_num = 1, line_num = 48},  // 9
-  //  {offset = 5767, header_num = 0, file_num = 1, line_num = 49},  // 10
-  //  {offset = 5768, header_num = 0, file_num = 1, line_num = 50},  // 11
-  //  {offset = 5773, header_num = 0, file_num = 1, line_num = -1},  // 12
-  //  {offset = 5787, header_num = 1, file_num = 1, line_num = 19},  // 13
-  //  {offset = 5790, header_num = 1, file_num = 1, line_num = 20},  // 14
-  //  {offset = 5793, header_num = 1, file_num = 1, line_num = 67},  // 15
-  //  {offset = 5793, header_num = 1, file_num = 1, line_num = -1},  // 16
-  //  {offset = 5795, header_num = 1, file_num = 1, line_num = 68},  // 17
-  //  {offset = 5798, header_num = 1, file_num = 1, line_num = -1},  // 18
+  // {{offset = 3211, header_num = 0, file_num = 1, last, line_num = 16},  // 0
+  //  {offset = 3224, header_num = 0, file_num = 1, last, line_num = 20},  // 1
+  //  {offset = 3226, header_num = 0, file_num = 1, last, line_num = 22},  // 2
+  //  {offset = 3231, header_num = 0, file_num = 1, last, line_num = 25},  // 3
+  //  {offset = 3232, header_num = 0, file_num = 1, last, line_num = -1},  // 4
+  //  {offset = 3232, header_num = 0, file_num = 1, last, line_num = 65},  // 5
+  //  {offset = 3235, header_num = 0, file_num = 1, last, line_num = 66},  // 6
+  //  {offset = 3236, header_num = 0, file_num = 1, last, line_num = -1},  // 7
+  //  {offset = 5764, header_num = 0, file_num = 1, last, line_num = 48},  // 8
+  //  {offset = 5764, header_num = 0, file_num = 1,!last, line_num = 47},  // 9
+  //  {offset = 5765, header_num = 0, file_num = 1, last, line_num = 49},  // 10
+  //  {offset = 5767, header_num = 0, file_num = 1, last, line_num = 50},  // 11
+  //  {offset = 5768, header_num = 0, file_num = 1, last, line_num = 51},  // 12
+  //  {offset = 5773, header_num = 0, file_num = 1, last, line_num = -1},  // 13
+  //  {offset = 5787, header_num = 1, file_num = 1, last, line_num = 19},  // 14
+  //  {offset = 5790, header_num = 1, file_num = 1, last, line_num = 20},  // 15
+  //  {offset = 5793, header_num = 1, file_num = 1, last, line_num = 67},  // 16
+  //  {offset = 5793, header_num = 1, file_num = 1, last, line_num = -1},  // 17
+  //  {offset = 5793, header_num = 1, file_num = 1,!last, line_num = 66},  // 18
+  //  {offset = 5795, header_num = 1, file_num = 1, last, line_num = 68},  // 19
+  //  {offset = 5798, header_num = 1, file_num = 1, last, line_num = -1},  // 20
   // The entries with line_num == -1 mark the end of a function: the
   // associated offset is one past the last instruction in the
   // function.  This can correspond to the beginning of the next
@@ -651,7 +652,7 @@ offset_to_iterator(const std::vector<Offset_to_lineno_entry>* offsets,
   //         offsets[0].  Since it's not an exact match and we're
   //         at the beginning of offsets, we return end() (invalid).
   // Case 2: lookup_key has offset 10000.  lower_bound returns
-  //         offset[19] (end()).  We return end() (invalid).
+  //         offset[21] (end()).  We return end() (invalid).
   // Case 3: lookup_key has offset == 3211.  lower_bound matches
   //         offsets[0] exactly, and that's the entry we return.
   // Case 4: lookup_key has offset == 3232.  lower_bound returns
@@ -670,16 +671,17 @@ offset_to_iterator(const std::vector<Offset_to_lineno_entry>* offsets,
   //         end-of-function, we know lookup_key is between
   //         functions, so we return end() (not a valid offset).
   // Case 7: lookup_key has offset == 5794.  lower_bound returns
-  //         offsets[17].  Since it's not an exact match, we back
-  //         up to offsets[15].  Note we back up to the *first*
-  //         entry with offset 5793, not just offsets[17-1].
-  //         We note offsets[15] is a valid entry, so we return it.
-  //         If offsets[15] had had line_num == -1, we would have
-  //         checked offsets[16].  The reason for this is that
-  //         15 and 16 can be in an arbitrary order, since we sort
-  //         only by offset.  (Note it doesn't help to use line_number
-  //         as a secondary sort key, since sometimes we want the -1
-  //         to be first and sometimes we want it to be last.)
+  //         offsets[19].  Since it's not an exact match, we back
+  //         up to offsets[16].  Note we back up to the *first*
+  //         entry with offset 5793, not just offsets[19-1].
+  //         We note offsets[16] is a valid entry, so we return it.
+  //         If offsets[16] had had line_num == -1, we would have
+  //         checked offsets[17].  The reason for this is that
+  //         16 and 17 can be in an arbitrary order, since we sort
+  //         only by offset and last_line_for_offset.  (Note it
+  //         doesn't help to use line_number as a tertiary sort key,
+  //         since sometimes we want the -1 to be first and sometimes
+  //         we want it to be last.)
 
   // This deals with cases (1) and (2).
   if ((it == offsets->begin() && offset < it->offset)
@@ -710,19 +712,25 @@ offset_to_iterator(const std::vector<Offset_to_lineno_entry>* offsets,
 
   // This handles cases (5), (6), and (7): if any entry in the
   // equal_range [it, range_end) has a line_num != -1, it's a valid
-  // match.  If not, we're not in a function.
+  // match.  If not, we're not in a function.  The line number we saw
+  // last for an offset will be sorted first, so it'll get returned if
+  // it's present.
   for (; it != range_end; ++it)
     if (it->line_num != -1)
       return it;
   return offsets->end();
 }
 
-// Return a string for a file name and line number.
+// Returns the canonical filename:lineno for the address passed in.
+// If other_lines is not NULL, appends the non-canonical lines
+// assigned to the same address.
 
 template<int size, bool big_endian>
 std::string
-Sized_dwarf_line_info<size, big_endian>::do_addr2line(unsigned int shndx,
-                                                      off_t offset)
+Sized_dwarf_line_info<size, big_endian>::do_addr2line(
+    unsigned int shndx,
+    off_t offset,
+    std::vector<std::string>* other_lines)
 {
   if (this->data_valid_ == false)
     return "";
@@ -743,21 +751,38 @@ Sized_dwarf_line_info<size, big_endian>::do_addr2line(unsigned int shndx,
   if (it == offsets->end())
     return "";
 
-  // Convert the file_num + line_num into a string.
+  std::string result = this->format_file_lineno(*it);
+  if (other_lines != NULL)
+    for (++it; it != offsets->end() && it->offset == offset; ++it)
+      {
+        if (it->line_num == -1)
+          continue;  // The end of a previous function.
+        other_lines->push_back(this->format_file_lineno(*it));
+      }
+  return result;
+}
+
+// Convert the file_num + line_num into a string.
+
+template<int size, bool big_endian>
+std::string
+Sized_dwarf_line_info<size, big_endian>::format_file_lineno(
+    const Offset_to_lineno_entry& loc) const
+{
   std::string ret;
 
-  gold_assert(it->header_num < static_cast<int>(this->files_.size()));
-  gold_assert(it->file_num
-	      < static_cast<int>(this->files_[it->header_num].size()));
+  gold_assert(loc.header_num < static_cast<int>(this->files_.size()));
+  gold_assert(loc.file_num
+	      < static_cast<int>(this->files_[loc.header_num].size()));
   const std::pair<int, std::string>& filename_pair
-      = this->files_[it->header_num][it->file_num];
+      = this->files_[loc.header_num][loc.file_num];
   const std::string& filename = filename_pair.second;
 
-  gold_assert(it->header_num < static_cast<int>(this->directories_.size()));
+  gold_assert(loc.header_num < static_cast<int>(this->directories_.size()));
   gold_assert(filename_pair.first
-              < static_cast<int>(this->directories_[it->header_num].size()));
+              < static_cast<int>(this->directories_[loc.header_num].size()));
   const std::string& dirname
-      = this->directories_[it->header_num][filename_pair.first];
+      = this->directories_[loc.header_num][filename_pair.first];
 
   if (!dirname.empty())
     {
@@ -769,7 +794,7 @@ Sized_dwarf_line_info<size, big_endian>::do_addr2line(unsigned int shndx,
     ret = "(unknown)";
 
   char buffer[64];   // enough to hold a line number
-  snprintf(buffer, sizeof(buffer), "%d", it->line_num);
+  snprintf(buffer, sizeof(buffer), "%d", loc.line_num);
   ret += ":";
   ret += buffer;
 
@@ -803,7 +828,8 @@ static std::vector<Addr2line_cache_entry> addr2line_cache;
 std::string
 Dwarf_line_info::one_addr2line(Object* object,
                                unsigned int shndx, off_t offset,
-                               size_t cache_size)
+                               size_t cache_size,
+                               std::vector<std::string>* other_lines)
 {
   Dwarf_line_info* lineinfo = NULL;
   std::vector<Addr2line_cache_entry>::iterator it;
@@ -854,7 +880,7 @@ Dwarf_line_info::one_addr2line(Object* object,
   }
 
   // Now that we have our object, figure out the answer
-  std::string retval = lineinfo->addr2line(shndx, offset);
+  std::string retval = lineinfo->addr2line(shndx, offset, other_lines);
 
   // Finally, if our cache has grown too big, delete old objects.  We
   // assume the common (probably only) case is deleting only one object.