Add --debug=plugin option to record plugin actions.

With --debug=plugin, gold will log all plugin actions to a log file,
and make copies of plugin-supplied replacement files in a temporary
directory created under the current working directory.

gold/
	* debug.h (DEBUG_PLUGIN): New constant.
	(DEBUG_ALL): Add DEBUG_PLUGIN.
	(debug_string_to_enum): Likewise.
	* plugin.cc (make_sized_plugin_object): Add filename parameter.
	(Plugin_recorder): New class.
	(Plugin_manager::~Plugin_manager): Delete recorder_.
	(Plugin_manager::load_plugins): Create and initialize recorder_.
	(Plugin_manager::claim_file): Record claimed and unclaimed files.
	(Plugin_manager::make_plugin_object): Use object name as name for
	plugin object, if available.
	(Plugin_manager::add_input_file): Record replacement files.
	(Sized_pluginobj::do_add_symbols): Record plugin symbols.
	(Plugin_finish::run): Call Plugin_recorder::finish().
	(make_sized_plugin_object): Add filename parameter and pass to
	Sized_pluginobj constructor.
	* plugin.h (Plugin::filename): New method.
	(Plugin::recorder): New method.
	(Plugin::recorder_): New data member.

3 files changed, 294 insertions, 21 deletions

diff --git a/gold/debug.h b/gold/debug.h
index 0da1f9c..e82af3d 100644
--- a/gold/debug.h
+++ b/gold/debug.h
@@ -40,10 +40,11 @@ const int DEBUG_RELAXATION = 0x8;
 const int DEBUG_INCREMENTAL = 0x10;
 const int DEBUG_LOCATION = 0x20;
 const int DEBUG_TARGET = 0x40;
+const int DEBUG_PLUGIN = 0x80;
 
 const int DEBUG_ALL = (DEBUG_TASK | DEBUG_SCRIPT | DEBUG_FILES
 		       | DEBUG_RELAXATION | DEBUG_INCREMENTAL
-		       | DEBUG_LOCATION | DEBUG_TARGET);
+		       | DEBUG_LOCATION | DEBUG_TARGET | DEBUG_PLUGIN);
 
 // Convert a debug string to the appropriate enum.
 inline int
@@ -59,6 +60,7 @@ debug_string_to_enum(const char* arg)
     { "incremental", DEBUG_INCREMENTAL },
     { "location", DEBUG_LOCATION },
     { "target", DEBUG_TARGET },
+    { "plugin", DEBUG_PLUGIN },
     { "all", DEBUG_ALL }
   };
 
diff --git a/gold/plugin.cc b/gold/plugin.cc
index 442eda0..b12a7a9 100644
--- a/gold/plugin.cc
+++ b/gold/plugin.cc
@@ -22,11 +22,15 @@
 
 #include "gold.h"
 
+#include <cerrno>
 #include <cstdio>
 #include <cstdarg>
 #include <cstring>
 #include <string>
 #include <vector>
+#include <fcntl.h>
+#include <unistd.h>
+#include "libiberty.h"
 
 #ifdef ENABLE_PLUGINS
 #ifdef HAVE_DLFCN_H
@@ -63,6 +67,7 @@ dlerror(void)
 #endif /* ENABLE_PLUGINS */
 
 #include "parameters.h"
+#include "debug.h"
 #include "errors.h"
 #include "fileread.h"
 #include "layout.h"
@@ -177,7 +182,8 @@ get_wrap_symbols(uint64_t *num_symbols, const char ***wrap_symbol_list);
 
 #endif // ENABLE_PLUGINS
 
-static Pluginobj* make_sized_plugin_object(Input_file* input_file,
+static Pluginobj* make_sized_plugin_object(const std::string& filename,
+					   Input_file* input_file,
                                            off_t offset, off_t filesize);
 
 // Plugin methods.
@@ -460,6 +466,215 @@ class Plugin_rescan : public Task
   Task_token* next_blocker_;
 };
 
