WebSVN – Kolibri OS – Diff – /contrib/toolchain/binutils/bfd/coffcode.h

 /* Support for the generic parts of most COFF variants, for BFD.
-   Copyright 1990-2013 Free Software Foundation, Inc.
+   Copyright (C) 1990-2015 Free Software Foundation, Inc.
    Written by Cygnus Support.
    This file is part of BFD, the Binary File Descriptor library.
 .  union
 .  {
 .    union internal_auxent auxent;
 .    struct internal_syment syment;
 .  } u;
+.
+. {* Selector for the union above.  *}
+. bfd_boolean is_sym;
 .} combined_entry_type;
+.
+.
 .{* Each canonical asymbol really looks like this: *}
+.
       char buf[SYMNMLEN + 1];
       const char *symname;
       bfd_coff_swap_sym_in (abfd, esym, & isym);
-      if (sizeof (internal_s->s_name) > SYMNMLEN)
-	{
-	  /* This case implies that the matching
-	     symbol name will be in the string table.  */
 	  abort ();
       BFD_ASSERT (sizeof (internal_s->s_name) <= SYMNMLEN);
       if (isym.n_scnum == section->target_index)
 	     follows the $) as the comdat symbol.  */
 	  /* All 3 branches use this.  */
+	  symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
 	  symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
+	  /* PR 17512 file: 078-11867-0.004  */
+	  if (symname == NULL)
+	    {
+	      _bfd_error_handler (_("%B: unable to load COMDAT section name"), abfd);
-	  if (symname == NULL)
+	      break;
 	    abort ();
 	  switch (seen_state)
 		  _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
 				      abfd, symname, name);
+		seen_state = 1;
+		/* PR 17512: file: e2cfe54f.  */
+		if (esym + bfd_coff_symesz (abfd) >= esymend)
+		  {
+		    _bfd_error_handler (_("%B: warning: No symbol for section '%s' found"),
+					abfd, symname);
-		seen_state = 1;
+		    break;
+		  }
 		/* This is the section symbol.  */
 		bfd_coff_swap_aux_in (abfd, (esym + bfd_coff_symesz (abfd)),
 		   const char *name,
 		   asection *section,
 		   flagword *flags_ptr)
