gold/gc.h

   1 // gc.h -- garbage collection of unused sections
   2
   3 // Copyright 2009 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_GC_H
  24 #define GOLD_GC_H
  25
  26 #include <queue>
  27
  28 #include "elfcpp.h"
  29 #include "symtab.h"
  30
  31 namespace gold
  32 {
  33
  34 class Object;
  35
  36 template<int size, bool big_endian>
  37 class Sized_relobj;
  38
  39 template<int sh_type, int size, bool big_endian>
  40 class Reloc_types;
  41
  42 class Output_section;
  43 class General_options;
  44 class Layout;
  45
  46 typedef std::pair<Object *, unsigned int> Section_id;
  47
  48 class Garbage_collection
  49 {
  50   struct Section_id_hash
  51   {
  52     size_t operator()(const Section_id& loc) const
  53     { return reinterpret_cast<uintptr_t>(loc.first) ^ loc.second; }
  54   };
  55
  56   typedef Unordered_set<Section_id, Section_id_hash> Sections_reachable;
  57   typedef std::map<Section_id, Sections_reachable> Section_ref;
  58   typedef std::queue<Section_id> Worklist_type;
  59
  60   public :
  61     Garbage_collection()
  62       :is_worklist_ready_(false)
  63     { }
  64
  65     // Accessor methods for the private members.
  66
  67     Sections_reachable&
  68     referenced_list()
  69     { return referenced_list_; }
  70
  71     Section_ref&
  72     section_reloc_map()
  73     { return section_reloc_map_; }
  74
  75     Worklist_type&
  76     worklist()
  77     { return work_list_; }
  78
  79     bool
  80     is_worklist_ready()
  81     { return is_worklist_ready_; }
  82
  83     void
  84     worklist_ready()
  85     { is_worklist_ready_ = true; }
  86
  87     void
  88     do_transitive_closure();
  89
  90   private :
  91     Worklist_type work_list_;
  92     bool is_worklist_ready_;
  93     Section_ref section_reloc_map_;
  94     Sections_reachable referenced_list_;
  95 };
  96
  97 // Data to pass between successive invocations of do_layout
  98 // in object.cc while garbage collecting.  This data structure
  99 // is filled by using the data from Read_symbols_data.
 100
 101 struct Symbols_data
 102 {
 103   // Section headers.
 104   unsigned char* section_headers_data;
 105   // Section names.
 106   unsigned char* section_names_data;
 107   // Size of section name data in bytes.
 108   section_size_type section_names_size;
 109   // Symbol data.
 110   unsigned char* symbols_data;
 111   // Size of symbol data in bytes.
 112   section_size_type symbols_size;
 113   // Offset of external symbols within symbol data.  This structure
 114   // sometimes contains only external symbols, in which case this will
 115   // be zero.  Sometimes it contains all symbols.
 116   section_offset_type external_symbols_offset;
 117   // Symbol names.
 118   unsigned char* symbol_names_data;
 119   // Size of symbol name data in bytes.
 120   section_size_type symbol_names_size;
 121 };
 122
 123 // This function implements the  the generic part of reloc
 124 // processing to map a section to all the sections it
 125 // references through relocs.  It is used only during garbage
 126 // collection.
 127
 128 template<int size, bool big_endian, typename Target_type, int sh_type,
 129          typename Scan>
 130 inline void
 131 gc_process_relocs(
 132     const General_options& ,
 133     Symbol_table* symtab,
 134     Layout*,
 135     Target_type* ,
 136     Sized_relobj<size, big_endian>* object,
 137     unsigned int data_shndx,
 138     const unsigned char* prelocs,
 139     size_t reloc_count,
 140     Output_section*,
 141     bool ,
 142     size_t local_count,
 143     const unsigned char* plocal_syms)
 144 {
 145   Object *src_obj, *dst_obj;
 146   unsigned int src_indx, dst_indx;
 147
 148   src_obj = object;
 149   src_indx = data_shndx;
 150
 151   typedef typename Reloc_types<sh_type, size, big_endian>::Reloc Reltype;
 152   const int reloc_size = Reloc_types<sh_type, size, big_endian>::reloc_size;
 153   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
 154
 155   for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size)
 156     {
 157       Reltype reloc(prelocs);
 158       typename elfcpp::Elf_types<size>::Elf_WXword r_info = reloc.get_r_info();
 159       unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
 160
 161       if (r_sym < local_count)
 162         {
 163           gold_assert(plocal_syms != NULL);
 164           typename elfcpp::Sym<size, big_endian> lsym(plocal_syms
 165                                                       + r_sym * sym_size);
 166           unsigned int shndx = lsym.get_st_shndx();
 167           bool is_ordinary;
 168           shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
 169           if (!is_ordinary)
 170             continue;
 171           dst_obj = src_obj;
 172           if (shndx == src_indx)
 173             continue;
 174           dst_indx = shndx;
 175         }
 176       else
 177         {
 178           Symbol* gsym = object->global_symbol(r_sym);
 179           gold_assert(gsym != NULL);
 180           if (gsym->is_forwarder())
 181             gsym = symtab->resolve_forwards(gsym);
 182           if (gsym->source() != Symbol::FROM_OBJECT)
 183             continue;
 184           bool is_ordinary;
 185           dst_obj = gsym->object();
 186           dst_indx = gsym->shndx(&is_ordinary);
 187           if (!is_ordinary)
 188             continue;
 189         }
 190       Section_id p1(src_obj, src_indx);
 191       Section_id p2(dst_obj, dst_indx);
 192       Garbage_collection::Section_ref::iterator map_it;
 193       map_it = symtab->gc()->section_reloc_map().find(p1);
 194       if (map_it == symtab->gc()->section_reloc_map().end())
 195         {
 196           symtab->gc()->section_reloc_map()[p1].insert(p2);
 197         }
 198       else
 199         {
 200           Garbage_collection::Sections_reachable& v(map_it->second);
 201           v.insert(p2);
 202         }
 203     }
 204   return;
 205 }
 206
 207 } // End of namespace gold.
 208
 209 #endif