+// Plugin_recorder logs plugin actions and saves intermediate files
+// for later replay.
+
+class Plugin_recorder
+{
+ public:
+  Plugin_recorder() : file_count_(0), tempdir_(NULL), logfile_(NULL)
+  { }
+
+  bool
+  init();
+
+  void
+  claimed_file(const std::string& obj_name, off_t offset, off_t filesize,
+	       const std::string& plugin_name);
+
+  void
+  unclaimed_file(const std::string& obj_name, off_t offset, off_t filesize);
+
+  void
+  replacement_file(const char* name, bool is_lib);
+
+  void
+  record_symbols(const Object* obj, int nsyms,
+		 const struct ld_plugin_symbol* syms);
+
+  void
+  finish()
+  { ::fclose(this->logfile_); }
+
+ private:
+  unsigned int file_count_;
+  const char* tempdir_;
+  FILE* logfile_;
+};
+
+bool
+Plugin_recorder::init()
+{
+  // Create a temporary directory where we can stash the log and
+  // copies of replacement files.
+  char dir_template[] = "gold-recording-XXXXXX";
+  if (mkdtemp(dir_template) == NULL)
+    return false;
+
+  size_t len = strlen(dir_template) + 1;
+  char* tempdir = new char[len];
+  strncpy(tempdir, dir_template, len);
+
+  // Create the log file.
+  std::string logname(tempdir);
+  logname.append("/log");
+  FILE* logfile = ::fopen(logname.c_str(), "w");
+  if (logfile == NULL)
+    return false;
+
+  this->tempdir_ = tempdir;
+  this->logfile_ = logfile;
+
+  gold_info(_("%s: recording to %s"), program_name, this->tempdir_);
+
+  return true;
+}
+
+void
+Plugin_recorder::claimed_file(const std::string& obj_name,
+			      off_t offset,
+			      off_t filesize,
+			      const std::string& plugin_name)
+{
+  fprintf(this->logfile_, "PLUGIN: %s\n", plugin_name.c_str());
+  fprintf(this->logfile_, "CLAIMED: %s", obj_name.c_str());
+  if (offset > 0)
+    fprintf(this->logfile_, " @%ld", static_cast<long>(offset));
+  fprintf(this->logfile_, " %ld\n", static_cast<long>(filesize));
+}
+
+void
+Plugin_recorder::unclaimed_file(const std::string& obj_name,
+				off_t offset,
+				off_t filesize)
+{
+  fprintf(this->logfile_, "UNCLAIMED: %s", obj_name.c_str());
+  if (offset > 0)
+    fprintf(this->logfile_, " @%ld", static_cast<long>(offset));
+  fprintf(this->logfile_, " %ld\n", static_cast<long>(filesize));
+}
+
+// Make a hard link to INNAME from OUTNAME, if possible.
+// If not, copy the file.
+
+static bool
+link_or_copy_file(const char* inname, const char* outname)
+{
+  static char buf[4096];
+
+  if (::link(inname, outname) == 0)
+    return true;
+
+  int in = ::open(inname, O_RDONLY);
+  if (in < 0)
+    {
+      gold_warning(_("%s: can't open (%s)\n"), inname, strerror(errno));
+      return false;
+    }
+  int out = ::open(outname, O_CREAT | O_TRUNC | O_WRONLY, 0600);
+  if (out < 0)
+    {
+      gold_warning(_("%s: can't create (%s)\n"), outname, strerror(errno));
+      ::close(in);
+      return false;
+    }
+  ssize_t len;
+  while ((len = ::read(in, buf, sizeof(buf))) > 0)
+    static_cast<void>(::write(out, buf, len));
+  ::close(in);
+  ::close(out);
+  return true;
+}
+
+void
+Plugin_recorder::replacement_file(const char* name, bool is_lib)
+{
+  fprintf(this->logfile_, "REPLACEMENT: %s", name);
+  if (is_lib)
+    fprintf(this->logfile_, "(lib)");
+  else
+    {
+      char counter[10];
+      const char* basename = lbasename(name);
+      snprintf(counter, sizeof(counter), "%05d", this->file_count_);
+      ++this->file_count_;
+      std::string outname(this->tempdir_);
+      outname.append("/");
+      outname.append(counter);
+      outname.append("-");
+      outname.append(basename);
+      if (link_or_copy_file(name, outname.c_str()))
+        fprintf(this->logfile_, " -> %s", outname.c_str());
+    }
+  fprintf(this->logfile_, "\n");
+}
+
+void
+Plugin_recorder::record_symbols(const Object* obj, int nsyms,
+				const struct ld_plugin_symbol* syms)
+{
+  fprintf(this->logfile_, "SYMBOLS: %d %s\n", nsyms, obj->name().c_str());
+  for (int i = 0; i < nsyms; ++i)
+    {
+      const struct ld_plugin_symbol* isym = &syms[i];
+
+      const char* def;
+      switch (isym->def)
+        {
+        case LDPK_DEF:
+          def = "D";
+          break;
+        case LDPK_WEAKDEF:
+          def = "WD";
+          break;
+        case LDPK_UNDEF:
+          def = "U";
+          break;
+        case LDPK_WEAKUNDEF:
+          def = "WU";
+          break;
+        case LDPK_COMMON:
+          def = "C";
+          break;
+        default:
+          def = "?";
+          break;
+        }
+
+      char vis;
+      switch (isym->visibility)
+        {
+        case LDPV_PROTECTED:
+          vis = 'P';
+          break;
+        case LDPV_INTERNAL:
+          vis = 'I';
+          break;
+        case LDPV_HIDDEN:
+          vis = 'H';
+          break;
+        case LDPV_DEFAULT:
+          vis = 'D';
+          break;
+        default:
+          vis = '?';
+          break;
+        }
+
+      fprintf(this->logfile_, " %5d: %-2s %c %s", i, def, vis, isym->name);
+      if (isym->version != NULL && isym->version[0] != '\0')
+	fprintf(this->logfile_, "@%s", isym->version);
+      if (isym->comdat_key != NULL && isym->comdat_key[0] != '\0')
+	{
+	  if (strcmp(isym->name, isym->comdat_key) == 0)
+	    fprintf(this->logfile_, " [comdat]");
+	  else
+	    fprintf(this->logfile_, " [comdat: %s]", isym->comdat_key);
+	}
+      fprintf(this->logfile_, "\n");
+    }
+}
+
 // Plugin_manager methods.
 
 Plugin_manager::~Plugin_manager()
