WebSVN – Kolibri OS – Diff – /contrib/toolchain/binutils/ld/plugin.c

 /* Plugin control for the GNU linker.
-   Copyright 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
+   Copyright (C) 2010-2015 Free Software Foundation, Inc.
    This file is part of the GNU Binutils.
    MA 02110-1301, USA.  */
 #include "sysdep.h"
 #include "libiberty.h"
+#include "bfd.h"
-#include "bfd.h"
+#include "libbfd.h"
 #include "bfdlink.h"
 #include "bfdver.h"
 #include "ld.h"
 #include "ldmain.h"
 #include "ldmisc.h"
 #include "ldexp.h"
 #include "ldlang.h"
+#include "ldfile.h"
-#include "ldfile.h"
+#include "../bfd/plugin.h"
 #include "plugin.h"
 #include "plugin-api.h"
 #include "elf-bfd.h"
 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
   ld_plugin_cleanup_handler cleanup_handler;
   /* TRUE if the cleanup handlers have been called.  */
   bfd_boolean cleanup_done;
 } plugin_t;
+typedef struct view_buffer
+{
+  char *addr;
+  size_t filesize;
+  off_t offset;
+} view_buffer_t;
+/* The internal version of struct ld_plugin_input_file with a BFD
+   pointer.  */
+typedef struct plugin_input_file
+{
+  bfd *abfd;
+  view_buffer_t view_buffer;
+  char *name;
+  int fd;
+  bfd_boolean use_mmap;
+  off_t offset;
+  off_t filesize;
+} plugin_input_file_t;
 /* The master list of all plugins.  */
 static plugin_t *plugins_list = NULL;
   LDPT_REGISTER_CLAIM_FILE_HOOK,
   LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK,
   LDPT_REGISTER_CLEANUP_HOOK,
   LDPT_ADD_SYMBOLS,
   LDPT_GET_INPUT_FILE,
+  LDPT_GET_VIEW,
   LDPT_RELEASE_INPUT_FILE,
   LDPT_GET_SYMBOLS,
   LDPT_GET_SYMBOLS_V2,
   LDPT_ADD_INPUT_FILE,
   LDPT_ADD_INPUT_LIBRARY,
 /* How many entries in the constant leading part of the tv array.  */
 static const size_t tv_header_size = ARRAY_SIZE (tv_header_tags);
 /* Forward references.  */
+static bfd_boolean plugin_notice (struct bfd_link_info *,
-static bfd_boolean plugin_notice (struct bfd_link_info *,
+				  struct bfd_link_hash_entry *,
-				  struct bfd_link_hash_entry *, bfd *,
+				  struct bfd_link_hash_entry *,
+				  bfd *, asection *, bfd_vma, flagword);
-				  asection *, bfd_vma, flagword, const char *);
+static const bfd_target * plugin_object_p (bfd *);
   plugin_arg_t *newarg;
   if (!last_plugin)
+    return set_plugin_error (_(""));
+  /* Ignore -pass-through= from GCC driver.  */
+  if (*arg == '-')
+    {
+      const char *p = arg + 1;
+      if (*p == '-')
+	++p;
+      if (strncmp (p, "pass-through=", 13) == 0)
+	return 0;
     return set_plugin_error (_(""));
   newarg = xmalloc (sizeof *newarg);
   newarg->arg = arg;
   last_plugin_args_tail_chain_ptr = &newarg->next;
   last_plugin->n_args++;
   return 0;
+}
+/* Generate a dummy BFD to represent an IR file, for any callers of
+   plugin_call_claim_file to use as the handle in the ld_plugin_input_file
+   struct that they build to pass in.  The BFD is initially writable, so
+   that symbols can be added to it; it must be made readable after the
-/* Create a dummy BFD.  */
+   add_symbols hook has been called so that it can be read when linking.  */
-bfd *
+static bfd *
 plugin_get_ir_dummy_bfd (const char *name, bfd *srctemplate)
+{
+  bfd *abfd;
-  bfd *abfd;
+  bfd_boolean bfd_plugin_target;
   bfd_use_reserved_id = 1;
-  bfd_use_reserved_id = 1;
+  bfd_plugin_target = bfd_plugin_target_p (srctemplate->xvec);
   abfd = bfd_create (concat (name, IRONLY_SUFFIX, (const char *) NULL),
-		     srctemplate);
+		     bfd_plugin_target ? link_info.output_bfd : srctemplate);
   if (abfd != NULL)
