/* Initialize COOKIE for input bfd ABFD.  */

static bfd_boolean

init_reloc_cookie (struct coff_reloc_cookie *cookie,

		   struct bfd_link_info *info ATTRIBUTE_UNUSED, bfd *abfd)

{

  const bfd_coff_backend_data *bed;

  bed = coff_backend_info (abfd);

  cookie->abfd = abfd;

  cookie->sym_hashes = obj_coff_sym_hashes (abfd);

  /* FIXME: Sometimes the symbol table does not yet have been loaded here;

     is this the correct way to handle it? */

  bfd_coff_slurp_symbol_table(abfd);

  cookie->symbols = obj_symbols(abfd);

  return TRUE;

}

/* Free the memory allocated by init_reloc_cookie, if appropriate.  */

static void

fini_reloc_cookie (struct coff_reloc_cookie *cookie ATTRIBUTE_UNUSED, bfd *abfd ATTRIBUTE_UNUSED)

{

  /* FIXME: Nothing to do for the COFF case it seems? */

#if 0

  coff_Internal_Shdr *symtab_hdr;

  symtab_hdr = &coff_tdata (abfd)->symtab_hdr;

  if (cookie->locsyms != NULL

      && symtab_hdr->contents != (unsigned char *) cookie->locsyms)

    free (cookie->locsyms);

#endif

}

/* Initialize the relocation information in COOKIE for input section SEC

   of input bfd ABFD.  */

static bfd_boolean

init_reloc_cookie_rels (struct coff_reloc_cookie *cookie,

			struct bfd_link_info *info ATTRIBUTE_UNUSED, bfd *abfd,

			asection *sec)

{

  const bfd_coff_backend_data *bed;

  if (sec->reloc_count == 0)

    {

      cookie->rels = NULL;

      cookie->relend = NULL;

    }

  else

    {

      bed = coff_backend_info (abfd);

      cookie->rels = _bfd_coff_read_internal_relocs (abfd, sec, FALSE, NULL, 0, NULL);

      if (cookie->rels == NULL)

	return FALSE;

      cookie->rel = cookie->rels;

      cookie->relend = (cookie->rels + sec->reloc_count);

    }

  cookie->rel = cookie->rels;

  return TRUE;

}

/* Free the memory allocated by init_reloc_cookie_rels,

   if appropriate.  */

static void

fini_reloc_cookie_rels (struct coff_reloc_cookie *cookie,

			asection *sec)

{

  if (cookie->rels && coff_section_data (NULL, sec)->relocs != cookie->rels)

    free (cookie->rels);

}

/* Initialize the whole of COOKIE for input section SEC.  */

static bfd_boolean

init_reloc_cookie_for_section (struct coff_reloc_cookie *cookie,

			       struct bfd_link_info *info,

			       asection *sec) 

{

  if (!init_reloc_cookie (cookie, info, sec->owner))

    goto error1;

  if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))

    goto error2;

  return TRUE;

 error2:

  fini_reloc_cookie (cookie, sec->owner);

 error1:

  return FALSE;

}

/* Free the memory allocated by init_reloc_cookie_for_section,

   if appropriate.  */

static void

fini_reloc_cookie_for_section (struct coff_reloc_cookie *cookie,

			       asection *sec)

{

  fini_reloc_cookie_rels (cookie, sec);

  fini_reloc_cookie (cookie, sec->owner);

}

static asection *

_bfd_coff_gc_mark_hook (asection *sec,

		       struct bfd_link_info *info ATTRIBUTE_UNUSED,

		       struct internal_reloc *rel ATTRIBUTE_UNUSED,

		       struct coff_link_hash_entry *h,

		       struct internal_syment *sym)

{

  if (h != NULL)

    {

      switch (h->root.type)

        {

        case bfd_link_hash_defined:

        case bfd_link_hash_defweak:

          return h->root.u.def.section;

        case bfd_link_hash_common:

          return h->root.u.c.p->section;

        default:

          break;

        }

    }

  else

    return coff_section_from_bfd_index (sec->owner, sym->n_scnum);

    /* FIXME: is the above corrent? elflink.c has:

    return bfd_section_from_elf_index (sec->owner, sym->st_shndx); */

  return NULL;

}

/* COOKIE->rel describes a relocation against section SEC, which is

   a section we've decided to keep.  Return the section that contains

   the relocation symbol, or NULL if no section contains it.  */

static asection *

_bfd_coff_gc_mark_rsec (struct bfd_link_info *info, asection *sec,

		       coff_gc_mark_hook_fn gc_mark_hook,

		       struct coff_reloc_cookie *cookie)

{

  struct coff_link_hash_entry *h;

  h = cookie->sym_hashes[cookie->rel->r_symndx];

