Add icf_virtual_function_folding_test to check_PROGRAMS.

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

diff --git a/gold/plugin.cc b/gold/plugin.cc
index 6170d740d9ec594fdf3037b9e60f4cb3389f0a9b..2ee1301a537a735ddf0eab525210d4435c92c2e7 100644 (file)
--- a/gold/plugin.cc
+++ b/gold/plugin.cc
@@ -1,6 +1,6 @@
 // plugin.cc -- plugin manager for gold      -*- C++ -*-
 
-// Copyright 2008, 2009 Free Software Foundation, Inc.
+// Copyright 2008, 2009, 2010 Free Software Foundation, Inc.
 // Written by Cary Coutant <ccoutant@google.com>.
 
 // This file is part of gold.
@@ -20,6 +20,8 @@
 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
 // MA 02110-1301, USA.
 
+#include "gold.h"
+
 #include <cstdio>
 #include <cstdarg>
 #include <cstring>
@@ -30,7 +32,6 @@
 #include <dlfcn.h>
 #endif
 
-#include "gold.h"
 #include "parameters.h"
 #include "errors.h"
 #include "fileread.h"
@@ -108,14 +109,16 @@ Plugin::load()
     }
 
   // Find the plugin's onload entry point.
-  ld_plugin_onload onload = reinterpret_cast<ld_plugin_onload>
-    (dlsym(this->handle_, "onload"));
-  if (onload == NULL)
+  void* ptr = dlsym(this->handle_, "onload");
+  if (ptr == NULL)
     {
       gold_error(_("%s: could not find onload entry point"),
                  this->filename_.c_str());
       return;
     }
+  ld_plugin_onload onload;
+  gold_assert(sizeof(onload) == sizeof(ptr));
+  memcpy(&onload, &ptr, sizeof(ptr));
 
   // Get the linker's version number.
   const char* ver = get_version_string();
@@ -237,8 +240,14 @@ Plugin::all_symbols_read()
 inline void
 Plugin::cleanup()
 {
-  if (this->cleanup_handler_ != NULL)
-    (*this->cleanup_handler_)();
+  if (this->cleanup_handler_ != NULL && !this->cleanup_done_)
+    {
+      // Set this flag before calling to prevent a recursive plunge
+      // in the event that a plugin's cleanup handler issues a
+      // fatal error.
+      this->cleanup_done_ = true;
+      (*this->cleanup_handler_)();
+    }
 }
 
 // Plugin_manager methods.
@@ -349,13 +358,10 @@ Plugin_manager::layout_deferred_objects()
 void
 Plugin_manager::cleanup()
 {
-  if (this->cleanup_done_)
-    return;
   for (this->current_ = this->plugins_.begin();
        this->current_ != this->plugins_.end();
        ++this->current_)
     (*this->current_)->cleanup();
-  this->cleanup_done_ = true;
 }
 
 // Make a new Pluginobj object.  This is called when the plugin calls
@@ -422,8 +428,8 @@ Plugin_manager::add_input_file(char *pathname, bool is_lib)
   Task_token* next_blocker = new Task_token(true);
   next_blocker->add_blocker();
   if (this->layout_->incremental_inputs())
-    gold_error(_("Input files added by plug-ins in --incremental mode not "
-                "supported yet.\n"));
+    gold_error(_("input files added by plug-ins in --incremental mode not "
+                "supported yet"));
   this->workqueue_->queue_soon(new Read_symbols(this->input_objects_,
                                                 this->symtab_,
                                                 this->layout_,
@@ -432,6 +438,7 @@ Plugin_manager::add_input_file(char *pathname, bool is_lib)
                                                 this->mapfile_,
                                                 input_argument,
                                                 NULL,
+                                                NULL,
                                                 this->this_blocker_,
                                                 next_blocker));
   this->this_blocker_ = next_blocker;
@@ -469,6 +476,17 @@ Pluginobj::get_symbol_resolution_info(int nsyms, ld_plugin_symbol* syms) const
 {
   if (nsyms > this->nsyms_)
     return LDPS_NO_SYMS;
+
+  if (static_cast<size_t>(nsyms) > this->symbols_.size())
+    {
+      // We never decided to include this object. We mark all symbols as
+      // preempted.
+      gold_assert (this->symbols_.size() == 0);
+      for (int i = 0; i < nsyms; i++)
+        syms[i].resolution = LDPR_PREEMPTED_REG;
+      return LDPS_OK;
+    }
+
   for (int i = 0; i < nsyms; i++)
     {
       ld_plugin_symbol* isym = &syms[i];
@@ -485,6 +503,10 @@ Pluginobj::get_symbol_resolution_info(int nsyms, ld_plugin_symbol* syms) const
           // The original symbol was undefined or common.
           if (lsym->source() != Symbol::FROM_OBJECT)
             res = LDPR_RESOLVED_EXEC;
+          else if (lsym->object()->pluginobj() == this)
+            res = (is_visible_from_outside(lsym)
+                   ? LDPR_PREVAILING_DEF
+                   : LDPR_PREVAILING_DEF_IRONLY);
           else if (lsym->object()->pluginobj() != NULL)
             res = LDPR_RESOLVED_IR;
           else if (lsym->object()->is_dynamic())
@@ -656,6 +678,34 @@ Sized_pluginobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
     }
 }
 
+template<int size, bool big_endian>
+Archive::Should_include
+Sized_pluginobj<size, big_endian>::do_should_include_member(
+    Symbol_table* symtab, Read_symbols_data*, std::string* why)
+{
+  char* tmpbuf = NULL;
+  size_t tmpbuflen = 0;
+
+  for (int i = 0; i < this->nsyms_; ++i) {
+    const struct ld_plugin_symbol& sym = this->syms_[i];
+    const char* name = sym.name;
+    Symbol* symbol;
+    Archive::Should_include t = Archive::should_include_member(symtab, name,
+                                                               &symbol, why,
+                                                               &tmpbuf,
+                                                               &tmpbuflen);
+      if (t == Archive::SHOULD_INCLUDE_YES)
+       {
+         if (tmpbuf != NULL)
+           free(tmpbuf);
+         return t;
+       }
+  }
+  if (tmpbuf != NULL)
+    free(tmpbuf);
+  return Archive::SHOULD_INCLUDE_UNKNOWN;
+}
+
 // Get the size of a section.  Not used for plugin objects.
 
 template<int size, bool big_endian>
@@ -778,6 +828,15 @@ Sized_pluginobj<size, big_endian>::do_get_global_symbol_counts(const Symbol_tabl
   gold_unreachable();
 }
 
+// Get symbols.  Not used for plugin objects.
+
+template<int size, bool big_endian>
+const Object::Symbols*
+Sized_pluginobj<size, big_endian>::do_get_global_symbols() const
+{
+  gold_unreachable();
+}
+
 // Class Plugin_finish.  This task runs after all replacement files have
 // been added.  It calls each plugin's cleanup handler.