2009-01-20 Sriraman Tallam <tmsriram@google.com>

	* Makefile.am (CCFILES): Add gc.cc.
	(HFILES): Add gc.h.
	* Makefile.in: Regenerate.
	* gold.cc (Gc_runner): New class.
	(queue_initial_tasks): Call garbage collection related tasks
	when corresponding options are invoked.
	(queue_middle_gc_tasks): New function.
	(queue_middle_tasks): Reorder tasks to allow relocs to be read and
	processed early before laying out sections during garbage collection.
	* gold.h (queue_middle_gc_tasks): New function.
	(is_prefix_of): Move from "layout.cc".
	* i386.cc (Target_i386::gc_process_relocs): New function.
	* layout.cc (is_prefix_of): Remove. Move to "gold.h"
	* main.cc (main): Create object of class "Garbage_collection".
	* object.cc (Relobj::copy_symbols_data): New function.
	(Relobj::is_section_name_included): New function.
	(Sized_relobj::do_layout): Allow this function to be called twice
	during garbage collection and defer layout of section during the
	first call.
	* object.h (Relobj::get_symbols_data): New function.
	(Relobj::is_section_name_included): New function.
	(Relobj::copy_symbols_data): New function.
	(Relobj::set_symbols_data): New function.
	(Relobj::get_relocs_data): New function.
	(Relobj::set_relocs_data): New function.
	(Relobj::is_output_section_offset_invalid): New pure virtual function.
	(Relobj::gc_process_relocs): New function.
	(Relobj::do_gc_process_relocs): New pure virtual function.
	(Relobj::sd_): New data member.
	(Sized_relobj::is_output_section_offset_invalid): New function.
	(Sized_relobj::do_gc_process_relocs): New function.
	* options.h (General_options::gc_sections): Modify to not be a no-op.
	(General_options::print_gc_sections): New option.
	* plugin.cc (Plugin_finish::run): Remove function call to
	Plugin_manager::layout_deferred_objects.  Move it to "gold.cc".
	* powerpc.cc (Target_powerpc::gc_process_relocs): New function.
	* reloc.cc (Read_relocs::run): Add task to process relocs and
	determine unreferenced sections when doing garbage collection.
	(Gc_process_relocs): New class.
	(Sized_relobj::do_gc_process_relocs): New function.
	(Sized_relobj::do_scan_relocs): Don't try to scan the relocs for
	sections that are garbage collected.
	* reloc.h (Gc_process_relocs): New class.
	* sparc.cc (Target_sparc::gc_process_relocs): New function.
	* symtab.cc (Symbol::should_add_dynsym_entry): Do not add entries for
	symbols whose corresponding sections are garbage collected.
	(Symbol_table::Symbol_table): Add new parameter for the garbage
	collection object.
	(Symbol_table::gc_mark_undef_symbols): New function.
	(Symbol_table::gc_mark_symbol_for_shlib): New function.
	(Symbol_table::gc_mark_dyn_syms): New function.
	(Symbol_table::resolve): Do not treat symbols seen in dynamic objects
	as garbage.
	(Symbol_table::add_from_object): Likewise.
	(Symbol_table::add_from_relobj): When building shared objects, do not
	treat externally visible symbols as garbage.
	(Symbol_table::sized_finalize_symbol): Do not check dynamic symbol
	table information for static and relocatable links.
	* symtab.h (Symbol_table::set_gc): New function.
	(Symbol_table::gc): New function.
	(Symbol_table::gc_mark_undef_symbols): New function.
	(Symbol_table::gc_mark_symbol_for_shlib): New function.
	(Symbol_table::gc_mark_dyn_syms): New function.
	(Symbol_table::gc_): New data member.
	* target.h (Sized_target::gc_process_relocs): New pure virtual
	function.
	* x86_64.cc (Target_x86_64::gc_process_relocs): New function.
	* testsuite/testfile.cc (Target_test::gc_process_relocs): New function.

1 files changed, 209 insertions, 0 deletions