+{
   struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
-  long styp_flags = internal_s->s_flags;
+  unsigned long styp_flags = internal_s->s_flags;
   flagword sec_flags;
   bfd_boolean result = TRUE;
   bfd_boolean is_dbg = FALSE;
     sec_flags |= SEC_COFF_NOREAD;
   /* Process each flag bit in styp_flags in turn.  */
   while (styp_flags)
     {
-      long flag = styp_flags & - styp_flags;
+      unsigned long flag = styp_flags & - styp_flags;
       char * unhandled = NULL;
 .  COFF_SYMBOL_LOCAL,
 .  {* PE section symbol.  *}
 .  COFF_SYMBOL_PE_SECTION
 .};
+.
+.typedef asection * (*coff_gc_mark_hook_fn)
+.  (asection *, struct bfd_link_info *, struct internal_reloc *,
+.   struct coff_link_hash_entry *, struct internal_syment *);
+.
 Special entry points for gdb to swap in coff symbol table parts:
 .typedef struct
 .{
 .  void (*_bfd_coff_swap_aux_in)
 .    (bfd *, void *, int, int, int, int, void *);
 .    (bfd *, int);
+.
 .  unsigned int _bfd_coff_default_section_alignment_power;
 .  bfd_boolean _bfd_coff_force_symnames_in_strings;
 .  unsigned int _bfd_coff_debug_string_prefix_length;
+.  unsigned int _bfd_coff_max_nscns;
+.
 .  void (*_bfd_coff_swap_filehdr_in)
 .    (bfd *, void *, void *);
+.
 .  void (*_bfd_coff_swap_aouthdr_in)
 .  (coff_backend_info (abfd)->_bfd_coff_long_section_names)
 .#define bfd_coff_set_long_section_names(abfd, enable) \
 .  ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
 .#define bfd_coff_default_section_alignment_power(abfd) \
 .  (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
+.#define bfd_coff_max_nscns(abfd) \
+.  (coff_backend_info (abfd)->_bfd_coff_max_nscns)
+.
 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
 .  ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
+.
 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
 .  ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
      symbol information, since they'll be overridden by the BFD symbol
      anyhow.  However, we do need to set the type and storage class,
      in case this symbol winds up getting written out.  The value 0
      for n_numaux is already correct.  */
   native->is_sym = TRUE;
   native->u.syment.n_type = T_NULL;
   native->u.syment.n_sclass = sclass;
   if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
     abfd->flags |= HAS_DEBUG;
 #endif
+  if ((internal_f->f_flags & F_GO32STUB) != 0)
   if ((internal_f->f_flags & F_GO32STUB) != 0)
+    coff->go32stub = (char *) bfd_alloc (abfd, (bfd_size_type) GO32_STUBSIZE);
+      if (coff->go32stub == NULL)
+	return NULL;
     coff->go32stub = (char *) bfd_alloc (abfd, (bfd_size_type) GO32_STUBSIZE);
   if (coff->go32stub != NULL)
     memcpy (coff->go32stub, internal_f->go32stub, GO32_STUBSIZE);
   /* Zero selects the default machine for an arch.  */
   machine = 0;
   switch (internal_f->f_magic)
-    {
-#ifdef OR32_MAGIC_BIG
-    case OR32_MAGIC_BIG:
-    case OR32_MAGIC_LITTLE:
-      arch = bfd_arch_or32;
-      break;
 #endif
 #ifdef PPCMAGIC
     case PPCMAGIC:
       arch = bfd_arch_powerpc;
       break;
 		bfd_byte *buf;
 		struct internal_syment sym;
 		bfd_size_type amt = bfd_coff_symesz (abfd);
+		buf = bfd_malloc (amt);
+		if (buf == NULL)
-		buf = bfd_malloc (amt);
+		  return FALSE;
 		if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
 		    || bfd_bread (buf, amt, abfd) != amt)
+		  {
 		    free (buf);
 			  combined_entry_type *table_base,
 			  combined_entry_type *symbol,
 			  unsigned int indaux,
 			  combined_entry_type *aux)
+{
+  BFD_ASSERT (symbol->is_sym);
   int n_sclass = symbol->u.syment.n_sclass;
   if (CSECT_SYM_P (n_sclass)
       && indaux + 1 == symbol->u.syment.n_numaux)
+    {
       BFD_ASSERT (! aux->is_sym);
       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
+	{
 	  aux->u.auxent.x_csect.x_scnlen.p =
 	    table_base + aux->u.auxent.x_csect.x_scnlen.l;
 			  combined_entry_type *aux ATTRIBUTE_UNUSED)
+{
   /* Return TRUE if we don't want to pointerize this aux entry, which
      is the case for the lastfirst aux entry for a C_LEAFPROC symbol.  */
   return (indaux == 1
+	  && symbol->is_sym
 	  && (symbol->u.syment.n_sclass == C_LEAFPROC
 	      || symbol->u.syment.n_sclass == C_LEAFSTAT
 	      || symbol->u.syment.n_sclass == C_LEAFEXT));
+}
 		combined_entry_type *table_base ATTRIBUTE_UNUSED,
 		combined_entry_type *symbol ATTRIBUTE_UNUSED,
 		combined_entry_type *aux ATTRIBUTE_UNUSED,
 		unsigned int indaux ATTRIBUTE_UNUSED)
+{
+  BFD_ASSERT (symbol->is_sym);
+  BFD_ASSERT (! aux->is_sym);
 #ifdef RS6000COFF_C
   if (CSECT_SYM_P (symbol->u.syment.n_sclass)
       && indaux + 1 == symbol->u.syment.n_numaux)
+    {
       /* This is a csect entry.  */
 	bfd_size_type amt;
 	amt = s->reloc_count;
 	amt *= sizeof (arelent *);
+	p = bfd_malloc (amt);
+	if (p == NULL)
-	p = bfd_malloc (amt);
+	  {
-	if (p == NULL && s->reloc_count > 0)
+	    if (s->reloc_count > 0)
+	  return FALSE;
+	  }
+	else
 	  return FALSE;
 	memcpy (p, s->orelocation, (size_t) amt);
 	qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
+      }
+      }
 #endif
     case bfd_arch_w65:
       *magicp = W65MAGIC;
       return TRUE;
 #endif
-#ifdef OR32_MAGIC_BIG
-    case bfd_arch_or32:
-      if (bfd_big_endian (abfd))
-	* magicp = OR32_MAGIC_BIG;
-      else
-	* magicp = OR32_MAGIC_LITTLE;
-      return TRUE;
-#endif
     default:			/* Unknown architecture.  */
       /* Fall through to "return FALSE" below, to avoid
 	 "statement never reached" errors on the one below.  */
       break;
 coff_compute_section_file_positions (bfd * abfd)
+{
   asection *current;
   file_ptr sofar = bfd_coff_filhsz (abfd);
   bfd_boolean align_adjust;
-  int target_index;
+  unsigned int target_index;
 #ifdef ALIGN_SECTIONS_IN_FILE
   asection *previous = NULL;
   file_ptr old_sofar;
 #endif
 #ifdef COFF_IMAGE_WITH_PE
   int page_size;
   if (coff_data (abfd)->link_info
-  if (coff_data (abfd)->link_info)
+      || (pe_data (abfd) && pe_data (abfd)->pe_opthdr.FileAlignment))
+    {
       page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
       /* If no file alignment has been set, default to one.
+	 This repairs 'ld -r' for arm-wince-pe target.  */
+      if (page_size == 0)
+	page_size = 1;
+      /* PR 17512: file: 0ac816d3.  */
+      if (page_size < 0)
+	{
+	  bfd_set_error (bfd_error_file_too_big);
+	  (*_bfd_error_handler)
-	 This repairs 'ld -r' for arm-wince-pe target.  */
+	    (_("%B: page size is too large (0x%x)"), abfd, page_size);
-      if (page_size == 0)
+	  return FALSE;
 	page_size = 1;
+    }
   else
       symcount = bfd_get_symcount (abfd);
       for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
+	{
 	  coff_symbol_type *cf;
-	  cf = coff_symbol_from (abfd, *symp);
+	  cf = coff_symbol_from (*symp);
 	  if (cf != NULL
+	      && cf->native != NULL
-	      && cf->native != NULL
+	      && cf->native->is_sym
 	      && SYMNAME_IN_DEBUG (&cf->native->u.syment))
+	    {
 	      size_t len;
     for (current = abfd->sections; current != NULL; current = current->next)
       current->target_index = target_index++;
+  }
 #endif /* ! COFF_IMAGE_WITH_PE */
-  if (target_index >= 32768)
+  if (target_index >= bfd_coff_max_nscns (abfd))
+    {
       bfd_set_error (bfd_error_file_too_big);
       (*_bfd_error_handler)
 	(_("%B: too many sections (%d)"), abfd, target_index);
 		psymsec = psym;
 	      /* See if this is the section symbol.  */
 	      if (strcmp ((*psym)->name, current->name) == 0)
 		{
-		  csym = coff_symbol_from (abfd, *psym);
+		  csym = coff_symbol_from (*psym);
 		  if (csym == NULL
+		      || csym->native == NULL
-		      || csym->native == NULL
+		      || ! csym->native->is_sym
 		      || csym->native->u.syment.n_numaux < 1
 		      || csym->native->u.syment.n_sclass != C_STAT
 		      || csym->native->u.syment.n_type != T_NULL)
 	      /* We don't touch the x_checksum field.  The
 		 x_associated field is not currently supported.  */
 	      aux = csym->native + 1;
-	      aux = csym->native + 1;
+	      BFD_ASSERT (! aux->is_sym);
 	      switch (current->flags & SEC_LINK_DUPLICATES)
+		{
 		case SEC_LINK_DUPLICATES_DISCARD:
     internal_f.f_flags |= F_SHROBJ;
   if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
     internal_f.f_flags |= F_DYNLOAD;
 #endif
-  memset (&internal_a, 0, sizeof internal_a);
   /* Set up architecture-dependent stuff.  */
+  {
     unsigned int magic = 0;
 #if defined(MIPS) && defined(COFF_WITH_PE)
 #define __A_MAGIC_SET__
     internal_a.magic = MIPS_PE_MAGIC;
 #endif
-#ifdef OR32
-#define __A_MAGIC_SET__
-    internal_a.magic = NMAGIC; /* Assume separate i/d.  */
-#endif
 #ifndef __A_MAGIC_SET__
 #include "Your aouthdr magic number is not being set!"
 #else
 #undef __A_MAGIC_SET__
       internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
       internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
+    }
 #endif
+#ifdef COFF_WITH_PE
+  {
+    /* After object contents are finalized so we can compute a reasonable hash,
+       but before header is written so we can update it to point to debug directory.  */
+    struct pe_tdata *pe = pe_data (abfd);
+    if (pe->build_id.after_write_object_contents != NULL)
+      (*pe->build_id.after_write_object_contents) (abfd);
+  }
+#endif
-  /* Now write them.  */
+  /* Now write header.  */
   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
     return FALSE;
 buy_and_read (bfd *abfd, file_ptr where, bfd_size_type size)
+{
   void * area = bfd_alloc (abfd, size);
   if (!area)
-    return (NULL);
+    return NULL;
   if (bfd_seek (abfd, where, SEEK_SET) != 0
       || bfd_bread (area, size, abfd) != size)
-    return (NULL);
+    return NULL;
-  return (area);
+  return area;
+}
 /*
   const alent *al1 = *(const alent **) arg1;
   const alent *al2 = *(const alent **) arg2;
   const coff_symbol_type *s1 = (const coff_symbol_type *) (al1->u.sym);
   const coff_symbol_type *s2 = (const coff_symbol_type *) (al2->u.sym);
+  if (s1 == NULL || s2 == NULL)
     return 0;
   if (s1->symbol.value < s2->symbol.value)
     return -1;
   else if (s1->symbol.value > s2->symbol.value)
   alent *lineno_cache;
   bfd_size_type amt;
   unsigned int counter;
   alent *cache_ptr;
   bfd_vma prev_offset = 0;
-  int ordered = 1;
+  bfd_boolean ordered = TRUE;
   unsigned int nbr_func;
   LINENO *src;
+  bfd_boolean have_func;
+  bfd_boolean ret = TRUE;
   BFD_ASSERT (asect->lineno == NULL);
   cache_ptr = lineno_cache;
   asect->lineno = lineno_cache;
   src = native_lineno;
+  nbr_func = 0;
-  nbr_func = 0;
+  have_func = FALSE;
-  for (counter = 0; counter < asect->lineno_count; counter++)
+  for (counter = 0; counter < asect->lineno_count; counter++, src++)
+    {
       struct internal_lineno dst;
+      bfd_coff_swap_lineno_in (abfd, src, &dst);
+      cache_ptr->line_number = dst.l_lnno;
+      /* Appease memory checkers that get all excited about
 	 uninitialised memory when copying alents if u.offset is
-      bfd_coff_swap_lineno_in (abfd, src, &dst);
+	 larger than u.sym.  (64-bit BFD on 32-bit host.)  */
-      cache_ptr->line_number = dst.l_lnno;
+      memset (&cache_ptr->u, 0, sizeof (cache_ptr->u));
       if (cache_ptr->line_number == 0)
-	{
-	  bfd_boolean warned;
+	{
-	  bfd_signed_vma symndx;
+	  combined_entry_type * ent;
-	  coff_symbol_type *sym;
+	  bfd_vma symndx;
-	  nbr_func++;
+	  coff_symbol_type *sym;
 	  warned = FALSE;
-	  symndx = dst.l_addr.l_symndx;
+	  have_func = FALSE;
-	  if (symndx < 0
+	  symndx = dst.l_addr.l_symndx;
+	  if (symndx >= obj_raw_syment_count (abfd))
-	      || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
+	    {
-	    {
+	      (*_bfd_error_handler)
-	      (*_bfd_error_handler)
+		(_("%B: warning: illegal symbol index 0x%lx in line number entry %d"),
+		 abfd, (long) symndx, counter);
-		(_("%B: warning: illegal symbol index %ld in line numbers"),
+	      cache_ptr->line_number = -1;
-		 abfd, (long) symndx);
+	      ret = FALSE;
+	      continue;
+	    }
-	      symndx = 0;
+	  ent = obj_raw_syments (abfd) + symndx;
+	  /* FIXME: We should not be casting between ints and
+	     pointers like this.  */
+	  if (! ent->is_sym)
+	    {
+	      (*_bfd_error_handler)
+		(_("%B: warning: illegal symbol index 0x%lx in line number entry %d"),
+		 abfd, (long) symndx, counter);
+	      cache_ptr->line_number = -1;
-	      warned = TRUE;
+	      ret = FALSE;
+	      continue;
+	    }
+	  sym = (coff_symbol_type *) (ent->u.syment._n._n_n._n_zeroes);
+	  /* PR 17512 file: 078-10659-0.004  */
-	    }
+	  if (sym < obj_symbols (abfd)
+	      || sym >= obj_symbols (abfd) + bfd_get_symcount (abfd))
+	    {
+	      (*_bfd_error_handler)
+		(_("%B: warning: illegal symbol in line number entry %d"),
+		 abfd, counter);
+	      cache_ptr->line_number = -1;
 	      ret = FALSE;
-	  /* FIXME: We should not be casting between ints and
+	      continue;
 	     pointers like this.  */
 	  sym = ((coff_symbol_type *)
-		 ((symndx + obj_raw_syments (abfd))
+	  have_func = TRUE;
-		  ->u.syment._n._n_n._n_zeroes));
+	  nbr_func++;
 	  cache_ptr->u.sym = (asymbol *) sym;
-	  if (sym->lineno != NULL && ! warned)
+	  if (sym->lineno != NULL)
 	    (*_bfd_error_handler)
 	      (_("%B: warning: duplicate line number information for `%s'"),
+	       abfd, bfd_asymbol_name (&sym->symbol));
+	  sym->lineno = cache_ptr;
+	  if (sym->symbol.value < prev_offset)
-	       abfd, bfd_asymbol_name (&sym->symbol));
+	    ordered = FALSE;
+	  prev_offset = sym->symbol.value;
-	  sym->lineno = cache_ptr;
+	}
-	  if (sym->symbol.value < prev_offset)
-	    ordered = 0;
+      else if (!have_func)
-	  prev_offset = sym->symbol.value;
 	/* Drop line information that has no associated function.
+	   PR 17521: file: 078-10659-0.004.  */
+	continue;
       else
-	cache_ptr->u.offset = dst.l_addr.l_paddr
+	cache_ptr->u.offset = (dst.l_addr.l_paddr
-	  - bfd_section_vma (abfd, asect);
+			       - bfd_section_vma (abfd, asect));
       cache_ptr++;
       cache_ptr++;
       if (func_table != NULL)
+	{
 	  alent **p = func_table;
 	  unsigned int i;
-	  for (i = 0; i < counter; i++)
+	  for (i = 0; i < asect->lineno_count; i++)
 	    if (lineno_cache[i].line_number == 0)
+	      *p++ = &lineno_cache[i];
-	      *p++ = &lineno_cache[i];
+	  BFD_ASSERT ((unsigned int) (p - func_table) == nbr_func);
 	  /* Sort by functions.  */
 	  qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
 	  /* Create the new sorted table.  */
-	  amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
+	  amt = (bfd_size_type) asect->lineno_count * sizeof (alent);
 	  n_lineno_cache = (alent *) bfd_alloc (abfd, amt);
 	  if (n_lineno_cache != NULL)
+	    {
 	      alent *n_cache_ptr = n_lineno_cache;
 	      for (i = 0; i < nbr_func; i++)
-		{
-		  coff_symbol_type *sym;
+		{
-		  alent *old_ptr = func_table[i];
+		  coff_symbol_type *sym;
+		  alent *old_ptr = func_table[i];
-		  /* Copy the function entry and update it.  */
-		  *n_cache_ptr = *old_ptr;
-		  sym = (coff_symbol_type *)n_cache_ptr->u.sym;
+		  /* Update the function entry.  */
-		  sym->lineno = n_cache_ptr;
+		  sym = (coff_symbol_type *) old_ptr->u.sym;
-		  n_cache_ptr++;
+		  /* PR binutils/17512: Point the lineno to where
+		     this entry will be after the memcpy below.  */
-		  old_ptr++;
+		  sym->lineno = lineno_cache + (n_cache_ptr - n_lineno_cache);
+		  /* Copy the function and line number entries.  */
+		  do
-		  /* Copy the line number entries.  */
+		    *n_cache_ptr++ = *old_ptr++;
-		  while (old_ptr->line_number != 0)
+		  while (old_ptr->line_number != 0);
+		}
+	      BFD_ASSERT ((bfd_size_type) (n_cache_ptr - n_lineno_cache) == (amt / sizeof (alent)));
 		    *n_cache_ptr++ = *old_ptr++;
 	      memcpy (lineno_cache, n_lineno_cache, amt);
+	    }
+	  else
-	      n_cache_ptr->line_number = 0;
+	    ret = FALSE;
-	      memcpy (lineno_cache, n_lineno_cache, amt);
+	  bfd_release (abfd, func_table);
+	}
-	  bfd_release (abfd, func_table);
+      else
 	ret = FALSE;
+    }
   combined_entry_type *native_symbols;
   coff_symbol_type *cached_area;
   unsigned int *table_ptr;
   bfd_size_type amt;
   unsigned int number_of_symbols = 0;
+  bfd_boolean ret = TRUE;
   if (obj_symbols (abfd))
     return TRUE;
   if (cached_area == NULL)
     return FALSE;
   amt = obj_raw_syment_count (abfd);
   amt *= sizeof (unsigned int);
-  table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
+  table_ptr = (unsigned int *) bfd_zalloc (abfd, amt);
   if (table_ptr == NULL)
     return FALSE;
       while (this_index < last_native_index)
+	{
 	  combined_entry_type *src = native_symbols + this_index;
-	  table_ptr[this_index] = number_of_symbols;
+	  table_ptr[this_index] = number_of_symbols;
 	  dst->symbol.the_bfd = abfd;
 	  BFD_ASSERT (src->is_sym);
 	  dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
 	  /* We use the native name field to point to the cached field.  */
 	  src->u.syment._n._n_n._n_zeroes = (bfd_hostptr_t) dst;
 	  dst->symbol.section = coff_section_from_bfd_index (abfd,
+						     src->u.syment.n_scnum);
+	  dst->symbol.flags = 0;
-						     src->u.syment.n_scnum);
+	  /* PR 17512: file: 079-7098-0.001:0.1.  */
-	  dst->symbol.flags = 0;
+	  dst->symbol.value = 0;
 	  dst->done_lineno = FALSE;
 #endif
 	      /* New storage classes for TI COFF.  */
 #if defined(TIC80COFF) || defined(TICOFF)
 	    case C_UEXT:	/* Tentative external definition.  */
 #endif
-	    case C_EXTLAB:	/* External load time label.  */
-	    case C_HIDDEN:	/* Ext symbol in dmert public lib.  */
 	    default:
 	      (*_bfd_error_handler)
 		(_("%B: Unrecognized storage class %d for %s symbol `%s'"),
 		 abfd, src->u.syment.n_sclass,
 		 dst->symbol.section->name, dst->symbol.name);
+	      ret = FALSE;
+	    case C_EXTLAB:	/* External load time label.  */
+	    case C_HIDDEN:	/* Ext symbol in dmert public lib.  */
 	      dst->symbol.flags = BSF_DEBUGGING;
 	      dst->symbol.value = (src->u.syment.n_value);
 	      break;
+	    }
-	  dst->native = src;
 	  dst->native = src;
 	  dst->symbol.udata.i = 0;
+	  dst->lineno = NULL;
 	  dst->lineno = NULL;
 	  this_index += (src->u.syment.n_numaux) + 1;
 	  dst++;
 	  number_of_symbols++;
+	}
     asection *p;
     p = abfd->sections;
     while (p)
       {
+	if (! coff_slurp_line_table (abfd, p))
-	coff_slurp_line_table (abfd, p);
+	  return FALSE;
 	p = p->next;
+      }
   }
-  return TRUE;
+  return ret;
+}
       /* This is correct for Microsoft generated objects, but it
 	 breaks gas generated objects.  */
       if (syment->n_value == 0)
+	{
 	  asection *sec;
+	  char * name;
 	  char buf[SYMNMLEN + 1];
 	  name = _bfd_coff_internal_syment_name (abfd, syment, buf)
 	  sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
-	  if (sec != NULL
+	  if (sec != NULL && name != NULL
-	      && (strcmp (bfd_get_section_name (abfd, sec),
-			  _bfd_coff_internal_syment_name (abfd, syment, buf))
-		  == 0))
+	      && (strcmp (bfd_get_section_name (abfd, sec), name) == 0))
 	    return COFF_SYMBOL_PE_SECTION;
+	}
 #endif
+								\
     if (ptr && bfd_asymbol_bfd (ptr) != abfd)			\
       coffsym = (obj_symbols (abfd)				\
 		 + (cache_ptr->sym_ptr_ptr - symbols));		\
     else if (ptr)						\
-      coffsym = coff_symbol_from (abfd, ptr);			\
+      coffsym = coff_symbol_from (ptr);				\
     if (coffsym != NULL						\
+	&& coffsym->native->is_sym				\
 	&& coffsym->native->u.syment.n_scnum == 0)		\
       cache_ptr->addend = 0;					\
     else if (ptr && bfd_asymbol_bfd (ptr) == abfd		\
 	     && ptr->section != NULL)				\
       cache_ptr->addend = - (ptr->section->vma + ptr->value);	\
    make sure it is reasonable if it is needed.  */
 static reloc_howto_type *
 coff_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
 		     asection *sec ATTRIBUTE_UNUSED,
-		     struct internal_reloc *rel,
+		     struct internal_reloc *rel ATTRIBUTE_UNUSED,
 		     struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
 		     struct internal_syment *sym ATTRIBUTE_UNUSED,
 		     bfd_vma *addendp ATTRIBUTE_UNUSED)
+{
+{
   abort ();
+}
 #endif
-#ifndef coff_bfd_link_hash_table_free
-#define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
-#endif
 /* If coff_relocate_section is defined, we can use the optimized COFF
    backend linker.  Otherwise we must continue to use the old linker.  */
 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
 ,
 #else
 ,
 #endif
+,
   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
   coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
 ,
 #else
 ,
 #endif
+,
   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
   coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
 ,
 #else
 ,
 #endif
+,
   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
   coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook,
   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
   coff_link_output_has_begun, coff_final_link_postscript,
   bfd_pe_print_pdata	/* huh */
 };
 #endif
+#ifdef COFF_WITH_PE_BIGOBJ
+/* The UID for bigobj files.  */
+static const char header_bigobj_classid[16] =
+{
+xC7, 0xA1, 0xBA, 0xD1,
+xEE, 0xBA,
+xa9, 0x4b,
+xAF, 0x20,
+xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
+};
+/* Swap routines.  */
+static void
+coff_bigobj_swap_filehdr_in (bfd * abfd, void * src, void * dst)
+{
+  struct external_ANON_OBJECT_HEADER_BIGOBJ *filehdr_src =
+    (struct external_ANON_OBJECT_HEADER_BIGOBJ *) src;
+  struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst;
+  filehdr_dst->f_magic  = H_GET_16 (abfd, filehdr_src->Machine);
+  filehdr_dst->f_nscns  = H_GET_32 (abfd, filehdr_src->NumberOfSections);
+  filehdr_dst->f_timdat = H_GET_32 (abfd, filehdr_src->TimeDateStamp);
+  filehdr_dst->f_symptr =
+    GET_FILEHDR_SYMPTR (abfd, filehdr_src->PointerToSymbolTable);
+  filehdr_dst->f_nsyms  = H_GET_32 (abfd, filehdr_src->NumberOfSymbols);
+  filehdr_dst->f_opthdr = 0;
+  filehdr_dst->f_flags  = 0;
+  /* Check other magic numbers.  */
+  if (H_GET_16 (abfd, filehdr_src->Sig1) != IMAGE_FILE_MACHINE_UNKNOWN
+      || H_GET_16 (abfd, filehdr_src->Sig2) != 0xffff
+      || H_GET_16 (abfd, filehdr_src->Version) != 2
+      || memcmp (filehdr_src->ClassID, header_bigobj_classid, 16) != 0)
+    filehdr_dst->f_opthdr = 0xffff;
+  /* Note that CLR metadata are ignored.  */
+}
+static unsigned int
+coff_bigobj_swap_filehdr_out (bfd *abfd, void * in, void * out)
+{
+  struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
+  struct external_ANON_OBJECT_HEADER_BIGOBJ *filehdr_out =
+    (struct external_ANON_OBJECT_HEADER_BIGOBJ *) out;
+  memset (filehdr_out, 0, sizeof (*filehdr_out));
+  H_PUT_16 (abfd, IMAGE_FILE_MACHINE_UNKNOWN, filehdr_out->Sig1);
+  H_PUT_16 (abfd, 0xffff, filehdr_out->Sig2);
+  H_PUT_16 (abfd, 2, filehdr_out->Version);
+  memcpy (filehdr_out->ClassID, header_bigobj_classid, 16);
+  H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->Machine);
+  H_PUT_32 (abfd, filehdr_in->f_nscns, filehdr_out->NumberOfSections);
+  H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->TimeDateStamp);
+  PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
+		      filehdr_out->PointerToSymbolTable);
+  H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->NumberOfSymbols);
+  return bfd_coff_filhsz (abfd);
+}
+static void
+coff_bigobj_swap_sym_in (bfd * abfd, void * ext1, void * in1)
+{
+  SYMENT_BIGOBJ *ext = (SYMENT_BIGOBJ *) ext1;
+  struct internal_syment *in = (struct internal_syment *) in1;
+  if (ext->e.e_name[0] == 0)
+    {
+      in->_n._n_n._n_zeroes = 0;
+      in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
+    }
+  else
+    {
+#if SYMNMLEN != E_SYMNMLEN
+#error we need to cope with truncating or extending SYMNMLEN
+#else
+      memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
+#endif
+    }
+  in->n_value = H_GET_32 (abfd, ext->e_value);
+  in->n_scnum = H_GET_32 (abfd, ext->e_scnum);
+  in->n_type = H_GET_16 (abfd, ext->e_type);
+  in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
+  in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
+}
+static unsigned int
+coff_bigobj_swap_sym_out (bfd * abfd, void * inp, void * extp)
+{
+  struct internal_syment *in = (struct internal_syment *) inp;
+  SYMENT_BIGOBJ *ext = (SYMENT_BIGOBJ *) extp;
+  if (in->_n._n_name[0] == 0)
+    {
+      H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
+      H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
+    }
+  else
+    {
+#if SYMNMLEN != E_SYMNMLEN
+#error we need to cope with truncating or extending SYMNMLEN
+#else
+      memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
+#endif
+    }
+  H_PUT_32 (abfd, in->n_value, ext->e_value);
+  H_PUT_32 (abfd, in->n_scnum, ext->e_scnum);
+  H_PUT_16 (abfd, in->n_type, ext->e_type);
+  H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
+  H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
+  return SYMESZ_BIGOBJ;
+}
+static void
+coff_bigobj_swap_aux_in (bfd *abfd,
+			 void * ext1,
+			 int type,
+			 int in_class,
+			 int indx,
+			 int numaux,
+			 void * in1)
+{
+  AUXENT_BIGOBJ *ext = (AUXENT_BIGOBJ *) ext1;
+  union internal_auxent *in = (union internal_auxent *) in1;
+  switch (in_class)
+    {
+    case C_FILE:
+      if (numaux > 1)
+	{
+	  if (indx == 0)
+	    memcpy (in->x_file.x_fname, ext->File.Name,
+		    numaux * sizeof (AUXENT_BIGOBJ));
+	}
+      else
+	memcpy (in->x_file.x_fname, ext->File.Name, sizeof (ext->File.Name));
+      break;
+    case C_STAT:
+    case C_LEAFSTAT:
+    case C_HIDDEN:
+      if (type == T_NULL)
+	{
+	  in->x_scn.x_scnlen = H_GET_32 (abfd, ext->Section.Length);
+	  in->x_scn.x_nreloc =
+	    H_GET_16 (abfd, ext->Section.NumberOfRelocations);
+	  in->x_scn.x_nlinno =
+	    H_GET_16 (abfd, ext->Section.NumberOfLinenumbers);
+	  in->x_scn.x_checksum = H_GET_32 (abfd, ext->Section.Checksum);
+	  in->x_scn.x_associated = H_GET_16 (abfd, ext->Section.Number)
+	    | (H_GET_16 (abfd, ext->Section.HighNumber) << 16);
+	  in->x_scn.x_comdat = H_GET_8 (abfd, ext->Section.Selection);
+	  return;
+	}
+      break;
+    default:
+      in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->Sym.WeakDefaultSymIndex);
+      /* Characteristics is ignored.  */
+      break;
+    }
+}
+static unsigned int
+coff_bigobj_swap_aux_out (bfd * abfd,
+			  void * inp,
+			  int type,
+			  int in_class,
+			  int indx ATTRIBUTE_UNUSED,
+			  int numaux ATTRIBUTE_UNUSED,
+			  void * extp)
+{
+  union internal_auxent * in = (union internal_auxent *) inp;
+  AUXENT_BIGOBJ *ext = (AUXENT_BIGOBJ *) extp;
+  memset (ext, 0, AUXESZ);
+  switch (in_class)
+    {
+    case C_FILE:
+      memcpy (ext->File.Name, in->x_file.x_fname, sizeof (ext->File.Name));
+      return AUXESZ;
+    case C_STAT:
+    case C_LEAFSTAT:
+    case C_HIDDEN:
+      if (type == T_NULL)
+	{
+	  H_PUT_32 (abfd, in->x_scn.x_scnlen, ext->Section.Length);
+	  H_PUT_16 (abfd, in->x_scn.x_nreloc,
+		    ext->Section.NumberOfRelocations);
+	  H_PUT_16 (abfd, in->x_scn.x_nlinno,
+		    ext->Section.NumberOfLinenumbers);
+	  H_PUT_32 (abfd, in->x_scn.x_checksum, ext->Section.Checksum);
+	  H_PUT_16 (abfd, in->x_scn.x_associated & 0xffff,
+		    ext->Section.Number);
+	  H_PUT_16 (abfd, (in->x_scn.x_associated >> 16),
+		    ext->Section.HighNumber);
+	  H_PUT_8 (abfd, in->x_scn.x_comdat, ext->Section.Selection);
+	  return AUXESZ;
+	}
+      break;
+    }
+  H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->Sym.WeakDefaultSymIndex);
+  H_PUT_32 (abfd, 1, ext->Sym.WeakSearchType);
+  return AUXESZ;
+}
+static bfd_coff_backend_data bigobj_swap_table =
+{
+  coff_bigobj_swap_aux_in, coff_bigobj_swap_sym_in, coff_SWAP_lineno_in,
+  coff_bigobj_swap_aux_out, coff_bigobj_swap_sym_out,
+  coff_SWAP_lineno_out, coff_SWAP_reloc_out,
+  coff_bigobj_swap_filehdr_out, coff_SWAP_aouthdr_out,
+  coff_SWAP_scnhdr_out,
+  FILHSZ_BIGOBJ, AOUTSZ, SCNHSZ, SYMESZ_BIGOBJ, AUXESZ_BIGOBJ,
+   RELSZ, LINESZ, FILNMLEN_BIGOBJ,
+  TRUE,
+  COFF_DEFAULT_LONG_SECTION_NAMES,
+  COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
+  FALSE,
+,
+U << 31,
+  coff_bigobj_swap_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
+  coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
+  coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
+  coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
+  coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
+  coff_classify_symbol, coff_compute_section_file_positions,
+  coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
+  coff_adjust_symndx, coff_link_add_one_symbol,
+  coff_link_output_has_begun, coff_final_link_postscript,
+  bfd_pe_print_pdata	/* huh */
+};
+#endif /* COFF_WITH_PE_BIGOBJ */
 #ifndef coff_close_and_cleanup
 #define coff_close_and_cleanup		    _bfd_generic_close_and_cleanup
 #endif
 #ifndef coff_bfd_relax_section
 #define coff_bfd_relax_section		    bfd_generic_relax_section
 #endif
 #ifndef coff_bfd_gc_sections
-#define coff_bfd_gc_sections		    bfd_generic_gc_sections
+#define coff_bfd_gc_sections		    bfd_coff_gc_sections
 #endif
 #ifndef coff_bfd_lookup_section_flags

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/bfd/coffcode.h – Rev 5197 → 6324