@@ -475,6 +690,7 @@ Plugin_manager::~Plugin_manager()
     delete *obj;
   this->objects_.clear();
   delete this->lock_;
+  delete this->recorder_;
 }
 
 // Load all plugin libraries.
@@ -483,6 +699,13 @@ void
 Plugin_manager::load_plugins(Layout* layout)
 {
   this->layout_ = layout;
+
+  if (is_debugging_enabled(DEBUG_PLUGIN))
+    {
+      this->recorder_ = new Plugin_recorder();
+      this->recorder_->init();
+    }
+
   for (this->current_ = this->plugins_.begin();
        this->current_ != this->plugins_.end();
        ++this->current_)
@@ -524,6 +747,16 @@ Plugin_manager::claim_file(Input_file* input_file, off_t offset,
               this->any_claimed_ = true;
               this->in_claim_file_handler_ = false;
 
+	      if (this->recorder_ != NULL)
+		{
+		  const std::string& objname = (elf_object == NULL
+						? input_file->filename()
+						: elf_object->name());
+		  this->recorder_->claimed_file(objname,
+						offset, filesize,
+						(*this->current_)->filename());
+		}
+
               if (this->objects_.size() > handle
                   && this->objects_[handle]->pluginobj() != NULL)
                 return this->objects_[handle]->pluginobj();
@@ -541,6 +774,10 @@ Plugin_manager::claim_file(Input_file* input_file, off_t offset,
     }
 
   this->in_claim_file_handler_ = false;
+
+  if (this->recorder_ != NULL)
+    this->recorder_->unclaimed_file(input_file->filename(), offset, filesize);
+
   return NULL;
 }
 
@@ -787,15 +1024,23 @@ Plugin_manager::make_plugin_object(unsigned int handle)
       && this->objects_[handle]->pluginobj() != NULL)
     return NULL;
 
