WebSVN – Kolibri OS – Diff – /contrib/toolchain/binutils/bfd/cofflink.c

 /* COFF specific linker code.
-   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
-, 2005, 2006, 2007, 2008, 2009, 2011 Free Software Foundation, Inc.
+   Copyright (C) 1994-2015 Free Software Foundation, Inc.
    Written by Ian Lance Taylor, Cygnus Support.
    This file is part of BFD, the Binary File Descriptor library.
 #include "libbfd.h"
 #include "coff/internal.h"
 #include "libcoff.h"
 #include "safe-ctype.h"
-static bfd_boolean coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info);
+static bfd_boolean coff_link_add_object_symbols (bfd *, struct bfd_link_info *);
+static bfd_boolean coff_link_check_archive_element
+  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
-static bfd_boolean coff_link_check_archive_element (bfd *abfd, struct bfd_link_info *info, bfd_boolean *pneeded);
+   bfd_boolean *);
-static bfd_boolean coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info);
+static bfd_boolean coff_link_add_symbols (bfd *, struct bfd_link_info *);
 /* Return TRUE if SYM is a weak, external symbol.  */
 #define IS_WEAK_EXTERNAL(abfd, sym)			\
     return FALSE;
   return TRUE;
-}
-/* Look through the symbols to see if this object file should be
-   included in the link.  */
-static bfd_boolean
-coff_link_check_ar_symbols (bfd *abfd,
-			    struct bfd_link_info *info,
-			    bfd_boolean *pneeded,
-			    bfd **subsbfd)
-{
-  bfd_size_type symesz;
-  bfd_byte *esym;
-  bfd_byte *esym_end;
-  *pneeded = FALSE;
-  symesz = bfd_coff_symesz (abfd);
-  esym = (bfd_byte *) obj_coff_external_syms (abfd);
-  esym_end = esym + obj_raw_syment_count (abfd) * symesz;
-  while (esym < esym_end)
-    {
-      struct internal_syment sym;
-      enum coff_symbol_classification classification;
-      bfd_coff_swap_sym_in (abfd, esym, &sym);
-      classification = bfd_coff_classify_symbol (abfd, &sym);
-      if (classification == COFF_SYMBOL_GLOBAL
-	  || classification == COFF_SYMBOL_COMMON)
-	{
-	  const char *name;
-	  char buf[SYMNMLEN + 1];
-	  struct bfd_link_hash_entry *h;
-	  /* This symbol is externally visible, and is defined by this
-             object file.  */
-	  name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
-	  if (name == NULL)
-	    return FALSE;
-	  h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
-	  /* Auto import.  */
-	  if (!h
-	      && info->pei386_auto_import
-	      && CONST_STRNEQ (name, "__imp_"))
-	    h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
-	  /* We are only interested in symbols that are currently
-	     undefined.  If a symbol is currently known to be common,
-	     COFF linkers do not bring in an object file which defines
-	     it.  */
-	  if (h != (struct bfd_link_hash_entry *) NULL
-	      && h->type == bfd_link_hash_undefined)
-	    {
-	      if (!(*info->callbacks
-		    ->add_archive_element) (info, abfd, name, subsbfd))
-		return FALSE;
-	      *pneeded = TRUE;
-	      return TRUE;
-	    }
-	}
-      esym += (sym.n_numaux + 1) * symesz;
-    }
-  /* We do not need this object file.  */
-  return TRUE;
+}
 /* Check a single archive element to see if we need to include it in
    the link.  *PNEEDED is set according to whether this element is
    needed in the link or not.  This is called via
    _bfd_generic_link_add_archive_symbols.  */