  if (h != NULL) {

    while (h->root.type == bfd_link_hash_indirect

           || h->root.type == bfd_link_hash_warning)

      h = (struct coff_link_hash_entry *) h->root.u.i.link;

    return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);

  }

  return (*gc_mark_hook) (sec, info, cookie->rel, NULL,

			  &(cookie->symbols + obj_convert (sec->owner)[cookie->rel->r_symndx])->native->u.syment);

}

static

bfd_boolean

_bfd_coff_gc_mark (struct bfd_link_info *info,

		  asection *sec,

		  coff_gc_mark_hook_fn gc_mark_hook);

/* COOKIE->rel describes a relocation against section SEC, which is

   a section we've decided to keep.  Mark the section that contains

   the relocation symbol.  */

static bfd_boolean

_bfd_coff_gc_mark_reloc (struct bfd_link_info *info,

			asection *sec,

			coff_gc_mark_hook_fn gc_mark_hook,

			struct coff_reloc_cookie *cookie)

{

  asection *rsec;

  rsec = _bfd_coff_gc_mark_rsec (info, sec, gc_mark_hook, cookie);

  if (rsec && !rsec->gc_mark)

    {

      if (bfd_get_flavour (rsec->owner) != bfd_target_coff_flavour)

	rsec->gc_mark = 1;

      else if (!_bfd_coff_gc_mark (info, rsec, gc_mark_hook))

	return FALSE;

    }

  return TRUE;

}

/* The mark phase of garbage collection.  For a given section, mark

   it and any sections in this section's group, and all the sections

   which define symbols to which it refers.  */

static

bfd_boolean

_bfd_coff_gc_mark (struct bfd_link_info *info,

		  asection *sec,

		  coff_gc_mark_hook_fn gc_mark_hook)

{

  bfd_boolean ret;

  sec->gc_mark = 1;

  /* FIXME: elflink.c has "Mark all the sections in the group."

     functionality here - does COFF require something similar? */

  /* FIXME: elflink.c has some eh_frame handling here - does COFF

     require something similar? */

  /* Look through the section relocs.  */

  ret = TRUE;

  if ((sec->flags & SEC_RELOC) != 0

      && sec->reloc_count > 0)

    {

      struct coff_reloc_cookie cookie;

      if (!init_reloc_cookie_for_section (&cookie, info, sec))

        ret = FALSE;

      else

        {

          for (; cookie.rel < cookie.relend; cookie.rel++) {

            if (!_bfd_coff_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))

              {

                ret = FALSE;

                break;

              }

          }

          fini_reloc_cookie_for_section (&cookie, sec);

        }

    }

  /* FIXME: elflink.c has some eh_frame handling here - does COFF

     require something similar? */

  return ret;

}

/* Sweep symbols in swept sections.  Called via coff_link_hash_traverse.  */

struct coff_gc_sweep_symbol_info

{

  struct bfd_link_info *info;

  void (*hide_symbol) (struct bfd_link_info *, struct coff_link_hash_entry *,

		       bfd_boolean);

};

static bfd_boolean

coff_gc_sweep_symbol (struct coff_link_hash_entry *h, void *data)

{

  if (h->root.type == bfd_link_hash_warning)

    h = (struct coff_link_hash_entry *) h->root.u.i.link;

  if ((h->root.type == bfd_link_hash_defined

       || h->root.type == bfd_link_hash_defweak)

      && !h->root.u.def.section->gc_mark

      && !(h->root.u.def.section->owner->flags & DYNAMIC))

    {

      struct coff_gc_sweep_symbol_info *inf ATTRIBUTE_UNUSED =

          (struct coff_gc_sweep_symbol_info *) data;

      /* FIXME: elflink.c hides the symbol here - how can we do this for COFF?

      (*inf->hide_symbol) (inf->info, h, TRUE); */

    }

  return TRUE;

}

/* The sweep phase of garbage collection.  Remove all garbage sections.  */

typedef bfd_boolean (*gc_sweep_hook_fn)

  (bfd *, struct bfd_link_info *, asection *, const struct internal_reloc *);

static bfd_boolean

coff_gc_sweep (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)

