gold/icf.h

   1 // icf.h --  Identical Code Folding
   2
   3 // Copyright 2009, 2010 Free Software Foundation, Inc.
   4 // Written by Sriraman Tallam <tmsriram@google.com>.
   5
   6 // This file is part of gold.
   7
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 3 of the License, or
  11 // (at your option) any later version.
  12
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21 // MA 02110-1301, USA.
  22
  23 #ifndef GOLD_ICF_H
  24 #define GOLD_ICF_H
  25
  26 #include <vector>
  27
  28 #include "elfcpp.h"
  29 #include "symtab.h"
  30 #include "object.h"
  31
  32 namespace gold
  33 {
  34
  35 class Object;
  36 class Input_objects;
  37 class Symbol_table;
  38
  39 class Icf
  40 {
  41  public:
  42   typedef std::vector<Section_id> Sections_reachable_info;
  43   typedef std::vector<Symbol*> Symbol_info;
  44   typedef std::vector<std::pair<long long, long long> > Addend_info;
  45   typedef std::vector<uint64_t> Offset_info;
  46   typedef std::vector<unsigned int> Reloc_addend_size_info;
  47   typedef Unordered_map<Section_id,
  48                         unsigned int,
  49                         Section_id_hash> Uniq_secn_id_map;
  50   typedef Unordered_set<Section_id, Section_id_hash> Secn_fptr_taken_set;
  51
  52   typedef struct
  53   {
  54     // This stores the section corresponding to the reloc.
  55     Sections_reachable_info section_info;
  56     // This stores the symbol corresponding to the reloc.
  57     Symbol_info symbol_info;
  58     // This stores the symbol value and the addend for a reloc.
  59     Addend_info addend_info;
  60     Offset_info offset_info;
  61     Reloc_addend_size_info reloc_addend_size_info;
  62   } Reloc_info;
  63
  64   typedef Unordered_map<Section_id, Reloc_info,
  65                         Section_id_hash> Reloc_info_list;
  66
  67   Icf()
  68   : id_section_(), section_id_(), kept_section_id_(),
  69     fptr_section_id_(),
  70     num_tracked_relocs(NULL), icf_ready_(false),
  71     reloc_info_list_()
  72   { }
  73
  74   // Returns the kept folded identical section corresponding to
  75   // dup_obj and dup_shndx.
  76   Section_id
  77   get_folded_section(Object* dup_obj, unsigned int dup_shndx);
  78
  79   // Forms groups of identical sections where the first member
  80   // of each group is the kept section during folding.
  81   void
  82   find_identical_sections(const Input_objects* input_objects,
  83                           Symbol_table* symtab);
  84
  85   // This is set when ICF has been run and the groups of
  86   // identical sections have been formed.
  87   void
  88   icf_ready()
  89   { this->icf_ready_ = true; }
  90
  91   // Returns true if ICF has been run.
  92   bool
  93   is_icf_ready()
  94   { return this->icf_ready_; }
  95
  96   // Unfolds the section denoted by OBJ and SHNDX if folded.
  97   void
  98   unfold_section(Object* obj, unsigned int shndx);
  99
 100   // Returns the kept section corresponding to the
 101   // given section.
 102   bool
 103   is_section_folded(Object* obj, unsigned int shndx);
 104
 105   // Given an object and a section index, this returns true if the
 106   // pointer of the function defined in this section is taken.
 107   bool
 108   section_has_function_pointers(Object* obj, unsigned int shndx)
 109   {
 110     return (this->fptr_section_id_.find(Section_id(obj, shndx))
 111             != this->fptr_section_id_.end());
 112   }
 113
 114   // Records that a pointer of the function defined in this section
 115   // is taken.
 116   void
 117   set_section_has_function_pointers(Object* obj, unsigned int shndx)
 118   {
 119     this->fptr_section_id_.insert(Section_id(obj, shndx));
 120   }
 121
 122   // Checks if the section_name should be searched for relocs
 123   // corresponding to taken function pointers.  Ignores eh_frame
 124   // and vtable sections.
 125   inline bool
 126   check_section_for_function_pointers(const std::string& section_name,
 127                                       Target* target)
 128   {
 129     return (parameters->options().icf_safe_folding()
 130             && target->can_check_for_function_pointers()
 131             && target->section_may_have_icf_unsafe_pointers(
 132                 section_name.c_str()));
 133   }
 134
 135   // Returns a map of a section to info (Reloc_info) about its relocations.
 136   Reloc_info_list&
 137   reloc_info_list()
 138   { return this->reloc_info_list_; }
 139
 140   // Returns a mapping of each section to a unique integer.
 141   Uniq_secn_id_map&
 142   section_to_int_map()
 143   { return this->section_id_; }
 144
 145  private:
 146
 147   // Maps integers to sections.
 148   std::vector<Section_id> id_section_;
 149   // Does the reverse.
 150   Uniq_secn_id_map section_id_;
 151   // Given a section id, this maps it to the id of the kept
 152   // section.  If the id's are the same then this section is
 153   // not folded.
 154   std::vector<unsigned int> kept_section_id_;
 155   // Given a section id, this says if the pointer to this
 156   // function is taken in which case it is dangerous to fold
 157   // this function.
 158   Secn_fptr_taken_set fptr_section_id_;
 159   unsigned int* num_tracked_relocs;
 160   // Flag to indicate if ICF has been run.
 161   bool icf_ready_;
 162   // This list is populated by gc_process_relocs in gc.h.
 163   Reloc_info_list reloc_info_list_;
 164 };
 165
 166 // This function returns true if this section corresponds to a function that
 167 // should be considered by icf as a possible candidate for folding.  Some
 168 // earlier gcc versions, like 4.0.3, put constructors and destructors in
 169 // .gnu.linkonce.t sections and hence should be included too.
 170 inline bool
 171 is_section_foldable_candidate(const char* section_name)
 172 {
 173   return (is_prefix_of(".text", section_name)
 174           || is_prefix_of(".gnu.linkonce.t", section_name));
 175 }
 176
 177 } // End of namespace gold.
 178
 179 #endif