+static bfd_boolean
+coff_link_check_archive_element (bfd *abfd,
-static bfd_boolean
+				 struct bfd_link_info *info,
-coff_link_check_archive_element (bfd *abfd,
+				 struct bfd_link_hash_entry *h,
-				 struct bfd_link_info *info,
+				 const char *name,
-				 bfd_boolean *pneeded)
+				 bfd_boolean *pneeded)
+{
+  *pneeded = FALSE;
-{
-  bfd *oldbfd;
+  /* We are only interested in symbols that are currently undefined.
-  bfd_boolean needed;
+     If a symbol is currently known to be common, COFF linkers do not
-  if (!_bfd_coff_get_external_symbols (abfd))
+     bring in an object file which defines it.  */
+  if (h->type != bfd_link_hash_undefined)
-    return FALSE;
-  oldbfd = abfd;
-  if (!coff_link_check_ar_symbols (abfd, info, pneeded, &abfd))
-    return FALSE;
-  needed = *pneeded;
-  if (needed)
-    {
-      /* Potentially, the add_archive_element hook may have set a
-	 substitute BFD for us.  */
-      if (abfd != oldbfd)
-	{
-	  if (!info->keep_memory
+    return TRUE;
-	      && !_bfd_coff_free_symbols (oldbfd))
-	    return FALSE;
-	  if (!_bfd_coff_get_external_symbols (abfd))
-	    return FALSE;
-	}
-      if (!coff_link_add_symbols (abfd, info))
-	return FALSE;
-    }
   if (!info->keep_memory || !needed)
   if (!(*info->callbacks->add_archive_element) (info, abfd, name, &abfd))
-      if (!_bfd_coff_free_symbols (abfd))
+    return FALSE;
       sym_hash += sym.n_numaux + 1;
+    }
   /* If this is a non-traditional, non-relocatable link, try to
      optimize the handling of any .stab/.stabstr sections.  */
-  if (! info->relocatable
+  if (! bfd_link_relocatable (info)
       && ! info->traditional_format
       && bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)
       && (info->strip != strip_all && info->strip != strip_debugger))
+    {
 	      if (info->strip == strip_none
 		  || info->strip == strip_some)
 		o->lineno_count += sec->lineno_count;
-	      if (info->relocatable)
+	      if (bfd_link_relocatable (info))
 		o->reloc_count += sec->reloc_count;
 	      if (sec->lineno_count > max_lineno_count)
 		max_lineno_count = sec->lineno_count;
 	      if (sec->reloc_count > max_reloc_count)
 		max_reloc_count = sec->reloc_count;
+	    }
-	  else if (info->relocatable
+	  else if (bfd_link_relocatable (info)
 		   && (p->type == bfd_section_reloc_link_order
 		       || p->type == bfd_symbol_reloc_link_order))
 	    ++o->reloc_count;
+	}
       if (o->reloc_count == 0)
+	}
+    }
   /* If doing a relocatable link, allocate space for the pointers we
      need to keep.  */
