* merge.h (Output_merge_string::Merged_string): Remove object, shndx,

[binutils-gdb.git] / gold / icf.cc

diff --git a/gold/icf.cc b/gold/icf.cc
index ec3269c0550e8b28724df652ef11156512a23609..47b6c60a32629988e871e2429eed83f762ab19f2 100644 (file)
--- a/gold/icf.cc
+++ b/gold/icf.cc
@@ -248,39 +248,64 @@ get_section_contents(bool first_iteration,
   if (num_tracked_relocs)
     *num_tracked_relocs = 0;
 
-  Icf::Section_list& seclist = symtab->icf()->section_reloc_list();
-  Icf::Symbol_list& symlist = symtab->icf()->symbol_reloc_list();
-  Icf::Addend_list& addendlist = symtab->icf()->addend_reloc_list();
+  Icf::Reloc_info_list& reloc_info_list = 
+    symtab->icf()->reloc_info_list();
 
-  Icf::Section_list::iterator it_seclist = seclist.find(secn);
-  Icf::Symbol_list::iterator it_symlist = symlist.find(secn);
-  Icf::Addend_list::iterator it_addendlist = addendlist.find(secn);
+  Icf::Reloc_info_list::iterator it_reloc_info_list =
+    reloc_info_list.find(secn);
 
   buffer.clear();
   icf_reloc_buffer.clear();
 
   // Process relocs and put them into the buffer.
 
-  if (it_seclist != seclist.end())
+  if (it_reloc_info_list != reloc_info_list.end())
     {
-      gold_assert(it_symlist != symlist.end());
-      gold_assert(it_addendlist != addendlist.end());
-      Icf::Sections_reachable_list v = it_seclist->second;
-      Icf::Symbol_info s = it_symlist->second;
-      Icf::Addend_info a = it_addendlist->second;
-      Icf::Sections_reachable_list::iterator it_v = v.begin();
+      Icf::Sections_reachable_info v =
+        (it_reloc_info_list->second).section_info;
+      // Stores the information of the symbol pointed to by the reloc.
+      Icf::Symbol_info s = (it_reloc_info_list->second).symbol_info;
+      // Stores the addend and the symbol value.
+      Icf::Addend_info a = (it_reloc_info_list->second).addend_info;
+      // Stores the offset of the reloc.
+      Icf::Offset_info o = (it_reloc_info_list->second).offset_info;
+      Icf::Sections_reachable_info::iterator it_v = v.begin();
       Icf::Symbol_info::iterator it_s = s.begin();
       Icf::Addend_info::iterator it_a = a.begin();
+      Icf::Offset_info::iterator it_o = o.begin();
 
-      for (; it_v != v.end(); ++it_v, ++it_s, ++it_a)
+      for (; it_v != v.end(); ++it_v, ++it_s, ++it_a, ++it_o)
         {
-          // ADDEND_STR stores the symbol value and addend, each
-          // atmost 16 hex digits long.  it_v points to a pair
+          // ADDEND_STR stores the symbol value and addend and offset,
+          // each atmost 16 hex digits long.  it_a points to a pair
           // where first is the symbol value and second is the
           // addend.
-          char addend_str[34];
-          snprintf(addend_str, sizeof(addend_str), "%llx %llx",
-                   (*it_a).first, (*it_a).second);
+          char addend_str[50];
+
+         // It would be nice if we could use format macros in inttypes.h
+         // here but there are not in ISO/IEC C++ 1998.
+          snprintf(addend_str, sizeof(addend_str), "%llx %llx %llux",
+                   static_cast<long long>((*it_a).first),
+                  static_cast<long long>((*it_a).second),
+                  static_cast<unsigned long long>(*it_o));
+
+         // If the symbol pointed to by the reloc is not in an ordinary
+         // section or if the symbol type is not FROM_OBJECT, then the
+         // object is NULL.
+         if (it_v->first == NULL)
+            {
+             if (first_iteration)
+                {
+                 // If the symbol name is available, use it.
+                  if ((*it_s) != NULL)
+                      buffer.append((*it_s)->name());
+                  // Append the addend.
+                  buffer.append(addend_str);
+                  buffer.append("@");
+               }
+             continue;
+           }
+
           Section_id reloc_secn(it_v->first, it_v->second);
 
           // If this reloc turns back and points to the same section,
@@ -300,7 +325,12 @@ get_section_contents(bool first_iteration,
             symtab->icf()->section_to_int_map();
           Icf::Uniq_secn_id_map::iterator section_id_map_it =
             section_id_map.find(reloc_secn);
-          if (section_id_map_it != section_id_map.end())
+          bool is_sym_preemptible = (*it_s != NULL
+                                    && !(*it_s)->is_from_dynobj()
+                                    && !(*it_s)->is_undefined()
+                                    && (*it_s)->is_preemptible());
+          if (!is_sym_preemptible
+              && section_id_map_it != section_id_map.end())
             {
               // This is a reloc to a section that might be folded.
               if (num_tracked_relocs)
@@ -334,7 +364,14 @@ get_section_contents(bool first_iteration,
                 {
                   uint64_t entsize =
                     (it_v->first)->section_entsize(it_v->second);
-                  long long offset = it_a->first + it_a->second;
+                 long long offset = it_a->first;
+
+                  unsigned long long addend = it_a->second;
+                  // Ignoring the addend when it is a negative value.  See the 
+                  // comments in Merged_symbol_value::Value in object.h.
+                  if (addend < 0xffffff00)
+                    offset = offset + addend;
+
                   section_size_type secn_len;
                   const unsigned char* str_contents =
                   (it_v->first)->section_contents(it_v->second,
@@ -385,12 +422,12 @@ get_section_contents(bool first_iteration,
                                                      char*>(str_contents),
                                     entsize);
                     }
+                 buffer.append("@");
                 }
               else if ((*it_s) != NULL)
                 {
                   // If symbol name is available use that.
-                  const char *sym_name = (*it_s)->name();
-                  buffer.append(sym_name);
+                  buffer.append((*it_s)->name());
                   // Append the addend.
                   buffer.append(addend_str);
                   buffer.append("@");