// icf.cc -- Identical Code Folding.
//
-// Copyright 2009 Free Software Foundation, Inc.
+// Copyright 2009, 2010 Free Software Foundation, Inc.
// Written by Sriraman Tallam <tmsriram@google.com>.
// This file is part of gold.
// Identical Code Folding Algorithm
// ----------------------------------
// Detecting identical functions is done here and the basic algorithm
-// is as follows. A checksum is computed on each .text section using
+// is as follows. A checksum is computed on each foldable section using
// its contents and relocations. If the symbol name corresponding to
// a relocation is known it is used to compute the checksum. If the
// symbol name is not known the stringified name of the object and the
// checking the contents when two sections have the same checksum.
//
// However, two functions A and B with identical text but with
-// relocations pointing to different .text sections can be identical if
-// the corresponding .text sections to which their relocations point to
+// relocations pointing to different foldable sections can be identical if
+// the corresponding foldable sections to which their relocations point to
// turn out to be identical. Hence, this checksumming process must be
// done repeatedly until convergence is obtained. Here is an example for
// the following case :
// when folding takes place. This could lead to unexpected run-time
// behaviour.
//
+// Safe Folding :
+// ------------
+//
+// ICF in safe mode folds only ctors and dtors if their function pointers can
+// never be taken. Also, for X86-64, safe folding uses the relocation
+// type to determine if a function's pointer is taken or not and only folds
+// functions whose pointers are definitely not taken.
+//
+// Caveat with safe folding :
+// ------------------------
+//
+// This applies only to x86_64.
+//
+// Position independent executables are created from PIC objects (compiled
+// with -fPIC) and/or PIE objects (compiled with -fPIE). For PIE objects, the
+// relocation types for function pointer taken and a call are the same.
+// Now, it is not always possible to tell if an object used in the link of
+// a pie executable is a PIC object or a PIE object. Hence, for pie
+// executables, using relocation types to disambiguate function pointers is
+// currently disabled.
//
-// How to run : --icf
+// Further, it is not correct to use safe folding to build non-pie
+// executables using PIC/PIE objects. PIC/PIE objects have different
+// relocation types for function pointers than non-PIC objects, and the
+// current implementation of safe folding does not handle those relocation
+// types. Hence, if used, functions whose pointers are taken could still be
+// folded causing unpredictable run-time behaviour if the pointers were used
+// in comparisons.
+//
+//
+//
+// How to run : --icf=[safe|all|none]
// Optional parameters : --icf-iterations <num> --print-icf-sections
//
// Performance : Less than 20 % link-time overhead on industry strength
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,
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)
{
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,
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("@");
Symbol_table* symtab)
{
unsigned int section_num = 0;
- std::vector<unsigned int> num_tracked_rels;
+ std::vector<unsigned int> num_tracked_relocs;
std::vector<bool> is_secn_or_group_unique;
std::vector<std::string> section_contents;
+ const Target& target = parameters->target();
// Decide which sections are possible candidates first.
for (unsigned int i = 0;i < (*p)->shnum(); ++i)
{
const char* section_name = (*p)->section_name(i).c_str();
- // Only looking to fold functions, so just look at .text sections.
- if (!is_prefix_of(".text.", section_name))
+ if (!is_section_foldable_candidate(section_name))
continue;
if (!(*p)->is_section_included(i))
continue;
if (parameters->options().gc_sections()
&& symtab->gc()->is_section_garbage(*p, i))
continue;
- // With --icf=safe, check if mangled name is a ctor or a dtor.
+ const char* mangled_func_name = strrchr(section_name, '.');
+ gold_assert(mangled_func_name != NULL);
+ // With --icf=safe, check if the mangled function name is a ctor
+ // or a dtor. The mangled function name can be obtained from the
+ // section name by stripping the section prefix.
if (parameters->options().icf_safe_folding()
- && !is_function_ctor_or_dtor(section_name + 6))
- continue;
+ && !is_function_ctor_or_dtor(mangled_func_name + 1)
+ && (!target.can_check_for_function_pointers()
+ || section_has_function_pointers(*p, i)))
+ {
+ continue;
+ }
this->id_section_.push_back(Section_id(*p, i));
this->section_id_[Section_id(*p, i)] = section_num;
this->kept_section_id_.push_back(section_num);
- num_tracked_rels.push_back(0);
+ num_tracked_relocs.push_back(0);
is_secn_or_group_unique.push_back(false);
section_contents.push_back("");
section_num++;
{
num_iterations++;
converged = match_sections(num_iterations, symtab,
- &num_tracked_rels, &this->kept_section_id_,
+ &num_tracked_relocs, &this->kept_section_id_,
this->id_section_, &is_secn_or_group_unique,
§ion_contents);
}
projects / binutils-gdb.git / blobdiff