-  if (info->relocatable)
+  if (bfd_link_relocatable (info))
+    {
       unsigned int i;
 	     Because of this problem, we also keep the relocs in
 	     memory until the end of the link.  This wastes memory,
 	     but only when doing a relocatable link, which is not the
 	     common case.  */
-	  BFD_ASSERT (info->relocatable);
+	  BFD_ASSERT (bfd_link_relocatable (info));
 	  amt = o->reloc_count;
 	  amt *= sizeof (struct internal_reloc);
 	  flaginfo.section_info[o->target_index].relocs =
               (struct internal_reloc *) bfd_malloc (amt);
   /* Figure out the largest number of symbols in an input BFD.  Take
      the opportunity to clear the output_has_begun fields of all the
      input BFD's.  */
   max_sym_count = 0;
-  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
+  for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
+    {
       size_t sz;
   amt = max_lineno_count * bfd_coff_linesz (abfd);
   flaginfo.linenos = (bfd_byte *) bfd_malloc (amt);
   flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
   amt = max_reloc_count * relsz;
   flaginfo.external_relocs = (bfd_byte *) bfd_malloc (amt);
-  if (! info->relocatable)
+  if (! bfd_link_relocatable (info))
+    {
       amt = max_reloc_count * sizeof (struct internal_reloc);
       flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
+    }
   if ((flaginfo.internal_syms == NULL && max_sym_count > 0)
       || (flaginfo.sym_indices == NULL && max_sym_count > 0)
       || flaginfo.outsyms == NULL
       || (flaginfo.linenos == NULL && max_lineno_count > 0)
       || (flaginfo.contents == NULL && max_contents_size > 0)
       || (flaginfo.external_relocs == NULL && max_reloc_count > 0)
-      || (! info->relocatable
+      || (! bfd_link_relocatable (info)
 	  && flaginfo.internal_relocs == NULL
 	  && max_reloc_count > 0))
     goto error_return;
+    }
   if (flaginfo.info->strip != strip_all && flaginfo.info->discard != discard_all)
+    {
       /* Add local symbols from foreign inputs.  */
-      for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
+      for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
+	{
 	  unsigned int i;
 		   && (bfd_hash_lookup (flaginfo.info->keep_hash,
 					bfd_asymbol_name(sym), FALSE, FALSE)
 		       == NULL))
 		  || (((flaginfo.info->discard == discard_sec_merge
 			&& (bfd_get_section (sym)->flags & SEC_MERGE)
-			&& ! flaginfo.info->relocatable)
+			&& ! bfd_link_relocatable (flaginfo.info))
 		       || flaginfo.info->discard == discard_l)
 		      && bfd_is_local_label_name (sub, bfd_asymbol_name(sym))))
 		continue;
+    {
       free (flaginfo.outsyms);
       flaginfo.outsyms = NULL;
+    }
-  if (info->relocatable && max_output_reloc_count > 0)
+  if (bfd_link_relocatable (info) && max_output_reloc_count > 0)
+    {
       /* Now that we have written out all the global symbols, we know
 	 the symbol indices to use for relocs against them, and we can
 	 finally write out the relocs.  */
       /* Read in the relocs.  */
       internal_relocs = _bfd_coff_read_internal_relocs
 	(input_bfd, a, FALSE,
 	 flaginfo->external_relocs,
-	 flaginfo->info->relocatable,
+	 bfd_link_relocatable (flaginfo->info),
-	 (flaginfo->info->relocatable
+	 (bfd_link_relocatable (flaginfo->info)
 	  ? (flaginfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
 	  : flaginfo->internal_relocs)
 	);
   /* If we are going to perform relocations and also strip/discard some
      symbols then we must make sure that we do not strip/discard those
      symbols that are going to be involved in the relocations.  */
   if ((   flaginfo->info->strip   != strip_none
        || flaginfo->info->discard != discard_none)
-      && flaginfo->info->relocatable)
+      && bfd_link_relocatable (flaginfo->info))
+    {
       /* Mark the symbol array as 'not-used'.  */
       memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
       /* Extract the flag indicating if this symbol is used by a
          relocation.  */
       if ((flaginfo->info->strip != strip_none
 	   || flaginfo->info->discard != discard_none)
-	  && flaginfo->info->relocatable)
+	  && bfd_link_relocatable (flaginfo->info))
 	dont_skip_symbol = *indexp;
       else
 	dont_skip_symbol = FALSE;
+			{
 			  strings = _bfd_coff_read_string_table (input_bfd);
 			  if (strings == NULL)
 			    return FALSE;
+			}
+		      if ((bfd_size_type) auxp->x_file.x_n.x_offset >= obj_coff_strings_len (input_bfd))
+			filename = _("");
+		      else
 		      filename = strings + auxp->x_file.x_n.x_offset;
 		      indx = _bfd_stringtab_add (flaginfo->strtab, filename,
 						 hash, copy);
 		      if (indx == (bfd_size_type) -1)
 			return FALSE;
 	  /* Read in the relocs.  */
 	  target_index = o->output_section->target_index;
 	  internal_relocs = (_bfd_coff_read_internal_relocs
 			     (input_bfd, o, FALSE, flaginfo->external_relocs,
-			      flaginfo->info->relocatable,
+			      bfd_link_relocatable (flaginfo->info),
-			      (flaginfo->info->relocatable
+			      (bfd_link_relocatable (flaginfo->info)
 			       ? (flaginfo->section_info[target_index].relocs
 				  + o->output_section->reloc_count)
 			       : flaginfo->internal_relocs)));
 	  if (internal_relocs == NULL
 					   internal_relocs,
 					   flaginfo->internal_syms,
 					   flaginfo->sec_ptrs))
 	    return FALSE;
-	  if (flaginfo->info->relocatable)
+	  if (bfd_link_relocatable (flaginfo->info))
+	    {
 	      bfd_vma offset;
 	      struct internal_reloc *irelend;
+    }
   /* When a weak symbol is not overridden by a strong one,
      turn it into an external symbol when not building a
      shared or relocatable object.  */
-  if (! flaginfo->info->shared
+  if (! bfd_link_pic (flaginfo->info)
-      && ! flaginfo->info->relocatable
+      && ! bfd_link_relocatable (flaginfo->info)
       && IS_WEAK_EXTERNAL (flaginfo->output_bfd, isym))
     isym.n_sclass = C_EXT;
 	      /* For PE, an overflow on the final link reportedly does
                  not matter.  FIXME: Why not?  */
 	      if (sec->reloc_count > 0xffff
 		  && (! obj_pe (output_bfd)
-		      || flaginfo->info->relocatable))
+		      || bfd_link_relocatable (flaginfo->info)))
 		(*_bfd_error_handler)
 		  (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
 		   bfd_get_filename (output_bfd),
 		   bfd_get_section_name (output_bfd, sec),
 		   sec->reloc_count);
 	      if (sec->lineno_count > 0xffff
 		  && (! obj_pe (output_bfd)
-		      || flaginfo->info->relocatable))
+		      || bfd_link_relocatable (flaginfo->info)))
 		(*_bfd_error_handler)
 		  (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
 		   bfd_get_filename (output_bfd),
       bfd_boolean ok;
       file_ptr loc;
       size = bfd_get_reloc_size (howto);
       buf = (bfd_byte *) bfd_zmalloc (size);
-      if (buf == NULL)
+      if (buf == NULL && size != 0)
 	return FALSE;
       rstat = _bfd_relocate_contents (howto, output_bfd,
       long symndx;
       struct coff_link_hash_entry *h;
       struct internal_syment *sym;
       bfd_vma addend;
       bfd_vma val;
+      asection *sec;
       reloc_howto_type *howto;
       bfd_reloc_status_type rstat;
          a PC relative reloc that is pcrel_offset.  It will already
          have the correct value.  If this is not a relocatable link,
          then we should ignore the symbol value.  */
       if (howto->pc_relative && howto->pcrel_offset)
+	{
-	  if (info->relocatable)
+	  if (bfd_link_relocatable (info))
 	    continue;
 	  if (sym != NULL && sym->n_scnum != 0)
 	    addend += sym->n_value;
+	}
-      val = 0;
+      val = 0;
       sec = NULL;
       if (h == NULL)
-	{
-	  asection *sec;
+	{
 	  if (symndx == -1)
+	    {
 	      sec = bfd_abs_section_ptr;
 	      val = 0;
+	{
 	  if (h->root.type == bfd_link_hash_defined
 	      || h->root.type == bfd_link_hash_defweak)
+	    {
 	      /* Defined weak symbols are a GNU extension. */
-	      asection *sec;
 	      sec = h->root.u.def.section;
 	      val = (h->root.u.def.value
 		     + sec->output_section->vma
 		     + sec->output_offset);
+	    }
 		     characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1).
 		     These behave as per SVR4 ABI:  A library member
 		     will resolve a weak external only if a normal
 		     external causes the library member to be linked.
 		     See also linker.c: generic_link_check_archive_element. */
-		  asection *sec;
 		  struct coff_link_hash_entry *h2 =
 		    h->auxbfd->tdata.coff_obj_data->sym_hashes[
 		    h->aux->x_sym.x_tagndx.l];
 	      else
                 /* This is a GNU extension.  */
 		val = 0;
+	    }
-	  else if (! info->relocatable)
+	  else if (! bfd_link_relocatable (info))
+	    {
 	      if (! ((*info->callbacks->undefined_symbol)
 		     (info, h->root.root.string, input_bfd, input_section,
 		      rel->r_vaddr - input_section->vma, TRUE)))
 		return FALSE;
+	    }
+	}
+      /* If the input section defining the symbol has been discarded
+	 then zero this reloc field.  */
+      if (sec != NULL && discarded_section (sec))
+	{
+	  _bfd_clear_contents (howto, input_bfd, input_section,
+			       contents + (rel->r_vaddr - input_section->vma));
+	  continue;
+	}
       if (info->base_file)
+	{
 	  /* Emit a reloc if the backend thinks it needs it.  */

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/bfd/cofflink.c – Rev 5197 → 6324