diff --git a/gold/gc.h b/gold/gc.h
new file mode 100644
index 00000000000..b7d520f2589
--- /dev/null
+++ b/gold/gc.h
@@ -0,0 +1,209 @@
+// gc.h -- garbage collection of unused sections
+
+// Copyright 2009 Free Software Foundation, Inc.
+// Written by Sriraman Tallam <tmsriram@google.com>.
+
+// This file is part of gold.
+
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+// MA 02110-1301, USA.
+
+#ifndef GOLD_GC_H
+#define GOLD_GC_H
+
+#include <queue>
+
+#include "elfcpp.h"
+#include "symtab.h"
+
+namespace gold
+{
+
+class Object;
+
+template<int size, bool big_endian>
+class Sized_relobj;
+
+template<int sh_type, int size, bool big_endian>
+class Reloc_types;
+
+class Output_section;
+class General_options;
+class Layout;
+
+typedef std::pair<Object *, unsigned int> Section_id;
+
+class Garbage_collection
+{
+  struct Section_id_hash
+  {
+    size_t operator()(const Section_id& loc) const
+    { return reinterpret_cast<uintptr_t>(loc.first) ^ loc.second; }
+  };
+
+  typedef Unordered_set<Section_id, Section_id_hash> Sections_reachable;
+  typedef std::map<Section_id, Sections_reachable> Section_ref;
+  typedef std::queue<Section_id> Worklist_type;
+
+  public :  
+    Garbage_collection() 
+      :is_worklist_ready_(false)
+    { }
+
+    // Accessor methods for the private members.
+
+    Sections_reachable&
+    referenced_list()
+    { return referenced_list_; }
+
+    Section_ref&
+    section_reloc_map()
+    { return section_reloc_map_; }
+
+    Worklist_type&
+    worklist()
+    { return work_list_; }
+ 
+    bool
+    is_worklist_ready()
+    { return is_worklist_ready_; }
+
+    void
+    worklist_ready()
+    { is_worklist_ready_ = true; }
+
+    void
+    do_transitive_closure();
+
+  private :
+    Worklist_type work_list_;
+    bool is_worklist_ready_;
+    Section_ref section_reloc_map_;
+    Sections_reachable referenced_list_;
+};
+
+// Data to pass between successive invocations of do_layout
+// in object.cc while garbage collecting.  This data structure
+// is filled by using the data from Read_symbols_data.
+
+struct Symbols_data
+{
+  // Section headers.
+  unsigned char* section_headers_data;
+  // Section names.
+  unsigned char* section_names_data;
+  // Size of section name data in bytes.
+  section_size_type section_names_size;
+  // Symbol data.
+  unsigned char* symbols_data;
+  // Size of symbol data in bytes.
+  section_size_type symbols_size;
+  // Offset of external symbols within symbol data.  This structure
+  // sometimes contains only external symbols, in which case this will
+  // be zero.  Sometimes it contains all symbols.
+  section_offset_type external_symbols_offset;
+  // Symbol names.
+  unsigned char* symbol_names_data;
+  // Size of symbol name data in bytes.
+  section_size_type symbol_names_size;
+};
+
+// This function implements the  the generic part of reloc 
+// processing to map a section to all the sections it 
+// references through relocs.  It is used only during garbage 
+// collection.
+
+template<int size, bool big_endian, typename Target_type, int sh_type,
+	 typename Scan>
+inline void
+gc_process_relocs(
+    const General_options& ,
+    Symbol_table* symtab,
+    Layout*,
+    Target_type* ,
+    Sized_relobj<size, big_endian>* object,
+    unsigned int data_shndx,
+    const unsigned char* prelocs,
+    size_t reloc_count,
+    Output_section*,
+    bool ,
+    size_t local_count,
+    const unsigned char* plocal_syms)
+{
+  Object *src_obj, *dst_obj;
+  unsigned int src_indx, dst_indx;
+
+  src_obj = object;
+  src_indx = data_shndx; 
+  
+  typedef typename Reloc_types<sh_type, size, big_endian>::Reloc Reltype;
+  const int reloc_size = Reloc_types<sh_type, size, big_endian>::reloc_size;
+  const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
+
+  for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size)
+    {
+      Reltype reloc(prelocs);
+      typename elfcpp::Elf_types<size>::Elf_WXword r_info = reloc.get_r_info();
+      unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
+      
+      if (r_sym < local_count)
+        {
+          gold_assert(plocal_syms != NULL);
+          typename elfcpp::Sym<size, big_endian> lsym(plocal_syms
+                                                      + r_sym * sym_size);
+          unsigned int shndx = lsym.get_st_shndx();
+          bool is_ordinary;
+          shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
+          if (!is_ordinary) 
+            continue;
+          dst_obj = src_obj;
+          if (shndx == src_indx) 
+            continue;
+          dst_indx = shndx;
+        }
+      else
+        {
+          Symbol* gsym = object->global_symbol(r_sym);
+          gold_assert(gsym != NULL);
+          if (gsym->is_forwarder())
+            gsym = symtab->resolve_forwards(gsym);
+          if (gsym->source() != Symbol::FROM_OBJECT)
+            continue;
+          bool is_ordinary;
+          dst_obj = gsym->object();
+          dst_indx = gsym->shndx(&is_ordinary);
+          if (!is_ordinary)
+            continue;
+        }
+      Section_id p1(src_obj, src_indx);
+      Section_id p2(dst_obj, dst_indx);
+      Garbage_collection::Section_ref::iterator map_it;
+      map_it = symtab->gc()->section_reloc_map().find(p1);
+      if (map_it == symtab->gc()->section_reloc_map().end())
+        {
+          symtab->gc()->section_reloc_map()[p1].insert(p2);
+        }
+      else
+        {
+          Garbage_collection::Sections_reachable& v(map_it->second);
+          v.insert(p2);
+        }
+    }
+  return;
+}
+
+} // End of namespace gold.
+
+#endif