+    {
+      abfd->flags |= BFD_LINKER_CREATED | BFD_PLUGIN;
+      if (!bfd_make_writable (abfd))
+	goto report_error;
       if (!bfd_plugin_target)
       abfd->flags |= BFD_LINKER_CREATED | BFD_PLUGIN;
-      bfd_set_arch_info (abfd, bfd_get_arch_info (srctemplate));
-      bfd_set_gp_size (abfd, bfd_get_gp_size (srctemplate));
+      bfd_set_arch_info (abfd, bfd_get_arch_info (srctemplate));
+      bfd_set_gp_size (abfd, bfd_get_gp_size (srctemplate));
+	  if (!bfd_copy_private_bfd_data (srctemplate, abfd))
-      if (bfd_make_writable (abfd)
+	    goto report_error;
 	  && bfd_copy_private_bfd_data (srctemplate, abfd))
+	{
 	  flagword flags;
 	  /* Create section to own the symbols.  */
 	  flags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
 		   | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE);
 	  if (bfd_make_section_anyway_with_flags (abfd, ".text", flags))
+	    return abfd;
 	    return abfd;
+    }
 report_error:
   einfo (_("could not create dummy IR bfd: %F%E\n"));
   return NULL;
+}
 /* Check if the BFD passed in is an IR dummy object file.  */
-static bfd_boolean
+static inline bfd_boolean
 is_ir_dummy_bfd (const bfd *abfd)
-{
-  /* ABFD can sometimes legitimately be NULL, e.g. when called from one
-     of the linker callbacks for a symbol in the *ABS* or *UND* sections.
-     Likewise, the usrdata field may be NULL if ABFD was added by the
-     backend without a corresponding input statement, as happens e.g.
      when processing DT_NEEDED dependencies.  */
-  return (abfd
+  /* ABFD can sometimes legitimately be NULL, e.g. when called from one
-	  && abfd->usrdata
+     of the linker callbacks for a symbol in the *ABS* or *UND* sections.  */
-	  && ((lang_input_statement_type *)(abfd->usrdata))->flags.claimed);
+  return abfd != NULL && (abfd->flags & BFD_PLUGIN) != 0;
 /* Add symbols from a plugin-claimed input file.  */
 static enum ld_plugin_status
 add_symbols (void *handle, int nsyms, const struct ld_plugin_symbol *syms)
+{
   asymbol **symptrs;
+  plugin_input_file_t *input = handle;
-  bfd *abfd = handle;
+  bfd *abfd = input->abfd;
   int n;
   ASSERT (called_plugin);
   symptrs = xmalloc (nsyms * sizeof *symptrs);
+}
 /* Get the input file information with an open (possibly re-opened)
    file descriptor.  */
 static enum ld_plugin_status
+get_input_file (const void *handle, struct ld_plugin_input_file *file)
-get_input_file (const void *handle ATTRIBUTE_UNUSED,
+{
+  const plugin_input_file_t *input = handle;
+  ASSERT (called_plugin);
+  file->name = input->name;
+  file->offset = input->offset;
+  file->filesize = input->filesize;
+  file->handle = (void *) handle;
+  return LDPS_OK;
+}
+/* Get view of the input file.  */
+static enum ld_plugin_status
-                struct ld_plugin_input_file *file ATTRIBUTE_UNUSED)
+get_view (const void *handle, const void **viewp)
+{
   ASSERT (called_plugin);
   return LDPS_ERR;
+}
 /* Release the input file.  */
 static enum ld_plugin_status
-release_input_file (const void *handle ATTRIBUTE_UNUSED)
+release_input_file (const void *handle)
+{
   ASSERT (called_plugin);
 is_visible_from_outside (struct ld_plugin_symbol *lsym,
 			 struct bfd_link_hash_entry *blhe)
+{
   struct bfd_sym_chain *sym;
-  if (link_info.relocatable)
+  if (bfd_link_relocatable (&link_info))
     return TRUE;
-  if (link_info.export_dynamic || !link_info.executable)
+  if (link_info.export_dynamic || bfd_link_dll (&link_info))
+    {
       /* Check if symbol is hidden by version script.  */
       if (bfd_hide_sym_by_version (link_info.version_info,
 				   blhe->root.string))
 /* Get the symbol resolution info for a plugin-claimed input file.  */
 static enum ld_plugin_status
 get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms,
 	     int def_ironly_exp)
+{
+  const plugin_input_file_t *input = handle;
-  const bfd *abfd = handle;
+  const bfd *abfd = (const bfd *) input->abfd;
   int n;
   ASSERT (called_plugin);
   for (n = 0; n < nsyms; n++)
 /* Add a new (real) input file generated by a plugin.  */
 static enum ld_plugin_status
 add_input_file (const char *pathname)
+{
+  lang_input_statement_type *is;
   ASSERT (called_plugin);
-  if (!lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum,
+  is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum,
+			    NULL);
-			    NULL))
+  if (!is)
+    return LDPS_ERR;
-    return LDPS_ERR;
+  is->flags.lto_output = 1;
   return LDPS_OK;
+}
 /* Add a new (real) library required by a plugin.  */
 static enum ld_plugin_status
+add_input_library (const char *pathname)
+{
-add_input_library (const char *pathname)
+  lang_input_statement_type *is;
-{
   ASSERT (called_plugin);
+  is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum,
-  if (!lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum,
+			    NULL);
+  if (!is)
-			    NULL))
+    return LDPS_ERR;
-    return LDPS_ERR;
+  is->flags.lto_output = 1;
   return LDPS_OK;
+}
     case LDPL_INFO:
       vfinfo (stdout, format, args, FALSE);
       putchar ('\n');
       break;
     case LDPL_WARNING:
+      {
+	char *newfmt = ACONCAT (("%P: warning: ", format, "\n",
+				 (const char *) NULL));
-      vfinfo (stdout, format, args, TRUE);
+	vfinfo (stdout, newfmt, args, TRUE);
-      putchar ('\n');
+      }
       break;
     case LDPL_FATAL:
     case LDPL_ERROR:
     default:
+      {
-	char *newfmt = ACONCAT ((level == LDPL_FATAL ? "%P%F: " : "%P%X: ",
+	char *newfmt = ACONCAT ((level == LDPL_FATAL ? "%P%F" : "%P%X",
+				 ": error: ", format, "\n",
-				 format, "\n", (const char *) NULL));
+				 (const char *) NULL));
 	fflush (stdout);
 	vfinfo (stderr, newfmt, args, TRUE);
 	fflush (stderr);
+      }
       break;
 	  break;
 	case LDPT_GNU_LD_VERSION:
 	  TVU(val) = major * 100 + minor;
 	  break;
 	case LDPT_LINKER_OUTPUT:
-	  TVU(val) = (link_info.relocatable
+	  TVU(val) = (bfd_link_relocatable (&link_info) ? LDPO_REL
-		      ? LDPO_REL
-		      : (link_info.executable
+		      : bfd_link_pde (&link_info) ? LDPO_EXEC
-			 ? (link_info.pie ? LDPO_PIE : LDPO_EXEC)
+		      : bfd_link_pie (&link_info) ? LDPO_PIE
-			 : LDPO_DYN));
+		      : LDPO_DYN);
 	  break;
 	case LDPT_OUTPUT_NAME:
 	  TVU(string) = output_filename;
 	  break;
 	case LDPT_REGISTER_CLAIM_FILE_HOOK:
 	  TVU(add_symbols) = add_symbols;
 	  break;
 	case LDPT_GET_INPUT_FILE:
 	  TVU(get_input_file) = get_input_file;
 	  break;
+	case LDPT_GET_VIEW:
+	  TVU(get_view) = get_view;
+	  break;
 	case LDPT_RELEASE_INPUT_FILE:
 	  TVU(release_input_file) = release_input_file;
 	  break;
 	case LDPT_GET_SYMBOLS:
 	  TVU(get_symbols) = get_symbols_v1;
+    }
   tv->tv_tag = LDPT_NULL;
   tv->tv_u.tv_val = 0;