-  Pluginobj* obj = make_sized_plugin_object(this->input_file_,
+  const std::string* filename = &this->input_file_->filename();
+
+  // If the elf object for this file was pushed into the objects_ vector,
+  // use its filename, then delete it to make room for the Pluginobj as
+  // this file is claimed.
+  if (this->objects_.size() != handle)
+    {
+      filename = &this->objects_.back()->name();
+      this->objects_.pop_back();
+    }
+
+  Pluginobj* obj = make_sized_plugin_object(*filename,
+					    this->input_file_,
                                             this->plugin_input_file_.offset,
                                             this->plugin_input_file_.filesize);
 
 
-  // If the elf object for this file was pushed into the objects_ vector, delete
-  // it to make room for the Pluginobj as this file is claimed.
-  if (this->objects_.size() != handle)
-    this->objects_.pop_back();
 
   this->objects_.push_back(obj);
   return obj;
@@ -915,6 +1160,10 @@ Plugin_manager::add_input_file(const char* pathname, bool is_lib)
   if (parameters->incremental())
     gold_error(_("input files added by plug-ins in --incremental mode not "
 		 "supported yet"));
+
+  if (this->recorder_ != NULL)
+    this->recorder_->replacement_file(pathname, is_lib);
+
   this->workqueue_->queue_soon(new Read_symbols(this->input_objects_,
                                                 this->symtab_,
                                                 this->layout_,
@@ -1130,6 +1379,10 @@ Sized_pluginobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
   elfcpp::Sym<size, big_endian> sym(symbuf);
   elfcpp::Sym_write<size, big_endian> osym(symbuf);
 
+  Plugin_recorder* recorder = parameters->options().plugins()->recorder();
+  if (recorder != NULL)
+    recorder->record_symbols(this, this->nsyms_, this->syms_);
+
   this->symbols_.resize(this->nsyms_);
 
   for (int i = 0; i < this->nsyms_; ++i)
@@ -1442,7 +1695,11 @@ class Plugin_finish : public Task
   void
   run(Workqueue*)
   {
+    Plugin_manager* plugins = parameters->options().plugins();
+    gold_assert(plugins != NULL);
     // We could call early cleanup handlers here.
+    if (plugins->recorder())
+      plugins->recorder()->finish();
   }
 
   std::string
@@ -1982,7 +2239,8 @@ register_new_input(ld_plugin_new_input_handler handler)
 // Allocate a Pluginobj object of the appropriate size and endianness.
 
 static Pluginobj*
-make_sized_plugin_object(Input_file* input_file, off_t offset, off_t filesize)
+make_sized_plugin_object(const std::string& filename,
+			 Input_file* input_file, off_t offset, off_t filesize)
 {
   Pluginobj* obj = NULL;
 
@@ -1993,42 +2251,42 @@ make_sized_plugin_object(Input_file* input_file, off_t offset, off_t filesize)
     {
       if (target.is_big_endian())
 #ifdef HAVE_TARGET_32_BIG
-        obj = new Sized_pluginobj<32, true>(input_file->filename(),
-                                            input_file, offset, filesize);
+        obj = new Sized_pluginobj<32, true>(filename, input_file,
+					    offset, filesize);
 #else
         gold_error(_("%s: not configured to support "
 		     "32-bit big-endian object"),
-		   input_file->filename().c_str());
+		   filename.c_str());
 #endif
       else
 #ifdef HAVE_TARGET_32_LITTLE
-        obj = new Sized_pluginobj<32, false>(input_file->filename(),
-                                             input_file, offset, filesize);
+        obj = new Sized_pluginobj<32, false>(filename, input_file,
+                                             offset, filesize);
 #else
         gold_error(_("%s: not configured to support "
 		     "32-bit little-endian object"),
-		   input_file->filename().c_str());
+		   filename.c_str());
 #endif
     }
   else if (target.get_size() == 64)
     {
       if (target.is_big_endian())
 #ifdef HAVE_TARGET_64_BIG
-        obj = new Sized_pluginobj<64, true>(input_file->filename(),
-                                            input_file, offset, filesize);
+        obj = new Sized_pluginobj<64, true>(filename, input_file,
+                                            offset, filesize);
 #else
         gold_error(_("%s: not configured to support "
 		     "64-bit big-endian object"),
-		   input_file->filename().c_str());
+		   filename.c_str());
 #endif
       else
 #ifdef HAVE_TARGET_64_LITTLE
-        obj = new Sized_pluginobj<64, false>(input_file->filename(),
-                                             input_file, offset, filesize);
+        obj = new Sized_pluginobj<64, false>(filename, input_file,
+                                             offset, filesize);
 #else
         gold_error(_("%s: not configured to support "
 		     "64-bit little-endian object"),
-		   input_file->filename().c_str());
+		   filename.c_str());
 #endif
     }
 
diff --git a/gold/plugin.h b/gold/plugin.h
index e64ee07..c12bdc0 100644
--- a/gold/plugin.h
+++ b/gold/plugin.h
@@ -47,6 +47,7 @@ class Task;
 class Task_token;
 class Pluginobj;
 class Plugin_rescan;
+class Plugin_recorder;
 
 // This class represents a single plugin library.
 
@@ -114,6 +115,10 @@ class Plugin
     this->args_.push_back(arg);
   }
 
+  const std::string&
+  filename() const
+  { return this->filename_; }
+
  private:
   Plugin(const Plugin&);
   Plugin& operator=(const Plugin&);
@@ -146,7 +151,8 @@ class Plugin_manager
       options_(options), workqueue_(NULL), task_(NULL), input_objects_(NULL),
       symtab_(NULL), layout_(NULL), dirpath_(NULL), mapfile_(NULL),
       this_blocker_(NULL), extra_search_path_(), lock_(NULL),
-      initialize_lock_(&lock_), defsym_defines_set_()
+      initialize_lock_(&lock_), defsym_defines_set_(),
+      recorder_(NULL)
   { this->current_ = plugins_.end(); }
 
   ~Plugin_manager();
@@ -316,6 +322,10 @@ class Plugin_manager
   layout()
   { return this->layout_; }
 
+  Plugin_recorder*
+  recorder() const
+  { return this->recorder_; }
+
  private:
   Plugin_manager(const Plugin_manager&);
   Plugin_manager& operator=(const Plugin_manager&);
@@ -413,6 +423,9 @@ class Plugin_manager
   // Keep track of all symbols defined by defsym.
   typedef Unordered_set<std::string> Defsym_defines_set;
   Defsym_defines_set defsym_defines_set_;
+
+  // Class to record plugin actions.
+  Plugin_recorder* recorder_;
 };