{

  bfd *sub;

  struct coff_gc_sweep_symbol_info sweep_info;

  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)

    {

      asection *o;

      if (bfd_get_flavour (sub) != bfd_target_coff_flavour)

	continue;

      for (o = sub->sections; o != NULL; o = o->next)

	{

          /* FIXME: We must preserve the import table, but is this the correct

             way to do it? */

          if (strncmp(o->name, ".idata", 6) == 0)

            o->gc_mark = 1;

          /* FIXME: elflink.c has some section group

             functionality here - does COFF require something similar? */

          if ((o->flags & (SEC_DEBUGGING | SEC_LINKER_CREATED)) != 0

		   || (o->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)

	    {

	      /* Keep debug and special sections.  */

	      o->gc_mark = 1;

	    }

	  if (o->gc_mark)

	    continue;

	  /* Skip sweeping sections already excluded.  */

	  if (o->flags & SEC_EXCLUDE)

	    continue;

	  /* Since this is early in the link process, it is simple

	     to remove a section from the output.  */

	  o->flags |= SEC_EXCLUDE;

	  if (info->print_gc_sections && o->size != 0)

            _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name);

          /* FIXME: Do we need something like this for COFF? */

#if 0

	  /* But we also have to update some of the relocation

	     info we collected before.  */

	  if (gc_sweep_hook

	      && (o->flags & SEC_RELOC) != 0

	      && o->reloc_count > 0

	      && !bfd_is_abs_section (o->output_section))

	    {

	      struct internal_reloc *internal_relocs;

	      bfd_boolean r;

	      internal_relocs

		= _bfd_coff_link_read_relocs (o->owner, o, NULL, NULL,

					     info->keep_memory);

	      if (internal_relocs == NULL)

		return FALSE;

	      r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);

	      if (coff_section_data (o)->relocs != internal_relocs)

		free (internal_relocs);

	      if (!r)

		return FALSE;

	    }

#endif

	}

    }

  /* Remove the symbols that were in the swept sections from the dynamic

     symbol table.  GCFIXME: Anyone know how to get them out of the

     static symbol table as well?  */

  sweep_info.info = info;

  /* FIXME: Do we need this for COFF?

  sweep_info.hide_symbol = bed->coff_backend_hide_symbol; */

  coff_link_hash_traverse (coff_hash_table (info), coff_gc_sweep_symbol,

			  &sweep_info);

  /* FIXME: Do we need this for COFF?

  _bfd_coff_link_renumber_dynsyms (abfd, info, &section_sym_count); */

  return TRUE;

}

/* Keep all sections containing symbols undefined on the command-line,

   and the section containing the entry symbol.  */

static void

_bfd_coff_gc_keep (struct bfd_link_info *info)

{

  struct bfd_sym_chain *sym;

  for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)

    {

      struct coff_link_hash_entry *h;

      h = coff_link_hash_lookup (coff_hash_table (info), sym->name,

				FALSE, FALSE, FALSE);

      if (h != NULL

      /* FIXME: elflink.c has more conditions - what about COFF?

	  && (h->root.type == bfd_link_hash_defined

	      || h->root.type == bfd_link_hash_defweak)

	  && !bfd_is_abs_section (h->root.u.def.section)*/)

	h->root.u.def.section->flags |= SEC_KEEP;

    }

}

/* Do mark and sweep of unused sections.  */

bfd_boolean

bfd_coff_gc_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)

{

  bfd *sub;

  /* FIXME: Should we implement this? */

#if 0

  const bfd_coff_backend_data *bed = coff_backend_info (abfd);

  if (!bed->can_gc_sections

      || !is_coff_hash_table (info->hash))

    {

      (*_bfd_error_handler)(_("Warning: gc-sections option ignored"));

      return TRUE;

    }

#endif

  _bfd_coff_gc_keep (info);

  /* FIXME: elflink.c has some eh_frame handling here - does COFF

     require something similar? */

  /* FIXME: elflink.c does two things here:

     - Apply transitive closure to the vtable entry usage info.

     - Kill the vtable relocations that were not used.

     does COFF require something similar? */

  /* FIXME: elflink.c does a traverse with bfd_elf_gc_mark_dynamic_ref_symbol

     here - does COFF require something similar? */

  /* Grovel through relocs to find out who stays ...  */

  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)

    {

      asection *o;

      if (bfd_get_flavour (sub) != bfd_target_coff_flavour)

        continue;

      for (o = sub->sections; o != NULL; o = o->next) {

        /* FIXME: Is this the proper way to check for global constructors? */

        if (((o->flags & (SEC_EXCLUDE | SEC_KEEP)) == SEC_KEEP || strncmp(o->name, ".ctors", 6) == 0) && !o->gc_mark) {

          if (!_bfd_coff_gc_mark (info, o, _bfd_coff_gc_mark_hook)) {

            return FALSE;

          }

        }

      }

    }

  /* FIXME: elflink.c has an hook for gc_mark_extra_sections

     here - does COFF require something similar? */

  /* ... and mark SEC_EXCLUDE for those that go.  */

  return coff_gc_sweep (abfd, info);

}

struct coff_reloc_cookie

{

  struct internal_reloc *rels, *rel, *relend;

  struct coff_symbol_struct *symbols;	/* Symtab for input bfd.  */

  bfd *abfd;

  struct coff_link_hash_entry **sym_hashes;

};

extern bfd_boolean bfd_coff_gc_sections

  (bfd *abfd, struct bfd_link_info *info);

typedef asection * (*coff_gc_mark_hook_fn)

  (asection *, struct bfd_link_info *, struct internal_reloc *,

   struct coff_link_hash_entry *, struct internal_syment *);