+}
-/* Return true if any plugins are active this run.  Only valid
-   after options have been processed.  */
-bfd_boolean
-plugin_active_plugins_p (void)
-{
-  return plugins_list != NULL;
-}
 /* Load up and initialise all plugins after argument parsing.  */
 void
 plugin_load_plugins (void)
+{
   orig_notice_all = link_info.notice_all;
   orig_callbacks = link_info.callbacks;
   plugin_callbacks = *orig_callbacks;
   plugin_callbacks.notice = &plugin_notice;
   link_info.notice_all = TRUE;
+  link_info.lto_plugin_active = TRUE;
   link_info.callbacks = &plugin_callbacks;
+  register_ld_plugin_object_p (plugin_object_p);
+#if HAVE_MMAP && HAVE_GETPAGESIZE
+  plugin_pagesize = getpagesize ();
+#endif
+}
 /* Call 'claim file' hook for all plugins.  */
 static int
       curplug = curplug->next;
+    }
   return plugin_error_p () ? -1 : 0;
+}
+/* Duplicates a character string with memory attached to ABFD.  */
-void
-plugin_maybe_claim (struct ld_plugin_input_file *file,
+static char *
-		    lang_input_statement_type *entry)
+plugin_strdup (bfd *abfd, const char *str)
+{
+  size_t strlength;
+  char *copy;
+  strlength = strlen (str) + 1;
+  copy = bfd_alloc (abfd, strlength);
+  if (copy == NULL)
+    einfo (_("%P%F: plugin_strdup failed to allocate memory: %s\n"),
+	   bfd_get_error ());
+  memcpy (copy, str, strlength);
+  return copy;
+}
+static const bfd_target *
+plugin_object_p (bfd *ibfd)
 {
+  int claimed;
+  plugin_input_file_t *input;
+  off_t offset, filesize;
+  struct ld_plugin_input_file file;
+  bfd *abfd;
+  bfd_boolean inarchive;
+  const char *name;
+  int fd;
+  /* Don't try the dummy object file.  */
+  if ((ibfd->flags & BFD_PLUGIN) != 0)
+    return NULL;
+  if (ibfd->plugin_format != bfd_plugin_uknown)
+    {
+      if (ibfd->plugin_format == bfd_plugin_yes)
+	return ibfd->plugin_dummy_bfd->xvec;
+      else
+	return NULL;
+    }
+  inarchive = bfd_my_archive (ibfd) != NULL;
+  name = inarchive ? bfd_my_archive (ibfd)->filename : ibfd->filename;
+  fd = open (name, O_RDONLY | O_BINARY);
+  if (fd < 0)
-  int claimed = 0;
+    return NULL;
   /* We create a dummy BFD, initially empty, to house whatever symbols
+     the plugin may want to add.  */
+  abfd = plugin_get_ir_dummy_bfd (ibfd->filename, ibfd);
+  input = bfd_alloc (abfd, sizeof (*input));
+  if (input == NULL)
+    einfo (_("%P%F: plugin failed to allocate memory for input: %s\n"),
+	   bfd_get_error ());
+  if (inarchive)
+    {
+      /* Offset and filesize must refer to the individual archive
+	 member, not the whole file, and must exclude the header.
+	 Fortunately for us, that is how the data is stored in the
+	 origin field of the bfd and in the arelt_data.  */
+      offset = ibfd->origin;
+      filesize = arelt_size (ibfd);
+    }
+  else
+    {
+      offset = 0;
+      filesize = lseek (fd, 0, SEEK_END);
+      /* We must copy filename attached to ibfd if it is not an archive
+	 member since it may be freed by bfd_close below.  */
+      name = plugin_strdup (abfd, name);
+    }
+  file.name = name;
+  file.offset = offset;
+  file.filesize = filesize;
+  file.fd = fd;
+  file.handle = input;
+  input->abfd = abfd;
+  input->view_buffer.addr = NULL;
-     the plugin may want to add.  */
+  input->view_buffer.filesize = 0;
+  input->view_buffer.offset = 0;
+  input->fd = fd;
+  input->use_mmap = FALSE;
+  input->offset = offset;
+  input->filesize = filesize;
+  input->name = plugin_strdup (abfd, ibfd->filename);
-  file->handle = plugin_get_ir_dummy_bfd (entry->the_bfd->filename,
+  claimed = 0;
 					  entry->the_bfd);
-  if (plugin_call_claim_file (file, &claimed))
+  if (plugin_call_claim_file (&file, &claimed))
+    einfo (_("%P%F: %s: plugin reported error claiming file\n"),
+	   plugin_error_plugin ());
-    einfo (_("%P%F: %s: plugin reported error claiming file\n"),
+  if (input->fd != -1 && ! bfd_plugin_target_p (ibfd->xvec))
+    {
+      /* FIXME: fd belongs to us, not the plugin.  GCC plugin, which
+	 doesn't need fd after plugin_call_claim_file, doesn't use
+	 BFD plugin target vector.  Since GCC plugin doesn't call
+	 release_input_file, we close it here.  LLVM plugin, which
+	 needs fd after plugin_call_claim_file and calls
+	 release_input_file after it is done, uses BFD plugin target
-	   plugin_error_plugin ());
+	 vector.  This scheme doesn't work when a plugin needs fd and
+	 doesn't use BFD plugin target vector neither.  */
+      close (fd);
+      input->fd = -1;
   /* fd belongs to us, not the plugin; but we don't need it.  */
   close (file->fd);
+  if (claimed)
+    {
+      ibfd->plugin_format = bfd_plugin_yes;
+      ibfd->plugin_dummy_bfd = abfd;
+      bfd_make_readable (abfd);
+      return abfd->xvec;
+    }
+  else
+    {
+#if HAVE_MMAP
+      if (input->use_mmap)
+	{
+	  /* If plugin didn't claim the file, unmap the buffer.  */
+	  char *addr = input->view_buffer.addr;
+	  off_t size = input->view_buffer.filesize;
+# if HAVE_GETPAGESIZE
+	  off_t bias = input->view_buffer.offset % plugin_pagesize;
+	  size += bias;
+	  addr -= bias;
+# endif
+	  munmap (addr, size);
+	}
+#endif
+      /* If plugin didn't claim the file, we don't need the dummy bfd.
+	 Can't avoid speculatively creating it, alas.  */
+      ibfd->plugin_format = bfd_plugin_no;
+      bfd_close_all_done (abfd);
+      return NULL;
+    }
+}
+void
+plugin_maybe_claim (lang_input_statement_type *entry)
+{
+  if (plugin_object_p (entry->the_bfd))
+    {
-  if (claimed)
+      bfd *abfd = entry->the_bfd->plugin_dummy_bfd;
       /* Discard the real file's BFD and substitute the dummy one.  */
       /* BFD archive handling caches elements so we can't call
 	 bfd_close for archives.  */
       if (entry->the_bfd->my_archive == NULL)
-	bfd_close (entry->the_bfd);
-      entry->the_bfd = file->handle;
-      entry->flags.claimed = TRUE;
-      bfd_make_readable (entry->the_bfd);
-    }
-  else
-    {
-      /* If plugin didn't claim the file, we don't need the dummy bfd.
-	 Can't avoid speculatively creating it, alas.  */
+	bfd_close (entry->the_bfd);
-      bfd_close_all_done (file->handle);
+      entry->the_bfd = abfd;
-      entry->flags.claimed = FALSE;
+      entry->flags.claimed = 1;
+    }
    notice_all symbols, because we won't necessarily know until later
    which ones will be contributed by IR files.  */
 static bfd_boolean
 plugin_notice (struct bfd_link_info *info,
 	       struct bfd_link_hash_entry *h,
+	       struct bfd_link_hash_entry *inh,
 	       bfd *abfd,
 	       asection *section,
 	       bfd_vma value,
-	       flagword flags,
+	       flagword flags)
-	       const char *string)
+{
+  struct bfd_link_hash_entry *orig_h = h;
   if (h != NULL)
+    {
       bfd *sym_bfd;
+      if (h->type == bfd_link_hash_warning)
+	h = h->u.i.link;
       /* Nothing to do here if this def/ref is from an IR dummy BFD.  */
       if (is_ir_dummy_bfd (abfd))
+	;
       /* Making an indirect symbol counts as a reference unless this
 	 is a brand new symbol.  */
       else if (bfd_is_ind_section (section)
+	       || (flags & BSF_INDIRECT) != 0)
+	{
-	       || (flags & BSF_INDIRECT) != 0)
+	  /* ??? Some of this is questionable.  See comments in
 	     _bfd_generic_link_add_one_symbol for case IND.  */
-	  if (h->type != bfd_link_hash_new)
-	    {
-	      struct bfd_link_hash_entry *inh;
+	  if (h->type != bfd_link_hash_new)
-	      h->non_ir_ref = TRUE;
-	      inh = bfd_wrapped_link_hash_lookup (abfd, info, string, FALSE,
 						  FALSE, FALSE);
-	      if (inh != NULL)
+	      h->non_ir_ref = TRUE;
+		inh->non_ir_ref = TRUE;
+	    }
-		inh->non_ir_ref = TRUE;
+	  else if (inh->type == bfd_link_hash_new)
 	    inh->non_ir_ref = TRUE;
+	}
 	  h->u.undef.abfd = sym_bfd;
+	}
+    }
   /* Continue with cref/nocrossref/trace-sym processing.  */
-  if (h == NULL
+  if (orig_h == NULL
       || orig_notice_all
       || (info->notice_hash != NULL
-	  && bfd_hash_lookup (info->notice_hash, h->root.string,
+	  && bfd_hash_lookup (info->notice_hash, orig_h->root.string,
 			      FALSE, FALSE) != NULL))
-    return (*orig_callbacks->notice) (info, h,
+    return (*orig_callbacks->notice) (info, orig_h, inh,
-				      abfd, section, value, flags, string);
+				      abfd, section, value, flags);
   return TRUE;
-}
-/* Return true if bfd is a dynamic library that should be reloaded.  */
-bfd_boolean
-plugin_should_reload (bfd *abfd)
-{
-  return ((abfd->flags & DYNAMIC) != 0
-	  && bfd_get_flavour (abfd) == bfd_target_elf_flavour
-	  && bfd_get_format (abfd) == bfd_object
-	  && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0);

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/ld/plugin.c – Rev 5199 → 6324