OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [ld/] [ldlang.c] - Diff between revs 156 and 816

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 156 Rev 816
/* Linker command language support.
/* Linker command language support.
   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
 
 
   This file is part of the GNU Binutils.
   This file is part of the GNU Binutils.
 
 
   This program is free software; you can redistribute it and/or modify
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
   (at your option) any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   GNU General Public License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
   MA 02110-1301, USA.  */
 
 
#include "sysdep.h"
#include "sysdep.h"
#include "bfd.h"
#include "bfd.h"
#include "libiberty.h"
#include "libiberty.h"
#include "safe-ctype.h"
#include "safe-ctype.h"
#include "obstack.h"
#include "obstack.h"
#include "bfdlink.h"
#include "bfdlink.h"
 
 
#include "ld.h"
#include "ld.h"
#include "ldmain.h"
#include "ldmain.h"
#include "ldexp.h"
#include "ldexp.h"
#include "ldlang.h"
#include "ldlang.h"
#include <ldgram.h>
#include <ldgram.h>
#include "ldlex.h"
#include "ldlex.h"
#include "ldmisc.h"
#include "ldmisc.h"
#include "ldctor.h"
#include "ldctor.h"
#include "ldfile.h"
#include "ldfile.h"
#include "ldemul.h"
#include "ldemul.h"
#include "fnmatch.h"
#include "fnmatch.h"
#include "demangle.h"
#include "demangle.h"
#include "hashtab.h"
#include "hashtab.h"
 
 
#ifndef offsetof
#ifndef offsetof
#define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
#define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
#endif
#endif
 
 
/* Locals variables.  */
/* Locals variables.  */
static struct obstack stat_obstack;
static struct obstack stat_obstack;
static struct obstack map_obstack;
static struct obstack map_obstack;
 
 
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
#define obstack_chunk_free free
static const char *startup_file;
static const char *startup_file;
static bfd_boolean placed_commons = FALSE;
static bfd_boolean placed_commons = FALSE;
static bfd_boolean stripped_excluded_sections = FALSE;
static bfd_boolean stripped_excluded_sections = FALSE;
static lang_output_section_statement_type *default_common_section;
static lang_output_section_statement_type *default_common_section;
static bfd_boolean map_option_f;
static bfd_boolean map_option_f;
static bfd_vma print_dot;
static bfd_vma print_dot;
static lang_input_statement_type *first_file;
static lang_input_statement_type *first_file;
static const char *current_target;
static const char *current_target;
static const char *output_target;
static const char *output_target;
static lang_statement_list_type statement_list;
static lang_statement_list_type statement_list;
static struct bfd_hash_table lang_definedness_table;
static struct bfd_hash_table lang_definedness_table;
 
 
/* Forward declarations.  */
/* Forward declarations.  */
static void exp_init_os (etree_type *);
static void exp_init_os (etree_type *);
static void init_map_userdata (bfd *, asection *, void *);
static void init_map_userdata (bfd *, asection *, void *);
static lang_input_statement_type *lookup_name (const char *);
static lang_input_statement_type *lookup_name (const char *);
static struct bfd_hash_entry *lang_definedness_newfunc
static struct bfd_hash_entry *lang_definedness_newfunc
 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
static void insert_undefined (const char *);
static void insert_undefined (const char *);
static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
static void print_statement (lang_statement_union_type *,
static void print_statement (lang_statement_union_type *,
                             lang_output_section_statement_type *);
                             lang_output_section_statement_type *);
static void print_statement_list (lang_statement_union_type *,
static void print_statement_list (lang_statement_union_type *,
                                  lang_output_section_statement_type *);
                                  lang_output_section_statement_type *);
static void print_statements (void);
static void print_statements (void);
static void print_input_section (asection *);
static void print_input_section (asection *);
static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
static void lang_record_phdrs (void);
static void lang_record_phdrs (void);
static void lang_do_version_exports_section (void);
static void lang_do_version_exports_section (void);
static void lang_finalize_version_expr_head
static void lang_finalize_version_expr_head
  (struct bfd_elf_version_expr_head *);
  (struct bfd_elf_version_expr_head *);
 
 
/* Exported variables.  */
/* Exported variables.  */
lang_output_section_statement_type *abs_output_section;
lang_output_section_statement_type *abs_output_section;
lang_statement_list_type lang_output_section_statement;
lang_statement_list_type lang_output_section_statement;
lang_statement_list_type *stat_ptr = &statement_list;
lang_statement_list_type *stat_ptr = &statement_list;
lang_statement_list_type file_chain = { NULL, NULL };
lang_statement_list_type file_chain = { NULL, NULL };
lang_statement_list_type input_file_chain;
lang_statement_list_type input_file_chain;
struct bfd_sym_chain entry_symbol = { NULL, NULL };
struct bfd_sym_chain entry_symbol = { NULL, NULL };
static const char *entry_symbol_default = "start";
static const char *entry_symbol_default = "start";
const char *entry_section = ".text";
const char *entry_section = ".text";
bfd_boolean entry_from_cmdline;
bfd_boolean entry_from_cmdline;
bfd_boolean lang_has_input_file = FALSE;
bfd_boolean lang_has_input_file = FALSE;
bfd_boolean had_output_filename = FALSE;
bfd_boolean had_output_filename = FALSE;
bfd_boolean lang_float_flag = FALSE;
bfd_boolean lang_float_flag = FALSE;
bfd_boolean delete_output_file_on_failure = FALSE;
bfd_boolean delete_output_file_on_failure = FALSE;
struct lang_phdr *lang_phdr_list;
struct lang_phdr *lang_phdr_list;
struct lang_nocrossrefs *nocrossref_list;
struct lang_nocrossrefs *nocrossref_list;
static struct unique_sections *unique_section_list;
static struct unique_sections *unique_section_list;
static bfd_boolean ldlang_sysrooted_script = FALSE;
static bfd_boolean ldlang_sysrooted_script = FALSE;
 
 
 /* Functions that traverse the linker script and might evaluate
 /* Functions that traverse the linker script and might evaluate
    DEFINED() need to increment this.  */
    DEFINED() need to increment this.  */
int lang_statement_iteration = 0;
int lang_statement_iteration = 0;
 
 
etree_type *base; /* Relocation base - or null */
etree_type *base; /* Relocation base - or null */
 
 
/* Return TRUE if the PATTERN argument is a wildcard pattern.
/* Return TRUE if the PATTERN argument is a wildcard pattern.
   Although backslashes are treated specially if a pattern contains
   Although backslashes are treated specially if a pattern contains
   wildcards, we do not consider the mere presence of a backslash to
   wildcards, we do not consider the mere presence of a backslash to
   be enough to cause the pattern to be treated as a wildcard.
   be enough to cause the pattern to be treated as a wildcard.
   That lets us handle DOS filenames more naturally.  */
   That lets us handle DOS filenames more naturally.  */
#define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
#define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
 
 
#define new_stat(x, y) \
#define new_stat(x, y) \
  (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
  (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
 
 
#define outside_section_address(q) \
#define outside_section_address(q) \
  ((q)->output_offset + (q)->output_section->vma)
  ((q)->output_offset + (q)->output_section->vma)
 
 
#define outside_symbol_address(q) \
#define outside_symbol_address(q) \
  ((q)->value + outside_section_address (q->section))
  ((q)->value + outside_section_address (q->section))
 
 
#define SECTION_NAME_MAP_LENGTH (16)
#define SECTION_NAME_MAP_LENGTH (16)
 
 
void *
void *
stat_alloc (size_t size)
stat_alloc (size_t size)
{
{
  return obstack_alloc (&stat_obstack, size);
  return obstack_alloc (&stat_obstack, size);
}
}
 
 
bfd_boolean
bfd_boolean
unique_section_p (const asection *sec)
unique_section_p (const asection *sec)
{
{
  struct unique_sections *unam;
  struct unique_sections *unam;
  const char *secnam;
  const char *secnam;
 
 
  if (link_info.relocatable
  if (link_info.relocatable
      && sec->owner != NULL
      && sec->owner != NULL
      && bfd_is_group_section (sec->owner, sec))
      && bfd_is_group_section (sec->owner, sec))
    return TRUE;
    return TRUE;
 
 
  secnam = sec->name;
  secnam = sec->name;
  for (unam = unique_section_list; unam; unam = unam->next)
  for (unam = unique_section_list; unam; unam = unam->next)
    if (wildcardp (unam->name)
    if (wildcardp (unam->name)
        ? fnmatch (unam->name, secnam, 0) == 0
        ? fnmatch (unam->name, secnam, 0) == 0
        : strcmp (unam->name, secnam) == 0)
        : strcmp (unam->name, secnam) == 0)
      {
      {
        return TRUE;
        return TRUE;
      }
      }
 
 
  return FALSE;
  return FALSE;
}
}
 
 
/* Generic traversal routines for finding matching sections.  */
/* Generic traversal routines for finding matching sections.  */
 
 
/* Try processing a section against a wildcard.  This just calls
/* Try processing a section against a wildcard.  This just calls
   the callback unless the filename exclusion list is present
   the callback unless the filename exclusion list is present
   and excludes the file.  It's hardly ever present so this
   and excludes the file.  It's hardly ever present so this
   function is very fast.  */
   function is very fast.  */
 
 
static void
static void
walk_wild_consider_section (lang_wild_statement_type *ptr,
walk_wild_consider_section (lang_wild_statement_type *ptr,
                            lang_input_statement_type *file,
                            lang_input_statement_type *file,
                            asection *s,
                            asection *s,
                            struct wildcard_list *sec,
                            struct wildcard_list *sec,
                            callback_t callback,
                            callback_t callback,
                            void *data)
                            void *data)
{
{
  bfd_boolean skip = FALSE;
  bfd_boolean skip = FALSE;
  struct name_list *list_tmp;
  struct name_list *list_tmp;
 
 
  /* Don't process sections from files which were
  /* Don't process sections from files which were
     excluded.  */
     excluded.  */
  for (list_tmp = sec->spec.exclude_name_list;
  for (list_tmp = sec->spec.exclude_name_list;
       list_tmp;
       list_tmp;
       list_tmp = list_tmp->next)
       list_tmp = list_tmp->next)
    {
    {
      bfd_boolean is_wildcard = wildcardp (list_tmp->name);
      bfd_boolean is_wildcard = wildcardp (list_tmp->name);
      if (is_wildcard)
      if (is_wildcard)
        skip = fnmatch (list_tmp->name, file->filename, 0) == 0;
        skip = fnmatch (list_tmp->name, file->filename, 0) == 0;
      else
      else
        skip = strcmp (list_tmp->name, file->filename) == 0;
        skip = strcmp (list_tmp->name, file->filename) == 0;
 
 
      /* If this file is part of an archive, and the archive is
      /* If this file is part of an archive, and the archive is
         excluded, exclude this file.  */
         excluded, exclude this file.  */
      if (! skip && file->the_bfd != NULL
      if (! skip && file->the_bfd != NULL
          && file->the_bfd->my_archive != NULL
          && file->the_bfd->my_archive != NULL
          && file->the_bfd->my_archive->filename != NULL)
          && file->the_bfd->my_archive->filename != NULL)
        {
        {
          if (is_wildcard)
          if (is_wildcard)
            skip = fnmatch (list_tmp->name,
            skip = fnmatch (list_tmp->name,
                            file->the_bfd->my_archive->filename,
                            file->the_bfd->my_archive->filename,
                            0) == 0;
                            0) == 0;
          else
          else
            skip = strcmp (list_tmp->name,
            skip = strcmp (list_tmp->name,
                           file->the_bfd->my_archive->filename) == 0;
                           file->the_bfd->my_archive->filename) == 0;
        }
        }
 
 
      if (skip)
      if (skip)
        break;
        break;
    }
    }
 
 
  if (!skip)
  if (!skip)
    (*callback) (ptr, sec, s, file, data);
    (*callback) (ptr, sec, s, file, data);
}
}
 
 
/* Lowest common denominator routine that can handle everything correctly,
/* Lowest common denominator routine that can handle everything correctly,
   but slowly.  */
   but slowly.  */
 
 
static void
static void
walk_wild_section_general (lang_wild_statement_type *ptr,
walk_wild_section_general (lang_wild_statement_type *ptr,
                           lang_input_statement_type *file,
                           lang_input_statement_type *file,
                           callback_t callback,
                           callback_t callback,
                           void *data)
                           void *data)
{
{
  asection *s;
  asection *s;
  struct wildcard_list *sec;
  struct wildcard_list *sec;
 
 
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
    {
    {
      sec = ptr->section_list;
      sec = ptr->section_list;
      if (sec == NULL)
      if (sec == NULL)
        (*callback) (ptr, sec, s, file, data);
        (*callback) (ptr, sec, s, file, data);
 
 
      while (sec != NULL)
      while (sec != NULL)
        {
        {
          bfd_boolean skip = FALSE;
          bfd_boolean skip = FALSE;
 
 
          if (sec->spec.name != NULL)
          if (sec->spec.name != NULL)
            {
            {
              const char *sname = bfd_get_section_name (file->the_bfd, s);
              const char *sname = bfd_get_section_name (file->the_bfd, s);
 
 
              if (wildcardp (sec->spec.name))
              if (wildcardp (sec->spec.name))
                skip = fnmatch (sec->spec.name, sname, 0) != 0;
                skip = fnmatch (sec->spec.name, sname, 0) != 0;
              else
              else
                skip = strcmp (sec->spec.name, sname) != 0;
                skip = strcmp (sec->spec.name, sname) != 0;
            }
            }
 
 
          if (!skip)
          if (!skip)
            walk_wild_consider_section (ptr, file, s, sec, callback, data);
            walk_wild_consider_section (ptr, file, s, sec, callback, data);
 
 
          sec = sec->next;
          sec = sec->next;
        }
        }
    }
    }
}
}
 
 
/* Routines to find a single section given its name.  If there's more
/* Routines to find a single section given its name.  If there's more
   than one section with that name, we report that.  */
   than one section with that name, we report that.  */
 
 
typedef struct
typedef struct
{
{
  asection *found_section;
  asection *found_section;
  bfd_boolean multiple_sections_found;
  bfd_boolean multiple_sections_found;
} section_iterator_callback_data;
} section_iterator_callback_data;
 
 
static bfd_boolean
static bfd_boolean
section_iterator_callback (bfd *bfd ATTRIBUTE_UNUSED, asection *s, void *data)
section_iterator_callback (bfd *bfd ATTRIBUTE_UNUSED, asection *s, void *data)
{
{
  section_iterator_callback_data *d = data;
  section_iterator_callback_data *d = data;
 
 
  if (d->found_section != NULL)
  if (d->found_section != NULL)
    {
    {
      d->multiple_sections_found = TRUE;
      d->multiple_sections_found = TRUE;
      return TRUE;
      return TRUE;
    }
    }
 
 
  d->found_section = s;
  d->found_section = s;
  return FALSE;
  return FALSE;
}
}
 
 
static asection *
static asection *
find_section (lang_input_statement_type *file,
find_section (lang_input_statement_type *file,
              struct wildcard_list *sec,
              struct wildcard_list *sec,
              bfd_boolean *multiple_sections_found)
              bfd_boolean *multiple_sections_found)
{
{
  section_iterator_callback_data cb_data = { NULL, FALSE };
  section_iterator_callback_data cb_data = { NULL, FALSE };
 
 
  bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,
  bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,
                              section_iterator_callback, &cb_data);
                              section_iterator_callback, &cb_data);
  *multiple_sections_found = cb_data.multiple_sections_found;
  *multiple_sections_found = cb_data.multiple_sections_found;
  return cb_data.found_section;
  return cb_data.found_section;
}
}
 
 
/* Code for handling simple wildcards without going through fnmatch,
/* Code for handling simple wildcards without going through fnmatch,
   which can be expensive because of charset translations etc.  */
   which can be expensive because of charset translations etc.  */
 
 
/* A simple wild is a literal string followed by a single '*',
/* A simple wild is a literal string followed by a single '*',
   where the literal part is at least 4 characters long.  */
   where the literal part is at least 4 characters long.  */
 
 
static bfd_boolean
static bfd_boolean
is_simple_wild (const char *name)
is_simple_wild (const char *name)
{
{
  size_t len = strcspn (name, "*?[");
  size_t len = strcspn (name, "*?[");
  return len >= 4 && name[len] == '*' && name[len + 1] == '\0';
  return len >= 4 && name[len] == '*' && name[len + 1] == '\0';
}
}
 
 
static bfd_boolean
static bfd_boolean
match_simple_wild (const char *pattern, const char *name)
match_simple_wild (const char *pattern, const char *name)
{
{
  /* The first four characters of the pattern are guaranteed valid
  /* The first four characters of the pattern are guaranteed valid
     non-wildcard characters.  So we can go faster.  */
     non-wildcard characters.  So we can go faster.  */
  if (pattern[0] != name[0] || pattern[1] != name[1]
  if (pattern[0] != name[0] || pattern[1] != name[1]
      || pattern[2] != name[2] || pattern[3] != name[3])
      || pattern[2] != name[2] || pattern[3] != name[3])
    return FALSE;
    return FALSE;
 
 
  pattern += 4;
  pattern += 4;
  name += 4;
  name += 4;
  while (*pattern != '*')
  while (*pattern != '*')
    if (*name++ != *pattern++)
    if (*name++ != *pattern++)
      return FALSE;
      return FALSE;
 
 
  return TRUE;
  return TRUE;
}
}
 
 
/* Compare sections ASEC and BSEC according to SORT.  */
/* Compare sections ASEC and BSEC according to SORT.  */
 
 
static int
static int
compare_section (sort_type sort, asection *asec, asection *bsec)
compare_section (sort_type sort, asection *asec, asection *bsec)
{
{
  int ret;
  int ret;
 
 
  switch (sort)
  switch (sort)
    {
    {
    default:
    default:
      abort ();
      abort ();
 
 
    case by_alignment_name:
    case by_alignment_name:
      ret = (bfd_section_alignment (bsec->owner, bsec)
      ret = (bfd_section_alignment (bsec->owner, bsec)
             - bfd_section_alignment (asec->owner, asec));
             - bfd_section_alignment (asec->owner, asec));
      if (ret)
      if (ret)
        break;
        break;
      /* Fall through.  */
      /* Fall through.  */
 
 
    case by_name:
    case by_name:
      ret = strcmp (bfd_get_section_name (asec->owner, asec),
      ret = strcmp (bfd_get_section_name (asec->owner, asec),
                    bfd_get_section_name (bsec->owner, bsec));
                    bfd_get_section_name (bsec->owner, bsec));
      break;
      break;
 
 
    case by_name_alignment:
    case by_name_alignment:
      ret = strcmp (bfd_get_section_name (asec->owner, asec),
      ret = strcmp (bfd_get_section_name (asec->owner, asec),
                    bfd_get_section_name (bsec->owner, bsec));
                    bfd_get_section_name (bsec->owner, bsec));
      if (ret)
      if (ret)
        break;
        break;
      /* Fall through.  */
      /* Fall through.  */
 
 
    case by_alignment:
    case by_alignment:
      ret = (bfd_section_alignment (bsec->owner, bsec)
      ret = (bfd_section_alignment (bsec->owner, bsec)
             - bfd_section_alignment (asec->owner, asec));
             - bfd_section_alignment (asec->owner, asec));
      break;
      break;
    }
    }
 
 
  return ret;
  return ret;
}
}
 
 
/* Build a Binary Search Tree to sort sections, unlike insertion sort
/* Build a Binary Search Tree to sort sections, unlike insertion sort
   used in wild_sort(). BST is considerably faster if the number of
   used in wild_sort(). BST is considerably faster if the number of
   of sections are large.  */
   of sections are large.  */
 
 
static lang_section_bst_type **
static lang_section_bst_type **
wild_sort_fast (lang_wild_statement_type *wild,
wild_sort_fast (lang_wild_statement_type *wild,
                struct wildcard_list *sec,
                struct wildcard_list *sec,
                lang_input_statement_type *file ATTRIBUTE_UNUSED,
                lang_input_statement_type *file ATTRIBUTE_UNUSED,
                asection *section)
                asection *section)
{
{
  lang_section_bst_type **tree;
  lang_section_bst_type **tree;
 
 
  tree = &wild->tree;
  tree = &wild->tree;
  if (!wild->filenames_sorted
  if (!wild->filenames_sorted
      && (sec == NULL || sec->spec.sorted == none))
      && (sec == NULL || sec->spec.sorted == none))
    {
    {
      /* Append at the right end of tree.  */
      /* Append at the right end of tree.  */
      while (*tree)
      while (*tree)
        tree = &((*tree)->right);
        tree = &((*tree)->right);
      return tree;
      return tree;
    }
    }
 
 
  while (*tree)
  while (*tree)
    {
    {
      /* Find the correct node to append this section.  */
      /* Find the correct node to append this section.  */
      if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)
      if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)
        tree = &((*tree)->left);
        tree = &((*tree)->left);
      else
      else
        tree = &((*tree)->right);
        tree = &((*tree)->right);
    }
    }
 
 
  return tree;
  return tree;
}
}
 
 
/* Use wild_sort_fast to build a BST to sort sections.  */
/* Use wild_sort_fast to build a BST to sort sections.  */
 
 
static void
static void
output_section_callback_fast (lang_wild_statement_type *ptr,
output_section_callback_fast (lang_wild_statement_type *ptr,
                              struct wildcard_list *sec,
                              struct wildcard_list *sec,
                              asection *section,
                              asection *section,
                              lang_input_statement_type *file,
                              lang_input_statement_type *file,
                              void *output ATTRIBUTE_UNUSED)
                              void *output ATTRIBUTE_UNUSED)
{
{
  lang_section_bst_type *node;
  lang_section_bst_type *node;
  lang_section_bst_type **tree;
  lang_section_bst_type **tree;
 
 
  if (unique_section_p (section))
  if (unique_section_p (section))
    return;
    return;
 
 
  node = xmalloc (sizeof (lang_section_bst_type));
  node = xmalloc (sizeof (lang_section_bst_type));
  node->left = 0;
  node->left = 0;
  node->right = 0;
  node->right = 0;
  node->section = section;
  node->section = section;
 
 
  tree = wild_sort_fast (ptr, sec, file, section);
  tree = wild_sort_fast (ptr, sec, file, section);
  if (tree != NULL)
  if (tree != NULL)
    *tree = node;
    *tree = node;
}
}
 
 
/* Convert a sorted sections' BST back to list form.  */
/* Convert a sorted sections' BST back to list form.  */
 
 
static void
static void
output_section_callback_tree_to_list (lang_wild_statement_type *ptr,
output_section_callback_tree_to_list (lang_wild_statement_type *ptr,
                                      lang_section_bst_type *tree,
                                      lang_section_bst_type *tree,
                                      void *output)
                                      void *output)
{
{
  if (tree->left)
  if (tree->left)
    output_section_callback_tree_to_list (ptr, tree->left, output);
    output_section_callback_tree_to_list (ptr, tree->left, output);
 
 
  lang_add_section (&ptr->children, tree->section,
  lang_add_section (&ptr->children, tree->section,
                    (lang_output_section_statement_type *) output);
                    (lang_output_section_statement_type *) output);
 
 
  if (tree->right)
  if (tree->right)
    output_section_callback_tree_to_list (ptr, tree->right, output);
    output_section_callback_tree_to_list (ptr, tree->right, output);
 
 
  free (tree);
  free (tree);
}
}
 
 
/* Specialized, optimized routines for handling different kinds of
/* Specialized, optimized routines for handling different kinds of
   wildcards */
   wildcards */
 
 
static void
static void
walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
                                lang_input_statement_type *file,
                                lang_input_statement_type *file,
                                callback_t callback,
                                callback_t callback,
                                void *data)
                                void *data)
{
{
  /* We can just do a hash lookup for the section with the right name.
  /* We can just do a hash lookup for the section with the right name.
     But if that lookup discovers more than one section with the name
     But if that lookup discovers more than one section with the name
     (should be rare), we fall back to the general algorithm because
     (should be rare), we fall back to the general algorithm because
     we would otherwise have to sort the sections to make sure they
     we would otherwise have to sort the sections to make sure they
     get processed in the bfd's order.  */
     get processed in the bfd's order.  */
  bfd_boolean multiple_sections_found;
  bfd_boolean multiple_sections_found;
  struct wildcard_list *sec0 = ptr->handler_data[0];
  struct wildcard_list *sec0 = ptr->handler_data[0];
  asection *s0 = find_section (file, sec0, &multiple_sections_found);
  asection *s0 = find_section (file, sec0, &multiple_sections_found);
 
 
  if (multiple_sections_found)
  if (multiple_sections_found)
    walk_wild_section_general (ptr, file, callback, data);
    walk_wild_section_general (ptr, file, callback, data);
  else if (s0)
  else if (s0)
    walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
    walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
}
}
 
 
static void
static void
walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
                                lang_input_statement_type *file,
                                lang_input_statement_type *file,
                                callback_t callback,
                                callback_t callback,
                                void *data)
                                void *data)
{
{
  asection *s;
  asection *s;
  struct wildcard_list *wildsec0 = ptr->handler_data[0];
  struct wildcard_list *wildsec0 = ptr->handler_data[0];
 
 
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
    {
    {
      const char *sname = bfd_get_section_name (file->the_bfd, s);
      const char *sname = bfd_get_section_name (file->the_bfd, s);
      bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);
      bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);
 
 
      if (!skip)
      if (!skip)
        walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
        walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
    }
    }
}
}
 
 
static void
static void
walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
                                lang_input_statement_type *file,
                                lang_input_statement_type *file,
                                callback_t callback,
                                callback_t callback,
                                void *data)
                                void *data)
{
{
  asection *s;
  asection *s;
  struct wildcard_list *sec0 = ptr->handler_data[0];
  struct wildcard_list *sec0 = ptr->handler_data[0];
  struct wildcard_list *wildsec1 = ptr->handler_data[1];
  struct wildcard_list *wildsec1 = ptr->handler_data[1];
  bfd_boolean multiple_sections_found;
  bfd_boolean multiple_sections_found;
  asection *s0 = find_section (file, sec0, &multiple_sections_found);
  asection *s0 = find_section (file, sec0, &multiple_sections_found);
 
 
  if (multiple_sections_found)
  if (multiple_sections_found)
    {
    {
      walk_wild_section_general (ptr, file, callback, data);
      walk_wild_section_general (ptr, file, callback, data);
      return;
      return;
    }
    }
 
 
  /* Note that if the section was not found, s0 is NULL and
  /* Note that if the section was not found, s0 is NULL and
     we'll simply never succeed the s == s0 test below.  */
     we'll simply never succeed the s == s0 test below.  */
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
    {
    {
      /* Recall that in this code path, a section cannot satisfy more
      /* Recall that in this code path, a section cannot satisfy more
         than one spec, so if s == s0 then it cannot match
         than one spec, so if s == s0 then it cannot match
         wildspec1.  */
         wildspec1.  */
      if (s == s0)
      if (s == s0)
        walk_wild_consider_section (ptr, file, s, sec0, callback, data);
        walk_wild_consider_section (ptr, file, s, sec0, callback, data);
      else
      else
        {
        {
          const char *sname = bfd_get_section_name (file->the_bfd, s);
          const char *sname = bfd_get_section_name (file->the_bfd, s);
          bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
          bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
 
 
          if (!skip)
          if (!skip)
            walk_wild_consider_section (ptr, file, s, wildsec1, callback,
            walk_wild_consider_section (ptr, file, s, wildsec1, callback,
                                        data);
                                        data);
        }
        }
    }
    }
}
}
 
 
static void
static void
walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
                                lang_input_statement_type *file,
                                lang_input_statement_type *file,
                                callback_t callback,
                                callback_t callback,
                                void *data)
                                void *data)
{
{
  asection *s;
  asection *s;
  struct wildcard_list *sec0 = ptr->handler_data[0];
  struct wildcard_list *sec0 = ptr->handler_data[0];
  struct wildcard_list *wildsec1 = ptr->handler_data[1];
  struct wildcard_list *wildsec1 = ptr->handler_data[1];
  struct wildcard_list *wildsec2 = ptr->handler_data[2];
  struct wildcard_list *wildsec2 = ptr->handler_data[2];
  bfd_boolean multiple_sections_found;
  bfd_boolean multiple_sections_found;
  asection *s0 = find_section (file, sec0, &multiple_sections_found);
  asection *s0 = find_section (file, sec0, &multiple_sections_found);
 
 
  if (multiple_sections_found)
  if (multiple_sections_found)
    {
    {
      walk_wild_section_general (ptr, file, callback, data);
      walk_wild_section_general (ptr, file, callback, data);
      return;
      return;
    }
    }
 
 
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
    {
    {
      if (s == s0)
      if (s == s0)
        walk_wild_consider_section (ptr, file, s, sec0, callback, data);
        walk_wild_consider_section (ptr, file, s, sec0, callback, data);
      else
      else
        {
        {
          const char *sname = bfd_get_section_name (file->the_bfd, s);
          const char *sname = bfd_get_section_name (file->the_bfd, s);
          bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
          bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
 
 
          if (!skip)
          if (!skip)
            walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
            walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
          else
          else
            {
            {
              skip = !match_simple_wild (wildsec2->spec.name, sname);
              skip = !match_simple_wild (wildsec2->spec.name, sname);
              if (!skip)
              if (!skip)
                walk_wild_consider_section (ptr, file, s, wildsec2, callback,
                walk_wild_consider_section (ptr, file, s, wildsec2, callback,
                                            data);
                                            data);
            }
            }
        }
        }
    }
    }
}
}
 
 
static void
static void
walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
                                lang_input_statement_type *file,
                                lang_input_statement_type *file,
                                callback_t callback,
                                callback_t callback,
                                void *data)
                                void *data)
{
{
  asection *s;
  asection *s;
  struct wildcard_list *sec0 = ptr->handler_data[0];
  struct wildcard_list *sec0 = ptr->handler_data[0];
  struct wildcard_list *sec1 = ptr->handler_data[1];
  struct wildcard_list *sec1 = ptr->handler_data[1];
  struct wildcard_list *wildsec2 = ptr->handler_data[2];
  struct wildcard_list *wildsec2 = ptr->handler_data[2];
  struct wildcard_list *wildsec3 = ptr->handler_data[3];
  struct wildcard_list *wildsec3 = ptr->handler_data[3];
  bfd_boolean multiple_sections_found;
  bfd_boolean multiple_sections_found;
  asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1;
  asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1;
 
 
  if (multiple_sections_found)
  if (multiple_sections_found)
    {
    {
      walk_wild_section_general (ptr, file, callback, data);
      walk_wild_section_general (ptr, file, callback, data);
      return;
      return;
    }
    }
 
 
  s1 = find_section (file, sec1, &multiple_sections_found);
  s1 = find_section (file, sec1, &multiple_sections_found);
  if (multiple_sections_found)
  if (multiple_sections_found)
    {
    {
      walk_wild_section_general (ptr, file, callback, data);
      walk_wild_section_general (ptr, file, callback, data);
      return;
      return;
    }
    }
 
 
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
    {
    {
      if (s == s0)
      if (s == s0)
        walk_wild_consider_section (ptr, file, s, sec0, callback, data);
        walk_wild_consider_section (ptr, file, s, sec0, callback, data);
      else
      else
        if (s == s1)
        if (s == s1)
          walk_wild_consider_section (ptr, file, s, sec1, callback, data);
          walk_wild_consider_section (ptr, file, s, sec1, callback, data);
        else
        else
          {
          {
            const char *sname = bfd_get_section_name (file->the_bfd, s);
            const char *sname = bfd_get_section_name (file->the_bfd, s);
            bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,
            bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,
                                                   sname);
                                                   sname);
 
 
            if (!skip)
            if (!skip)
              walk_wild_consider_section (ptr, file, s, wildsec2, callback,
              walk_wild_consider_section (ptr, file, s, wildsec2, callback,
                                          data);
                                          data);
            else
            else
              {
              {
                skip = !match_simple_wild (wildsec3->spec.name, sname);
                skip = !match_simple_wild (wildsec3->spec.name, sname);
                if (!skip)
                if (!skip)
                  walk_wild_consider_section (ptr, file, s, wildsec3,
                  walk_wild_consider_section (ptr, file, s, wildsec3,
                                              callback, data);
                                              callback, data);
              }
              }
          }
          }
    }
    }
}
}
 
 
static void
static void
walk_wild_section (lang_wild_statement_type *ptr,
walk_wild_section (lang_wild_statement_type *ptr,
                   lang_input_statement_type *file,
                   lang_input_statement_type *file,
                   callback_t callback,
                   callback_t callback,
                   void *data)
                   void *data)
{
{
  if (file->just_syms_flag)
  if (file->just_syms_flag)
    return;
    return;
 
 
  (*ptr->walk_wild_section_handler) (ptr, file, callback, data);
  (*ptr->walk_wild_section_handler) (ptr, file, callback, data);
}
}
 
 
/* Returns TRUE when name1 is a wildcard spec that might match
/* Returns TRUE when name1 is a wildcard spec that might match
   something name2 can match.  We're conservative: we return FALSE
   something name2 can match.  We're conservative: we return FALSE
   only if the prefixes of name1 and name2 are different up to the
   only if the prefixes of name1 and name2 are different up to the
   first wildcard character.  */
   first wildcard character.  */
 
 
static bfd_boolean
static bfd_boolean
wild_spec_can_overlap (const char *name1, const char *name2)
wild_spec_can_overlap (const char *name1, const char *name2)
{
{
  size_t prefix1_len = strcspn (name1, "?*[");
  size_t prefix1_len = strcspn (name1, "?*[");
  size_t prefix2_len = strcspn (name2, "?*[");
  size_t prefix2_len = strcspn (name2, "?*[");
  size_t min_prefix_len;
  size_t min_prefix_len;
 
 
  /* Note that if there is no wildcard character, then we treat the
  /* Note that if there is no wildcard character, then we treat the
     terminating 0 as part of the prefix.  Thus ".text" won't match
     terminating 0 as part of the prefix.  Thus ".text" won't match
     ".text." or ".text.*", for example.  */
     ".text." or ".text.*", for example.  */
  if (name1[prefix1_len] == '\0')
  if (name1[prefix1_len] == '\0')
    prefix1_len++;
    prefix1_len++;
  if (name2[prefix2_len] == '\0')
  if (name2[prefix2_len] == '\0')
    prefix2_len++;
    prefix2_len++;
 
 
  min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;
  min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;
 
 
  return memcmp (name1, name2, min_prefix_len) == 0;
  return memcmp (name1, name2, min_prefix_len) == 0;
}
}
 
 
/* Select specialized code to handle various kinds of wildcard
/* Select specialized code to handle various kinds of wildcard
   statements.  */
   statements.  */
 
 
static void
static void
analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
{
{
  int sec_count = 0;
  int sec_count = 0;
  int wild_name_count = 0;
  int wild_name_count = 0;
  struct wildcard_list *sec;
  struct wildcard_list *sec;
  int signature;
  int signature;
  int data_counter;
  int data_counter;
 
 
  ptr->walk_wild_section_handler = walk_wild_section_general;
  ptr->walk_wild_section_handler = walk_wild_section_general;
  ptr->handler_data[0] = NULL;
  ptr->handler_data[0] = NULL;
  ptr->handler_data[1] = NULL;
  ptr->handler_data[1] = NULL;
  ptr->handler_data[2] = NULL;
  ptr->handler_data[2] = NULL;
  ptr->handler_data[3] = NULL;
  ptr->handler_data[3] = NULL;
  ptr->tree = NULL;
  ptr->tree = NULL;
 
 
  /* Count how many wildcard_specs there are, and how many of those
  /* Count how many wildcard_specs there are, and how many of those
     actually use wildcards in the name.  Also, bail out if any of the
     actually use wildcards in the name.  Also, bail out if any of the
     wildcard names are NULL. (Can this actually happen?
     wildcard names are NULL. (Can this actually happen?
     walk_wild_section used to test for it.)  And bail out if any
     walk_wild_section used to test for it.)  And bail out if any
     of the wildcards are more complex than a simple string
     of the wildcards are more complex than a simple string
     ending in a single '*'.  */
     ending in a single '*'.  */
  for (sec = ptr->section_list; sec != NULL; sec = sec->next)
  for (sec = ptr->section_list; sec != NULL; sec = sec->next)
    {
    {
      ++sec_count;
      ++sec_count;
      if (sec->spec.name == NULL)
      if (sec->spec.name == NULL)
        return;
        return;
      if (wildcardp (sec->spec.name))
      if (wildcardp (sec->spec.name))
        {
        {
          ++wild_name_count;
          ++wild_name_count;
          if (!is_simple_wild (sec->spec.name))
          if (!is_simple_wild (sec->spec.name))
            return;
            return;
        }
        }
    }
    }
 
 
  /* The zero-spec case would be easy to optimize but it doesn't
  /* The zero-spec case would be easy to optimize but it doesn't
     happen in practice.  Likewise, more than 4 specs doesn't
     happen in practice.  Likewise, more than 4 specs doesn't
     happen in practice.  */
     happen in practice.  */
  if (sec_count == 0 || sec_count > 4)
  if (sec_count == 0 || sec_count > 4)
    return;
    return;
 
 
  /* Check that no two specs can match the same section.  */
  /* Check that no two specs can match the same section.  */
  for (sec = ptr->section_list; sec != NULL; sec = sec->next)
  for (sec = ptr->section_list; sec != NULL; sec = sec->next)
    {
    {
      struct wildcard_list *sec2;
      struct wildcard_list *sec2;
      for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)
      for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)
        {
        {
          if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))
          if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))
            return;
            return;
        }
        }
    }
    }
 
 
  signature = (sec_count << 8) + wild_name_count;
  signature = (sec_count << 8) + wild_name_count;
  switch (signature)
  switch (signature)
    {
    {
    case 0x0100:
    case 0x0100:
      ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
      ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
      break;
      break;
    case 0x0101:
    case 0x0101:
      ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
      ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
      break;
      break;
    case 0x0201:
    case 0x0201:
      ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
      ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
      break;
      break;
    case 0x0302:
    case 0x0302:
      ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
      ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
      break;
      break;
    case 0x0402:
    case 0x0402:
      ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
      ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
      break;
      break;
    default:
    default:
      return;
      return;
    }
    }
 
 
  /* Now fill the data array with pointers to the specs, first the
  /* Now fill the data array with pointers to the specs, first the
     specs with non-wildcard names, then the specs with wildcard
     specs with non-wildcard names, then the specs with wildcard
     names.  It's OK to process the specs in different order from the
     names.  It's OK to process the specs in different order from the
     given order, because we've already determined that no section
     given order, because we've already determined that no section
     will match more than one spec.  */
     will match more than one spec.  */
  data_counter = 0;
  data_counter = 0;
  for (sec = ptr->section_list; sec != NULL; sec = sec->next)
  for (sec = ptr->section_list; sec != NULL; sec = sec->next)
    if (!wildcardp (sec->spec.name))
    if (!wildcardp (sec->spec.name))
      ptr->handler_data[data_counter++] = sec;
      ptr->handler_data[data_counter++] = sec;
  for (sec = ptr->section_list; sec != NULL; sec = sec->next)
  for (sec = ptr->section_list; sec != NULL; sec = sec->next)
    if (wildcardp (sec->spec.name))
    if (wildcardp (sec->spec.name))
      ptr->handler_data[data_counter++] = sec;
      ptr->handler_data[data_counter++] = sec;
}
}
 
 
/* Handle a wild statement for a single file F.  */
/* Handle a wild statement for a single file F.  */
 
 
static void
static void
walk_wild_file (lang_wild_statement_type *s,
walk_wild_file (lang_wild_statement_type *s,
                lang_input_statement_type *f,
                lang_input_statement_type *f,
                callback_t callback,
                callback_t callback,
                void *data)
                void *data)
{
{
  if (f->the_bfd == NULL
  if (f->the_bfd == NULL
      || ! bfd_check_format (f->the_bfd, bfd_archive))
      || ! bfd_check_format (f->the_bfd, bfd_archive))
    walk_wild_section (s, f, callback, data);
    walk_wild_section (s, f, callback, data);
  else
  else
    {
    {
      bfd *member;
      bfd *member;
 
 
      /* This is an archive file.  We must map each member of the
      /* This is an archive file.  We must map each member of the
         archive separately.  */
         archive separately.  */
      member = bfd_openr_next_archived_file (f->the_bfd, NULL);
      member = bfd_openr_next_archived_file (f->the_bfd, NULL);
      while (member != NULL)
      while (member != NULL)
        {
        {
          /* When lookup_name is called, it will call the add_symbols
          /* When lookup_name is called, it will call the add_symbols
             entry point for the archive.  For each element of the
             entry point for the archive.  For each element of the
             archive which is included, BFD will call ldlang_add_file,
             archive which is included, BFD will call ldlang_add_file,
             which will set the usrdata field of the member to the
             which will set the usrdata field of the member to the
             lang_input_statement.  */
             lang_input_statement.  */
          if (member->usrdata != NULL)
          if (member->usrdata != NULL)
            {
            {
              walk_wild_section (s, member->usrdata, callback, data);
              walk_wild_section (s, member->usrdata, callback, data);
            }
            }
 
 
          member = bfd_openr_next_archived_file (f->the_bfd, member);
          member = bfd_openr_next_archived_file (f->the_bfd, member);
        }
        }
    }
    }
}
}
 
 
static void
static void
walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
{
{
  const char *file_spec = s->filename;
  const char *file_spec = s->filename;
 
 
  if (file_spec == NULL)
  if (file_spec == NULL)
    {
    {
      /* Perform the iteration over all files in the list.  */
      /* Perform the iteration over all files in the list.  */
      LANG_FOR_EACH_INPUT_STATEMENT (f)
      LANG_FOR_EACH_INPUT_STATEMENT (f)
        {
        {
          walk_wild_file (s, f, callback, data);
          walk_wild_file (s, f, callback, data);
        }
        }
    }
    }
  else if (wildcardp (file_spec))
  else if (wildcardp (file_spec))
    {
    {
      LANG_FOR_EACH_INPUT_STATEMENT (f)
      LANG_FOR_EACH_INPUT_STATEMENT (f)
        {
        {
          if (fnmatch (file_spec, f->filename, 0) == 0)
          if (fnmatch (file_spec, f->filename, 0) == 0)
            walk_wild_file (s, f, callback, data);
            walk_wild_file (s, f, callback, data);
        }
        }
    }
    }
  else
  else
    {
    {
      lang_input_statement_type *f;
      lang_input_statement_type *f;
 
 
      /* Perform the iteration over a single file.  */
      /* Perform the iteration over a single file.  */
      f = lookup_name (file_spec);
      f = lookup_name (file_spec);
      if (f)
      if (f)
        walk_wild_file (s, f, callback, data);
        walk_wild_file (s, f, callback, data);
    }
    }
}
}
 
 
/* lang_for_each_statement walks the parse tree and calls the provided
/* lang_for_each_statement walks the parse tree and calls the provided
   function for each node.  */
   function for each node.  */
 
 
static void
static void
lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
                                lang_statement_union_type *s)
                                lang_statement_union_type *s)
{
{
  for (; s != NULL; s = s->header.next)
  for (; s != NULL; s = s->header.next)
    {
    {
      func (s);
      func (s);
 
 
      switch (s->header.type)
      switch (s->header.type)
        {
        {
        case lang_constructors_statement_enum:
        case lang_constructors_statement_enum:
          lang_for_each_statement_worker (func, constructor_list.head);
          lang_for_each_statement_worker (func, constructor_list.head);
          break;
          break;
        case lang_output_section_statement_enum:
        case lang_output_section_statement_enum:
          lang_for_each_statement_worker
          lang_for_each_statement_worker
            (func, s->output_section_statement.children.head);
            (func, s->output_section_statement.children.head);
          break;
          break;
        case lang_wild_statement_enum:
        case lang_wild_statement_enum:
          lang_for_each_statement_worker (func,
          lang_for_each_statement_worker (func,
                                          s->wild_statement.children.head);
                                          s->wild_statement.children.head);
          break;
          break;
        case lang_group_statement_enum:
        case lang_group_statement_enum:
          lang_for_each_statement_worker (func,
          lang_for_each_statement_worker (func,
                                          s->group_statement.children.head);
                                          s->group_statement.children.head);
          break;
          break;
        case lang_data_statement_enum:
        case lang_data_statement_enum:
        case lang_reloc_statement_enum:
        case lang_reloc_statement_enum:
        case lang_object_symbols_statement_enum:
        case lang_object_symbols_statement_enum:
        case lang_output_statement_enum:
        case lang_output_statement_enum:
        case lang_target_statement_enum:
        case lang_target_statement_enum:
        case lang_input_section_enum:
        case lang_input_section_enum:
        case lang_input_statement_enum:
        case lang_input_statement_enum:
        case lang_assignment_statement_enum:
        case lang_assignment_statement_enum:
        case lang_padding_statement_enum:
        case lang_padding_statement_enum:
        case lang_address_statement_enum:
        case lang_address_statement_enum:
        case lang_fill_statement_enum:
        case lang_fill_statement_enum:
        case lang_insert_statement_enum:
        case lang_insert_statement_enum:
          break;
          break;
        default:
        default:
          FAIL ();
          FAIL ();
          break;
          break;
        }
        }
    }
    }
}
}
 
 
void
void
lang_for_each_statement (void (*func) (lang_statement_union_type *))
lang_for_each_statement (void (*func) (lang_statement_union_type *))
{
{
  lang_for_each_statement_worker (func, statement_list.head);
  lang_for_each_statement_worker (func, statement_list.head);
}
}
 
 
/*----------------------------------------------------------------------*/
/*----------------------------------------------------------------------*/
 
 
void
void
lang_list_init (lang_statement_list_type *list)
lang_list_init (lang_statement_list_type *list)
{
{
  list->head = NULL;
  list->head = NULL;
  list->tail = &list->head;
  list->tail = &list->head;
}
}
 
 
/* Build a new statement node for the parse tree.  */
/* Build a new statement node for the parse tree.  */
 
 
static lang_statement_union_type *
static lang_statement_union_type *
new_statement (enum statement_enum type,
new_statement (enum statement_enum type,
               size_t size,
               size_t size,
               lang_statement_list_type *list)
               lang_statement_list_type *list)
{
{
  lang_statement_union_type *new;
  lang_statement_union_type *new;
 
 
  new = stat_alloc (size);
  new = stat_alloc (size);
  new->header.type = type;
  new->header.type = type;
  new->header.next = NULL;
  new->header.next = NULL;
  lang_statement_append (list, new, &new->header.next);
  lang_statement_append (list, new, &new->header.next);
  return new;
  return new;
}
}
 
 
/* Build a new input file node for the language.  There are several
/* Build a new input file node for the language.  There are several
   ways in which we treat an input file, eg, we only look at symbols,
   ways in which we treat an input file, eg, we only look at symbols,
   or prefix it with a -l etc.
   or prefix it with a -l etc.
 
 
   We can be supplied with requests for input files more than once;
   We can be supplied with requests for input files more than once;
   they may, for example be split over several lines like foo.o(.text)
   they may, for example be split over several lines like foo.o(.text)
   foo.o(.data) etc, so when asked for a file we check that we haven't
   foo.o(.data) etc, so when asked for a file we check that we haven't
   got it already so we don't duplicate the bfd.  */
   got it already so we don't duplicate the bfd.  */
 
 
static lang_input_statement_type *
static lang_input_statement_type *
new_afile (const char *name,
new_afile (const char *name,
           lang_input_file_enum_type file_type,
           lang_input_file_enum_type file_type,
           const char *target,
           const char *target,
           bfd_boolean add_to_list)
           bfd_boolean add_to_list)
{
{
  lang_input_statement_type *p;
  lang_input_statement_type *p;
 
 
  if (add_to_list)
  if (add_to_list)
    p = new_stat (lang_input_statement, stat_ptr);
    p = new_stat (lang_input_statement, stat_ptr);
  else
  else
    {
    {
      p = stat_alloc (sizeof (lang_input_statement_type));
      p = stat_alloc (sizeof (lang_input_statement_type));
      p->header.type = lang_input_statement_enum;
      p->header.type = lang_input_statement_enum;
      p->header.next = NULL;
      p->header.next = NULL;
    }
    }
 
 
  lang_has_input_file = TRUE;
  lang_has_input_file = TRUE;
  p->target = target;
  p->target = target;
  p->sysrooted = FALSE;
  p->sysrooted = FALSE;
 
 
  if (file_type == lang_input_file_is_l_enum
  if (file_type == lang_input_file_is_l_enum
      && name[0] == ':' && name[1] != '\0')
      && name[0] == ':' && name[1] != '\0')
    {
    {
      file_type = lang_input_file_is_search_file_enum;
      file_type = lang_input_file_is_search_file_enum;
      name = name + 1;
      name = name + 1;
    }
    }
 
 
  switch (file_type)
  switch (file_type)
    {
    {
    case lang_input_file_is_symbols_only_enum:
    case lang_input_file_is_symbols_only_enum:
      p->filename = name;
      p->filename = name;
      p->is_archive = FALSE;
      p->is_archive = FALSE;
      p->real = TRUE;
      p->real = TRUE;
      p->local_sym_name = name;
      p->local_sym_name = name;
      p->just_syms_flag = TRUE;
      p->just_syms_flag = TRUE;
      p->search_dirs_flag = FALSE;
      p->search_dirs_flag = FALSE;
      break;
      break;
    case lang_input_file_is_fake_enum:
    case lang_input_file_is_fake_enum:
      p->filename = name;
      p->filename = name;
      p->is_archive = FALSE;
      p->is_archive = FALSE;
      p->real = FALSE;
      p->real = FALSE;
      p->local_sym_name = name;
      p->local_sym_name = name;
      p->just_syms_flag = FALSE;
      p->just_syms_flag = FALSE;
      p->search_dirs_flag = FALSE;
      p->search_dirs_flag = FALSE;
      break;
      break;
    case lang_input_file_is_l_enum:
    case lang_input_file_is_l_enum:
      p->is_archive = TRUE;
      p->is_archive = TRUE;
      p->filename = name;
      p->filename = name;
      p->real = TRUE;
      p->real = TRUE;
      p->local_sym_name = concat ("-l", name, (const char *) NULL);
      p->local_sym_name = concat ("-l", name, (const char *) NULL);
      p->just_syms_flag = FALSE;
      p->just_syms_flag = FALSE;
      p->search_dirs_flag = TRUE;
      p->search_dirs_flag = TRUE;
      break;
      break;
    case lang_input_file_is_marker_enum:
    case lang_input_file_is_marker_enum:
      p->filename = name;
      p->filename = name;
      p->is_archive = FALSE;
      p->is_archive = FALSE;
      p->real = FALSE;
      p->real = FALSE;
      p->local_sym_name = name;
      p->local_sym_name = name;
      p->just_syms_flag = FALSE;
      p->just_syms_flag = FALSE;
      p->search_dirs_flag = TRUE;
      p->search_dirs_flag = TRUE;
      break;
      break;
    case lang_input_file_is_search_file_enum:
    case lang_input_file_is_search_file_enum:
      p->sysrooted = ldlang_sysrooted_script;
      p->sysrooted = ldlang_sysrooted_script;
      p->filename = name;
      p->filename = name;
      p->is_archive = FALSE;
      p->is_archive = FALSE;
      p->real = TRUE;
      p->real = TRUE;
      p->local_sym_name = name;
      p->local_sym_name = name;
      p->just_syms_flag = FALSE;
      p->just_syms_flag = FALSE;
      p->search_dirs_flag = TRUE;
      p->search_dirs_flag = TRUE;
      break;
      break;
    case lang_input_file_is_file_enum:
    case lang_input_file_is_file_enum:
      p->filename = name;
      p->filename = name;
      p->is_archive = FALSE;
      p->is_archive = FALSE;
      p->real = TRUE;
      p->real = TRUE;
      p->local_sym_name = name;
      p->local_sym_name = name;
      p->just_syms_flag = FALSE;
      p->just_syms_flag = FALSE;
      p->search_dirs_flag = FALSE;
      p->search_dirs_flag = FALSE;
      break;
      break;
    default:
    default:
      FAIL ();
      FAIL ();
    }
    }
  p->the_bfd = NULL;
  p->the_bfd = NULL;
  p->asymbols = NULL;
  p->asymbols = NULL;
  p->next_real_file = NULL;
  p->next_real_file = NULL;
  p->next = NULL;
  p->next = NULL;
  p->symbol_count = 0;
  p->symbol_count = 0;
  p->dynamic = config.dynamic_link;
  p->dynamic = config.dynamic_link;
  p->add_needed = add_needed;
  p->add_needed = add_needed;
  p->as_needed = as_needed;
  p->as_needed = as_needed;
  p->whole_archive = whole_archive;
  p->whole_archive = whole_archive;
  p->loaded = FALSE;
  p->loaded = FALSE;
  lang_statement_append (&input_file_chain,
  lang_statement_append (&input_file_chain,
                         (lang_statement_union_type *) p,
                         (lang_statement_union_type *) p,
                         &p->next_real_file);
                         &p->next_real_file);
  return p;
  return p;
}
}
 
 
lang_input_statement_type *
lang_input_statement_type *
lang_add_input_file (const char *name,
lang_add_input_file (const char *name,
                     lang_input_file_enum_type file_type,
                     lang_input_file_enum_type file_type,
                     const char *target)
                     const char *target)
{
{
  return new_afile (name, file_type, target, TRUE);
  return new_afile (name, file_type, target, TRUE);
}
}
 
 
struct out_section_hash_entry
struct out_section_hash_entry
{
{
  struct bfd_hash_entry root;
  struct bfd_hash_entry root;
  lang_statement_union_type s;
  lang_statement_union_type s;
};
};
 
 
/* The hash table.  */
/* The hash table.  */
 
 
static struct bfd_hash_table output_section_statement_table;
static struct bfd_hash_table output_section_statement_table;
 
 
/* Support routines for the hash table used by lang_output_section_find,
/* Support routines for the hash table used by lang_output_section_find,
   initialize the table, fill in an entry and remove the table.  */
   initialize the table, fill in an entry and remove the table.  */
 
 
static struct bfd_hash_entry *
static struct bfd_hash_entry *
output_section_statement_newfunc (struct bfd_hash_entry *entry,
output_section_statement_newfunc (struct bfd_hash_entry *entry,
                                  struct bfd_hash_table *table,
                                  struct bfd_hash_table *table,
                                  const char *string)
                                  const char *string)
{
{
  lang_output_section_statement_type **nextp;
  lang_output_section_statement_type **nextp;
  struct out_section_hash_entry *ret;
  struct out_section_hash_entry *ret;
 
 
  if (entry == NULL)
  if (entry == NULL)
    {
    {
      entry = bfd_hash_allocate (table, sizeof (*ret));
      entry = bfd_hash_allocate (table, sizeof (*ret));
      if (entry == NULL)
      if (entry == NULL)
        return entry;
        return entry;
    }
    }
 
 
  entry = bfd_hash_newfunc (entry, table, string);
  entry = bfd_hash_newfunc (entry, table, string);
  if (entry == NULL)
  if (entry == NULL)
    return entry;
    return entry;
 
 
  ret = (struct out_section_hash_entry *) entry;
  ret = (struct out_section_hash_entry *) entry;
  memset (&ret->s, 0, sizeof (ret->s));
  memset (&ret->s, 0, sizeof (ret->s));
  ret->s.header.type = lang_output_section_statement_enum;
  ret->s.header.type = lang_output_section_statement_enum;
  ret->s.output_section_statement.subsection_alignment = -1;
  ret->s.output_section_statement.subsection_alignment = -1;
  ret->s.output_section_statement.section_alignment = -1;
  ret->s.output_section_statement.section_alignment = -1;
  ret->s.output_section_statement.block_value = 1;
  ret->s.output_section_statement.block_value = 1;
  lang_list_init (&ret->s.output_section_statement.children);
  lang_list_init (&ret->s.output_section_statement.children);
  lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);
  lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);
 
 
  /* For every output section statement added to the list, except the
  /* For every output section statement added to the list, except the
     first one, lang_output_section_statement.tail points to the "next"
     first one, lang_output_section_statement.tail points to the "next"
     field of the last element of the list.  */
     field of the last element of the list.  */
  if (lang_output_section_statement.head != NULL)
  if (lang_output_section_statement.head != NULL)
    ret->s.output_section_statement.prev
    ret->s.output_section_statement.prev
      = ((lang_output_section_statement_type *)
      = ((lang_output_section_statement_type *)
         ((char *) lang_output_section_statement.tail
         ((char *) lang_output_section_statement.tail
          - offsetof (lang_output_section_statement_type, next)));
          - offsetof (lang_output_section_statement_type, next)));
 
 
  /* GCC's strict aliasing rules prevent us from just casting the
  /* GCC's strict aliasing rules prevent us from just casting the
     address, so we store the pointer in a variable and cast that
     address, so we store the pointer in a variable and cast that
     instead.  */
     instead.  */
  nextp = &ret->s.output_section_statement.next;
  nextp = &ret->s.output_section_statement.next;
  lang_statement_append (&lang_output_section_statement,
  lang_statement_append (&lang_output_section_statement,
                         &ret->s,
                         &ret->s,
                         (lang_statement_union_type **) nextp);
                         (lang_statement_union_type **) nextp);
  return &ret->root;
  return &ret->root;
}
}
 
 
static void
static void
output_section_statement_table_init (void)
output_section_statement_table_init (void)
{
{
  if (!bfd_hash_table_init_n (&output_section_statement_table,
  if (!bfd_hash_table_init_n (&output_section_statement_table,
                              output_section_statement_newfunc,
                              output_section_statement_newfunc,
                              sizeof (struct out_section_hash_entry),
                              sizeof (struct out_section_hash_entry),
                              61))
                              61))
    einfo (_("%P%F: can not create hash table: %E\n"));
    einfo (_("%P%F: can not create hash table: %E\n"));
}
}
 
 
static void
static void
output_section_statement_table_free (void)
output_section_statement_table_free (void)
{
{
  bfd_hash_table_free (&output_section_statement_table);
  bfd_hash_table_free (&output_section_statement_table);
}
}
 
 
/* Build enough state so that the parser can build its tree.  */
/* Build enough state so that the parser can build its tree.  */
 
 
void
void
lang_init (void)
lang_init (void)
{
{
  obstack_begin (&stat_obstack, 1000);
  obstack_begin (&stat_obstack, 1000);
 
 
  stat_ptr = &statement_list;
  stat_ptr = &statement_list;
 
 
  output_section_statement_table_init ();
  output_section_statement_table_init ();
 
 
  lang_list_init (stat_ptr);
  lang_list_init (stat_ptr);
 
 
  lang_list_init (&input_file_chain);
  lang_list_init (&input_file_chain);
  lang_list_init (&lang_output_section_statement);
  lang_list_init (&lang_output_section_statement);
  lang_list_init (&file_chain);
  lang_list_init (&file_chain);
  first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
  first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
                                    NULL);
                                    NULL);
  abs_output_section =
  abs_output_section =
    lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
    lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
 
 
  abs_output_section->bfd_section = bfd_abs_section_ptr;
  abs_output_section->bfd_section = bfd_abs_section_ptr;
 
 
  /* The value "3" is ad-hoc, somewhat related to the expected number of
  /* The value "3" is ad-hoc, somewhat related to the expected number of
     DEFINED expressions in a linker script.  For most default linker
     DEFINED expressions in a linker script.  For most default linker
     scripts, there are none.  Why a hash table then?  Well, it's somewhat
     scripts, there are none.  Why a hash table then?  Well, it's somewhat
     simpler to re-use working machinery than using a linked list in terms
     simpler to re-use working machinery than using a linked list in terms
     of code-complexity here in ld, besides the initialization which just
     of code-complexity here in ld, besides the initialization which just
     looks like other code here.  */
     looks like other code here.  */
  if (!bfd_hash_table_init_n (&lang_definedness_table,
  if (!bfd_hash_table_init_n (&lang_definedness_table,
                              lang_definedness_newfunc,
                              lang_definedness_newfunc,
                              sizeof (struct lang_definedness_hash_entry),
                              sizeof (struct lang_definedness_hash_entry),
                              3))
                              3))
    einfo (_("%P%F: can not create hash table: %E\n"));
    einfo (_("%P%F: can not create hash table: %E\n"));
}
}
 
 
void
void
lang_finish (void)
lang_finish (void)
{
{
  output_section_statement_table_free ();
  output_section_statement_table_free ();
}
}
 
 
/*----------------------------------------------------------------------
/*----------------------------------------------------------------------
  A region is an area of memory declared with the
  A region is an area of memory declared with the
  MEMORY {  name:org=exp, len=exp ... }
  MEMORY {  name:org=exp, len=exp ... }
  syntax.
  syntax.
 
 
  We maintain a list of all the regions here.
  We maintain a list of all the regions here.
 
 
  If no regions are specified in the script, then the default is used
  If no regions are specified in the script, then the default is used
  which is created when looked up to be the entire data space.
  which is created when looked up to be the entire data space.
 
 
  If create is true we are creating a region inside a MEMORY block.
  If create is true we are creating a region inside a MEMORY block.
  In this case it is probably an error to create a region that has
  In this case it is probably an error to create a region that has
  already been created.  If we are not inside a MEMORY block it is
  already been created.  If we are not inside a MEMORY block it is
  dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
  dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
  and so we issue a warning.  */
  and so we issue a warning.  */
 
 
static lang_memory_region_type *lang_memory_region_list;
static lang_memory_region_type *lang_memory_region_list;
static lang_memory_region_type **lang_memory_region_list_tail
static lang_memory_region_type **lang_memory_region_list_tail
  = &lang_memory_region_list;
  = &lang_memory_region_list;
 
 
lang_memory_region_type *
lang_memory_region_type *
lang_memory_region_lookup (const char *const name, bfd_boolean create)
lang_memory_region_lookup (const char *const name, bfd_boolean create)
{
{
  lang_memory_region_type *p;
  lang_memory_region_type *p;
  lang_memory_region_type *new;
  lang_memory_region_type *new;
 
 
  /* NAME is NULL for LMA memspecs if no region was specified.  */
  /* NAME is NULL for LMA memspecs if no region was specified.  */
  if (name == NULL)
  if (name == NULL)
    return NULL;
    return NULL;
 
 
  for (p = lang_memory_region_list; p != NULL; p = p->next)
  for (p = lang_memory_region_list; p != NULL; p = p->next)
    if (strcmp (p->name, name) == 0)
    if (strcmp (p->name, name) == 0)
      {
      {
        if (create)
        if (create)
          einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
          einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
                 name);
                 name);
        return p;
        return p;
      }
      }
 
 
  if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
  if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
    einfo (_("%P:%S: warning: memory region %s not declared\n"), name);
    einfo (_("%P:%S: warning: memory region %s not declared\n"), name);
 
 
  new = stat_alloc (sizeof (lang_memory_region_type));
  new = stat_alloc (sizeof (lang_memory_region_type));
 
 
  new->name = xstrdup (name);
  new->name = xstrdup (name);
  new->next = NULL;
  new->next = NULL;
  new->origin = 0;
  new->origin = 0;
  new->length = ~(bfd_size_type) 0;
  new->length = ~(bfd_size_type) 0;
  new->current = 0;
  new->current = 0;
  new->last_os = NULL;
  new->last_os = NULL;
  new->flags = 0;
  new->flags = 0;
  new->not_flags = 0;
  new->not_flags = 0;
  new->had_full_message = FALSE;
  new->had_full_message = FALSE;
 
 
  *lang_memory_region_list_tail = new;
  *lang_memory_region_list_tail = new;
  lang_memory_region_list_tail = &new->next;
  lang_memory_region_list_tail = &new->next;
 
 
  return new;
  return new;
}
}
 
 
static lang_memory_region_type *
static lang_memory_region_type *
lang_memory_default (asection *section)
lang_memory_default (asection *section)
{
{
  lang_memory_region_type *p;
  lang_memory_region_type *p;
 
 
  flagword sec_flags = section->flags;
  flagword sec_flags = section->flags;
 
 
  /* Override SEC_DATA to mean a writable section.  */
  /* Override SEC_DATA to mean a writable section.  */
  if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
  if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
    sec_flags |= SEC_DATA;
    sec_flags |= SEC_DATA;
 
 
  for (p = lang_memory_region_list; p != NULL; p = p->next)
  for (p = lang_memory_region_list; p != NULL; p = p->next)
    {
    {
      if ((p->flags & sec_flags) != 0
      if ((p->flags & sec_flags) != 0
          && (p->not_flags & sec_flags) == 0)
          && (p->not_flags & sec_flags) == 0)
        {
        {
          return p;
          return p;
        }
        }
    }
    }
  return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
  return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
}
}
 
 
lang_output_section_statement_type *
lang_output_section_statement_type *
lang_output_section_find (const char *const name)
lang_output_section_find (const char *const name)
{
{
  struct out_section_hash_entry *entry;
  struct out_section_hash_entry *entry;
  unsigned long hash;
  unsigned long hash;
 
 
  entry = ((struct out_section_hash_entry *)
  entry = ((struct out_section_hash_entry *)
           bfd_hash_lookup (&output_section_statement_table, name,
           bfd_hash_lookup (&output_section_statement_table, name,
                            FALSE, FALSE));
                            FALSE, FALSE));
  if (entry == NULL)
  if (entry == NULL)
    return NULL;
    return NULL;
 
 
  hash = entry->root.hash;
  hash = entry->root.hash;
  do
  do
    {
    {
      if (entry->s.output_section_statement.constraint != -1)
      if (entry->s.output_section_statement.constraint != -1)
        return &entry->s.output_section_statement;
        return &entry->s.output_section_statement;
      entry = (struct out_section_hash_entry *) entry->root.next;
      entry = (struct out_section_hash_entry *) entry->root.next;
    }
    }
  while (entry != NULL
  while (entry != NULL
         && entry->root.hash == hash
         && entry->root.hash == hash
         && strcmp (name, entry->s.output_section_statement.name) == 0);
         && strcmp (name, entry->s.output_section_statement.name) == 0);
 
 
  return NULL;
  return NULL;
}
}
 
 
static lang_output_section_statement_type *
static lang_output_section_statement_type *
lang_output_section_statement_lookup_1 (const char *const name, int constraint)
lang_output_section_statement_lookup_1 (const char *const name, int constraint)
{
{
  struct out_section_hash_entry *entry;
  struct out_section_hash_entry *entry;
  struct out_section_hash_entry *last_ent;
  struct out_section_hash_entry *last_ent;
  unsigned long hash;
  unsigned long hash;
 
 
  entry = ((struct out_section_hash_entry *)
  entry = ((struct out_section_hash_entry *)
           bfd_hash_lookup (&output_section_statement_table, name,
           bfd_hash_lookup (&output_section_statement_table, name,
                            TRUE, FALSE));
                            TRUE, FALSE));
  if (entry == NULL)
  if (entry == NULL)
    {
    {
      einfo (_("%P%F: failed creating section `%s': %E\n"), name);
      einfo (_("%P%F: failed creating section `%s': %E\n"), name);
      return NULL;
      return NULL;
    }
    }
 
 
  if (entry->s.output_section_statement.name != NULL)
  if (entry->s.output_section_statement.name != NULL)
    {
    {
      /* We have a section of this name, but it might not have the correct
      /* We have a section of this name, but it might not have the correct
         constraint.  */
         constraint.  */
      hash = entry->root.hash;
      hash = entry->root.hash;
      do
      do
        {
        {
          if (entry->s.output_section_statement.constraint != -1
          if (entry->s.output_section_statement.constraint != -1
              && (constraint == 0
              && (constraint == 0
                  || (constraint == entry->s.output_section_statement.constraint
                  || (constraint == entry->s.output_section_statement.constraint
                      && constraint != SPECIAL)))
                      && constraint != SPECIAL)))
            return &entry->s.output_section_statement;
            return &entry->s.output_section_statement;
          last_ent = entry;
          last_ent = entry;
          entry = (struct out_section_hash_entry *) entry->root.next;
          entry = (struct out_section_hash_entry *) entry->root.next;
        }
        }
      while (entry != NULL
      while (entry != NULL
             && entry->root.hash == hash
             && entry->root.hash == hash
             && strcmp (name, entry->s.output_section_statement.name) == 0);
             && strcmp (name, entry->s.output_section_statement.name) == 0);
 
 
      entry
      entry
        = ((struct out_section_hash_entry *)
        = ((struct out_section_hash_entry *)
           output_section_statement_newfunc (NULL,
           output_section_statement_newfunc (NULL,
                                             &output_section_statement_table,
                                             &output_section_statement_table,
                                             name));
                                             name));
      if (entry == NULL)
      if (entry == NULL)
        {
        {
          einfo (_("%P%F: failed creating section `%s': %E\n"), name);
          einfo (_("%P%F: failed creating section `%s': %E\n"), name);
          return NULL;
          return NULL;
        }
        }
      entry->root = last_ent->root;
      entry->root = last_ent->root;
      last_ent->root.next = &entry->root;
      last_ent->root.next = &entry->root;
    }
    }
 
 
  entry->s.output_section_statement.name = name;
  entry->s.output_section_statement.name = name;
  entry->s.output_section_statement.constraint = constraint;
  entry->s.output_section_statement.constraint = constraint;
  return &entry->s.output_section_statement;
  return &entry->s.output_section_statement;
}
}
 
 
lang_output_section_statement_type *
lang_output_section_statement_type *
lang_output_section_statement_lookup (const char *const name)
lang_output_section_statement_lookup (const char *const name)
{
{
  return lang_output_section_statement_lookup_1 (name, 0);
  return lang_output_section_statement_lookup_1 (name, 0);
}
}
 
 
/* A variant of lang_output_section_find used by place_orphan.
/* A variant of lang_output_section_find used by place_orphan.
   Returns the output statement that should precede a new output
   Returns the output statement that should precede a new output
   statement for SEC.  If an exact match is found on certain flags,
   statement for SEC.  If an exact match is found on certain flags,
   sets *EXACT too.  */
   sets *EXACT too.  */
 
 
lang_output_section_statement_type *
lang_output_section_statement_type *
lang_output_section_find_by_flags (const asection *sec,
lang_output_section_find_by_flags (const asection *sec,
                                   lang_output_section_statement_type **exact,
                                   lang_output_section_statement_type **exact,
                                   lang_match_sec_type_func match_type)
                                   lang_match_sec_type_func match_type)
{
{
  lang_output_section_statement_type *first, *look, *found;
  lang_output_section_statement_type *first, *look, *found;
  flagword flags;
  flagword flags;
 
 
  /* We know the first statement on this list is *ABS*.  May as well
  /* We know the first statement on this list is *ABS*.  May as well
     skip it.  */
     skip it.  */
  first = &lang_output_section_statement.head->output_section_statement;
  first = &lang_output_section_statement.head->output_section_statement;
  first = first->next;
  first = first->next;
 
 
  /* First try for an exact match.  */
  /* First try for an exact match.  */
  found = NULL;
  found = NULL;
  for (look = first; look; look = look->next)
  for (look = first; look; look = look->next)
    {
    {
      flags = look->flags;
      flags = look->flags;
      if (look->bfd_section != NULL)
      if (look->bfd_section != NULL)
        {
        {
          flags = look->bfd_section->flags;
          flags = look->bfd_section->flags;
          if (match_type && !match_type (link_info.output_bfd,
          if (match_type && !match_type (link_info.output_bfd,
                                         look->bfd_section,
                                         look->bfd_section,
                                         sec->owner, sec))
                                         sec->owner, sec))
            continue;
            continue;
        }
        }
      flags ^= sec->flags;
      flags ^= sec->flags;
      if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
      if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
                     | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
                     | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
        found = look;
        found = look;
    }
    }
  if (found != NULL)
  if (found != NULL)
    {
    {
      if (exact != NULL)
      if (exact != NULL)
        *exact = found;
        *exact = found;
      return found;
      return found;
    }
    }
 
 
  if (sec->flags & SEC_CODE)
  if (sec->flags & SEC_CODE)
    {
    {
      /* Try for a rw code section.  */
      /* Try for a rw code section.  */
      for (look = first; look; look = look->next)
      for (look = first; look; look = look->next)
        {
        {
          flags = look->flags;
          flags = look->flags;
          if (look->bfd_section != NULL)
          if (look->bfd_section != NULL)
            {
            {
              flags = look->bfd_section->flags;
              flags = look->bfd_section->flags;
              if (match_type && !match_type (link_info.output_bfd,
              if (match_type && !match_type (link_info.output_bfd,
                                             look->bfd_section,
                                             look->bfd_section,
                                             sec->owner, sec))
                                             sec->owner, sec))
                continue;
                continue;
            }
            }
          flags ^= sec->flags;
          flags ^= sec->flags;
          if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
          if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
                         | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
                         | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
            found = look;
            found = look;
        }
        }
    }
    }
  else if (sec->flags & (SEC_READONLY | SEC_THREAD_LOCAL))
  else if (sec->flags & (SEC_READONLY | SEC_THREAD_LOCAL))
    {
    {
      /* .rodata can go after .text, .sdata2 after .rodata.  */
      /* .rodata can go after .text, .sdata2 after .rodata.  */
      for (look = first; look; look = look->next)
      for (look = first; look; look = look->next)
        {
        {
          flags = look->flags;
          flags = look->flags;
          if (look->bfd_section != NULL)
          if (look->bfd_section != NULL)
            {
            {
              flags = look->bfd_section->flags;
              flags = look->bfd_section->flags;
              if (match_type && !match_type (link_info.output_bfd,
              if (match_type && !match_type (link_info.output_bfd,
                                             look->bfd_section,
                                             look->bfd_section,
                                             sec->owner, sec))
                                             sec->owner, sec))
                continue;
                continue;
            }
            }
          flags ^= sec->flags;
          flags ^= sec->flags;
          if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
          if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
                         | SEC_READONLY))
                         | SEC_READONLY))
              && !(look->flags & (SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
              && !(look->flags & (SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
            found = look;
            found = look;
        }
        }
    }
    }
  else if (sec->flags & SEC_SMALL_DATA)
  else if (sec->flags & SEC_SMALL_DATA)
    {
    {
      /* .sdata goes after .data, .sbss after .sdata.  */
      /* .sdata goes after .data, .sbss after .sdata.  */
      for (look = first; look; look = look->next)
      for (look = first; look; look = look->next)
        {
        {
          flags = look->flags;
          flags = look->flags;
          if (look->bfd_section != NULL)
          if (look->bfd_section != NULL)
            {
            {
              flags = look->bfd_section->flags;
              flags = look->bfd_section->flags;
              if (match_type && !match_type (link_info.output_bfd,
              if (match_type && !match_type (link_info.output_bfd,
                                             look->bfd_section,
                                             look->bfd_section,
                                             sec->owner, sec))
                                             sec->owner, sec))
                continue;
                continue;
            }
            }
          flags ^= sec->flags;
          flags ^= sec->flags;
          if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
          if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
                         | SEC_THREAD_LOCAL))
                         | SEC_THREAD_LOCAL))
              || ((look->flags & SEC_SMALL_DATA)
              || ((look->flags & SEC_SMALL_DATA)
                  && !(sec->flags & SEC_HAS_CONTENTS)))
                  && !(sec->flags & SEC_HAS_CONTENTS)))
            found = look;
            found = look;
        }
        }
    }
    }
  else if (sec->flags & SEC_HAS_CONTENTS)
  else if (sec->flags & SEC_HAS_CONTENTS)
    {
    {
      /* .data goes after .rodata.  */
      /* .data goes after .rodata.  */
      for (look = first; look; look = look->next)
      for (look = first; look; look = look->next)
        {
        {
          flags = look->flags;
          flags = look->flags;
          if (look->bfd_section != NULL)
          if (look->bfd_section != NULL)
            {
            {
              flags = look->bfd_section->flags;
              flags = look->bfd_section->flags;
              if (match_type && !match_type (link_info.output_bfd,
              if (match_type && !match_type (link_info.output_bfd,
                                             look->bfd_section,
                                             look->bfd_section,
                                             sec->owner, sec))
                                             sec->owner, sec))
                continue;
                continue;
            }
            }
          flags ^= sec->flags;
          flags ^= sec->flags;
          if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
          if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
                         | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
                         | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
            found = look;
            found = look;
        }
        }
    }
    }
  else
  else
    {
    {
      /* .bss goes last.  */
      /* .bss goes last.  */
      for (look = first; look; look = look->next)
      for (look = first; look; look = look->next)
        {
        {
          flags = look->flags;
          flags = look->flags;
          if (look->bfd_section != NULL)
          if (look->bfd_section != NULL)
            {
            {
              flags = look->bfd_section->flags;
              flags = look->bfd_section->flags;
              if (match_type && !match_type (link_info.output_bfd,
              if (match_type && !match_type (link_info.output_bfd,
                                             look->bfd_section,
                                             look->bfd_section,
                                             sec->owner, sec))
                                             sec->owner, sec))
                continue;
                continue;
            }
            }
          flags ^= sec->flags;
          flags ^= sec->flags;
          if (!(flags & SEC_ALLOC))
          if (!(flags & SEC_ALLOC))
            found = look;
            found = look;
        }
        }
    }
    }
 
 
  if (found || !match_type)
  if (found || !match_type)
    return found;
    return found;
 
 
  return lang_output_section_find_by_flags (sec, NULL, NULL);
  return lang_output_section_find_by_flags (sec, NULL, NULL);
}
}
 
 
/* Find the last output section before given output statement.
/* Find the last output section before given output statement.
   Used by place_orphan.  */
   Used by place_orphan.  */
 
 
static asection *
static asection *
output_prev_sec_find (lang_output_section_statement_type *os)
output_prev_sec_find (lang_output_section_statement_type *os)
{
{
  lang_output_section_statement_type *lookup;
  lang_output_section_statement_type *lookup;
 
 
  for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)
  for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)
    {
    {
      if (lookup->constraint == -1)
      if (lookup->constraint == -1)
        continue;
        continue;
 
 
      if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
      if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
        return lookup->bfd_section;
        return lookup->bfd_section;
    }
    }
 
 
  return NULL;
  return NULL;
}
}
 
 
/* Look for a suitable place for a new output section statement.  The
/* Look for a suitable place for a new output section statement.  The
   idea is to skip over anything that might be inside a SECTIONS {}
   idea is to skip over anything that might be inside a SECTIONS {}
   statement in a script, before we find another output section
   statement in a script, before we find another output section
   statement.  Assignments to "dot" before an output section statement
   statement.  Assignments to "dot" before an output section statement
   are assumed to belong to it.  An exception to this rule is made for
   are assumed to belong to it.  An exception to this rule is made for
   the first assignment to dot, otherwise we might put an orphan
   the first assignment to dot, otherwise we might put an orphan
   before . = . + SIZEOF_HEADERS or similar assignments that set the
   before . = . + SIZEOF_HEADERS or similar assignments that set the
   initial address.  */
   initial address.  */
 
 
static lang_statement_union_type **
static lang_statement_union_type **
insert_os_after (lang_output_section_statement_type *after)
insert_os_after (lang_output_section_statement_type *after)
{
{
  lang_statement_union_type **where;
  lang_statement_union_type **where;
  lang_statement_union_type **assign = NULL;
  lang_statement_union_type **assign = NULL;
  bfd_boolean ignore_first;
  bfd_boolean ignore_first;
 
 
  ignore_first
  ignore_first
    = after == &lang_output_section_statement.head->output_section_statement;
    = after == &lang_output_section_statement.head->output_section_statement;
 
 
  for (where = &after->header.next;
  for (where = &after->header.next;
       *where != NULL;
       *where != NULL;
       where = &(*where)->header.next)
       where = &(*where)->header.next)
    {
    {
      switch ((*where)->header.type)
      switch ((*where)->header.type)
        {
        {
        case lang_assignment_statement_enum:
        case lang_assignment_statement_enum:
          if (assign == NULL)
          if (assign == NULL)
            {
            {
              lang_assignment_statement_type *ass;
              lang_assignment_statement_type *ass;
 
 
              ass = &(*where)->assignment_statement;
              ass = &(*where)->assignment_statement;
              if (ass->exp->type.node_class != etree_assert
              if (ass->exp->type.node_class != etree_assert
                  && ass->exp->assign.dst[0] == '.'
                  && ass->exp->assign.dst[0] == '.'
                  && ass->exp->assign.dst[1] == 0
                  && ass->exp->assign.dst[1] == 0
                  && !ignore_first)
                  && !ignore_first)
                assign = where;
                assign = where;
            }
            }
          ignore_first = FALSE;
          ignore_first = FALSE;
          continue;
          continue;
        case lang_wild_statement_enum:
        case lang_wild_statement_enum:
        case lang_input_section_enum:
        case lang_input_section_enum:
        case lang_object_symbols_statement_enum:
        case lang_object_symbols_statement_enum:
        case lang_fill_statement_enum:
        case lang_fill_statement_enum:
        case lang_data_statement_enum:
        case lang_data_statement_enum:
        case lang_reloc_statement_enum:
        case lang_reloc_statement_enum:
        case lang_padding_statement_enum:
        case lang_padding_statement_enum:
        case lang_constructors_statement_enum:
        case lang_constructors_statement_enum:
          assign = NULL;
          assign = NULL;
          continue;
          continue;
        case lang_output_section_statement_enum:
        case lang_output_section_statement_enum:
          if (assign != NULL)
          if (assign != NULL)
            where = assign;
            where = assign;
          break;
          break;
        case lang_input_statement_enum:
        case lang_input_statement_enum:
        case lang_address_statement_enum:
        case lang_address_statement_enum:
        case lang_target_statement_enum:
        case lang_target_statement_enum:
        case lang_output_statement_enum:
        case lang_output_statement_enum:
        case lang_group_statement_enum:
        case lang_group_statement_enum:
        case lang_insert_statement_enum:
        case lang_insert_statement_enum:
          continue;
          continue;
        }
        }
      break;
      break;
    }
    }
 
 
  return where;
  return where;
}
}
 
 
lang_output_section_statement_type *
lang_output_section_statement_type *
lang_insert_orphan (asection *s,
lang_insert_orphan (asection *s,
                    const char *secname,
                    const char *secname,
                    lang_output_section_statement_type *after,
                    lang_output_section_statement_type *after,
                    struct orphan_save *place,
                    struct orphan_save *place,
                    etree_type *address,
                    etree_type *address,
                    lang_statement_list_type *add_child)
                    lang_statement_list_type *add_child)
{
{
  lang_statement_list_type *old;
  lang_statement_list_type *old;
  lang_statement_list_type add;
  lang_statement_list_type add;
  const char *ps;
  const char *ps;
  lang_output_section_statement_type *os;
  lang_output_section_statement_type *os;
  lang_output_section_statement_type **os_tail;
  lang_output_section_statement_type **os_tail;
 
 
  /* Start building a list of statements for this section.
  /* Start building a list of statements for this section.
     First save the current statement pointer.  */
     First save the current statement pointer.  */
  old = stat_ptr;
  old = stat_ptr;
 
 
  /* If we have found an appropriate place for the output section
  /* If we have found an appropriate place for the output section
     statements for this orphan, add them to our own private list,
     statements for this orphan, add them to our own private list,
     inserting them later into the global statement list.  */
     inserting them later into the global statement list.  */
  if (after != NULL)
  if (after != NULL)
    {
    {
      stat_ptr = &add;
      stat_ptr = &add;
      lang_list_init (stat_ptr);
      lang_list_init (stat_ptr);
    }
    }
 
 
  ps = NULL;
  ps = NULL;
  if (config.build_constructors)
  if (config.build_constructors)
    {
    {
      /* If the name of the section is representable in C, then create
      /* If the name of the section is representable in C, then create
         symbols to mark the start and the end of the section.  */
         symbols to mark the start and the end of the section.  */
      for (ps = secname; *ps != '\0'; ps++)
      for (ps = secname; *ps != '\0'; ps++)
        if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
        if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
          break;
          break;
      if (*ps == '\0')
      if (*ps == '\0')
        {
        {
          char *symname;
          char *symname;
          etree_type *e_align;
          etree_type *e_align;
 
 
          symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
          symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
          symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
          symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
          sprintf (symname + (symname[0] != 0), "__start_%s", secname);
          sprintf (symname + (symname[0] != 0), "__start_%s", secname);
          e_align = exp_unop (ALIGN_K,
          e_align = exp_unop (ALIGN_K,
                              exp_intop ((bfd_vma) 1 << s->alignment_power));
                              exp_intop ((bfd_vma) 1 << s->alignment_power));
          lang_add_assignment (exp_assop ('=', ".", e_align));
          lang_add_assignment (exp_assop ('=', ".", e_align));
          lang_add_assignment (exp_provide (symname,
          lang_add_assignment (exp_provide (symname,
                                            exp_nameop (NAME, "."),
                                            exp_nameop (NAME, "."),
                                            FALSE));
                                            FALSE));
        }
        }
    }
    }
 
 
  if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
  if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
    address = exp_intop (0);
    address = exp_intop (0);
 
 
  os_tail = ((lang_output_section_statement_type **)
  os_tail = ((lang_output_section_statement_type **)
             lang_output_section_statement.tail);
             lang_output_section_statement.tail);
  os = lang_enter_output_section_statement (secname, address, 0, NULL, NULL,
  os = lang_enter_output_section_statement (secname, address, 0, NULL, NULL,
                                            NULL, 0);
                                            NULL, 0);
 
 
  if (add_child == NULL)
  if (add_child == NULL)
    add_child = &os->children;
    add_child = &os->children;
  lang_add_section (add_child, s, os);
  lang_add_section (add_child, s, os);
 
 
  lang_leave_output_section_statement (0, "*default*", NULL, NULL);
  lang_leave_output_section_statement (0, "*default*", NULL, NULL);
 
 
  if (config.build_constructors && *ps == '\0')
  if (config.build_constructors && *ps == '\0')
    {
    {
      char *symname;
      char *symname;
 
 
      /* lang_leave_ouput_section_statement resets stat_ptr.
      /* lang_leave_ouput_section_statement resets stat_ptr.
         Put stat_ptr back where we want it.  */
         Put stat_ptr back where we want it.  */
      if (after != NULL)
      if (after != NULL)
        stat_ptr = &add;
        stat_ptr = &add;
 
 
      symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
      symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
      symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
      symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
      sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
      sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
      lang_add_assignment (exp_provide (symname,
      lang_add_assignment (exp_provide (symname,
                                        exp_nameop (NAME, "."),
                                        exp_nameop (NAME, "."),
                                        FALSE));
                                        FALSE));
    }
    }
 
 
  /* Restore the global list pointer.  */
  /* Restore the global list pointer.  */
  if (after != NULL)
  if (after != NULL)
    stat_ptr = old;
    stat_ptr = old;
 
 
  if (after != NULL && os->bfd_section != NULL)
  if (after != NULL && os->bfd_section != NULL)
    {
    {
      asection *snew, *as;
      asection *snew, *as;
 
 
      snew = os->bfd_section;
      snew = os->bfd_section;
 
 
      /* Shuffle the bfd section list to make the output file look
      /* Shuffle the bfd section list to make the output file look
         neater.  This is really only cosmetic.  */
         neater.  This is really only cosmetic.  */
      if (place->section == NULL
      if (place->section == NULL
          && after != (&lang_output_section_statement.head
          && after != (&lang_output_section_statement.head
                       ->output_section_statement))
                       ->output_section_statement))
        {
        {
          asection *bfd_section = after->bfd_section;
          asection *bfd_section = after->bfd_section;
 
 
          /* If the output statement hasn't been used to place any input
          /* If the output statement hasn't been used to place any input
             sections (and thus doesn't have an output bfd_section),
             sections (and thus doesn't have an output bfd_section),
             look for the closest prior output statement having an
             look for the closest prior output statement having an
             output section.  */
             output section.  */
          if (bfd_section == NULL)
          if (bfd_section == NULL)
            bfd_section = output_prev_sec_find (after);
            bfd_section = output_prev_sec_find (after);
 
 
          if (bfd_section != NULL && bfd_section != snew)
          if (bfd_section != NULL && bfd_section != snew)
            place->section = &bfd_section->next;
            place->section = &bfd_section->next;
        }
        }
 
 
      if (place->section == NULL)
      if (place->section == NULL)
        place->section = &link_info.output_bfd->sections;
        place->section = &link_info.output_bfd->sections;
 
 
      as = *place->section;
      as = *place->section;
 
 
      if (!as)
      if (!as)
        {
        {
          /* Put the section at the end of the list.  */
          /* Put the section at the end of the list.  */
 
 
          /* Unlink the section.  */
          /* Unlink the section.  */
          bfd_section_list_remove (link_info.output_bfd, snew);
          bfd_section_list_remove (link_info.output_bfd, snew);
 
 
          /* Now tack it back on in the right place.  */
          /* Now tack it back on in the right place.  */
          bfd_section_list_append (link_info.output_bfd, snew);
          bfd_section_list_append (link_info.output_bfd, snew);
        }
        }
      else if (as != snew && as->prev != snew)
      else if (as != snew && as->prev != snew)
        {
        {
          /* Unlink the section.  */
          /* Unlink the section.  */
          bfd_section_list_remove (link_info.output_bfd, snew);
          bfd_section_list_remove (link_info.output_bfd, snew);
 
 
          /* Now tack it back on in the right place.  */
          /* Now tack it back on in the right place.  */
          bfd_section_list_insert_before (link_info.output_bfd, as, snew);
          bfd_section_list_insert_before (link_info.output_bfd, as, snew);
        }
        }
 
 
      /* Save the end of this list.  Further ophans of this type will
      /* Save the end of this list.  Further ophans of this type will
         follow the one we've just added.  */
         follow the one we've just added.  */
      place->section = &snew->next;
      place->section = &snew->next;
 
 
      /* The following is non-cosmetic.  We try to put the output
      /* The following is non-cosmetic.  We try to put the output
         statements in some sort of reasonable order here, because they
         statements in some sort of reasonable order here, because they
         determine the final load addresses of the orphan sections.
         determine the final load addresses of the orphan sections.
         In addition, placing output statements in the wrong order may
         In addition, placing output statements in the wrong order may
         require extra segments.  For instance, given a typical
         require extra segments.  For instance, given a typical
         situation of all read-only sections placed in one segment and
         situation of all read-only sections placed in one segment and
         following that a segment containing all the read-write
         following that a segment containing all the read-write
         sections, we wouldn't want to place an orphan read/write
         sections, we wouldn't want to place an orphan read/write
         section before or amongst the read-only ones.  */
         section before or amongst the read-only ones.  */
      if (add.head != NULL)
      if (add.head != NULL)
        {
        {
          lang_output_section_statement_type *newly_added_os;
          lang_output_section_statement_type *newly_added_os;
 
 
          if (place->stmt == NULL)
          if (place->stmt == NULL)
            {
            {
              lang_statement_union_type **where = insert_os_after (after);
              lang_statement_union_type **where = insert_os_after (after);
 
 
              *add.tail = *where;
              *add.tail = *where;
              *where = add.head;
              *where = add.head;
 
 
              place->os_tail = &after->next;
              place->os_tail = &after->next;
            }
            }
          else
          else
            {
            {
              /* Put it after the last orphan statement we added.  */
              /* Put it after the last orphan statement we added.  */
              *add.tail = *place->stmt;
              *add.tail = *place->stmt;
              *place->stmt = add.head;
              *place->stmt = add.head;
            }
            }
 
 
          /* Fix the global list pointer if we happened to tack our
          /* Fix the global list pointer if we happened to tack our
             new list at the tail.  */
             new list at the tail.  */
          if (*old->tail == add.head)
          if (*old->tail == add.head)
            old->tail = add.tail;
            old->tail = add.tail;
 
 
          /* Save the end of this list.  */
          /* Save the end of this list.  */
          place->stmt = add.tail;
          place->stmt = add.tail;
 
 
          /* Do the same for the list of output section statements.  */
          /* Do the same for the list of output section statements.  */
          newly_added_os = *os_tail;
          newly_added_os = *os_tail;
          *os_tail = NULL;
          *os_tail = NULL;
          newly_added_os->prev = (lang_output_section_statement_type *)
          newly_added_os->prev = (lang_output_section_statement_type *)
            ((char *) place->os_tail
            ((char *) place->os_tail
             - offsetof (lang_output_section_statement_type, next));
             - offsetof (lang_output_section_statement_type, next));
          newly_added_os->next = *place->os_tail;
          newly_added_os->next = *place->os_tail;
          if (newly_added_os->next != NULL)
          if (newly_added_os->next != NULL)
            newly_added_os->next->prev = newly_added_os;
            newly_added_os->next->prev = newly_added_os;
          *place->os_tail = newly_added_os;
          *place->os_tail = newly_added_os;
          place->os_tail = &newly_added_os->next;
          place->os_tail = &newly_added_os->next;
 
 
          /* Fixing the global list pointer here is a little different.
          /* Fixing the global list pointer here is a little different.
             We added to the list in lang_enter_output_section_statement,
             We added to the list in lang_enter_output_section_statement,
             trimmed off the new output_section_statment above when
             trimmed off the new output_section_statment above when
             assigning *os_tail = NULL, but possibly added it back in
             assigning *os_tail = NULL, but possibly added it back in
             the same place when assigning *place->os_tail.  */
             the same place when assigning *place->os_tail.  */
          if (*os_tail == NULL)
          if (*os_tail == NULL)
            lang_output_section_statement.tail
            lang_output_section_statement.tail
              = (lang_statement_union_type **) os_tail;
              = (lang_statement_union_type **) os_tail;
        }
        }
    }
    }
  return os;
  return os;
}
}
 
 
static void
static void
lang_map_flags (flagword flag)
lang_map_flags (flagword flag)
{
{
  if (flag & SEC_ALLOC)
  if (flag & SEC_ALLOC)
    minfo ("a");
    minfo ("a");
 
 
  if (flag & SEC_CODE)
  if (flag & SEC_CODE)
    minfo ("x");
    minfo ("x");
 
 
  if (flag & SEC_READONLY)
  if (flag & SEC_READONLY)
    minfo ("r");
    minfo ("r");
 
 
  if (flag & SEC_DATA)
  if (flag & SEC_DATA)
    minfo ("w");
    minfo ("w");
 
 
  if (flag & SEC_LOAD)
  if (flag & SEC_LOAD)
    minfo ("l");
    minfo ("l");
}
}
 
 
void
void
lang_map (void)
lang_map (void)
{
{
  lang_memory_region_type *m;
  lang_memory_region_type *m;
  bfd_boolean dis_header_printed = FALSE;
  bfd_boolean dis_header_printed = FALSE;
  bfd *p;
  bfd *p;
 
 
  LANG_FOR_EACH_INPUT_STATEMENT (file)
  LANG_FOR_EACH_INPUT_STATEMENT (file)
    {
    {
      asection *s;
      asection *s;
 
 
      if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
      if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
          || file->just_syms_flag)
          || file->just_syms_flag)
        continue;
        continue;
 
 
      for (s = file->the_bfd->sections; s != NULL; s = s->next)
      for (s = file->the_bfd->sections; s != NULL; s = s->next)
        if ((s->output_section == NULL
        if ((s->output_section == NULL
             || s->output_section->owner != link_info.output_bfd)
             || s->output_section->owner != link_info.output_bfd)
            && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0)
            && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0)
          {
          {
            if (! dis_header_printed)
            if (! dis_header_printed)
              {
              {
                fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
                fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
                dis_header_printed = TRUE;
                dis_header_printed = TRUE;
              }
              }
 
 
            print_input_section (s);
            print_input_section (s);
          }
          }
    }
    }
 
 
  minfo (_("\nMemory Configuration\n\n"));
  minfo (_("\nMemory Configuration\n\n"));
  fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
  fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
           _("Name"), _("Origin"), _("Length"), _("Attributes"));
           _("Name"), _("Origin"), _("Length"), _("Attributes"));
 
 
  for (m = lang_memory_region_list; m != NULL; m = m->next)
  for (m = lang_memory_region_list; m != NULL; m = m->next)
    {
    {
      char buf[100];
      char buf[100];
      int len;
      int len;
 
 
      fprintf (config.map_file, "%-16s ", m->name);
      fprintf (config.map_file, "%-16s ", m->name);
 
 
      sprintf_vma (buf, m->origin);
      sprintf_vma (buf, m->origin);
      minfo ("0x%s ", buf);
      minfo ("0x%s ", buf);
      len = strlen (buf);
      len = strlen (buf);
      while (len < 16)
      while (len < 16)
        {
        {
          print_space ();
          print_space ();
          ++len;
          ++len;
        }
        }
 
 
      minfo ("0x%V", m->length);
      minfo ("0x%V", m->length);
      if (m->flags || m->not_flags)
      if (m->flags || m->not_flags)
        {
        {
#ifndef BFD64
#ifndef BFD64
          minfo ("        ");
          minfo ("        ");
#endif
#endif
          if (m->flags)
          if (m->flags)
            {
            {
              print_space ();
              print_space ();
              lang_map_flags (m->flags);
              lang_map_flags (m->flags);
            }
            }
 
 
          if (m->not_flags)
          if (m->not_flags)
            {
            {
              minfo (" !");
              minfo (" !");
              lang_map_flags (m->not_flags);
              lang_map_flags (m->not_flags);
            }
            }
        }
        }
 
 
      print_nl ();
      print_nl ();
    }
    }
 
 
  fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
  fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
 
 
  if (! link_info.reduce_memory_overheads)
  if (! link_info.reduce_memory_overheads)
    {
    {
      obstack_begin (&map_obstack, 1000);
      obstack_begin (&map_obstack, 1000);
      for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
      for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
        bfd_map_over_sections (p, init_map_userdata, 0);
        bfd_map_over_sections (p, init_map_userdata, 0);
      bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
      bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
    }
    }
  lang_statement_iteration ++;
  lang_statement_iteration ++;
  print_statements ();
  print_statements ();
}
}
 
 
static void
static void
init_map_userdata (abfd, sec, data)
init_map_userdata (abfd, sec, data)
     bfd *abfd ATTRIBUTE_UNUSED;
     bfd *abfd ATTRIBUTE_UNUSED;
     asection *sec;
     asection *sec;
     void *data ATTRIBUTE_UNUSED;
     void *data ATTRIBUTE_UNUSED;
{
{
  fat_section_userdata_type *new_data
  fat_section_userdata_type *new_data
    = ((fat_section_userdata_type *) (stat_alloc
    = ((fat_section_userdata_type *) (stat_alloc
                                      (sizeof (fat_section_userdata_type))));
                                      (sizeof (fat_section_userdata_type))));
 
 
  ASSERT (get_userdata (sec) == NULL);
  ASSERT (get_userdata (sec) == NULL);
  get_userdata (sec) = new_data;
  get_userdata (sec) = new_data;
  new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
  new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
}
}
 
 
static bfd_boolean
static bfd_boolean
sort_def_symbol (hash_entry, info)
sort_def_symbol (hash_entry, info)
     struct bfd_link_hash_entry *hash_entry;
     struct bfd_link_hash_entry *hash_entry;
     void *info ATTRIBUTE_UNUSED;
     void *info ATTRIBUTE_UNUSED;
{
{
  if (hash_entry->type == bfd_link_hash_defined
  if (hash_entry->type == bfd_link_hash_defined
      || hash_entry->type == bfd_link_hash_defweak)
      || hash_entry->type == bfd_link_hash_defweak)
    {
    {
      struct fat_user_section_struct *ud;
      struct fat_user_section_struct *ud;
      struct map_symbol_def *def;
      struct map_symbol_def *def;
 
 
      ud = get_userdata (hash_entry->u.def.section);
      ud = get_userdata (hash_entry->u.def.section);
      if  (! ud)
      if  (! ud)
        {
        {
          /* ??? What do we have to do to initialize this beforehand?  */
          /* ??? What do we have to do to initialize this beforehand?  */
          /* The first time we get here is bfd_abs_section...  */
          /* The first time we get here is bfd_abs_section...  */
          init_map_userdata (0, hash_entry->u.def.section, 0);
          init_map_userdata (0, hash_entry->u.def.section, 0);
          ud = get_userdata (hash_entry->u.def.section);
          ud = get_userdata (hash_entry->u.def.section);
        }
        }
      else if  (!ud->map_symbol_def_tail)
      else if  (!ud->map_symbol_def_tail)
        ud->map_symbol_def_tail = &ud->map_symbol_def_head;
        ud->map_symbol_def_tail = &ud->map_symbol_def_head;
 
 
      def = obstack_alloc (&map_obstack, sizeof *def);
      def = obstack_alloc (&map_obstack, sizeof *def);
      def->entry = hash_entry;
      def->entry = hash_entry;
      *(ud->map_symbol_def_tail) = def;
      *(ud->map_symbol_def_tail) = def;
      ud->map_symbol_def_tail = &def->next;
      ud->map_symbol_def_tail = &def->next;
    }
    }
  return TRUE;
  return TRUE;
}
}
 
 
/* Initialize an output section.  */
/* Initialize an output section.  */
 
 
static void
static void
init_os (lang_output_section_statement_type *s, asection *isec,
init_os (lang_output_section_statement_type *s, asection *isec,
         flagword flags)
         flagword flags)
{
{
  if (s->bfd_section != NULL)
  if (s->bfd_section != NULL)
    return;
    return;
 
 
  if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
  if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
    einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
    einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
 
 
  s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);
  s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);
  if (s->bfd_section == NULL)
  if (s->bfd_section == NULL)
    s->bfd_section = bfd_make_section_with_flags (link_info.output_bfd,
    s->bfd_section = bfd_make_section_with_flags (link_info.output_bfd,
                                                  s->name, flags);
                                                  s->name, flags);
  if (s->bfd_section == NULL)
  if (s->bfd_section == NULL)
    {
    {
      einfo (_("%P%F: output format %s cannot represent section called %s\n"),
      einfo (_("%P%F: output format %s cannot represent section called %s\n"),
             link_info.output_bfd->xvec->name, s->name);
             link_info.output_bfd->xvec->name, s->name);
    }
    }
  s->bfd_section->output_section = s->bfd_section;
  s->bfd_section->output_section = s->bfd_section;
  s->bfd_section->output_offset = 0;
  s->bfd_section->output_offset = 0;
 
 
  if (!link_info.reduce_memory_overheads)
  if (!link_info.reduce_memory_overheads)
    {
    {
      fat_section_userdata_type *new
      fat_section_userdata_type *new
        = stat_alloc (sizeof (fat_section_userdata_type));
        = stat_alloc (sizeof (fat_section_userdata_type));
      memset (new, 0, sizeof (fat_section_userdata_type));
      memset (new, 0, sizeof (fat_section_userdata_type));
      get_userdata (s->bfd_section) = new;
      get_userdata (s->bfd_section) = new;
    }
    }
 
 
  /* If there is a base address, make sure that any sections it might
  /* If there is a base address, make sure that any sections it might
     mention are initialized.  */
     mention are initialized.  */
  if (s->addr_tree != NULL)
  if (s->addr_tree != NULL)
    exp_init_os (s->addr_tree);
    exp_init_os (s->addr_tree);
 
 
  if (s->load_base != NULL)
  if (s->load_base != NULL)
    exp_init_os (s->load_base);
    exp_init_os (s->load_base);
 
 
  /* If supplied an alignment, set it.  */
  /* If supplied an alignment, set it.  */
  if (s->section_alignment != -1)
  if (s->section_alignment != -1)
    s->bfd_section->alignment_power = s->section_alignment;
    s->bfd_section->alignment_power = s->section_alignment;
 
 
  if (isec)
  if (isec)
    bfd_init_private_section_data (isec->owner, isec,
    bfd_init_private_section_data (isec->owner, isec,
                                   link_info.output_bfd, s->bfd_section,
                                   link_info.output_bfd, s->bfd_section,
                                   &link_info);
                                   &link_info);
}
}
 
 
/* Make sure that all output sections mentioned in an expression are
/* Make sure that all output sections mentioned in an expression are
   initialized.  */
   initialized.  */
 
 
static void
static void
exp_init_os (etree_type *exp)
exp_init_os (etree_type *exp)
{
{
  switch (exp->type.node_class)
  switch (exp->type.node_class)
    {
    {
    case etree_assign:
    case etree_assign:
    case etree_provide:
    case etree_provide:
      exp_init_os (exp->assign.src);
      exp_init_os (exp->assign.src);
      break;
      break;
 
 
    case etree_binary:
    case etree_binary:
      exp_init_os (exp->binary.lhs);
      exp_init_os (exp->binary.lhs);
      exp_init_os (exp->binary.rhs);
      exp_init_os (exp->binary.rhs);
      break;
      break;
 
 
    case etree_trinary:
    case etree_trinary:
      exp_init_os (exp->trinary.cond);
      exp_init_os (exp->trinary.cond);
      exp_init_os (exp->trinary.lhs);
      exp_init_os (exp->trinary.lhs);
      exp_init_os (exp->trinary.rhs);
      exp_init_os (exp->trinary.rhs);
      break;
      break;
 
 
    case etree_assert:
    case etree_assert:
      exp_init_os (exp->assert_s.child);
      exp_init_os (exp->assert_s.child);
      break;
      break;
 
 
    case etree_unary:
    case etree_unary:
      exp_init_os (exp->unary.child);
      exp_init_os (exp->unary.child);
      break;
      break;
 
 
    case etree_name:
    case etree_name:
      switch (exp->type.node_code)
      switch (exp->type.node_code)
        {
        {
        case ADDR:
        case ADDR:
        case LOADADDR:
        case LOADADDR:
        case SIZEOF:
        case SIZEOF:
          {
          {
            lang_output_section_statement_type *os;
            lang_output_section_statement_type *os;
 
 
            os = lang_output_section_find (exp->name.name);
            os = lang_output_section_find (exp->name.name);
            if (os != NULL && os->bfd_section == NULL)
            if (os != NULL && os->bfd_section == NULL)
              init_os (os, NULL, 0);
              init_os (os, NULL, 0);
          }
          }
        }
        }
      break;
      break;
 
 
    default:
    default:
      break;
      break;
    }
    }
}
}


static void
static void
section_already_linked (bfd *abfd, asection *sec, void *data)
section_already_linked (bfd *abfd, asection *sec, void *data)
{
{
  lang_input_statement_type *entry = data;
  lang_input_statement_type *entry = data;
 
 
  /* If we are only reading symbols from this object, then we want to
  /* If we are only reading symbols from this object, then we want to
     discard all sections.  */
     discard all sections.  */
  if (entry->just_syms_flag)
  if (entry->just_syms_flag)
    {
    {
      bfd_link_just_syms (abfd, sec, &link_info);
      bfd_link_just_syms (abfd, sec, &link_info);
      return;
      return;
    }
    }
 
 
  if (!(abfd->flags & DYNAMIC))
  if (!(abfd->flags & DYNAMIC))
    bfd_section_already_linked (abfd, sec, &link_info);
    bfd_section_already_linked (abfd, sec, &link_info);
}
}


/* The wild routines.
/* The wild routines.
 
 
   These expand statements like *(.text) and foo.o to a list of
   These expand statements like *(.text) and foo.o to a list of
   explicit actions, like foo.o(.text), bar.o(.text) and
   explicit actions, like foo.o(.text), bar.o(.text) and
   foo.o(.text, .data).  */
   foo.o(.text, .data).  */
 
 
/* Add SECTION to the output section OUTPUT.  Do this by creating a
/* Add SECTION to the output section OUTPUT.  Do this by creating a
   lang_input_section statement which is placed at PTR.  FILE is the
   lang_input_section statement which is placed at PTR.  FILE is the
   input file which holds SECTION.  */
   input file which holds SECTION.  */
 
 
void
void
lang_add_section (lang_statement_list_type *ptr,
lang_add_section (lang_statement_list_type *ptr,
                  asection *section,
                  asection *section,
                  lang_output_section_statement_type *output)
                  lang_output_section_statement_type *output)
{
{
  flagword flags = section->flags;
  flagword flags = section->flags;
  bfd_boolean discard;
  bfd_boolean discard;
 
 
  /* Discard sections marked with SEC_EXCLUDE.  */
  /* Discard sections marked with SEC_EXCLUDE.  */
  discard = (flags & SEC_EXCLUDE) != 0;
  discard = (flags & SEC_EXCLUDE) != 0;
 
 
  /* Discard input sections which are assigned to a section named
  /* Discard input sections which are assigned to a section named
     DISCARD_SECTION_NAME.  */
     DISCARD_SECTION_NAME.  */
  if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
  if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
    discard = TRUE;
    discard = TRUE;
 
 
  /* Discard debugging sections if we are stripping debugging
  /* Discard debugging sections if we are stripping debugging
     information.  */
     information.  */
  if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
  if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
      && (flags & SEC_DEBUGGING) != 0)
      && (flags & SEC_DEBUGGING) != 0)
    discard = TRUE;
    discard = TRUE;
 
 
  if (discard)
  if (discard)
    {
    {
      if (section->output_section == NULL)
      if (section->output_section == NULL)
        {
        {
          /* This prevents future calls from assigning this section.  */
          /* This prevents future calls from assigning this section.  */
          section->output_section = bfd_abs_section_ptr;
          section->output_section = bfd_abs_section_ptr;
        }
        }
      return;
      return;
    }
    }
 
 
  if (section->output_section == NULL)
  if (section->output_section == NULL)
    {
    {
      bfd_boolean first;
      bfd_boolean first;
      lang_input_section_type *new;
      lang_input_section_type *new;
      flagword flags;
      flagword flags;
 
 
      flags = section->flags;
      flags = section->flags;
 
 
      /* We don't copy the SEC_NEVER_LOAD flag from an input section
      /* We don't copy the SEC_NEVER_LOAD flag from an input section
         to an output section, because we want to be able to include a
         to an output section, because we want to be able to include a
         SEC_NEVER_LOAD section in the middle of an otherwise loaded
         SEC_NEVER_LOAD section in the middle of an otherwise loaded
         section (I don't know why we want to do this, but we do).
         section (I don't know why we want to do this, but we do).
         build_link_order in ldwrite.c handles this case by turning
         build_link_order in ldwrite.c handles this case by turning
         the embedded SEC_NEVER_LOAD section into a fill.  */
         the embedded SEC_NEVER_LOAD section into a fill.  */
 
 
      flags &= ~ SEC_NEVER_LOAD;
      flags &= ~ SEC_NEVER_LOAD;
 
 
      switch (output->sectype)
      switch (output->sectype)
        {
        {
        case normal_section:
        case normal_section:
        case overlay_section:
        case overlay_section:
          break;
          break;
        case noalloc_section:
        case noalloc_section:
          flags &= ~SEC_ALLOC;
          flags &= ~SEC_ALLOC;
          break;
          break;
        case noload_section:
        case noload_section:
          flags &= ~SEC_LOAD;
          flags &= ~SEC_LOAD;
          flags |= SEC_NEVER_LOAD;
          flags |= SEC_NEVER_LOAD;
          break;
          break;
        }
        }
 
 
      if (output->bfd_section == NULL)
      if (output->bfd_section == NULL)
        init_os (output, section, flags);
        init_os (output, section, flags);
 
 
      first = ! output->bfd_section->linker_has_input;
      first = ! output->bfd_section->linker_has_input;
      output->bfd_section->linker_has_input = 1;
      output->bfd_section->linker_has_input = 1;
 
 
      if (!link_info.relocatable
      if (!link_info.relocatable
          && !stripped_excluded_sections)
          && !stripped_excluded_sections)
        {
        {
          asection *s = output->bfd_section->map_tail.s;
          asection *s = output->bfd_section->map_tail.s;
          output->bfd_section->map_tail.s = section;
          output->bfd_section->map_tail.s = section;
          section->map_head.s = NULL;
          section->map_head.s = NULL;
          section->map_tail.s = s;
          section->map_tail.s = s;
          if (s != NULL)
          if (s != NULL)
            s->map_head.s = section;
            s->map_head.s = section;
          else
          else
            output->bfd_section->map_head.s = section;
            output->bfd_section->map_head.s = section;
        }
        }
 
 
      /* Add a section reference to the list.  */
      /* Add a section reference to the list.  */
      new = new_stat (lang_input_section, ptr);
      new = new_stat (lang_input_section, ptr);
 
 
      new->section = section;
      new->section = section;
      section->output_section = output->bfd_section;
      section->output_section = output->bfd_section;
 
 
      /* If final link, don't copy the SEC_LINK_ONCE flags, they've
      /* If final link, don't copy the SEC_LINK_ONCE flags, they've
         already been processed.  One reason to do this is that on pe
         already been processed.  One reason to do this is that on pe
         format targets, .text$foo sections go into .text and it's odd
         format targets, .text$foo sections go into .text and it's odd
         to see .text with SEC_LINK_ONCE set.  */
         to see .text with SEC_LINK_ONCE set.  */
 
 
      if (! link_info.relocatable)
      if (! link_info.relocatable)
        flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
        flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
 
 
      /* If this is not the first input section, and the SEC_READONLY
      /* If this is not the first input section, and the SEC_READONLY
         flag is not currently set, then don't set it just because the
         flag is not currently set, then don't set it just because the
         input section has it set.  */
         input section has it set.  */
 
 
      if (! first && (output->bfd_section->flags & SEC_READONLY) == 0)
      if (! first && (output->bfd_section->flags & SEC_READONLY) == 0)
        flags &= ~ SEC_READONLY;
        flags &= ~ SEC_READONLY;
 
 
      /* Keep SEC_MERGE and SEC_STRINGS only if they are the same.  */
      /* Keep SEC_MERGE and SEC_STRINGS only if they are the same.  */
      if (! first
      if (! first
          && ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
          && ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
              != (flags & (SEC_MERGE | SEC_STRINGS))
              != (flags & (SEC_MERGE | SEC_STRINGS))
              || ((flags & SEC_MERGE)
              || ((flags & SEC_MERGE)
                  && output->bfd_section->entsize != section->entsize)))
                  && output->bfd_section->entsize != section->entsize)))
        {
        {
          output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
          output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
          flags &= ~ (SEC_MERGE | SEC_STRINGS);
          flags &= ~ (SEC_MERGE | SEC_STRINGS);
        }
        }
 
 
      output->bfd_section->flags |= flags;
      output->bfd_section->flags |= flags;
 
 
      if (flags & SEC_MERGE)
      if (flags & SEC_MERGE)
        output->bfd_section->entsize = section->entsize;
        output->bfd_section->entsize = section->entsize;
 
 
      /* If SEC_READONLY is not set in the input section, then clear
      /* If SEC_READONLY is not set in the input section, then clear
         it from the output section.  */
         it from the output section.  */
      if ((section->flags & SEC_READONLY) == 0)
      if ((section->flags & SEC_READONLY) == 0)
        output->bfd_section->flags &= ~SEC_READONLY;
        output->bfd_section->flags &= ~SEC_READONLY;
 
 
      /* Copy over SEC_SMALL_DATA.  */
      /* Copy over SEC_SMALL_DATA.  */
      if (section->flags & SEC_SMALL_DATA)
      if (section->flags & SEC_SMALL_DATA)
        output->bfd_section->flags |= SEC_SMALL_DATA;
        output->bfd_section->flags |= SEC_SMALL_DATA;
 
 
      if (section->alignment_power > output->bfd_section->alignment_power)
      if (section->alignment_power > output->bfd_section->alignment_power)
        output->bfd_section->alignment_power = section->alignment_power;
        output->bfd_section->alignment_power = section->alignment_power;
 
 
      if (bfd_get_arch (section->owner) == bfd_arch_tic54x
      if (bfd_get_arch (section->owner) == bfd_arch_tic54x
          && (section->flags & SEC_TIC54X_BLOCK) != 0)
          && (section->flags & SEC_TIC54X_BLOCK) != 0)
        {
        {
          output->bfd_section->flags |= SEC_TIC54X_BLOCK;
          output->bfd_section->flags |= SEC_TIC54X_BLOCK;
          /* FIXME: This value should really be obtained from the bfd...  */
          /* FIXME: This value should really be obtained from the bfd...  */
          output->block_value = 128;
          output->block_value = 128;
        }
        }
    }
    }
}
}
 
 
/* Handle wildcard sorting.  This returns the lang_input_section which
/* Handle wildcard sorting.  This returns the lang_input_section which
   should follow the one we are going to create for SECTION and FILE,
   should follow the one we are going to create for SECTION and FILE,
   based on the sorting requirements of WILD.  It returns NULL if the
   based on the sorting requirements of WILD.  It returns NULL if the
   new section should just go at the end of the current list.  */
   new section should just go at the end of the current list.  */
 
 
static lang_statement_union_type *
static lang_statement_union_type *
wild_sort (lang_wild_statement_type *wild,
wild_sort (lang_wild_statement_type *wild,
           struct wildcard_list *sec,
           struct wildcard_list *sec,
           lang_input_statement_type *file,
           lang_input_statement_type *file,
           asection *section)
           asection *section)
{
{
  const char *section_name;
  const char *section_name;
  lang_statement_union_type *l;
  lang_statement_union_type *l;
 
 
  if (!wild->filenames_sorted
  if (!wild->filenames_sorted
      && (sec == NULL || sec->spec.sorted == none))
      && (sec == NULL || sec->spec.sorted == none))
    return NULL;
    return NULL;
 
 
  section_name = bfd_get_section_name (file->the_bfd, section);
  section_name = bfd_get_section_name (file->the_bfd, section);
  for (l = wild->children.head; l != NULL; l = l->header.next)
  for (l = wild->children.head; l != NULL; l = l->header.next)
    {
    {
      lang_input_section_type *ls;
      lang_input_section_type *ls;
 
 
      if (l->header.type != lang_input_section_enum)
      if (l->header.type != lang_input_section_enum)
        continue;
        continue;
      ls = &l->input_section;
      ls = &l->input_section;
 
 
      /* Sorting by filename takes precedence over sorting by section
      /* Sorting by filename takes precedence over sorting by section
         name.  */
         name.  */
 
 
      if (wild->filenames_sorted)
      if (wild->filenames_sorted)
        {
        {
          const char *fn, *ln;
          const char *fn, *ln;
          bfd_boolean fa, la;
          bfd_boolean fa, la;
          int i;
          int i;
 
 
          /* The PE support for the .idata section as generated by
          /* The PE support for the .idata section as generated by
             dlltool assumes that files will be sorted by the name of
             dlltool assumes that files will be sorted by the name of
             the archive and then the name of the file within the
             the archive and then the name of the file within the
             archive.  */
             archive.  */
 
 
          if (file->the_bfd != NULL
          if (file->the_bfd != NULL
              && bfd_my_archive (file->the_bfd) != NULL)
              && bfd_my_archive (file->the_bfd) != NULL)
            {
            {
              fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
              fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
              fa = TRUE;
              fa = TRUE;
            }
            }
          else
          else
            {
            {
              fn = file->filename;
              fn = file->filename;
              fa = FALSE;
              fa = FALSE;
            }
            }
 
 
          if (bfd_my_archive (ls->section->owner) != NULL)
          if (bfd_my_archive (ls->section->owner) != NULL)
            {
            {
              ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
              ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
              la = TRUE;
              la = TRUE;
            }
            }
          else
          else
            {
            {
              ln = ls->section->owner->filename;
              ln = ls->section->owner->filename;
              la = FALSE;
              la = FALSE;
            }
            }
 
 
          i = strcmp (fn, ln);
          i = strcmp (fn, ln);
          if (i > 0)
          if (i > 0)
            continue;
            continue;
          else if (i < 0)
          else if (i < 0)
            break;
            break;
 
 
          if (fa || la)
          if (fa || la)
            {
            {
              if (fa)
              if (fa)
                fn = file->filename;
                fn = file->filename;
              if (la)
              if (la)
                ln = ls->section->owner->filename;
                ln = ls->section->owner->filename;
 
 
              i = strcmp (fn, ln);
              i = strcmp (fn, ln);
              if (i > 0)
              if (i > 0)
                continue;
                continue;
              else if (i < 0)
              else if (i < 0)
                break;
                break;
            }
            }
        }
        }
 
 
      /* Here either the files are not sorted by name, or we are
      /* Here either the files are not sorted by name, or we are
         looking at the sections for this file.  */
         looking at the sections for this file.  */
 
 
      if (sec != NULL && sec->spec.sorted != none)
      if (sec != NULL && sec->spec.sorted != none)
        if (compare_section (sec->spec.sorted, section, ls->section) < 0)
        if (compare_section (sec->spec.sorted, section, ls->section) < 0)
          break;
          break;
    }
    }
 
 
  return l;
  return l;
}
}
 
 
/* Expand a wild statement for a particular FILE.  SECTION may be
/* Expand a wild statement for a particular FILE.  SECTION may be
   NULL, in which case it is a wild card.  */
   NULL, in which case it is a wild card.  */
 
 
static void
static void
output_section_callback (lang_wild_statement_type *ptr,
output_section_callback (lang_wild_statement_type *ptr,
                         struct wildcard_list *sec,
                         struct wildcard_list *sec,
                         asection *section,
                         asection *section,
                         lang_input_statement_type *file,
                         lang_input_statement_type *file,
                         void *output)
                         void *output)
{
{
  lang_statement_union_type *before;
  lang_statement_union_type *before;
 
 
  /* Exclude sections that match UNIQUE_SECTION_LIST.  */
  /* Exclude sections that match UNIQUE_SECTION_LIST.  */
  if (unique_section_p (section))
  if (unique_section_p (section))
    return;
    return;
 
 
  before = wild_sort (ptr, sec, file, section);
  before = wild_sort (ptr, sec, file, section);
 
 
  /* Here BEFORE points to the lang_input_section which
  /* Here BEFORE points to the lang_input_section which
     should follow the one we are about to add.  If BEFORE
     should follow the one we are about to add.  If BEFORE
     is NULL, then the section should just go at the end
     is NULL, then the section should just go at the end
     of the current list.  */
     of the current list.  */
 
 
  if (before == NULL)
  if (before == NULL)
    lang_add_section (&ptr->children, section,
    lang_add_section (&ptr->children, section,
                      (lang_output_section_statement_type *) output);
                      (lang_output_section_statement_type *) output);
  else
  else
    {
    {
      lang_statement_list_type list;
      lang_statement_list_type list;
      lang_statement_union_type **pp;
      lang_statement_union_type **pp;
 
 
      lang_list_init (&list);
      lang_list_init (&list);
      lang_add_section (&list, section,
      lang_add_section (&list, section,
                        (lang_output_section_statement_type *) output);
                        (lang_output_section_statement_type *) output);
 
 
      /* If we are discarding the section, LIST.HEAD will
      /* If we are discarding the section, LIST.HEAD will
         be NULL.  */
         be NULL.  */
      if (list.head != NULL)
      if (list.head != NULL)
        {
        {
          ASSERT (list.head->header.next == NULL);
          ASSERT (list.head->header.next == NULL);
 
 
          for (pp = &ptr->children.head;
          for (pp = &ptr->children.head;
               *pp != before;
               *pp != before;
               pp = &(*pp)->header.next)
               pp = &(*pp)->header.next)
            ASSERT (*pp != NULL);
            ASSERT (*pp != NULL);
 
 
          list.head->header.next = *pp;
          list.head->header.next = *pp;
          *pp = list.head;
          *pp = list.head;
        }
        }
    }
    }
}
}
 
 
/* Check if all sections in a wild statement for a particular FILE
/* Check if all sections in a wild statement for a particular FILE
   are readonly.  */
   are readonly.  */
 
 
static void
static void
check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
                        struct wildcard_list *sec ATTRIBUTE_UNUSED,
                        struct wildcard_list *sec ATTRIBUTE_UNUSED,
                        asection *section,
                        asection *section,
                        lang_input_statement_type *file ATTRIBUTE_UNUSED,
                        lang_input_statement_type *file ATTRIBUTE_UNUSED,
                        void *data)
                        void *data)
{
{
  /* Exclude sections that match UNIQUE_SECTION_LIST.  */
  /* Exclude sections that match UNIQUE_SECTION_LIST.  */
  if (unique_section_p (section))
  if (unique_section_p (section))
    return;
    return;
 
 
  if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
  if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
    ((lang_output_section_statement_type *) data)->all_input_readonly = FALSE;
    ((lang_output_section_statement_type *) data)->all_input_readonly = FALSE;
}
}
 
 
/* This is passed a file name which must have been seen already and
/* This is passed a file name which must have been seen already and
   added to the statement tree.  We will see if it has been opened
   added to the statement tree.  We will see if it has been opened
   already and had its symbols read.  If not then we'll read it.  */
   already and had its symbols read.  If not then we'll read it.  */
 
 
static lang_input_statement_type *
static lang_input_statement_type *
lookup_name (const char *name)
lookup_name (const char *name)
{
{
  lang_input_statement_type *search;
  lang_input_statement_type *search;
 
 
  for (search = (lang_input_statement_type *) input_file_chain.head;
  for (search = (lang_input_statement_type *) input_file_chain.head;
       search != NULL;
       search != NULL;
       search = (lang_input_statement_type *) search->next_real_file)
       search = (lang_input_statement_type *) search->next_real_file)
    {
    {
      /* Use the local_sym_name as the name of the file that has
      /* Use the local_sym_name as the name of the file that has
         already been loaded as filename might have been transformed
         already been loaded as filename might have been transformed
         via the search directory lookup mechanism.  */
         via the search directory lookup mechanism.  */
      const char *filename = search->local_sym_name;
      const char *filename = search->local_sym_name;
 
 
      if (filename != NULL
      if (filename != NULL
          && strcmp (filename, name) == 0)
          && strcmp (filename, name) == 0)
        break;
        break;
    }
    }
 
 
  if (search == NULL)
  if (search == NULL)
    search = new_afile (name, lang_input_file_is_search_file_enum,
    search = new_afile (name, lang_input_file_is_search_file_enum,
                        default_target, FALSE);
                        default_target, FALSE);
 
 
  /* If we have already added this file, or this file is not real
  /* If we have already added this file, or this file is not real
     don't add this file.  */
     don't add this file.  */
  if (search->loaded || !search->real)
  if (search->loaded || !search->real)
    return search;
    return search;
 
 
  if (! load_symbols (search, NULL))
  if (! load_symbols (search, NULL))
    return NULL;
    return NULL;
 
 
  return search;
  return search;
}
}
 
 
/* Save LIST as a list of libraries whose symbols should not be exported.  */
/* Save LIST as a list of libraries whose symbols should not be exported.  */
 
 
struct excluded_lib
struct excluded_lib
{
{
  char *name;
  char *name;
  struct excluded_lib *next;
  struct excluded_lib *next;
};
};
static struct excluded_lib *excluded_libs;
static struct excluded_lib *excluded_libs;
 
 
void
void
add_excluded_libs (const char *list)
add_excluded_libs (const char *list)
{
{
  const char *p = list, *end;
  const char *p = list, *end;
 
 
  while (*p != '\0')
  while (*p != '\0')
    {
    {
      struct excluded_lib *entry;
      struct excluded_lib *entry;
      end = strpbrk (p, ",:");
      end = strpbrk (p, ",:");
      if (end == NULL)
      if (end == NULL)
        end = p + strlen (p);
        end = p + strlen (p);
      entry = xmalloc (sizeof (*entry));
      entry = xmalloc (sizeof (*entry));
      entry->next = excluded_libs;
      entry->next = excluded_libs;
      entry->name = xmalloc (end - p + 1);
      entry->name = xmalloc (end - p + 1);
      memcpy (entry->name, p, end - p);
      memcpy (entry->name, p, end - p);
      entry->name[end - p] = '\0';
      entry->name[end - p] = '\0';
      excluded_libs = entry;
      excluded_libs = entry;
      if (*end == '\0')
      if (*end == '\0')
        break;
        break;
      p = end + 1;
      p = end + 1;
    }
    }
}
}
 
 
static void
static void
check_excluded_libs (bfd *abfd)
check_excluded_libs (bfd *abfd)
{
{
  struct excluded_lib *lib = excluded_libs;
  struct excluded_lib *lib = excluded_libs;
 
 
  while (lib)
  while (lib)
    {
    {
      int len = strlen (lib->name);
      int len = strlen (lib->name);
      const char *filename = lbasename (abfd->filename);
      const char *filename = lbasename (abfd->filename);
 
 
      if (strcmp (lib->name, "ALL") == 0)
      if (strcmp (lib->name, "ALL") == 0)
        {
        {
          abfd->no_export = TRUE;
          abfd->no_export = TRUE;
          return;
          return;
        }
        }
 
 
      if (strncmp (lib->name, filename, len) == 0
      if (strncmp (lib->name, filename, len) == 0
          && (filename[len] == '\0'
          && (filename[len] == '\0'
              || (filename[len] == '.' && filename[len + 1] == 'a'
              || (filename[len] == '.' && filename[len + 1] == 'a'
                  && filename[len + 2] == '\0')))
                  && filename[len + 2] == '\0')))
        {
        {
          abfd->no_export = TRUE;
          abfd->no_export = TRUE;
          return;
          return;
        }
        }
 
 
      lib = lib->next;
      lib = lib->next;
    }
    }
}
}
 
 
/* Get the symbols for an input file.  */
/* Get the symbols for an input file.  */
 
 
bfd_boolean
bfd_boolean
load_symbols (lang_input_statement_type *entry,
load_symbols (lang_input_statement_type *entry,
              lang_statement_list_type *place)
              lang_statement_list_type *place)
{
{
  char **matching;
  char **matching;
 
 
  if (entry->loaded)
  if (entry->loaded)
    return TRUE;
    return TRUE;
 
 
  ldfile_open_file (entry);
  ldfile_open_file (entry);
 
 
  if (! bfd_check_format (entry->the_bfd, bfd_archive)
  if (! bfd_check_format (entry->the_bfd, bfd_archive)
      && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
      && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
    {
    {
      bfd_error_type err;
      bfd_error_type err;
      lang_statement_list_type *hold;
      lang_statement_list_type *hold;
      bfd_boolean bad_load = TRUE;
      bfd_boolean bad_load = TRUE;
      bfd_boolean save_ldlang_sysrooted_script;
      bfd_boolean save_ldlang_sysrooted_script;
      bfd_boolean save_as_needed, save_add_needed;
      bfd_boolean save_as_needed, save_add_needed;
 
 
      err = bfd_get_error ();
      err = bfd_get_error ();
 
 
      /* See if the emulation has some special knowledge.  */
      /* See if the emulation has some special knowledge.  */
      if (ldemul_unrecognized_file (entry))
      if (ldemul_unrecognized_file (entry))
        return TRUE;
        return TRUE;
 
 
      if (err == bfd_error_file_ambiguously_recognized)
      if (err == bfd_error_file_ambiguously_recognized)
        {
        {
          char **p;
          char **p;
 
 
          einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
          einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
          einfo (_("%B: matching formats:"), entry->the_bfd);
          einfo (_("%B: matching formats:"), entry->the_bfd);
          for (p = matching; *p != NULL; p++)
          for (p = matching; *p != NULL; p++)
            einfo (" %s", *p);
            einfo (" %s", *p);
          einfo ("%F\n");
          einfo ("%F\n");
        }
        }
      else if (err != bfd_error_file_not_recognized
      else if (err != bfd_error_file_not_recognized
               || place == NULL)
               || place == NULL)
          einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
          einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
      else
      else
        bad_load = FALSE;
        bad_load = FALSE;
 
 
      bfd_close (entry->the_bfd);
      bfd_close (entry->the_bfd);
      entry->the_bfd = NULL;
      entry->the_bfd = NULL;
 
 
      /* Try to interpret the file as a linker script.  */
      /* Try to interpret the file as a linker script.  */
      ldfile_open_command_file (entry->filename);
      ldfile_open_command_file (entry->filename);
 
 
      hold = stat_ptr;
      hold = stat_ptr;
      stat_ptr = place;
      stat_ptr = place;
      save_ldlang_sysrooted_script = ldlang_sysrooted_script;
      save_ldlang_sysrooted_script = ldlang_sysrooted_script;
      ldlang_sysrooted_script = entry->sysrooted;
      ldlang_sysrooted_script = entry->sysrooted;
      save_as_needed = as_needed;
      save_as_needed = as_needed;
      as_needed = entry->as_needed;
      as_needed = entry->as_needed;
      save_add_needed = add_needed;
      save_add_needed = add_needed;
      add_needed = entry->add_needed;
      add_needed = entry->add_needed;
 
 
      ldfile_assumed_script = TRUE;
      ldfile_assumed_script = TRUE;
      parser_input = input_script;
      parser_input = input_script;
      /* We want to use the same -Bdynamic/-Bstatic as the one for
      /* We want to use the same -Bdynamic/-Bstatic as the one for
         ENTRY.  */
         ENTRY.  */
      config.dynamic_link = entry->dynamic;
      config.dynamic_link = entry->dynamic;
      yyparse ();
      yyparse ();
      ldfile_assumed_script = FALSE;
      ldfile_assumed_script = FALSE;
 
 
      ldlang_sysrooted_script = save_ldlang_sysrooted_script;
      ldlang_sysrooted_script = save_ldlang_sysrooted_script;
      as_needed = save_as_needed;
      as_needed = save_as_needed;
      add_needed = save_add_needed;
      add_needed = save_add_needed;
      stat_ptr = hold;
      stat_ptr = hold;
 
 
      return ! bad_load;
      return ! bad_load;
    }
    }
 
 
  if (ldemul_recognized_file (entry))
  if (ldemul_recognized_file (entry))
    return TRUE;
    return TRUE;
 
 
  /* We don't call ldlang_add_file for an archive.  Instead, the
  /* We don't call ldlang_add_file for an archive.  Instead, the
     add_symbols entry point will call ldlang_add_file, via the
     add_symbols entry point will call ldlang_add_file, via the
     add_archive_element callback, for each element of the archive
     add_archive_element callback, for each element of the archive
     which is used.  */
     which is used.  */
  switch (bfd_get_format (entry->the_bfd))
  switch (bfd_get_format (entry->the_bfd))
    {
    {
    default:
    default:
      break;
      break;
 
 
    case bfd_object:
    case bfd_object:
      ldlang_add_file (entry);
      ldlang_add_file (entry);
      if (trace_files || trace_file_tries)
      if (trace_files || trace_file_tries)
        info_msg ("%I\n", entry);
        info_msg ("%I\n", entry);
      break;
      break;
 
 
    case bfd_archive:
    case bfd_archive:
      check_excluded_libs (entry->the_bfd);
      check_excluded_libs (entry->the_bfd);
 
 
      if (entry->whole_archive)
      if (entry->whole_archive)
        {
        {
          bfd *member = NULL;
          bfd *member = NULL;
          bfd_boolean loaded = TRUE;
          bfd_boolean loaded = TRUE;
 
 
          for (;;)
          for (;;)
            {
            {
              member = bfd_openr_next_archived_file (entry->the_bfd, member);
              member = bfd_openr_next_archived_file (entry->the_bfd, member);
 
 
              if (member == NULL)
              if (member == NULL)
                break;
                break;
 
 
              if (! bfd_check_format (member, bfd_object))
              if (! bfd_check_format (member, bfd_object))
                {
                {
                  einfo (_("%F%B: member %B in archive is not an object\n"),
                  einfo (_("%F%B: member %B in archive is not an object\n"),
                         entry->the_bfd, member);
                         entry->the_bfd, member);
                  loaded = FALSE;
                  loaded = FALSE;
                }
                }
 
 
              if (! ((*link_info.callbacks->add_archive_element)
              if (! ((*link_info.callbacks->add_archive_element)
                     (&link_info, member, "--whole-archive")))
                     (&link_info, member, "--whole-archive")))
                abort ();
                abort ();
 
 
              if (! bfd_link_add_symbols (member, &link_info))
              if (! bfd_link_add_symbols (member, &link_info))
                {
                {
                  einfo (_("%F%B: could not read symbols: %E\n"), member);
                  einfo (_("%F%B: could not read symbols: %E\n"), member);
                  loaded = FALSE;
                  loaded = FALSE;
                }
                }
            }
            }
 
 
          entry->loaded = loaded;
          entry->loaded = loaded;
          return loaded;
          return loaded;
        }
        }
      break;
      break;
    }
    }
 
 
  if (bfd_link_add_symbols (entry->the_bfd, &link_info))
  if (bfd_link_add_symbols (entry->the_bfd, &link_info))
    entry->loaded = TRUE;
    entry->loaded = TRUE;
  else
  else
    einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
    einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
 
 
  return entry->loaded;
  return entry->loaded;
}
}
 
 
/* Handle a wild statement.  S->FILENAME or S->SECTION_LIST or both
/* Handle a wild statement.  S->FILENAME or S->SECTION_LIST or both
   may be NULL, indicating that it is a wildcard.  Separate
   may be NULL, indicating that it is a wildcard.  Separate
   lang_input_section statements are created for each part of the
   lang_input_section statements are created for each part of the
   expansion; they are added after the wild statement S.  OUTPUT is
   expansion; they are added after the wild statement S.  OUTPUT is
   the output section.  */
   the output section.  */
 
 
static void
static void
wild (lang_wild_statement_type *s,
wild (lang_wild_statement_type *s,
      const char *target ATTRIBUTE_UNUSED,
      const char *target ATTRIBUTE_UNUSED,
      lang_output_section_statement_type *output)
      lang_output_section_statement_type *output)
{
{
  struct wildcard_list *sec;
  struct wildcard_list *sec;
 
 
  if (s->handler_data[0]
  if (s->handler_data[0]
      && s->handler_data[0]->spec.sorted == by_name
      && s->handler_data[0]->spec.sorted == by_name
      && !s->filenames_sorted)
      && !s->filenames_sorted)
    {
    {
      lang_section_bst_type *tree;
      lang_section_bst_type *tree;
 
 
      walk_wild (s, output_section_callback_fast, output);
      walk_wild (s, output_section_callback_fast, output);
 
 
      tree = s->tree;
      tree = s->tree;
      if (tree)
      if (tree)
        {
        {
          output_section_callback_tree_to_list (s, tree, output);
          output_section_callback_tree_to_list (s, tree, output);
          s->tree = NULL;
          s->tree = NULL;
        }
        }
    }
    }
  else
  else
    walk_wild (s, output_section_callback, output);
    walk_wild (s, output_section_callback, output);
 
 
  if (default_common_section == NULL)
  if (default_common_section == NULL)
    for (sec = s->section_list; sec != NULL; sec = sec->next)
    for (sec = s->section_list; sec != NULL; sec = sec->next)
      if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
      if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
        {
        {
          /* Remember the section that common is going to in case we
          /* Remember the section that common is going to in case we
             later get something which doesn't know where to put it.  */
             later get something which doesn't know where to put it.  */
          default_common_section = output;
          default_common_section = output;
          break;
          break;
        }
        }
}
}
 
 
/* Return TRUE iff target is the sought target.  */
/* Return TRUE iff target is the sought target.  */
 
 
static int
static int
get_target (const bfd_target *target, void *data)
get_target (const bfd_target *target, void *data)
{
{
  const char *sought = data;
  const char *sought = data;
 
 
  return strcmp (target->name, sought) == 0;
  return strcmp (target->name, sought) == 0;
}
}
 
 
/* Like strcpy() but convert to lower case as well.  */
/* Like strcpy() but convert to lower case as well.  */
 
 
static void
static void
stricpy (char *dest, char *src)
stricpy (char *dest, char *src)
{
{
  char c;
  char c;
 
 
  while ((c = *src++) != 0)
  while ((c = *src++) != 0)
    *dest++ = TOLOWER (c);
    *dest++ = TOLOWER (c);
 
 
  *dest = 0;
  *dest = 0;
}
}
 
 
/* Remove the first occurrence of needle (if any) in haystack
/* Remove the first occurrence of needle (if any) in haystack
   from haystack.  */
   from haystack.  */
 
 
static void
static void
strcut (char *haystack, char *needle)
strcut (char *haystack, char *needle)
{
{
  haystack = strstr (haystack, needle);
  haystack = strstr (haystack, needle);
 
 
  if (haystack)
  if (haystack)
    {
    {
      char *src;
      char *src;
 
 
      for (src = haystack + strlen (needle); *src;)
      for (src = haystack + strlen (needle); *src;)
        *haystack++ = *src++;
        *haystack++ = *src++;
 
 
      *haystack = 0;
      *haystack = 0;
    }
    }
}
}
 
 
/* Compare two target format name strings.
/* Compare two target format name strings.
   Return a value indicating how "similar" they are.  */
   Return a value indicating how "similar" they are.  */
 
 
static int
static int
name_compare (char *first, char *second)
name_compare (char *first, char *second)
{
{
  char *copy1;
  char *copy1;
  char *copy2;
  char *copy2;
  int result;
  int result;
 
 
  copy1 = xmalloc (strlen (first) + 1);
  copy1 = xmalloc (strlen (first) + 1);
  copy2 = xmalloc (strlen (second) + 1);
  copy2 = xmalloc (strlen (second) + 1);
 
 
  /* Convert the names to lower case.  */
  /* Convert the names to lower case.  */
  stricpy (copy1, first);
  stricpy (copy1, first);
  stricpy (copy2, second);
  stricpy (copy2, second);
 
 
  /* Remove size and endian strings from the name.  */
  /* Remove size and endian strings from the name.  */
  strcut (copy1, "big");
  strcut (copy1, "big");
  strcut (copy1, "little");
  strcut (copy1, "little");
  strcut (copy2, "big");
  strcut (copy2, "big");
  strcut (copy2, "little");
  strcut (copy2, "little");
 
 
  /* Return a value based on how many characters match,
  /* Return a value based on how many characters match,
     starting from the beginning.   If both strings are
     starting from the beginning.   If both strings are
     the same then return 10 * their length.  */
     the same then return 10 * their length.  */
  for (result = 0; copy1[result] == copy2[result]; result++)
  for (result = 0; copy1[result] == copy2[result]; result++)
    if (copy1[result] == 0)
    if (copy1[result] == 0)
      {
      {
        result *= 10;
        result *= 10;
        break;
        break;
      }
      }
 
 
  free (copy1);
  free (copy1);
  free (copy2);
  free (copy2);
 
 
  return result;
  return result;
}
}
 
 
/* Set by closest_target_match() below.  */
/* Set by closest_target_match() below.  */
static const bfd_target *winner;
static const bfd_target *winner;
 
 
/* Scan all the valid bfd targets looking for one that has the endianness
/* Scan all the valid bfd targets looking for one that has the endianness
   requirement that was specified on the command line, and is the nearest
   requirement that was specified on the command line, and is the nearest
   match to the original output target.  */
   match to the original output target.  */
 
 
static int
static int
closest_target_match (const bfd_target *target, void *data)
closest_target_match (const bfd_target *target, void *data)
{
{
  const bfd_target *original = data;
  const bfd_target *original = data;
 
 
  if (command_line.endian == ENDIAN_BIG
  if (command_line.endian == ENDIAN_BIG
      && target->byteorder != BFD_ENDIAN_BIG)
      && target->byteorder != BFD_ENDIAN_BIG)
    return 0;
    return 0;
 
 
  if (command_line.endian == ENDIAN_LITTLE
  if (command_line.endian == ENDIAN_LITTLE
      && target->byteorder != BFD_ENDIAN_LITTLE)
      && target->byteorder != BFD_ENDIAN_LITTLE)
    return 0;
    return 0;
 
 
  /* Must be the same flavour.  */
  /* Must be the same flavour.  */
  if (target->flavour != original->flavour)
  if (target->flavour != original->flavour)
    return 0;
    return 0;
 
 
  /* If we have not found a potential winner yet, then record this one.  */
  /* If we have not found a potential winner yet, then record this one.  */
  if (winner == NULL)
  if (winner == NULL)
    {
    {
      winner = target;
      winner = target;
      return 0;
      return 0;
    }
    }
 
 
  /* Oh dear, we now have two potential candidates for a successful match.
  /* Oh dear, we now have two potential candidates for a successful match.
     Compare their names and choose the better one.  */
     Compare their names and choose the better one.  */
  if (name_compare (target->name, original->name)
  if (name_compare (target->name, original->name)
      > name_compare (winner->name, original->name))
      > name_compare (winner->name, original->name))
    winner = target;
    winner = target;
 
 
  /* Keep on searching until wqe have checked them all.  */
  /* Keep on searching until wqe have checked them all.  */
  return 0;
  return 0;
}
}
 
 
/* Return the BFD target format of the first input file.  */
/* Return the BFD target format of the first input file.  */
 
 
static char *
static char *
get_first_input_target (void)
get_first_input_target (void)
{
{
  char *target = NULL;
  char *target = NULL;
 
 
  LANG_FOR_EACH_INPUT_STATEMENT (s)
  LANG_FOR_EACH_INPUT_STATEMENT (s)
    {
    {
      if (s->header.type == lang_input_statement_enum
      if (s->header.type == lang_input_statement_enum
          && s->real)
          && s->real)
        {
        {
          ldfile_open_file (s);
          ldfile_open_file (s);
 
 
          if (s->the_bfd != NULL
          if (s->the_bfd != NULL
              && bfd_check_format (s->the_bfd, bfd_object))
              && bfd_check_format (s->the_bfd, bfd_object))
            {
            {
              target = bfd_get_target (s->the_bfd);
              target = bfd_get_target (s->the_bfd);
 
 
              if (target != NULL)
              if (target != NULL)
                break;
                break;
            }
            }
        }
        }
    }
    }
 
 
  return target;
  return target;
}
}
 
 
const char *
const char *
lang_get_output_target (void)
lang_get_output_target (void)
{
{
  const char *target;
  const char *target;
 
 
  /* Has the user told us which output format to use?  */
  /* Has the user told us which output format to use?  */
  if (output_target != NULL)
  if (output_target != NULL)
    return output_target;
    return output_target;
 
 
  /* No - has the current target been set to something other than
  /* No - has the current target been set to something other than
     the default?  */
     the default?  */
  if (current_target != default_target)
  if (current_target != default_target)
    return current_target;
    return current_target;
 
 
  /* No - can we determine the format of the first input file?  */
  /* No - can we determine the format of the first input file?  */
  target = get_first_input_target ();
  target = get_first_input_target ();
  if (target != NULL)
  if (target != NULL)
    return target;
    return target;
 
 
  /* Failed - use the default output target.  */
  /* Failed - use the default output target.  */
  return default_target;
  return default_target;
}
}
 
 
/* Open the output file.  */
/* Open the output file.  */
 
 
static void
static void
open_output (const char *name)
open_output (const char *name)
{
{
  output_target = lang_get_output_target ();
  output_target = lang_get_output_target ();
 
 
  /* Has the user requested a particular endianness on the command
  /* Has the user requested a particular endianness on the command
     line?  */
     line?  */
  if (command_line.endian != ENDIAN_UNSET)
  if (command_line.endian != ENDIAN_UNSET)
    {
    {
      const bfd_target *target;
      const bfd_target *target;
      enum bfd_endian desired_endian;
      enum bfd_endian desired_endian;
 
 
      /* Get the chosen target.  */
      /* Get the chosen target.  */
      target = bfd_search_for_target (get_target, (void *) output_target);
      target = bfd_search_for_target (get_target, (void *) output_target);
 
 
      /* If the target is not supported, we cannot do anything.  */
      /* If the target is not supported, we cannot do anything.  */
      if (target != NULL)
      if (target != NULL)
        {
        {
          if (command_line.endian == ENDIAN_BIG)
          if (command_line.endian == ENDIAN_BIG)
            desired_endian = BFD_ENDIAN_BIG;
            desired_endian = BFD_ENDIAN_BIG;
          else
          else
            desired_endian = BFD_ENDIAN_LITTLE;
            desired_endian = BFD_ENDIAN_LITTLE;
 
 
          /* See if the target has the wrong endianness.  This should
          /* See if the target has the wrong endianness.  This should
             not happen if the linker script has provided big and
             not happen if the linker script has provided big and
             little endian alternatives, but some scrips don't do
             little endian alternatives, but some scrips don't do
             this.  */
             this.  */
          if (target->byteorder != desired_endian)
          if (target->byteorder != desired_endian)
            {
            {
              /* If it does, then see if the target provides
              /* If it does, then see if the target provides
                 an alternative with the correct endianness.  */
                 an alternative with the correct endianness.  */
              if (target->alternative_target != NULL
              if (target->alternative_target != NULL
                  && (target->alternative_target->byteorder == desired_endian))
                  && (target->alternative_target->byteorder == desired_endian))
                output_target = target->alternative_target->name;
                output_target = target->alternative_target->name;
              else
              else
                {
                {
                  /* Try to find a target as similar as possible to
                  /* Try to find a target as similar as possible to
                     the default target, but which has the desired
                     the default target, but which has the desired
                     endian characteristic.  */
                     endian characteristic.  */
                  bfd_search_for_target (closest_target_match,
                  bfd_search_for_target (closest_target_match,
                                         (void *) target);
                                         (void *) target);
 
 
                  /* Oh dear - we could not find any targets that
                  /* Oh dear - we could not find any targets that
                     satisfy our requirements.  */
                     satisfy our requirements.  */
                  if (winner == NULL)
                  if (winner == NULL)
                    einfo (_("%P: warning: could not find any targets"
                    einfo (_("%P: warning: could not find any targets"
                             " that match endianness requirement\n"));
                             " that match endianness requirement\n"));
                  else
                  else
                    output_target = winner->name;
                    output_target = winner->name;
                }
                }
            }
            }
        }
        }
    }
    }
 
 
  link_info.output_bfd = bfd_openw (name, output_target);
  link_info.output_bfd = bfd_openw (name, output_target);
 
 
  if (link_info.output_bfd == NULL)
  if (link_info.output_bfd == NULL)
    {
    {
      if (bfd_get_error () == bfd_error_invalid_target)
      if (bfd_get_error () == bfd_error_invalid_target)
        einfo (_("%P%F: target %s not found\n"), output_target);
        einfo (_("%P%F: target %s not found\n"), output_target);
 
 
      einfo (_("%P%F: cannot open output file %s: %E\n"), name);
      einfo (_("%P%F: cannot open output file %s: %E\n"), name);
    }
    }
 
 
  delete_output_file_on_failure = TRUE;
  delete_output_file_on_failure = TRUE;
 
 
  if (! bfd_set_format (link_info.output_bfd, bfd_object))
  if (! bfd_set_format (link_info.output_bfd, bfd_object))
    einfo (_("%P%F:%s: can not make object file: %E\n"), name);
    einfo (_("%P%F:%s: can not make object file: %E\n"), name);
  if (! bfd_set_arch_mach (link_info.output_bfd,
  if (! bfd_set_arch_mach (link_info.output_bfd,
                           ldfile_output_architecture,
                           ldfile_output_architecture,
                           ldfile_output_machine))
                           ldfile_output_machine))
    einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
    einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
 
 
  link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);
  link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);
  if (link_info.hash == NULL)
  if (link_info.hash == NULL)
    einfo (_("%P%F: can not create hash table: %E\n"));
    einfo (_("%P%F: can not create hash table: %E\n"));
 
 
  bfd_set_gp_size (link_info.output_bfd, g_switch_value);
  bfd_set_gp_size (link_info.output_bfd, g_switch_value);
}
}
 
 
static void
static void
ldlang_open_output (lang_statement_union_type *statement)
ldlang_open_output (lang_statement_union_type *statement)
{
{
  switch (statement->header.type)
  switch (statement->header.type)
    {
    {
    case lang_output_statement_enum:
    case lang_output_statement_enum:
      ASSERT (link_info.output_bfd == NULL);
      ASSERT (link_info.output_bfd == NULL);
      open_output (statement->output_statement.name);
      open_output (statement->output_statement.name);
      ldemul_set_output_arch ();
      ldemul_set_output_arch ();
      if (config.magic_demand_paged && !link_info.relocatable)
      if (config.magic_demand_paged && !link_info.relocatable)
        link_info.output_bfd->flags |= D_PAGED;
        link_info.output_bfd->flags |= D_PAGED;
      else
      else
        link_info.output_bfd->flags &= ~D_PAGED;
        link_info.output_bfd->flags &= ~D_PAGED;
      if (config.text_read_only)
      if (config.text_read_only)
        link_info.output_bfd->flags |= WP_TEXT;
        link_info.output_bfd->flags |= WP_TEXT;
      else
      else
        link_info.output_bfd->flags &= ~WP_TEXT;
        link_info.output_bfd->flags &= ~WP_TEXT;
      if (link_info.traditional_format)
      if (link_info.traditional_format)
        link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
        link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
      else
      else
        link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
        link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
      break;
      break;
 
 
    case lang_target_statement_enum:
    case lang_target_statement_enum:
      current_target = statement->target_statement.target;
      current_target = statement->target_statement.target;
      break;
      break;
    default:
    default:
      break;
      break;
    }
    }
}
}
 
 
/* Convert between addresses in bytes and sizes in octets.
/* Convert between addresses in bytes and sizes in octets.
   For currently supported targets, octets_per_byte is always a power
   For currently supported targets, octets_per_byte is always a power
   of two, so we can use shifts.  */
   of two, so we can use shifts.  */
#define TO_ADDR(X) ((X) >> opb_shift)
#define TO_ADDR(X) ((X) >> opb_shift)
#define TO_SIZE(X) ((X) << opb_shift)
#define TO_SIZE(X) ((X) << opb_shift)
 
 
/* Support the above.  */
/* Support the above.  */
static unsigned int opb_shift = 0;
static unsigned int opb_shift = 0;
 
 
static void
static void
init_opb (void)
init_opb (void)
{
{
  unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
  unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
                                              ldfile_output_machine);
                                              ldfile_output_machine);
  opb_shift = 0;
  opb_shift = 0;
  if (x > 1)
  if (x > 1)
    while ((x & 1) == 0)
    while ((x & 1) == 0)
      {
      {
        x >>= 1;
        x >>= 1;
        ++opb_shift;
        ++opb_shift;
      }
      }
  ASSERT (x == 1);
  ASSERT (x == 1);
}
}
 
 
/* Open all the input files.  */
/* Open all the input files.  */
 
 
static void
static void
open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
{
{
  for (; s != NULL; s = s->header.next)
  for (; s != NULL; s = s->header.next)
    {
    {
      switch (s->header.type)
      switch (s->header.type)
        {
        {
        case lang_constructors_statement_enum:
        case lang_constructors_statement_enum:
          open_input_bfds (constructor_list.head, force);
          open_input_bfds (constructor_list.head, force);
          break;
          break;
        case lang_output_section_statement_enum:
        case lang_output_section_statement_enum:
          open_input_bfds (s->output_section_statement.children.head, force);
          open_input_bfds (s->output_section_statement.children.head, force);
          break;
          break;
        case lang_wild_statement_enum:
        case lang_wild_statement_enum:
          /* Maybe we should load the file's symbols.  */
          /* Maybe we should load the file's symbols.  */
          if (s->wild_statement.filename
          if (s->wild_statement.filename
              && ! wildcardp (s->wild_statement.filename))
              && ! wildcardp (s->wild_statement.filename))
            lookup_name (s->wild_statement.filename);
            lookup_name (s->wild_statement.filename);
          open_input_bfds (s->wild_statement.children.head, force);
          open_input_bfds (s->wild_statement.children.head, force);
          break;
          break;
        case lang_group_statement_enum:
        case lang_group_statement_enum:
          {
          {
            struct bfd_link_hash_entry *undefs;
            struct bfd_link_hash_entry *undefs;
 
 
            /* We must continually search the entries in the group
            /* We must continually search the entries in the group
               until no new symbols are added to the list of undefined
               until no new symbols are added to the list of undefined
               symbols.  */
               symbols.  */
 
 
            do
            do
              {
              {
                undefs = link_info.hash->undefs_tail;
                undefs = link_info.hash->undefs_tail;
                open_input_bfds (s->group_statement.children.head, TRUE);
                open_input_bfds (s->group_statement.children.head, TRUE);
              }
              }
            while (undefs != link_info.hash->undefs_tail);
            while (undefs != link_info.hash->undefs_tail);
          }
          }
          break;
          break;
        case lang_target_statement_enum:
        case lang_target_statement_enum:
          current_target = s->target_statement.target;
          current_target = s->target_statement.target;
          break;
          break;
        case lang_input_statement_enum:
        case lang_input_statement_enum:
          if (s->input_statement.real)
          if (s->input_statement.real)
            {
            {
              lang_statement_list_type add;
              lang_statement_list_type add;
 
 
              s->input_statement.target = current_target;
              s->input_statement.target = current_target;
 
 
              /* If we are being called from within a group, and this
              /* If we are being called from within a group, and this
                 is an archive which has already been searched, then
                 is an archive which has already been searched, then
                 force it to be researched unless the whole archive
                 force it to be researched unless the whole archive
                 has been loaded already.  */
                 has been loaded already.  */
              if (force
              if (force
                  && !s->input_statement.whole_archive
                  && !s->input_statement.whole_archive
                  && s->input_statement.loaded
                  && s->input_statement.loaded
                  && bfd_check_format (s->input_statement.the_bfd,
                  && bfd_check_format (s->input_statement.the_bfd,
                                       bfd_archive))
                                       bfd_archive))
                s->input_statement.loaded = FALSE;
                s->input_statement.loaded = FALSE;
 
 
              lang_list_init (&add);
              lang_list_init (&add);
 
 
              if (! load_symbols (&s->input_statement, &add))
              if (! load_symbols (&s->input_statement, &add))
                config.make_executable = FALSE;
                config.make_executable = FALSE;
 
 
              if (add.head != NULL)
              if (add.head != NULL)
                {
                {
                  *add.tail = s->header.next;
                  *add.tail = s->header.next;
                  s->header.next = add.head;
                  s->header.next = add.head;
                }
                }
            }
            }
          break;
          break;
        default:
        default:
          break;
          break;
        }
        }
    }
    }
}
}
 
 
/* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions.  */
/* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions.  */
 
 
void
void
lang_track_definedness (const char *name)
lang_track_definedness (const char *name)
{
{
  if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
  if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
    einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
    einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
}
}
 
 
/* New-function for the definedness hash table.  */
/* New-function for the definedness hash table.  */
 
 
static struct bfd_hash_entry *
static struct bfd_hash_entry *
lang_definedness_newfunc (struct bfd_hash_entry *entry,
lang_definedness_newfunc (struct bfd_hash_entry *entry,
                          struct bfd_hash_table *table ATTRIBUTE_UNUSED,
                          struct bfd_hash_table *table ATTRIBUTE_UNUSED,
                          const char *name ATTRIBUTE_UNUSED)
                          const char *name ATTRIBUTE_UNUSED)
{
{
  struct lang_definedness_hash_entry *ret
  struct lang_definedness_hash_entry *ret
    = (struct lang_definedness_hash_entry *) entry;
    = (struct lang_definedness_hash_entry *) entry;
 
 
  if (ret == NULL)
  if (ret == NULL)
    ret = (struct lang_definedness_hash_entry *)
    ret = (struct lang_definedness_hash_entry *)
      bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
      bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
 
 
  if (ret == NULL)
  if (ret == NULL)
    einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
    einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
 
 
  ret->iteration = -1;
  ret->iteration = -1;
  return &ret->root;
  return &ret->root;
}
}
 
 
/* Return the iteration when the definition of NAME was last updated.  A
/* Return the iteration when the definition of NAME was last updated.  A
   value of -1 means that the symbol is not defined in the linker script
   value of -1 means that the symbol is not defined in the linker script
   or the command line, but may be defined in the linker symbol table.  */
   or the command line, but may be defined in the linker symbol table.  */
 
 
int
int
lang_symbol_definition_iteration (const char *name)
lang_symbol_definition_iteration (const char *name)
{
{
  struct lang_definedness_hash_entry *defentry
  struct lang_definedness_hash_entry *defentry
    = (struct lang_definedness_hash_entry *)
    = (struct lang_definedness_hash_entry *)
    bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
    bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
 
 
  /* We've already created this one on the presence of DEFINED in the
  /* We've already created this one on the presence of DEFINED in the
     script, so it can't be NULL unless something is borked elsewhere in
     script, so it can't be NULL unless something is borked elsewhere in
     the code.  */
     the code.  */
  if (defentry == NULL)
  if (defentry == NULL)
    FAIL ();
    FAIL ();
 
 
  return defentry->iteration;
  return defentry->iteration;
}
}
 
 
/* Update the definedness state of NAME.  */
/* Update the definedness state of NAME.  */
 
 
void
void
lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
{
{
  struct lang_definedness_hash_entry *defentry
  struct lang_definedness_hash_entry *defentry
    = (struct lang_definedness_hash_entry *)
    = (struct lang_definedness_hash_entry *)
    bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
    bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
 
 
  /* We don't keep track of symbols not tested with DEFINED.  */
  /* We don't keep track of symbols not tested with DEFINED.  */
  if (defentry == NULL)
  if (defentry == NULL)
    return;
    return;
 
 
  /* If the symbol was already defined, and not from an earlier statement
  /* If the symbol was already defined, and not from an earlier statement
     iteration, don't update the definedness iteration, because that'd
     iteration, don't update the definedness iteration, because that'd
     make the symbol seem defined in the linker script at this point, and
     make the symbol seem defined in the linker script at this point, and
     it wasn't; it was defined in some object.  If we do anyway, DEFINED
     it wasn't; it was defined in some object.  If we do anyway, DEFINED
     would start to yield false before this point and the construct "sym =
     would start to yield false before this point and the construct "sym =
     DEFINED (sym) ? sym : X;" would change sym to X despite being defined
     DEFINED (sym) ? sym : X;" would change sym to X despite being defined
     in an object.  */
     in an object.  */
  if (h->type != bfd_link_hash_undefined
  if (h->type != bfd_link_hash_undefined
      && h->type != bfd_link_hash_common
      && h->type != bfd_link_hash_common
      && h->type != bfd_link_hash_new
      && h->type != bfd_link_hash_new
      && defentry->iteration == -1)
      && defentry->iteration == -1)
    return;
    return;
 
 
  defentry->iteration = lang_statement_iteration;
  defentry->iteration = lang_statement_iteration;
}
}
 
 
/* Add the supplied name to the symbol table as an undefined reference.
/* Add the supplied name to the symbol table as an undefined reference.
   This is a two step process as the symbol table doesn't even exist at
   This is a two step process as the symbol table doesn't even exist at
   the time the ld command line is processed.  First we put the name
   the time the ld command line is processed.  First we put the name
   on a list, then, once the output file has been opened, transfer the
   on a list, then, once the output file has been opened, transfer the
   name to the symbol table.  */
   name to the symbol table.  */
 
 
typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
 
 
#define ldlang_undef_chain_list_head entry_symbol.next
#define ldlang_undef_chain_list_head entry_symbol.next
 
 
void
void
ldlang_add_undef (const char *const name)
ldlang_add_undef (const char *const name)
{
{
  ldlang_undef_chain_list_type *new =
  ldlang_undef_chain_list_type *new =
    stat_alloc (sizeof (ldlang_undef_chain_list_type));
    stat_alloc (sizeof (ldlang_undef_chain_list_type));
 
 
  new->next = ldlang_undef_chain_list_head;
  new->next = ldlang_undef_chain_list_head;
  ldlang_undef_chain_list_head = new;
  ldlang_undef_chain_list_head = new;
 
 
  new->name = xstrdup (name);
  new->name = xstrdup (name);
 
 
  if (link_info.output_bfd != NULL)
  if (link_info.output_bfd != NULL)
    insert_undefined (new->name);
    insert_undefined (new->name);
}
}
 
 
/* Insert NAME as undefined in the symbol table.  */
/* Insert NAME as undefined in the symbol table.  */
 
 
static void
static void
insert_undefined (const char *name)
insert_undefined (const char *name)
{
{
  struct bfd_link_hash_entry *h;
  struct bfd_link_hash_entry *h;
 
 
  h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
  h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
  if (h == NULL)
  if (h == NULL)
    einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
    einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
  if (h->type == bfd_link_hash_new)
  if (h->type == bfd_link_hash_new)
    {
    {
      h->type = bfd_link_hash_undefined;
      h->type = bfd_link_hash_undefined;
      h->u.undef.abfd = NULL;
      h->u.undef.abfd = NULL;
      bfd_link_add_undef (link_info.hash, h);
      bfd_link_add_undef (link_info.hash, h);
    }
    }
}
}
 
 
/* Run through the list of undefineds created above and place them
/* Run through the list of undefineds created above and place them
   into the linker hash table as undefined symbols belonging to the
   into the linker hash table as undefined symbols belonging to the
   script file.  */
   script file.  */
 
 
static void
static void
lang_place_undefineds (void)
lang_place_undefineds (void)
{
{
  ldlang_undef_chain_list_type *ptr;
  ldlang_undef_chain_list_type *ptr;
 
 
  for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
  for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
    insert_undefined (ptr->name);
    insert_undefined (ptr->name);
}
}
 
 
/* Check for all readonly or some readwrite sections.  */
/* Check for all readonly or some readwrite sections.  */
 
 
static void
static void
check_input_sections
check_input_sections
  (lang_statement_union_type *s,
  (lang_statement_union_type *s,
   lang_output_section_statement_type *output_section_statement)
   lang_output_section_statement_type *output_section_statement)
{
{
  for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
  for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
    {
    {
      switch (s->header.type)
      switch (s->header.type)
      {
      {
      case lang_wild_statement_enum:
      case lang_wild_statement_enum:
        walk_wild (&s->wild_statement, check_section_callback,
        walk_wild (&s->wild_statement, check_section_callback,
                   output_section_statement);
                   output_section_statement);
        if (! output_section_statement->all_input_readonly)
        if (! output_section_statement->all_input_readonly)
          return;
          return;
        break;
        break;
      case lang_constructors_statement_enum:
      case lang_constructors_statement_enum:
        check_input_sections (constructor_list.head,
        check_input_sections (constructor_list.head,
                              output_section_statement);
                              output_section_statement);
        if (! output_section_statement->all_input_readonly)
        if (! output_section_statement->all_input_readonly)
          return;
          return;
        break;
        break;
      case lang_group_statement_enum:
      case lang_group_statement_enum:
        check_input_sections (s->group_statement.children.head,
        check_input_sections (s->group_statement.children.head,
                              output_section_statement);
                              output_section_statement);
        if (! output_section_statement->all_input_readonly)
        if (! output_section_statement->all_input_readonly)
          return;
          return;
        break;
        break;
      default:
      default:
        break;
        break;
      }
      }
    }
    }
}
}
 
 
/* Update wildcard statements if needed.  */
/* Update wildcard statements if needed.  */
 
 
static void
static void
update_wild_statements (lang_statement_union_type *s)
update_wild_statements (lang_statement_union_type *s)
{
{
  struct wildcard_list *sec;
  struct wildcard_list *sec;
 
 
  switch (sort_section)
  switch (sort_section)
    {
    {
    default:
    default:
      FAIL ();
      FAIL ();
 
 
    case none:
    case none:
      break;
      break;
 
 
    case by_name:
    case by_name:
    case by_alignment:
    case by_alignment:
      for (; s != NULL; s = s->header.next)
      for (; s != NULL; s = s->header.next)
        {
        {
          switch (s->header.type)
          switch (s->header.type)
            {
            {
            default:
            default:
              break;
              break;
 
 
            case lang_wild_statement_enum:
            case lang_wild_statement_enum:
              sec = s->wild_statement.section_list;
              sec = s->wild_statement.section_list;
              for (sec = s->wild_statement.section_list; sec != NULL;
              for (sec = s->wild_statement.section_list; sec != NULL;
                   sec = sec->next)
                   sec = sec->next)
                {
                {
                  switch (sec->spec.sorted)
                  switch (sec->spec.sorted)
                    {
                    {
                    case none:
                    case none:
                      sec->spec.sorted = sort_section;
                      sec->spec.sorted = sort_section;
                      break;
                      break;
                    case by_name:
                    case by_name:
                      if (sort_section == by_alignment)
                      if (sort_section == by_alignment)
                        sec->spec.sorted = by_name_alignment;
                        sec->spec.sorted = by_name_alignment;
                      break;
                      break;
                    case by_alignment:
                    case by_alignment:
                      if (sort_section == by_name)
                      if (sort_section == by_name)
                        sec->spec.sorted = by_alignment_name;
                        sec->spec.sorted = by_alignment_name;
                      break;
                      break;
                    default:
                    default:
                      break;
                      break;
                    }
                    }
                }
                }
              break;
              break;
 
 
            case lang_constructors_statement_enum:
            case lang_constructors_statement_enum:
              update_wild_statements (constructor_list.head);
              update_wild_statements (constructor_list.head);
              break;
              break;
 
 
            case lang_output_section_statement_enum:
            case lang_output_section_statement_enum:
              update_wild_statements
              update_wild_statements
                (s->output_section_statement.children.head);
                (s->output_section_statement.children.head);
              break;
              break;
 
 
            case lang_group_statement_enum:
            case lang_group_statement_enum:
              update_wild_statements (s->group_statement.children.head);
              update_wild_statements (s->group_statement.children.head);
              break;
              break;
            }
            }
        }
        }
      break;
      break;
    }
    }
}
}
 
 
/* Open input files and attach to output sections.  */
/* Open input files and attach to output sections.  */
 
 
static void
static void
map_input_to_output_sections
map_input_to_output_sections
  (lang_statement_union_type *s, const char *target,
  (lang_statement_union_type *s, const char *target,
   lang_output_section_statement_type *os)
   lang_output_section_statement_type *os)
{
{
  flagword flags;
  flagword flags;
 
 
  for (; s != NULL; s = s->header.next)
  for (; s != NULL; s = s->header.next)
    {
    {
      switch (s->header.type)
      switch (s->header.type)
        {
        {
        case lang_wild_statement_enum:
        case lang_wild_statement_enum:
          wild (&s->wild_statement, target, os);
          wild (&s->wild_statement, target, os);
          break;
          break;
        case lang_constructors_statement_enum:
        case lang_constructors_statement_enum:
          map_input_to_output_sections (constructor_list.head,
          map_input_to_output_sections (constructor_list.head,
                                        target,
                                        target,
                                        os);
                                        os);
          break;
          break;
        case lang_output_section_statement_enum:
        case lang_output_section_statement_enum:
          if (s->output_section_statement.constraint)
          if (s->output_section_statement.constraint)
            {
            {
              if (s->output_section_statement.constraint != ONLY_IF_RW
              if (s->output_section_statement.constraint != ONLY_IF_RW
                  && s->output_section_statement.constraint != ONLY_IF_RO)
                  && s->output_section_statement.constraint != ONLY_IF_RO)
                break;
                break;
              s->output_section_statement.all_input_readonly = TRUE;
              s->output_section_statement.all_input_readonly = TRUE;
              check_input_sections (s->output_section_statement.children.head,
              check_input_sections (s->output_section_statement.children.head,
                                    &s->output_section_statement);
                                    &s->output_section_statement);
              if ((s->output_section_statement.all_input_readonly
              if ((s->output_section_statement.all_input_readonly
                   && s->output_section_statement.constraint == ONLY_IF_RW)
                   && s->output_section_statement.constraint == ONLY_IF_RW)
                  || (!s->output_section_statement.all_input_readonly
                  || (!s->output_section_statement.all_input_readonly
                      && s->output_section_statement.constraint == ONLY_IF_RO))
                      && s->output_section_statement.constraint == ONLY_IF_RO))
                {
                {
                  s->output_section_statement.constraint = -1;
                  s->output_section_statement.constraint = -1;
                  break;
                  break;
                }
                }
            }
            }
 
 
          map_input_to_output_sections (s->output_section_statement.children.head,
          map_input_to_output_sections (s->output_section_statement.children.head,
                                        target,
                                        target,
                                        &s->output_section_statement);
                                        &s->output_section_statement);
          break;
          break;
        case lang_output_statement_enum:
        case lang_output_statement_enum:
          break;
          break;
        case lang_target_statement_enum:
        case lang_target_statement_enum:
          target = s->target_statement.target;
          target = s->target_statement.target;
          break;
          break;
        case lang_group_statement_enum:
        case lang_group_statement_enum:
          map_input_to_output_sections (s->group_statement.children.head,
          map_input_to_output_sections (s->group_statement.children.head,
                                        target,
                                        target,
                                        os);
                                        os);
          break;
          break;
        case lang_data_statement_enum:
        case lang_data_statement_enum:
          /* Make sure that any sections mentioned in the expression
          /* Make sure that any sections mentioned in the expression
             are initialized.  */
             are initialized.  */
          exp_init_os (s->data_statement.exp);
          exp_init_os (s->data_statement.exp);
          flags = SEC_HAS_CONTENTS;
          flags = SEC_HAS_CONTENTS;
          /* The output section gets contents, and then we inspect for
          /* The output section gets contents, and then we inspect for
             any flags set in the input script which override any ALLOC.  */
             any flags set in the input script which override any ALLOC.  */
          if (!(os->flags & SEC_NEVER_LOAD))
          if (!(os->flags & SEC_NEVER_LOAD))
            flags |= SEC_ALLOC | SEC_LOAD;
            flags |= SEC_ALLOC | SEC_LOAD;
          if (os->bfd_section == NULL)
          if (os->bfd_section == NULL)
            init_os (os, NULL, flags);
            init_os (os, NULL, flags);
          else
          else
            os->bfd_section->flags |= flags;
            os->bfd_section->flags |= flags;
          break;
          break;
        case lang_input_section_enum:
        case lang_input_section_enum:
          break;
          break;
        case lang_fill_statement_enum:
        case lang_fill_statement_enum:
        case lang_object_symbols_statement_enum:
        case lang_object_symbols_statement_enum:
        case lang_reloc_statement_enum:
        case lang_reloc_statement_enum:
        case lang_padding_statement_enum:
        case lang_padding_statement_enum:
        case lang_input_statement_enum:
        case lang_input_statement_enum:
          if (os != NULL && os->bfd_section == NULL)
          if (os != NULL && os->bfd_section == NULL)
            init_os (os, NULL, 0);
            init_os (os, NULL, 0);
          break;
          break;
        case lang_assignment_statement_enum:
        case lang_assignment_statement_enum:
          if (os != NULL && os->bfd_section == NULL)
          if (os != NULL && os->bfd_section == NULL)
            init_os (os, NULL, 0);
            init_os (os, NULL, 0);
 
 
          /* Make sure that any sections mentioned in the assignment
          /* Make sure that any sections mentioned in the assignment
             are initialized.  */
             are initialized.  */
          exp_init_os (s->assignment_statement.exp);
          exp_init_os (s->assignment_statement.exp);
          break;
          break;
        case lang_address_statement_enum:
        case lang_address_statement_enum:
          /* Mark the specified section with the supplied address.
          /* Mark the specified section with the supplied address.
 
 
             If this section was actually a segment marker, then the
             If this section was actually a segment marker, then the
             directive is ignored if the linker script explicitly
             directive is ignored if the linker script explicitly
             processed the segment marker.  Originally, the linker
             processed the segment marker.  Originally, the linker
             treated segment directives (like -Ttext on the
             treated segment directives (like -Ttext on the
             command-line) as section directives.  We honor the
             command-line) as section directives.  We honor the
             section directive semantics for backwards compatibilty;
             section directive semantics for backwards compatibilty;
             linker scripts that do not specifically check for
             linker scripts that do not specifically check for
             SEGMENT_START automatically get the old semantics.  */
             SEGMENT_START automatically get the old semantics.  */
          if (!s->address_statement.segment
          if (!s->address_statement.segment
              || !s->address_statement.segment->used)
              || !s->address_statement.segment->used)
            {
            {
              lang_output_section_statement_type *aos
              lang_output_section_statement_type *aos
                = (lang_output_section_statement_lookup
                = (lang_output_section_statement_lookup
                   (s->address_statement.section_name));
                   (s->address_statement.section_name));
 
 
              if (aos->bfd_section == NULL)
              if (aos->bfd_section == NULL)
                init_os (aos, NULL, 0);
                init_os (aos, NULL, 0);
              aos->addr_tree = s->address_statement.address;
              aos->addr_tree = s->address_statement.address;
            }
            }
          break;
          break;
        case lang_insert_statement_enum:
        case lang_insert_statement_enum:
          break;
          break;
        }
        }
    }
    }
}
}
 
 
/* An insert statement snips out all the linker statements from the
/* An insert statement snips out all the linker statements from the
   start of the list and places them after the output section
   start of the list and places them after the output section
   statement specified by the insert.  This operation is complicated
   statement specified by the insert.  This operation is complicated
   by the fact that we keep a doubly linked list of output section
   by the fact that we keep a doubly linked list of output section
   statements as well as the singly linked list of all statements.  */
   statements as well as the singly linked list of all statements.  */
 
 
static void
static void
process_insert_statements (void)
process_insert_statements (void)
{
{
  lang_statement_union_type **s;
  lang_statement_union_type **s;
  lang_output_section_statement_type *first_os = NULL;
  lang_output_section_statement_type *first_os = NULL;
  lang_output_section_statement_type *last_os = NULL;
  lang_output_section_statement_type *last_os = NULL;
 
 
  /* "start of list" is actually the statement immediately after
  /* "start of list" is actually the statement immediately after
     the special abs_section output statement, so that it isn't
     the special abs_section output statement, so that it isn't
     reordered.  */
     reordered.  */
  s = &lang_output_section_statement.head;
  s = &lang_output_section_statement.head;
  while (*(s = &(*s)->header.next) != NULL)
  while (*(s = &(*s)->header.next) != NULL)
    {
    {
      if ((*s)->header.type == lang_output_section_statement_enum)
      if ((*s)->header.type == lang_output_section_statement_enum)
        {
        {
          /* Keep pointers to the first and last output section
          /* Keep pointers to the first and last output section
             statement in the sequence we may be about to move.  */
             statement in the sequence we may be about to move.  */
          last_os = &(*s)->output_section_statement;
          last_os = &(*s)->output_section_statement;
          if (first_os == NULL)
          if (first_os == NULL)
            first_os = last_os;
            first_os = last_os;
        }
        }
      else if ((*s)->header.type == lang_insert_statement_enum)
      else if ((*s)->header.type == lang_insert_statement_enum)
        {
        {
          lang_insert_statement_type *i = &(*s)->insert_statement;
          lang_insert_statement_type *i = &(*s)->insert_statement;
          lang_output_section_statement_type *where;
          lang_output_section_statement_type *where;
          lang_output_section_statement_type *os;
          lang_output_section_statement_type *os;
          lang_statement_union_type **ptr;
          lang_statement_union_type **ptr;
          lang_statement_union_type *first;
          lang_statement_union_type *first;
 
 
          where = lang_output_section_find (i->where);
          where = lang_output_section_find (i->where);
          if (where != NULL && i->is_before)
          if (where != NULL && i->is_before)
            {
            {
              do
              do
                where = where->prev;
                where = where->prev;
              while (where != NULL && where->constraint == -1);
              while (where != NULL && where->constraint == -1);
            }
            }
          if (where == NULL)
          if (where == NULL)
            {
            {
              einfo (_("%X%P: %s not found for insert\n"), i->where);
              einfo (_("%X%P: %s not found for insert\n"), i->where);
              continue;
              continue;
            }
            }
          /* You can't insert into the list you are moving.  */
          /* You can't insert into the list you are moving.  */
          for (os = first_os; os != NULL; os = os->next)
          for (os = first_os; os != NULL; os = os->next)
            if (os == where || os == last_os)
            if (os == where || os == last_os)
              break;
              break;
          if (os == where)
          if (os == where)
            {
            {
              einfo (_("%X%P: %s not found for insert\n"), i->where);
              einfo (_("%X%P: %s not found for insert\n"), i->where);
              continue;
              continue;
            }
            }
 
 
          /* Deal with reordering the output section statement list.  */
          /* Deal with reordering the output section statement list.  */
          if (last_os != NULL)
          if (last_os != NULL)
            {
            {
              asection *first_sec, *last_sec;
              asection *first_sec, *last_sec;
              struct lang_output_section_statement_struct **next;
              struct lang_output_section_statement_struct **next;
 
 
              /* Snip out the output sections we are moving.  */
              /* Snip out the output sections we are moving.  */
              first_os->prev->next = last_os->next;
              first_os->prev->next = last_os->next;
              if (last_os->next == NULL)
              if (last_os->next == NULL)
                {
                {
                  next = &first_os->prev->next;
                  next = &first_os->prev->next;
                  lang_output_section_statement.tail
                  lang_output_section_statement.tail
                    = (lang_statement_union_type **) next;
                    = (lang_statement_union_type **) next;
                }
                }
              else
              else
                last_os->next->prev = first_os->prev;
                last_os->next->prev = first_os->prev;
              /* Add them in at the new position.  */
              /* Add them in at the new position.  */
              last_os->next = where->next;
              last_os->next = where->next;
              if (where->next == NULL)
              if (where->next == NULL)
                {
                {
                  next = &last_os->next;
                  next = &last_os->next;
                  lang_output_section_statement.tail
                  lang_output_section_statement.tail
                    = (lang_statement_union_type **) next;
                    = (lang_statement_union_type **) next;
                }
                }
              else
              else
                where->next->prev = last_os;
                where->next->prev = last_os;
              first_os->prev = where;
              first_os->prev = where;
              where->next = first_os;
              where->next = first_os;
 
 
              /* Move the bfd sections in the same way.  */
              /* Move the bfd sections in the same way.  */
              first_sec = NULL;
              first_sec = NULL;
              last_sec = NULL;
              last_sec = NULL;
              for (os = first_os; os != NULL; os = os->next)
              for (os = first_os; os != NULL; os = os->next)
                {
                {
                  if (os->bfd_section != NULL
                  if (os->bfd_section != NULL
                      && os->bfd_section->owner != NULL)
                      && os->bfd_section->owner != NULL)
                    {
                    {
                      last_sec = os->bfd_section;
                      last_sec = os->bfd_section;
                      if (first_sec == NULL)
                      if (first_sec == NULL)
                        first_sec = last_sec;
                        first_sec = last_sec;
                    }
                    }
                  if (os == last_os)
                  if (os == last_os)
                    break;
                    break;
                }
                }
              if (last_sec != NULL)
              if (last_sec != NULL)
                {
                {
                  asection *sec = where->bfd_section;
                  asection *sec = where->bfd_section;
                  if (sec == NULL)
                  if (sec == NULL)
                    sec = output_prev_sec_find (where);
                    sec = output_prev_sec_find (where);
 
 
                  /* The place we want to insert must come after the
                  /* The place we want to insert must come after the
                     sections we are moving.  So if we find no
                     sections we are moving.  So if we find no
                     section or if the section is the same as our
                     section or if the section is the same as our
                     last section, then no move is needed.  */
                     last section, then no move is needed.  */
                  if (sec != NULL && sec != last_sec)
                  if (sec != NULL && sec != last_sec)
                    {
                    {
                      /* Trim them off.  */
                      /* Trim them off.  */
                      if (first_sec->prev != NULL)
                      if (first_sec->prev != NULL)
                        first_sec->prev->next = last_sec->next;
                        first_sec->prev->next = last_sec->next;
                      else
                      else
                        link_info.output_bfd->sections = last_sec->next;
                        link_info.output_bfd->sections = last_sec->next;
                      if (last_sec->next != NULL)
                      if (last_sec->next != NULL)
                        last_sec->next->prev = first_sec->prev;
                        last_sec->next->prev = first_sec->prev;
                      else
                      else
                        link_info.output_bfd->section_last = first_sec->prev;
                        link_info.output_bfd->section_last = first_sec->prev;
                      /* Add back.  */
                      /* Add back.  */
                      last_sec->next = sec->next;
                      last_sec->next = sec->next;
                      if (sec->next != NULL)
                      if (sec->next != NULL)
                        sec->next->prev = last_sec;
                        sec->next->prev = last_sec;
                      else
                      else
                        link_info.output_bfd->section_last = last_sec;
                        link_info.output_bfd->section_last = last_sec;
                      first_sec->prev = sec;
                      first_sec->prev = sec;
                      sec->next = first_sec;
                      sec->next = first_sec;
                    }
                    }
                }
                }
 
 
              first_os = NULL;
              first_os = NULL;
              last_os = NULL;
              last_os = NULL;
            }
            }
 
 
          ptr = insert_os_after (where);
          ptr = insert_os_after (where);
          /* Snip everything after the abs_section output statement we
          /* Snip everything after the abs_section output statement we
             know is at the start of the list, up to and including
             know is at the start of the list, up to and including
             the insert statement we are currently processing.  */
             the insert statement we are currently processing.  */
          first = lang_output_section_statement.head->header.next;
          first = lang_output_section_statement.head->header.next;
          lang_output_section_statement.head->header.next = (*s)->header.next;
          lang_output_section_statement.head->header.next = (*s)->header.next;
          /* Add them back where they belong.  */
          /* Add them back where they belong.  */
          *s = *ptr;
          *s = *ptr;
          if (*s == NULL)
          if (*s == NULL)
            statement_list.tail = s;
            statement_list.tail = s;
          *ptr = first;
          *ptr = first;
          s = &lang_output_section_statement.head;
          s = &lang_output_section_statement.head;
        }
        }
    }
    }
}
}
 
 
/* An output section might have been removed after its statement was
/* An output section might have been removed after its statement was
   added.  For example, ldemul_before_allocation can remove dynamic
   added.  For example, ldemul_before_allocation can remove dynamic
   sections if they turn out to be not needed.  Clean them up here.  */
   sections if they turn out to be not needed.  Clean them up here.  */
 
 
void
void
strip_excluded_output_sections (void)
strip_excluded_output_sections (void)
{
{
  lang_output_section_statement_type *os;
  lang_output_section_statement_type *os;
 
 
  /* Run lang_size_sections (if not already done).  */
  /* Run lang_size_sections (if not already done).  */
  if (expld.phase != lang_mark_phase_enum)
  if (expld.phase != lang_mark_phase_enum)
    {
    {
      expld.phase = lang_mark_phase_enum;
      expld.phase = lang_mark_phase_enum;
      expld.dataseg.phase = exp_dataseg_none;
      expld.dataseg.phase = exp_dataseg_none;
      one_lang_size_sections_pass (NULL, FALSE);
      one_lang_size_sections_pass (NULL, FALSE);
      lang_reset_memory_regions ();
      lang_reset_memory_regions ();
    }
    }
 
 
  for (os = &lang_output_section_statement.head->output_section_statement;
  for (os = &lang_output_section_statement.head->output_section_statement;
       os != NULL;
       os != NULL;
       os = os->next)
       os = os->next)
    {
    {
      asection *output_section;
      asection *output_section;
      bfd_boolean exclude;
      bfd_boolean exclude;
 
 
      if (os->constraint == -1)
      if (os->constraint == -1)
        continue;
        continue;
 
 
      output_section = os->bfd_section;
      output_section = os->bfd_section;
      if (output_section == NULL)
      if (output_section == NULL)
        continue;
        continue;
 
 
      exclude = (output_section->rawsize == 0
      exclude = (output_section->rawsize == 0
                 && (output_section->flags & SEC_KEEP) == 0
                 && (output_section->flags & SEC_KEEP) == 0
                 && !bfd_section_removed_from_list (link_info.output_bfd,
                 && !bfd_section_removed_from_list (link_info.output_bfd,
                                                    output_section));
                                                    output_section));
 
 
      /* Some sections have not yet been sized, notably .gnu.version,
      /* Some sections have not yet been sized, notably .gnu.version,
         .dynsym, .dynstr and .hash.  These all have SEC_LINKER_CREATED
         .dynsym, .dynstr and .hash.  These all have SEC_LINKER_CREATED
         input sections, so don't drop output sections that have such
         input sections, so don't drop output sections that have such
         input sections unless they are also marked SEC_EXCLUDE.  */
         input sections unless they are also marked SEC_EXCLUDE.  */
      if (exclude && output_section->map_head.s != NULL)
      if (exclude && output_section->map_head.s != NULL)
        {
        {
          asection *s;
          asection *s;
 
 
          for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
          for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
            if ((s->flags & SEC_LINKER_CREATED) != 0
            if ((s->flags & SEC_LINKER_CREATED) != 0
                && (s->flags & SEC_EXCLUDE) == 0)
                && (s->flags & SEC_EXCLUDE) == 0)
              {
              {
                exclude = FALSE;
                exclude = FALSE;
                break;
                break;
              }
              }
        }
        }
 
 
      /* TODO: Don't just junk map_head.s, turn them into link_orders.  */
      /* TODO: Don't just junk map_head.s, turn them into link_orders.  */
      output_section->map_head.link_order = NULL;
      output_section->map_head.link_order = NULL;
      output_section->map_tail.link_order = NULL;
      output_section->map_tail.link_order = NULL;
 
 
      if (exclude)
      if (exclude)
        {
        {
          /* We don't set bfd_section to NULL since bfd_section of the
          /* We don't set bfd_section to NULL since bfd_section of the
             removed output section statement may still be used.  */
             removed output section statement may still be used.  */
          if (!os->section_relative_symbol
          if (!os->section_relative_symbol
              && !os->update_dot_tree)
              && !os->update_dot_tree)
            os->ignored = TRUE;
            os->ignored = TRUE;
          output_section->flags |= SEC_EXCLUDE;
          output_section->flags |= SEC_EXCLUDE;
          bfd_section_list_remove (link_info.output_bfd, output_section);
          bfd_section_list_remove (link_info.output_bfd, output_section);
          link_info.output_bfd->section_count--;
          link_info.output_bfd->section_count--;
        }
        }
    }
    }
 
 
  /* Stop future calls to lang_add_section from messing with map_head
  /* Stop future calls to lang_add_section from messing with map_head
     and map_tail link_order fields.  */
     and map_tail link_order fields.  */
  stripped_excluded_sections = TRUE;
  stripped_excluded_sections = TRUE;
}
}
 
 
static void
static void
print_output_section_statement
print_output_section_statement
  (lang_output_section_statement_type *output_section_statement)
  (lang_output_section_statement_type *output_section_statement)
{
{
  asection *section = output_section_statement->bfd_section;
  asection *section = output_section_statement->bfd_section;
  int len;
  int len;
 
 
  if (output_section_statement != abs_output_section)
  if (output_section_statement != abs_output_section)
    {
    {
      minfo ("\n%s", output_section_statement->name);
      minfo ("\n%s", output_section_statement->name);
 
 
      if (section != NULL)
      if (section != NULL)
        {
        {
          print_dot = section->vma;
          print_dot = section->vma;
 
 
          len = strlen (output_section_statement->name);
          len = strlen (output_section_statement->name);
          if (len >= SECTION_NAME_MAP_LENGTH - 1)
          if (len >= SECTION_NAME_MAP_LENGTH - 1)
            {
            {
              print_nl ();
              print_nl ();
              len = 0;
              len = 0;
            }
            }
          while (len < SECTION_NAME_MAP_LENGTH)
          while (len < SECTION_NAME_MAP_LENGTH)
            {
            {
              print_space ();
              print_space ();
              ++len;
              ++len;
            }
            }
 
 
          minfo ("0x%V %W", section->vma, section->size);
          minfo ("0x%V %W", section->vma, section->size);
 
 
          if (section->vma != section->lma)
          if (section->vma != section->lma)
            minfo (_(" load address 0x%V"), section->lma);
            minfo (_(" load address 0x%V"), section->lma);
        }
        }
 
 
      print_nl ();
      print_nl ();
    }
    }
 
 
  print_statement_list (output_section_statement->children.head,
  print_statement_list (output_section_statement->children.head,
                        output_section_statement);
                        output_section_statement);
}
}
 
 
/* Scan for the use of the destination in the right hand side
/* Scan for the use of the destination in the right hand side
   of an expression.  In such cases we will not compute the
   of an expression.  In such cases we will not compute the
   correct expression, since the value of DST that is used on
   correct expression, since the value of DST that is used on
   the right hand side will be its final value, not its value
   the right hand side will be its final value, not its value
   just before this expression is evaluated.  */
   just before this expression is evaluated.  */
 
 
static bfd_boolean
static bfd_boolean
scan_for_self_assignment (const char * dst, etree_type * rhs)
scan_for_self_assignment (const char * dst, etree_type * rhs)
{
{
  if (rhs == NULL || dst == NULL)
  if (rhs == NULL || dst == NULL)
    return FALSE;
    return FALSE;
 
 
  switch (rhs->type.node_class)
  switch (rhs->type.node_class)
    {
    {
    case etree_binary:
    case etree_binary:
      return scan_for_self_assignment (dst, rhs->binary.lhs)
      return scan_for_self_assignment (dst, rhs->binary.lhs)
        ||   scan_for_self_assignment (dst, rhs->binary.rhs);
        ||   scan_for_self_assignment (dst, rhs->binary.rhs);
 
 
    case etree_trinary:
    case etree_trinary:
      return scan_for_self_assignment (dst, rhs->trinary.lhs)
      return scan_for_self_assignment (dst, rhs->trinary.lhs)
        ||   scan_for_self_assignment (dst, rhs->trinary.rhs);
        ||   scan_for_self_assignment (dst, rhs->trinary.rhs);
 
 
    case etree_assign:
    case etree_assign:
    case etree_provided:
    case etree_provided:
    case etree_provide:
    case etree_provide:
      if (strcmp (dst, rhs->assign.dst) == 0)
      if (strcmp (dst, rhs->assign.dst) == 0)
        return TRUE;
        return TRUE;
      return scan_for_self_assignment (dst, rhs->assign.src);
      return scan_for_self_assignment (dst, rhs->assign.src);
 
 
    case etree_unary:
    case etree_unary:
      return scan_for_self_assignment (dst, rhs->unary.child);
      return scan_for_self_assignment (dst, rhs->unary.child);
 
 
    case etree_value:
    case etree_value:
      if (rhs->value.str)
      if (rhs->value.str)
        return strcmp (dst, rhs->value.str) == 0;
        return strcmp (dst, rhs->value.str) == 0;
      return FALSE;
      return FALSE;
 
 
    case etree_name:
    case etree_name:
      if (rhs->name.name)
      if (rhs->name.name)
        return strcmp (dst, rhs->name.name) == 0;
        return strcmp (dst, rhs->name.name) == 0;
      return FALSE;
      return FALSE;
 
 
    default:
    default:
      break;
      break;
    }
    }
 
 
  return FALSE;
  return FALSE;
}
}
 
 
 
 
static void
static void
print_assignment (lang_assignment_statement_type *assignment,
print_assignment (lang_assignment_statement_type *assignment,
                  lang_output_section_statement_type *output_section)
                  lang_output_section_statement_type *output_section)
{
{
  unsigned int i;
  unsigned int i;
  bfd_boolean is_dot;
  bfd_boolean is_dot;
  bfd_boolean computation_is_valid = TRUE;
  bfd_boolean computation_is_valid = TRUE;
  etree_type *tree;
  etree_type *tree;
 
 
  for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
  for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
    print_space ();
    print_space ();
 
 
  if (assignment->exp->type.node_class == etree_assert)
  if (assignment->exp->type.node_class == etree_assert)
    {
    {
      is_dot = FALSE;
      is_dot = FALSE;
      tree = assignment->exp->assert_s.child;
      tree = assignment->exp->assert_s.child;
      computation_is_valid = TRUE;
      computation_is_valid = TRUE;
    }
    }
  else
  else
    {
    {
      const char *dst = assignment->exp->assign.dst;
      const char *dst = assignment->exp->assign.dst;
 
 
      is_dot = (dst[0] == '.' && dst[1] == 0);
      is_dot = (dst[0] == '.' && dst[1] == 0);
      tree = assignment->exp->assign.src;
      tree = assignment->exp->assign.src;
      computation_is_valid = is_dot || (scan_for_self_assignment (dst, tree) == FALSE);
      computation_is_valid = is_dot || (scan_for_self_assignment (dst, tree) == FALSE);
    }
    }
 
 
  exp_fold_tree (tree, output_section->bfd_section, &print_dot);
  exp_fold_tree (tree, output_section->bfd_section, &print_dot);
  if (expld.result.valid_p)
  if (expld.result.valid_p)
    {
    {
      bfd_vma value;
      bfd_vma value;
 
 
      if (computation_is_valid)
      if (computation_is_valid)
        {
        {
          value = expld.result.value;
          value = expld.result.value;
 
 
          if (expld.result.section)
          if (expld.result.section)
            value += expld.result.section->vma;
            value += expld.result.section->vma;
 
 
          minfo ("0x%V", value);
          minfo ("0x%V", value);
          if (is_dot)
          if (is_dot)
            print_dot = value;
            print_dot = value;
        }
        }
      else
      else
        {
        {
          struct bfd_link_hash_entry *h;
          struct bfd_link_hash_entry *h;
 
 
          h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
          h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
                                    FALSE, FALSE, TRUE);
                                    FALSE, FALSE, TRUE);
          if (h)
          if (h)
            {
            {
              value = h->u.def.value;
              value = h->u.def.value;
 
 
              if (expld.result.section)
              if (expld.result.section)
                value += expld.result.section->vma;
                value += expld.result.section->vma;
 
 
              minfo ("[0x%V]", value);
              minfo ("[0x%V]", value);
            }
            }
          else
          else
            minfo ("[unresolved]");
            minfo ("[unresolved]");
        }
        }
    }
    }
  else
  else
    {
    {
      minfo ("*undef*   ");
      minfo ("*undef*   ");
#ifdef BFD64
#ifdef BFD64
      minfo ("        ");
      minfo ("        ");
#endif
#endif
    }
    }
 
 
  minfo ("                ");
  minfo ("                ");
  exp_print_tree (assignment->exp);
  exp_print_tree (assignment->exp);
  print_nl ();
  print_nl ();
}
}
 
 
static void
static void
print_input_statement (lang_input_statement_type *statm)
print_input_statement (lang_input_statement_type *statm)
{
{
  if (statm->filename != NULL)
  if (statm->filename != NULL)
    {
    {
      fprintf (config.map_file, "LOAD %s\n", statm->filename);
      fprintf (config.map_file, "LOAD %s\n", statm->filename);
    }
    }
}
}
 
 
/* Print all symbols defined in a particular section.  This is called
/* Print all symbols defined in a particular section.  This is called
   via bfd_link_hash_traverse, or by print_all_symbols.  */
   via bfd_link_hash_traverse, or by print_all_symbols.  */
 
 
static bfd_boolean
static bfd_boolean
print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
{
{
  asection *sec = ptr;
  asection *sec = ptr;
 
 
  if ((hash_entry->type == bfd_link_hash_defined
  if ((hash_entry->type == bfd_link_hash_defined
       || hash_entry->type == bfd_link_hash_defweak)
       || hash_entry->type == bfd_link_hash_defweak)
      && sec == hash_entry->u.def.section)
      && sec == hash_entry->u.def.section)
    {
    {
      int i;
      int i;
 
 
      for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
      for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
        print_space ();
        print_space ();
      minfo ("0x%V   ",
      minfo ("0x%V   ",
             (hash_entry->u.def.value
             (hash_entry->u.def.value
              + hash_entry->u.def.section->output_offset
              + hash_entry->u.def.section->output_offset
              + hash_entry->u.def.section->output_section->vma));
              + hash_entry->u.def.section->output_section->vma));
 
 
      minfo ("             %T\n", hash_entry->root.string);
      minfo ("             %T\n", hash_entry->root.string);
    }
    }
 
 
  return TRUE;
  return TRUE;
}
}
 
 
static void
static void
print_all_symbols (asection *sec)
print_all_symbols (asection *sec)
{
{
  struct fat_user_section_struct *ud = get_userdata (sec);
  struct fat_user_section_struct *ud = get_userdata (sec);
  struct map_symbol_def *def;
  struct map_symbol_def *def;
 
 
  if (!ud)
  if (!ud)
    return;
    return;
 
 
  *ud->map_symbol_def_tail = 0;
  *ud->map_symbol_def_tail = 0;
  for (def = ud->map_symbol_def_head; def; def = def->next)
  for (def = ud->map_symbol_def_head; def; def = def->next)
    print_one_symbol (def->entry, sec);
    print_one_symbol (def->entry, sec);
}
}
 
 
/* Print information about an input section to the map file.  */
/* Print information about an input section to the map file.  */
 
 
static void
static void
print_input_section (asection *i)
print_input_section (asection *i)
{
{
  bfd_size_type size = i->size;
  bfd_size_type size = i->size;
  int len;
  int len;
  bfd_vma addr;
  bfd_vma addr;
 
 
  init_opb ();
  init_opb ();
 
 
  print_space ();
  print_space ();
  minfo ("%s", i->name);
  minfo ("%s", i->name);
 
 
  len = 1 + strlen (i->name);
  len = 1 + strlen (i->name);
  if (len >= SECTION_NAME_MAP_LENGTH - 1)
  if (len >= SECTION_NAME_MAP_LENGTH - 1)
    {
    {
      print_nl ();
      print_nl ();
      len = 0;
      len = 0;
    }
    }
  while (len < SECTION_NAME_MAP_LENGTH)
  while (len < SECTION_NAME_MAP_LENGTH)
    {
    {
      print_space ();
      print_space ();
      ++len;
      ++len;
    }
    }
 
 
  if (i->output_section != NULL
  if (i->output_section != NULL
      && i->output_section->owner == link_info.output_bfd)
      && i->output_section->owner == link_info.output_bfd)
    addr = i->output_section->vma + i->output_offset;
    addr = i->output_section->vma + i->output_offset;
  else
  else
    {
    {
      addr = print_dot;
      addr = print_dot;
      size = 0;
      size = 0;
    }
    }
 
 
  minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
  minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
 
 
  if (size != i->rawsize && i->rawsize != 0)
  if (size != i->rawsize && i->rawsize != 0)
    {
    {
      len = SECTION_NAME_MAP_LENGTH + 3;
      len = SECTION_NAME_MAP_LENGTH + 3;
#ifdef BFD64
#ifdef BFD64
      len += 16;
      len += 16;
#else
#else
      len += 8;
      len += 8;
#endif
#endif
      while (len > 0)
      while (len > 0)
        {
        {
          print_space ();
          print_space ();
          --len;
          --len;
        }
        }
 
 
      minfo (_("%W (size before relaxing)\n"), i->rawsize);
      minfo (_("%W (size before relaxing)\n"), i->rawsize);
    }
    }
 
 
  if (i->output_section != NULL
  if (i->output_section != NULL
      && i->output_section->owner == link_info.output_bfd)
      && i->output_section->owner == link_info.output_bfd)
    {
    {
      if (link_info.reduce_memory_overheads)
      if (link_info.reduce_memory_overheads)
        bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
        bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
      else
      else
        print_all_symbols (i);
        print_all_symbols (i);
 
 
      print_dot = addr + TO_ADDR (size);
      print_dot = addr + TO_ADDR (size);
    }
    }
}
}
 
 
static void
static void
print_fill_statement (lang_fill_statement_type *fill)
print_fill_statement (lang_fill_statement_type *fill)
{
{
  size_t size;
  size_t size;
  unsigned char *p;
  unsigned char *p;
  fputs (" FILL mask 0x", config.map_file);
  fputs (" FILL mask 0x", config.map_file);
  for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
  for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
    fprintf (config.map_file, "%02x", *p);
    fprintf (config.map_file, "%02x", *p);
  fputs ("\n", config.map_file);
  fputs ("\n", config.map_file);
}
}
 
 
static void
static void
print_data_statement (lang_data_statement_type *data)
print_data_statement (lang_data_statement_type *data)
{
{
  int i;
  int i;
  bfd_vma addr;
  bfd_vma addr;
  bfd_size_type size;
  bfd_size_type size;
  const char *name;
  const char *name;
 
 
  init_opb ();
  init_opb ();
  for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
  for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
    print_space ();
    print_space ();
 
 
  addr = data->output_offset;
  addr = data->output_offset;
  if (data->output_section != NULL)
  if (data->output_section != NULL)
    addr += data->output_section->vma;
    addr += data->output_section->vma;
 
 
  switch (data->type)
  switch (data->type)
    {
    {
    default:
    default:
      abort ();
      abort ();
    case BYTE:
    case BYTE:
      size = BYTE_SIZE;
      size = BYTE_SIZE;
      name = "BYTE";
      name = "BYTE";
      break;
      break;
    case SHORT:
    case SHORT:
      size = SHORT_SIZE;
      size = SHORT_SIZE;
      name = "SHORT";
      name = "SHORT";
      break;
      break;
    case LONG:
    case LONG:
      size = LONG_SIZE;
      size = LONG_SIZE;
      name = "LONG";
      name = "LONG";
      break;
      break;
    case QUAD:
    case QUAD:
      size = QUAD_SIZE;
      size = QUAD_SIZE;
      name = "QUAD";
      name = "QUAD";
      break;
      break;
    case SQUAD:
    case SQUAD:
      size = QUAD_SIZE;
      size = QUAD_SIZE;
      name = "SQUAD";
      name = "SQUAD";
      break;
      break;
    }
    }
 
 
  minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
  minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
 
 
  if (data->exp->type.node_class != etree_value)
  if (data->exp->type.node_class != etree_value)
    {
    {
      print_space ();
      print_space ();
      exp_print_tree (data->exp);
      exp_print_tree (data->exp);
    }
    }
 
 
  print_nl ();
  print_nl ();
 
 
  print_dot = addr + TO_ADDR (size);
  print_dot = addr + TO_ADDR (size);
}
}
 
 
/* Print an address statement.  These are generated by options like
/* Print an address statement.  These are generated by options like
   -Ttext.  */
   -Ttext.  */
 
 
static void
static void
print_address_statement (lang_address_statement_type *address)
print_address_statement (lang_address_statement_type *address)
{
{
  minfo (_("Address of section %s set to "), address->section_name);
  minfo (_("Address of section %s set to "), address->section_name);
  exp_print_tree (address->address);
  exp_print_tree (address->address);
  print_nl ();
  print_nl ();
}
}
 
 
/* Print a reloc statement.  */
/* Print a reloc statement.  */
 
 
static void
static void
print_reloc_statement (lang_reloc_statement_type *reloc)
print_reloc_statement (lang_reloc_statement_type *reloc)
{
{
  int i;
  int i;
  bfd_vma addr;
  bfd_vma addr;
  bfd_size_type size;
  bfd_size_type size;
 
 
  init_opb ();
  init_opb ();
  for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
  for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
    print_space ();
    print_space ();
 
 
  addr = reloc->output_offset;
  addr = reloc->output_offset;
  if (reloc->output_section != NULL)
  if (reloc->output_section != NULL)
    addr += reloc->output_section->vma;
    addr += reloc->output_section->vma;
 
 
  size = bfd_get_reloc_size (reloc->howto);
  size = bfd_get_reloc_size (reloc->howto);
 
 
  minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
  minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
 
 
  if (reloc->name != NULL)
  if (reloc->name != NULL)
    minfo ("%s+", reloc->name);
    minfo ("%s+", reloc->name);
  else
  else
    minfo ("%s+", reloc->section->name);
    minfo ("%s+", reloc->section->name);
 
 
  exp_print_tree (reloc->addend_exp);
  exp_print_tree (reloc->addend_exp);
 
 
  print_nl ();
  print_nl ();
 
 
  print_dot = addr + TO_ADDR (size);
  print_dot = addr + TO_ADDR (size);
}
}
 
 
static void
static void
print_padding_statement (lang_padding_statement_type *s)
print_padding_statement (lang_padding_statement_type *s)
{
{
  int len;
  int len;
  bfd_vma addr;
  bfd_vma addr;
 
 
  init_opb ();
  init_opb ();
  minfo (" *fill*");
  minfo (" *fill*");
 
 
  len = sizeof " *fill*" - 1;
  len = sizeof " *fill*" - 1;
  while (len < SECTION_NAME_MAP_LENGTH)
  while (len < SECTION_NAME_MAP_LENGTH)
    {
    {
      print_space ();
      print_space ();
      ++len;
      ++len;
    }
    }
 
 
  addr = s->output_offset;
  addr = s->output_offset;
  if (s->output_section != NULL)
  if (s->output_section != NULL)
    addr += s->output_section->vma;
    addr += s->output_section->vma;
  minfo ("0x%V %W ", addr, (bfd_vma) s->size);
  minfo ("0x%V %W ", addr, (bfd_vma) s->size);
 
 
  if (s->fill->size != 0)
  if (s->fill->size != 0)
    {
    {
      size_t size;
      size_t size;
      unsigned char *p;
      unsigned char *p;
      for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
      for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
        fprintf (config.map_file, "%02x", *p);
        fprintf (config.map_file, "%02x", *p);
    }
    }
 
 
  print_nl ();
  print_nl ();
 
 
  print_dot = addr + TO_ADDR (s->size);
  print_dot = addr + TO_ADDR (s->size);
}
}
 
 
static void
static void
print_wild_statement (lang_wild_statement_type *w,
print_wild_statement (lang_wild_statement_type *w,
                      lang_output_section_statement_type *os)
                      lang_output_section_statement_type *os)
{
{
  struct wildcard_list *sec;
  struct wildcard_list *sec;
 
 
  print_space ();
  print_space ();
 
 
  if (w->filenames_sorted)
  if (w->filenames_sorted)
    minfo ("SORT(");
    minfo ("SORT(");
  if (w->filename != NULL)
  if (w->filename != NULL)
    minfo ("%s", w->filename);
    minfo ("%s", w->filename);
  else
  else
    minfo ("*");
    minfo ("*");
  if (w->filenames_sorted)
  if (w->filenames_sorted)
    minfo (")");
    minfo (")");
 
 
  minfo ("(");
  minfo ("(");
  for (sec = w->section_list; sec; sec = sec->next)
  for (sec = w->section_list; sec; sec = sec->next)
    {
    {
      if (sec->spec.sorted)
      if (sec->spec.sorted)
        minfo ("SORT(");
        minfo ("SORT(");
      if (sec->spec.exclude_name_list != NULL)
      if (sec->spec.exclude_name_list != NULL)
        {
        {
          name_list *tmp;
          name_list *tmp;
          minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
          minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
          for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
          for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
            minfo (" %s", tmp->name);
            minfo (" %s", tmp->name);
          minfo (") ");
          minfo (") ");
        }
        }
      if (sec->spec.name != NULL)
      if (sec->spec.name != NULL)
        minfo ("%s", sec->spec.name);
        minfo ("%s", sec->spec.name);
      else
      else
        minfo ("*");
        minfo ("*");
      if (sec->spec.sorted)
      if (sec->spec.sorted)
        minfo (")");
        minfo (")");
      if (sec->next)
      if (sec->next)
        minfo (" ");
        minfo (" ");
    }
    }
  minfo (")");
  minfo (")");
 
 
  print_nl ();
  print_nl ();
 
 
  print_statement_list (w->children.head, os);
  print_statement_list (w->children.head, os);
}
}
 
 
/* Print a group statement.  */
/* Print a group statement.  */
 
 
static void
static void
print_group (lang_group_statement_type *s,
print_group (lang_group_statement_type *s,
             lang_output_section_statement_type *os)
             lang_output_section_statement_type *os)
{
{
  fprintf (config.map_file, "START GROUP\n");
  fprintf (config.map_file, "START GROUP\n");
  print_statement_list (s->children.head, os);
  print_statement_list (s->children.head, os);
  fprintf (config.map_file, "END GROUP\n");
  fprintf (config.map_file, "END GROUP\n");
}
}
 
 
/* Print the list of statements in S.
/* Print the list of statements in S.
   This can be called for any statement type.  */
   This can be called for any statement type.  */
 
 
static void
static void
print_statement_list (lang_statement_union_type *s,
print_statement_list (lang_statement_union_type *s,
                      lang_output_section_statement_type *os)
                      lang_output_section_statement_type *os)
{
{
  while (s != NULL)
  while (s != NULL)
    {
    {
      print_statement (s, os);
      print_statement (s, os);
      s = s->header.next;
      s = s->header.next;
    }
    }
}
}
 
 
/* Print the first statement in statement list S.
/* Print the first statement in statement list S.
   This can be called for any statement type.  */
   This can be called for any statement type.  */
 
 
static void
static void
print_statement (lang_statement_union_type *s,
print_statement (lang_statement_union_type *s,
                 lang_output_section_statement_type *os)
                 lang_output_section_statement_type *os)
{
{
  switch (s->header.type)
  switch (s->header.type)
    {
    {
    default:
    default:
      fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
      fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
      FAIL ();
      FAIL ();
      break;
      break;
    case lang_constructors_statement_enum:
    case lang_constructors_statement_enum:
      if (constructor_list.head != NULL)
      if (constructor_list.head != NULL)
        {
        {
          if (constructors_sorted)
          if (constructors_sorted)
            minfo (" SORT (CONSTRUCTORS)\n");
            minfo (" SORT (CONSTRUCTORS)\n");
          else
          else
            minfo (" CONSTRUCTORS\n");
            minfo (" CONSTRUCTORS\n");
          print_statement_list (constructor_list.head, os);
          print_statement_list (constructor_list.head, os);
        }
        }
      break;
      break;
    case lang_wild_statement_enum:
    case lang_wild_statement_enum:
      print_wild_statement (&s->wild_statement, os);
      print_wild_statement (&s->wild_statement, os);
      break;
      break;
    case lang_address_statement_enum:
    case lang_address_statement_enum:
      print_address_statement (&s->address_statement);
      print_address_statement (&s->address_statement);
      break;
      break;
    case lang_object_symbols_statement_enum:
    case lang_object_symbols_statement_enum:
      minfo (" CREATE_OBJECT_SYMBOLS\n");
      minfo (" CREATE_OBJECT_SYMBOLS\n");
      break;
      break;
    case lang_fill_statement_enum:
    case lang_fill_statement_enum:
      print_fill_statement (&s->fill_statement);
      print_fill_statement (&s->fill_statement);
      break;
      break;
    case lang_data_statement_enum:
    case lang_data_statement_enum:
      print_data_statement (&s->data_statement);
      print_data_statement (&s->data_statement);
      break;
      break;
    case lang_reloc_statement_enum:
    case lang_reloc_statement_enum:
      print_reloc_statement (&s->reloc_statement);
      print_reloc_statement (&s->reloc_statement);
      break;
      break;
    case lang_input_section_enum:
    case lang_input_section_enum:
      print_input_section (s->input_section.section);
      print_input_section (s->input_section.section);
      break;
      break;
    case lang_padding_statement_enum:
    case lang_padding_statement_enum:
      print_padding_statement (&s->padding_statement);
      print_padding_statement (&s->padding_statement);
      break;
      break;
    case lang_output_section_statement_enum:
    case lang_output_section_statement_enum:
      print_output_section_statement (&s->output_section_statement);
      print_output_section_statement (&s->output_section_statement);
      break;
      break;
    case lang_assignment_statement_enum:
    case lang_assignment_statement_enum:
      print_assignment (&s->assignment_statement, os);
      print_assignment (&s->assignment_statement, os);
      break;
      break;
    case lang_target_statement_enum:
    case lang_target_statement_enum:
      fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
      fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
      break;
      break;
    case lang_output_statement_enum:
    case lang_output_statement_enum:
      minfo ("OUTPUT(%s", s->output_statement.name);
      minfo ("OUTPUT(%s", s->output_statement.name);
      if (output_target != NULL)
      if (output_target != NULL)
        minfo (" %s", output_target);
        minfo (" %s", output_target);
      minfo (")\n");
      minfo (")\n");
      break;
      break;
    case lang_input_statement_enum:
    case lang_input_statement_enum:
      print_input_statement (&s->input_statement);
      print_input_statement (&s->input_statement);
      break;
      break;
    case lang_group_statement_enum:
    case lang_group_statement_enum:
      print_group (&s->group_statement, os);
      print_group (&s->group_statement, os);
      break;
      break;
    case lang_insert_statement_enum:
    case lang_insert_statement_enum:
      minfo ("INSERT %s %s\n",
      minfo ("INSERT %s %s\n",
             s->insert_statement.is_before ? "BEFORE" : "AFTER",
             s->insert_statement.is_before ? "BEFORE" : "AFTER",
             s->insert_statement.where);
             s->insert_statement.where);
      break;
      break;
    }
    }
}
}
 
 
static void
static void
print_statements (void)
print_statements (void)
{
{
  print_statement_list (statement_list.head, abs_output_section);
  print_statement_list (statement_list.head, abs_output_section);
}
}
 
 
/* Print the first N statements in statement list S to STDERR.
/* Print the first N statements in statement list S to STDERR.
   If N == 0, nothing is printed.
   If N == 0, nothing is printed.
   If N < 0, the entire list is printed.
   If N < 0, the entire list is printed.
   Intended to be called from GDB.  */
   Intended to be called from GDB.  */
 
 
void
void
dprint_statement (lang_statement_union_type *s, int n)
dprint_statement (lang_statement_union_type *s, int n)
{
{
  FILE *map_save = config.map_file;
  FILE *map_save = config.map_file;
 
 
  config.map_file = stderr;
  config.map_file = stderr;
 
 
  if (n < 0)
  if (n < 0)
    print_statement_list (s, abs_output_section);
    print_statement_list (s, abs_output_section);
  else
  else
    {
    {
      while (s && --n >= 0)
      while (s && --n >= 0)
        {
        {
          print_statement (s, abs_output_section);
          print_statement (s, abs_output_section);
          s = s->header.next;
          s = s->header.next;
        }
        }
    }
    }
 
 
  config.map_file = map_save;
  config.map_file = map_save;
}
}
 
 
static void
static void
insert_pad (lang_statement_union_type **ptr,
insert_pad (lang_statement_union_type **ptr,
            fill_type *fill,
            fill_type *fill,
            unsigned int alignment_needed,
            unsigned int alignment_needed,
            asection *output_section,
            asection *output_section,
            bfd_vma dot)
            bfd_vma dot)
{
{
  static fill_type zero_fill = { 1, { 0 } };
  static fill_type zero_fill = { 1, { 0 } };
  lang_statement_union_type *pad = NULL;
  lang_statement_union_type *pad = NULL;
 
 
  if (ptr != &statement_list.head)
  if (ptr != &statement_list.head)
    pad = ((lang_statement_union_type *)
    pad = ((lang_statement_union_type *)
           ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
           ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
  if (pad != NULL
  if (pad != NULL
      && pad->header.type == lang_padding_statement_enum
      && pad->header.type == lang_padding_statement_enum
      && pad->padding_statement.output_section == output_section)
      && pad->padding_statement.output_section == output_section)
    {
    {
      /* Use the existing pad statement.  */
      /* Use the existing pad statement.  */
    }
    }
  else if ((pad = *ptr) != NULL
  else if ((pad = *ptr) != NULL
      && pad->header.type == lang_padding_statement_enum
      && pad->header.type == lang_padding_statement_enum
      && pad->padding_statement.output_section == output_section)
      && pad->padding_statement.output_section == output_section)
    {
    {
      /* Use the existing pad statement.  */
      /* Use the existing pad statement.  */
    }
    }
  else
  else
    {
    {
      /* Make a new padding statement, linked into existing chain.  */
      /* Make a new padding statement, linked into existing chain.  */
      pad = stat_alloc (sizeof (lang_padding_statement_type));
      pad = stat_alloc (sizeof (lang_padding_statement_type));
      pad->header.next = *ptr;
      pad->header.next = *ptr;
      *ptr = pad;
      *ptr = pad;
      pad->header.type = lang_padding_statement_enum;
      pad->header.type = lang_padding_statement_enum;
      pad->padding_statement.output_section = output_section;
      pad->padding_statement.output_section = output_section;
      if (fill == NULL)
      if (fill == NULL)
        fill = &zero_fill;
        fill = &zero_fill;
      pad->padding_statement.fill = fill;
      pad->padding_statement.fill = fill;
    }
    }
  pad->padding_statement.output_offset = dot - output_section->vma;
  pad->padding_statement.output_offset = dot - output_section->vma;
  pad->padding_statement.size = alignment_needed;
  pad->padding_statement.size = alignment_needed;
  output_section->size += alignment_needed;
  output_section->size += alignment_needed;
}
}
 
 
/* Work out how much this section will move the dot point.  */
/* Work out how much this section will move the dot point.  */
 
 
static bfd_vma
static bfd_vma
size_input_section
size_input_section
  (lang_statement_union_type **this_ptr,
  (lang_statement_union_type **this_ptr,
   lang_output_section_statement_type *output_section_statement,
   lang_output_section_statement_type *output_section_statement,
   fill_type *fill,
   fill_type *fill,
   bfd_vma dot)
   bfd_vma dot)
{
{
  lang_input_section_type *is = &((*this_ptr)->input_section);
  lang_input_section_type *is = &((*this_ptr)->input_section);
  asection *i = is->section;
  asection *i = is->section;
 
 
  if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
  if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
      && (i->flags & SEC_EXCLUDE) == 0)
      && (i->flags & SEC_EXCLUDE) == 0)
    {
    {
      unsigned int alignment_needed;
      unsigned int alignment_needed;
      asection *o;
      asection *o;
 
 
      /* Align this section first to the input sections requirement,
      /* Align this section first to the input sections requirement,
         then to the output section's requirement.  If this alignment
         then to the output section's requirement.  If this alignment
         is greater than any seen before, then record it too.  Perform
         is greater than any seen before, then record it too.  Perform
         the alignment by inserting a magic 'padding' statement.  */
         the alignment by inserting a magic 'padding' statement.  */
 
 
      if (output_section_statement->subsection_alignment != -1)
      if (output_section_statement->subsection_alignment != -1)
        i->alignment_power = output_section_statement->subsection_alignment;
        i->alignment_power = output_section_statement->subsection_alignment;
 
 
      o = output_section_statement->bfd_section;
      o = output_section_statement->bfd_section;
      if (o->alignment_power < i->alignment_power)
      if (o->alignment_power < i->alignment_power)
        o->alignment_power = i->alignment_power;
        o->alignment_power = i->alignment_power;
 
 
      alignment_needed = align_power (dot, i->alignment_power) - dot;
      alignment_needed = align_power (dot, i->alignment_power) - dot;
 
 
      if (alignment_needed != 0)
      if (alignment_needed != 0)
        {
        {
          insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
          insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
          dot += alignment_needed;
          dot += alignment_needed;
        }
        }
 
 
      /* Remember where in the output section this input section goes.  */
      /* Remember where in the output section this input section goes.  */
 
 
      i->output_offset = dot - o->vma;
      i->output_offset = dot - o->vma;
 
 
      /* Mark how big the output section must be to contain this now.  */
      /* Mark how big the output section must be to contain this now.  */
      dot += TO_ADDR (i->size);
      dot += TO_ADDR (i->size);
      o->size = TO_SIZE (dot - o->vma);
      o->size = TO_SIZE (dot - o->vma);
    }
    }
  else
  else
    {
    {
      i->output_offset = i->vma - output_section_statement->bfd_section->vma;
      i->output_offset = i->vma - output_section_statement->bfd_section->vma;
    }
    }
 
 
  return dot;
  return dot;
}
}
 
 
static int
static int
sort_sections_by_lma (const void *arg1, const void *arg2)
sort_sections_by_lma (const void *arg1, const void *arg2)
{
{
  const asection *sec1 = *(const asection **) arg1;
  const asection *sec1 = *(const asection **) arg1;
  const asection *sec2 = *(const asection **) arg2;
  const asection *sec2 = *(const asection **) arg2;
 
 
  if (bfd_section_lma (sec1->owner, sec1)
  if (bfd_section_lma (sec1->owner, sec1)
      < bfd_section_lma (sec2->owner, sec2))
      < bfd_section_lma (sec2->owner, sec2))
    return -1;
    return -1;
  else if (bfd_section_lma (sec1->owner, sec1)
  else if (bfd_section_lma (sec1->owner, sec1)
           > bfd_section_lma (sec2->owner, sec2))
           > bfd_section_lma (sec2->owner, sec2))
    return 1;
    return 1;
  else if (sec1->id < sec2->id)
  else if (sec1->id < sec2->id)
    return -1;
    return -1;
  else if (sec1->id > sec2->id)
  else if (sec1->id > sec2->id)
    return 1;
    return 1;
 
 
  return 0;
  return 0;
}
}
 
 
#define IGNORE_SECTION(s) \
#define IGNORE_SECTION(s) \
  ((s->flags & SEC_NEVER_LOAD) != 0                              \
  ((s->flags & SEC_NEVER_LOAD) != 0                              \
   || (s->flags & SEC_ALLOC) == 0                                \
   || (s->flags & SEC_ALLOC) == 0                                \
   || ((s->flags & SEC_THREAD_LOCAL) != 0                        \
   || ((s->flags & SEC_THREAD_LOCAL) != 0                        \
        && (s->flags & SEC_LOAD) == 0))
        && (s->flags & SEC_LOAD) == 0))
 
 
/* Check to see if any allocated sections overlap with other allocated
/* Check to see if any allocated sections overlap with other allocated
   sections.  This can happen if a linker script specifies the output
   sections.  This can happen if a linker script specifies the output
   section addresses of the two sections.  Also check whether any memory
   section addresses of the two sections.  Also check whether any memory
   region has overflowed.  */
   region has overflowed.  */
 
 
static void
static void
lang_check_section_addresses (void)
lang_check_section_addresses (void)
{
{
  asection *s, *os;
  asection *s, *os;
  asection **sections, **spp;
  asection **sections, **spp;
  unsigned int count;
  unsigned int count;
  bfd_vma s_start;
  bfd_vma s_start;
  bfd_vma s_end;
  bfd_vma s_end;
  bfd_vma os_start;
  bfd_vma os_start;
  bfd_vma os_end;
  bfd_vma os_end;
  bfd_size_type amt;
  bfd_size_type amt;
  lang_memory_region_type *m;
  lang_memory_region_type *m;
 
 
  if (bfd_count_sections (link_info.output_bfd) <= 1)
  if (bfd_count_sections (link_info.output_bfd) <= 1)
    return;
    return;
 
 
  amt = bfd_count_sections (link_info.output_bfd) * sizeof (asection *);
  amt = bfd_count_sections (link_info.output_bfd) * sizeof (asection *);
  sections = xmalloc (amt);
  sections = xmalloc (amt);
 
 
  /* Scan all sections in the output list.  */
  /* Scan all sections in the output list.  */
  count = 0;
  count = 0;
  for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
  for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
    {
    {
      /* Only consider loadable sections with real contents.  */
      /* Only consider loadable sections with real contents.  */
      if (IGNORE_SECTION (s) || s->size == 0)
      if (IGNORE_SECTION (s) || s->size == 0)
        continue;
        continue;
 
 
      sections[count] = s;
      sections[count] = s;
      count++;
      count++;
    }
    }
 
 
  if (count <= 1)
  if (count <= 1)
    return;
    return;
 
 
  qsort (sections, (size_t) count, sizeof (asection *),
  qsort (sections, (size_t) count, sizeof (asection *),
         sort_sections_by_lma);
         sort_sections_by_lma);
 
 
  spp = sections;
  spp = sections;
  s = *spp++;
  s = *spp++;
  s_start = bfd_section_lma (link_info.output_bfd, s);
  s_start = bfd_section_lma (link_info.output_bfd, s);
  s_end = s_start + TO_ADDR (s->size) - 1;
  s_end = s_start + TO_ADDR (s->size) - 1;
  for (count--; count; count--)
  for (count--; count; count--)
    {
    {
      /* We must check the sections' LMA addresses not their VMA
      /* We must check the sections' LMA addresses not their VMA
         addresses because overlay sections can have overlapping VMAs
         addresses because overlay sections can have overlapping VMAs
         but they must have distinct LMAs.  */
         but they must have distinct LMAs.  */
      os = s;
      os = s;
      os_start = s_start;
      os_start = s_start;
      os_end = s_end;
      os_end = s_end;
      s = *spp++;
      s = *spp++;
      s_start = bfd_section_lma (link_info.output_bfd, s);
      s_start = bfd_section_lma (link_info.output_bfd, s);
      s_end = s_start + TO_ADDR (s->size) - 1;
      s_end = s_start + TO_ADDR (s->size) - 1;
 
 
      /* Look for an overlap.  */
      /* Look for an overlap.  */
      if (s_end >= os_start && s_start <= os_end)
      if (s_end >= os_start && s_start <= os_end)
        einfo (_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
        einfo (_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
               s->name, s_start, s_end, os->name, os_start, os_end);
               s->name, s_start, s_end, os->name, os_start, os_end);
    }
    }
 
 
  free (sections);
  free (sections);
 
 
  /* If any memory region has overflowed, report by how much.
  /* If any memory region has overflowed, report by how much.
     We do not issue this diagnostic for regions that had sections
     We do not issue this diagnostic for regions that had sections
     explicitly placed outside their bounds; os_region_check's
     explicitly placed outside their bounds; os_region_check's
     diagnostics are adequate for that case.
     diagnostics are adequate for that case.
 
 
     FIXME: It is conceivable that m->current - (m->origin + m->length)
     FIXME: It is conceivable that m->current - (m->origin + m->length)
     might overflow a 32-bit integer.  There is, alas, no way to print
     might overflow a 32-bit integer.  There is, alas, no way to print
     a bfd_vma quantity in decimal.  */
     a bfd_vma quantity in decimal.  */
  for (m = lang_memory_region_list; m; m = m->next)
  for (m = lang_memory_region_list; m; m = m->next)
    if (m->had_full_message)
    if (m->had_full_message)
      einfo (_("%X%P: region %s overflowed by %ld bytes\n"),
      einfo (_("%X%P: region %s overflowed by %ld bytes\n"),
             m->name, (long)(m->current - (m->origin + m->length)));
             m->name, (long)(m->current - (m->origin + m->length)));
 
 
}
}
 
 
/* Make sure the new address is within the region.  We explicitly permit the
/* Make sure the new address is within the region.  We explicitly permit the
   current address to be at the exact end of the region when the address is
   current address to be at the exact end of the region when the address is
   non-zero, in case the region is at the end of addressable memory and the
   non-zero, in case the region is at the end of addressable memory and the
   calculation wraps around.  */
   calculation wraps around.  */
 
 
static void
static void
os_region_check (lang_output_section_statement_type *os,
os_region_check (lang_output_section_statement_type *os,
                 lang_memory_region_type *region,
                 lang_memory_region_type *region,
                 etree_type *tree,
                 etree_type *tree,
                 bfd_vma base)
                 bfd_vma base)
{
{
  if ((region->current < region->origin
  if ((region->current < region->origin
       || (region->current - region->origin > region->length))
       || (region->current - region->origin > region->length))
      && ((region->current != region->origin + region->length)
      && ((region->current != region->origin + region->length)
          || base == 0))
          || base == 0))
    {
    {
      if (tree != NULL)
      if (tree != NULL)
        {
        {
          einfo (_("%X%P: address 0x%v of %B section %s"
          einfo (_("%X%P: address 0x%v of %B section %s"
                   " is not within region %s\n"),
                   " is not within region %s\n"),
                 region->current,
                 region->current,
                 os->bfd_section->owner,
                 os->bfd_section->owner,
                 os->bfd_section->name,
                 os->bfd_section->name,
                 region->name);
                 region->name);
        }
        }
      else if (!region->had_full_message)
      else if (!region->had_full_message)
        {
        {
          region->had_full_message = TRUE;
          region->had_full_message = TRUE;
 
 
          einfo (_("%X%P: %B section %s will not fit in region %s\n"),
          einfo (_("%X%P: %B section %s will not fit in region %s\n"),
                 os->bfd_section->owner,
                 os->bfd_section->owner,
                 os->bfd_section->name,
                 os->bfd_section->name,
                 region->name);
                 region->name);
        }
        }
    }
    }
}
}
 
 
/* Set the sizes for all the output sections.  */
/* Set the sizes for all the output sections.  */
 
 
static bfd_vma
static bfd_vma
lang_size_sections_1
lang_size_sections_1
  (lang_statement_union_type *s,
  (lang_statement_union_type *s,
   lang_output_section_statement_type *output_section_statement,
   lang_output_section_statement_type *output_section_statement,
   lang_statement_union_type **prev,
   lang_statement_union_type **prev,
   fill_type *fill,
   fill_type *fill,
   bfd_vma dot,
   bfd_vma dot,
   bfd_boolean *relax,
   bfd_boolean *relax,
   bfd_boolean check_regions)
   bfd_boolean check_regions)
{
{
  /* Size up the sections from their constituent parts.  */
  /* Size up the sections from their constituent parts.  */
  for (; s != NULL; s = s->header.next)
  for (; s != NULL; s = s->header.next)
    {
    {
      switch (s->header.type)
      switch (s->header.type)
        {
        {
        case lang_output_section_statement_enum:
        case lang_output_section_statement_enum:
          {
          {
            bfd_vma newdot, after;
            bfd_vma newdot, after;
            lang_output_section_statement_type *os;
            lang_output_section_statement_type *os;
            lang_memory_region_type *r;
            lang_memory_region_type *r;
 
 
            os = &s->output_section_statement;
            os = &s->output_section_statement;
            if (os->addr_tree != NULL)
            if (os->addr_tree != NULL)
              {
              {
                os->processed_vma = FALSE;
                os->processed_vma = FALSE;
                exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
                exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
 
 
                if (expld.result.valid_p)
                if (expld.result.valid_p)
                  dot = expld.result.value + expld.result.section->vma;
                  dot = expld.result.value + expld.result.section->vma;
                else if (expld.phase != lang_mark_phase_enum)
                else if (expld.phase != lang_mark_phase_enum)
                  einfo (_("%F%S: non constant or forward reference"
                  einfo (_("%F%S: non constant or forward reference"
                           " address expression for section %s\n"),
                           " address expression for section %s\n"),
                         os->name);
                         os->name);
              }
              }
 
 
            if (os->bfd_section == NULL)
            if (os->bfd_section == NULL)
              /* This section was removed or never actually created.  */
              /* This section was removed or never actually created.  */
              break;
              break;
 
 
            /* If this is a COFF shared library section, use the size and
            /* If this is a COFF shared library section, use the size and
               address from the input section.  FIXME: This is COFF
               address from the input section.  FIXME: This is COFF
               specific; it would be cleaner if there were some other way
               specific; it would be cleaner if there were some other way
               to do this, but nothing simple comes to mind.  */
               to do this, but nothing simple comes to mind.  */
            if (((bfd_get_flavour (link_info.output_bfd)
            if (((bfd_get_flavour (link_info.output_bfd)
                  == bfd_target_ecoff_flavour)
                  == bfd_target_ecoff_flavour)
                 || (bfd_get_flavour (link_info.output_bfd)
                 || (bfd_get_flavour (link_info.output_bfd)
                     == bfd_target_coff_flavour))
                     == bfd_target_coff_flavour))
                && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
                && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
              {
              {
                asection *input;
                asection *input;
 
 
                if (os->children.head == NULL
                if (os->children.head == NULL
                    || os->children.head->header.next != NULL
                    || os->children.head->header.next != NULL
                    || (os->children.head->header.type
                    || (os->children.head->header.type
                        != lang_input_section_enum))
                        != lang_input_section_enum))
                  einfo (_("%P%X: Internal error on COFF shared library"
                  einfo (_("%P%X: Internal error on COFF shared library"
                           " section %s\n"), os->name);
                           " section %s\n"), os->name);
 
 
                input = os->children.head->input_section.section;
                input = os->children.head->input_section.section;
                bfd_set_section_vma (os->bfd_section->owner,
                bfd_set_section_vma (os->bfd_section->owner,
                                     os->bfd_section,
                                     os->bfd_section,
                                     bfd_section_vma (input->owner, input));
                                     bfd_section_vma (input->owner, input));
                os->bfd_section->size = input->size;
                os->bfd_section->size = input->size;
                break;
                break;
              }
              }
 
 
            newdot = dot;
            newdot = dot;
            if (bfd_is_abs_section (os->bfd_section))
            if (bfd_is_abs_section (os->bfd_section))
              {
              {
                /* No matter what happens, an abs section starts at zero.  */
                /* No matter what happens, an abs section starts at zero.  */
                ASSERT (os->bfd_section->vma == 0);
                ASSERT (os->bfd_section->vma == 0);
              }
              }
            else
            else
              {
              {
                int align;
                int align;
 
 
                if (os->addr_tree == NULL)
                if (os->addr_tree == NULL)
                  {
                  {
                    /* No address specified for this section, get one
                    /* No address specified for this section, get one
                       from the region specification.  */
                       from the region specification.  */
                    if (os->region == NULL
                    if (os->region == NULL
                        || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
                        || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
                            && os->region->name[0] == '*'
                            && os->region->name[0] == '*'
                            && strcmp (os->region->name,
                            && strcmp (os->region->name,
                                       DEFAULT_MEMORY_REGION) == 0))
                                       DEFAULT_MEMORY_REGION) == 0))
                      {
                      {
                        os->region = lang_memory_default (os->bfd_section);
                        os->region = lang_memory_default (os->bfd_section);
                      }
                      }
 
 
                    /* If a loadable section is using the default memory
                    /* If a loadable section is using the default memory
                       region, and some non default memory regions were
                       region, and some non default memory regions were
                       defined, issue an error message.  */
                       defined, issue an error message.  */
                    if (!os->ignored
                    if (!os->ignored
                        && !IGNORE_SECTION (os->bfd_section)
                        && !IGNORE_SECTION (os->bfd_section)
                        && ! link_info.relocatable
                        && ! link_info.relocatable
                        && check_regions
                        && check_regions
                        && strcmp (os->region->name,
                        && strcmp (os->region->name,
                                   DEFAULT_MEMORY_REGION) == 0
                                   DEFAULT_MEMORY_REGION) == 0
                        && lang_memory_region_list != NULL
                        && lang_memory_region_list != NULL
                        && (strcmp (lang_memory_region_list->name,
                        && (strcmp (lang_memory_region_list->name,
                                    DEFAULT_MEMORY_REGION) != 0
                                    DEFAULT_MEMORY_REGION) != 0
                            || lang_memory_region_list->next != NULL)
                            || lang_memory_region_list->next != NULL)
                        && expld.phase != lang_mark_phase_enum)
                        && expld.phase != lang_mark_phase_enum)
                      {
                      {
                        /* By default this is an error rather than just a
                        /* By default this is an error rather than just a
                           warning because if we allocate the section to the
                           warning because if we allocate the section to the
                           default memory region we can end up creating an
                           default memory region we can end up creating an
                           excessively large binary, or even seg faulting when
                           excessively large binary, or even seg faulting when
                           attempting to perform a negative seek.  See
                           attempting to perform a negative seek.  See
                           sources.redhat.com/ml/binutils/2003-04/msg00423.html
                           sources.redhat.com/ml/binutils/2003-04/msg00423.html
                           for an example of this.  This behaviour can be
                           for an example of this.  This behaviour can be
                           overridden by the using the --no-check-sections
                           overridden by the using the --no-check-sections
                           switch.  */
                           switch.  */
                        if (command_line.check_section_addresses)
                        if (command_line.check_section_addresses)
                          einfo (_("%P%F: error: no memory region specified"
                          einfo (_("%P%F: error: no memory region specified"
                                   " for loadable section `%s'\n"),
                                   " for loadable section `%s'\n"),
                                 bfd_get_section_name (link_info.output_bfd,
                                 bfd_get_section_name (link_info.output_bfd,
                                                       os->bfd_section));
                                                       os->bfd_section));
                        else
                        else
                          einfo (_("%P: warning: no memory region specified"
                          einfo (_("%P: warning: no memory region specified"
                                   " for loadable section `%s'\n"),
                                   " for loadable section `%s'\n"),
                                 bfd_get_section_name (link_info.output_bfd,
                                 bfd_get_section_name (link_info.output_bfd,
                                                       os->bfd_section));
                                                       os->bfd_section));
                      }
                      }
 
 
                    newdot = os->region->current;
                    newdot = os->region->current;
                    align = os->bfd_section->alignment_power;
                    align = os->bfd_section->alignment_power;
                  }
                  }
                else
                else
                  align = os->section_alignment;
                  align = os->section_alignment;
 
 
                /* Align to what the section needs.  */
                /* Align to what the section needs.  */
                if (align > 0)
                if (align > 0)
                  {
                  {
                    bfd_vma savedot = newdot;
                    bfd_vma savedot = newdot;
                    newdot = align_power (newdot, align);
                    newdot = align_power (newdot, align);
 
 
                    if (newdot != savedot
                    if (newdot != savedot
                        && (config.warn_section_align
                        && (config.warn_section_align
                            || os->addr_tree != NULL)
                            || os->addr_tree != NULL)
                        && expld.phase != lang_mark_phase_enum)
                        && expld.phase != lang_mark_phase_enum)
                      einfo (_("%P: warning: changing start of section"
                      einfo (_("%P: warning: changing start of section"
                               " %s by %lu bytes\n"),
                               " %s by %lu bytes\n"),
                             os->name, (unsigned long) (newdot - savedot));
                             os->name, (unsigned long) (newdot - savedot));
                  }
                  }
 
 
                bfd_set_section_vma (0, os->bfd_section, newdot);
                bfd_set_section_vma (0, os->bfd_section, newdot);
 
 
                os->bfd_section->output_offset = 0;
                os->bfd_section->output_offset = 0;
              }
              }
 
 
            lang_size_sections_1 (os->children.head, os, &os->children.head,
            lang_size_sections_1 (os->children.head, os, &os->children.head,
                                  os->fill, newdot, relax, check_regions);
                                  os->fill, newdot, relax, check_regions);
 
 
            os->processed_vma = TRUE;
            os->processed_vma = TRUE;
 
 
            if (bfd_is_abs_section (os->bfd_section) || os->ignored)
            if (bfd_is_abs_section (os->bfd_section) || os->ignored)
              /* Except for some special linker created sections,
              /* Except for some special linker created sections,
                 no output section should change from zero size
                 no output section should change from zero size
                 after strip_excluded_output_sections.  A non-zero
                 after strip_excluded_output_sections.  A non-zero
                 size on an ignored section indicates that some
                 size on an ignored section indicates that some
                 input section was not sized early enough.  */
                 input section was not sized early enough.  */
              ASSERT (os->bfd_section->size == 0);
              ASSERT (os->bfd_section->size == 0);
            else
            else
              {
              {
                dot = os->bfd_section->vma;
                dot = os->bfd_section->vma;
 
 
                /* Put the section within the requested block size, or
                /* Put the section within the requested block size, or
                   align at the block boundary.  */
                   align at the block boundary.  */
                after = ((dot
                after = ((dot
                          + TO_ADDR (os->bfd_section->size)
                          + TO_ADDR (os->bfd_section->size)
                          + os->block_value - 1)
                          + os->block_value - 1)
                         & - (bfd_vma) os->block_value);
                         & - (bfd_vma) os->block_value);
 
 
                os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
                os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
              }
              }
 
 
            /* Set section lma.  */
            /* Set section lma.  */
            r = os->region;
            r = os->region;
            if (r == NULL)
            if (r == NULL)
              r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
              r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
 
 
            if (os->load_base)
            if (os->load_base)
              {
              {
                bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
                bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
                os->bfd_section->lma = lma;
                os->bfd_section->lma = lma;
              }
              }
            else if (os->lma_region != NULL)
            else if (os->lma_region != NULL)
              {
              {
                bfd_vma lma = os->lma_region->current;
                bfd_vma lma = os->lma_region->current;
 
 
                if (os->section_alignment != -1)
                if (os->section_alignment != -1)
                  lma = align_power (lma, os->section_alignment);
                  lma = align_power (lma, os->section_alignment);
                os->bfd_section->lma = lma;
                os->bfd_section->lma = lma;
              }
              }
            else if (r->last_os != NULL
            else if (r->last_os != NULL
                     && (os->bfd_section->flags & SEC_ALLOC) != 0)
                     && (os->bfd_section->flags & SEC_ALLOC) != 0)
              {
              {
                bfd_vma lma;
                bfd_vma lma;
                asection *last;
                asection *last;
 
 
                last = r->last_os->output_section_statement.bfd_section;
                last = r->last_os->output_section_statement.bfd_section;
 
 
                /* A backwards move of dot should be accompanied by
                /* A backwards move of dot should be accompanied by
                   an explicit assignment to the section LMA (ie.
                   an explicit assignment to the section LMA (ie.
                   os->load_base set) because backwards moves can
                   os->load_base set) because backwards moves can
                   create overlapping LMAs.  */
                   create overlapping LMAs.  */
                if (dot < last->vma
                if (dot < last->vma
                    && os->bfd_section->size != 0
                    && os->bfd_section->size != 0
                    && dot + os->bfd_section->size <= last->vma)
                    && dot + os->bfd_section->size <= last->vma)
                  {
                  {
                    /* If dot moved backwards then leave lma equal to
                    /* If dot moved backwards then leave lma equal to
                       vma.  This is the old default lma, which might
                       vma.  This is the old default lma, which might
                       just happen to work when the backwards move is
                       just happen to work when the backwards move is
                       sufficiently large.  Nag if this changes anything,
                       sufficiently large.  Nag if this changes anything,
                       so people can fix their linker scripts.  */
                       so people can fix their linker scripts.  */
 
 
                    if (last->vma != last->lma)
                    if (last->vma != last->lma)
                      einfo (_("%P: warning: dot moved backwards before `%s'\n"),
                      einfo (_("%P: warning: dot moved backwards before `%s'\n"),
                             os->name);
                             os->name);
                  }
                  }
                else
                else
                  {
                  {
                    /* If this is an overlay, set the current lma to that
                    /* If this is an overlay, set the current lma to that
                       at the end of the previous section.  */
                       at the end of the previous section.  */
                    if (os->sectype == overlay_section)
                    if (os->sectype == overlay_section)
                      lma = last->lma + last->size;
                      lma = last->lma + last->size;
 
 
                    /* Otherwise, keep the same lma to vma relationship
                    /* Otherwise, keep the same lma to vma relationship
                       as the previous section.  */
                       as the previous section.  */
                    else
                    else
                      lma = dot + last->lma - last->vma;
                      lma = dot + last->lma - last->vma;
 
 
                    if (os->section_alignment != -1)
                    if (os->section_alignment != -1)
                      lma = align_power (lma, os->section_alignment);
                      lma = align_power (lma, os->section_alignment);
                    os->bfd_section->lma = lma;
                    os->bfd_section->lma = lma;
                  }
                  }
              }
              }
            os->processed_lma = TRUE;
            os->processed_lma = TRUE;
 
 
            if (bfd_is_abs_section (os->bfd_section) || os->ignored)
            if (bfd_is_abs_section (os->bfd_section) || os->ignored)
              break;
              break;
 
 
            /* Keep track of normal sections using the default
            /* Keep track of normal sections using the default
               lma region.  We use this to set the lma for
               lma region.  We use this to set the lma for
               following sections.  Overlays or other linker
               following sections.  Overlays or other linker
               script assignment to lma might mean that the
               script assignment to lma might mean that the
               default lma == vma is incorrect.
               default lma == vma is incorrect.
               To avoid warnings about dot moving backwards when using
               To avoid warnings about dot moving backwards when using
               -Ttext, don't start tracking sections until we find one
               -Ttext, don't start tracking sections until we find one
               of non-zero size or with lma set differently to vma.  */
               of non-zero size or with lma set differently to vma.  */
            if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
            if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
                 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)
                 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)
                && (os->bfd_section->flags & SEC_ALLOC) != 0
                && (os->bfd_section->flags & SEC_ALLOC) != 0
                && (os->bfd_section->size != 0
                && (os->bfd_section->size != 0
                    || (r->last_os == NULL
                    || (r->last_os == NULL
                        && os->bfd_section->vma != os->bfd_section->lma)
                        && os->bfd_section->vma != os->bfd_section->lma)
                    || (r->last_os != NULL
                    || (r->last_os != NULL
                        && dot >= (r->last_os->output_section_statement
                        && dot >= (r->last_os->output_section_statement
                                   .bfd_section->vma)))
                                   .bfd_section->vma)))
                && os->lma_region == NULL
                && os->lma_region == NULL
                && !link_info.relocatable)
                && !link_info.relocatable)
              r->last_os = s;
              r->last_os = s;
 
 
            /* .tbss sections effectively have zero size.  */
            /* .tbss sections effectively have zero size.  */
            if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
            if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
                || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
                || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
                || link_info.relocatable)
                || link_info.relocatable)
              dot += TO_ADDR (os->bfd_section->size);
              dot += TO_ADDR (os->bfd_section->size);
 
 
            if (os->update_dot_tree != 0)
            if (os->update_dot_tree != 0)
              exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
              exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
 
 
            /* Update dot in the region ?
            /* Update dot in the region ?
               We only do this if the section is going to be allocated,
               We only do this if the section is going to be allocated,
               since unallocated sections do not contribute to the region's
               since unallocated sections do not contribute to the region's
               overall size in memory.
               overall size in memory.
 
 
               If the SEC_NEVER_LOAD bit is not set, it will affect the
               If the SEC_NEVER_LOAD bit is not set, it will affect the
               addresses of sections after it. We have to update
               addresses of sections after it. We have to update
               dot.  */
               dot.  */
            if (os->region != NULL
            if (os->region != NULL
                && ((os->bfd_section->flags & SEC_NEVER_LOAD) == 0
                && ((os->bfd_section->flags & SEC_NEVER_LOAD) == 0
                    || (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))))
                    || (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))))
              {
              {
                os->region->current = dot;
                os->region->current = dot;
 
 
                if (check_regions)
                if (check_regions)
                  /* Make sure the new address is within the region.  */
                  /* Make sure the new address is within the region.  */
                  os_region_check (os, os->region, os->addr_tree,
                  os_region_check (os, os->region, os->addr_tree,
                                   os->bfd_section->vma);
                                   os->bfd_section->vma);
 
 
                if (os->lma_region != NULL && os->lma_region != os->region
                if (os->lma_region != NULL && os->lma_region != os->region
                    && (os->bfd_section->flags & SEC_LOAD))
                    && (os->bfd_section->flags & SEC_LOAD))
                  {
                  {
                    os->lma_region->current
                    os->lma_region->current
                      = os->bfd_section->lma + TO_ADDR (os->bfd_section->size);
                      = os->bfd_section->lma + TO_ADDR (os->bfd_section->size);
 
 
                    if (check_regions)
                    if (check_regions)
                      os_region_check (os, os->lma_region, NULL,
                      os_region_check (os, os->lma_region, NULL,
                                       os->bfd_section->lma);
                                       os->bfd_section->lma);
                  }
                  }
              }
              }
          }
          }
          break;
          break;
 
 
        case lang_constructors_statement_enum:
        case lang_constructors_statement_enum:
          dot = lang_size_sections_1 (constructor_list.head,
          dot = lang_size_sections_1 (constructor_list.head,
                                      output_section_statement,
                                      output_section_statement,
                                      &s->wild_statement.children.head,
                                      &s->wild_statement.children.head,
                                      fill, dot, relax, check_regions);
                                      fill, dot, relax, check_regions);
          break;
          break;
 
 
        case lang_data_statement_enum:
        case lang_data_statement_enum:
          {
          {
            unsigned int size = 0;
            unsigned int size = 0;
 
 
            s->data_statement.output_offset =
            s->data_statement.output_offset =
              dot - output_section_statement->bfd_section->vma;
              dot - output_section_statement->bfd_section->vma;
            s->data_statement.output_section =
            s->data_statement.output_section =
              output_section_statement->bfd_section;
              output_section_statement->bfd_section;
 
 
            /* We might refer to provided symbols in the expression, and
            /* We might refer to provided symbols in the expression, and
               need to mark them as needed.  */
               need to mark them as needed.  */
            exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
            exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
 
 
            switch (s->data_statement.type)
            switch (s->data_statement.type)
              {
              {
              default:
              default:
                abort ();
                abort ();
              case QUAD:
              case QUAD:
              case SQUAD:
              case SQUAD:
                size = QUAD_SIZE;
                size = QUAD_SIZE;
                break;
                break;
              case LONG:
              case LONG:
                size = LONG_SIZE;
                size = LONG_SIZE;
                break;
                break;
              case SHORT:
              case SHORT:
                size = SHORT_SIZE;
                size = SHORT_SIZE;
                break;
                break;
              case BYTE:
              case BYTE:
                size = BYTE_SIZE;
                size = BYTE_SIZE;
                break;
                break;
              }
              }
            if (size < TO_SIZE ((unsigned) 1))
            if (size < TO_SIZE ((unsigned) 1))
              size = TO_SIZE ((unsigned) 1);
              size = TO_SIZE ((unsigned) 1);
            dot += TO_ADDR (size);
            dot += TO_ADDR (size);
            output_section_statement->bfd_section->size += size;
            output_section_statement->bfd_section->size += size;
          }
          }
          break;
          break;
 
 
        case lang_reloc_statement_enum:
        case lang_reloc_statement_enum:
          {
          {
            int size;
            int size;
 
 
            s->reloc_statement.output_offset =
            s->reloc_statement.output_offset =
              dot - output_section_statement->bfd_section->vma;
              dot - output_section_statement->bfd_section->vma;
            s->reloc_statement.output_section =
            s->reloc_statement.output_section =
              output_section_statement->bfd_section;
              output_section_statement->bfd_section;
            size = bfd_get_reloc_size (s->reloc_statement.howto);
            size = bfd_get_reloc_size (s->reloc_statement.howto);
            dot += TO_ADDR (size);
            dot += TO_ADDR (size);
            output_section_statement->bfd_section->size += size;
            output_section_statement->bfd_section->size += size;
          }
          }
          break;
          break;
 
 
        case lang_wild_statement_enum:
        case lang_wild_statement_enum:
          dot = lang_size_sections_1 (s->wild_statement.children.head,
          dot = lang_size_sections_1 (s->wild_statement.children.head,
                                      output_section_statement,
                                      output_section_statement,
                                      &s->wild_statement.children.head,
                                      &s->wild_statement.children.head,
                                      fill, dot, relax, check_regions);
                                      fill, dot, relax, check_regions);
          break;
          break;
 
 
        case lang_object_symbols_statement_enum:
        case lang_object_symbols_statement_enum:
          link_info.create_object_symbols_section =
          link_info.create_object_symbols_section =
            output_section_statement->bfd_section;
            output_section_statement->bfd_section;
          break;
          break;
 
 
        case lang_output_statement_enum:
        case lang_output_statement_enum:
        case lang_target_statement_enum:
        case lang_target_statement_enum:
          break;
          break;
 
 
        case lang_input_section_enum:
        case lang_input_section_enum:
          {
          {
            asection *i;
            asection *i;
 
 
            i = (*prev)->input_section.section;
            i = (*prev)->input_section.section;
            if (relax)
            if (relax)
              {
              {
                bfd_boolean again;
                bfd_boolean again;
 
 
                if (! bfd_relax_section (i->owner, i, &link_info, &again))
                if (! bfd_relax_section (i->owner, i, &link_info, &again))
                  einfo (_("%P%F: can't relax section: %E\n"));
                  einfo (_("%P%F: can't relax section: %E\n"));
                if (again)
                if (again)
                  *relax = TRUE;
                  *relax = TRUE;
              }
              }
            dot = size_input_section (prev, output_section_statement,
            dot = size_input_section (prev, output_section_statement,
                                      output_section_statement->fill, dot);
                                      output_section_statement->fill, dot);
          }
          }
          break;
          break;
 
 
        case lang_input_statement_enum:
        case lang_input_statement_enum:
          break;
          break;
 
 
        case lang_fill_statement_enum:
        case lang_fill_statement_enum:
          s->fill_statement.output_section =
          s->fill_statement.output_section =
            output_section_statement->bfd_section;
            output_section_statement->bfd_section;
 
 
          fill = s->fill_statement.fill;
          fill = s->fill_statement.fill;
          break;
          break;
 
 
        case lang_assignment_statement_enum:
        case lang_assignment_statement_enum:
          {
          {
            bfd_vma newdot = dot;
            bfd_vma newdot = dot;
            etree_type *tree = s->assignment_statement.exp;
            etree_type *tree = s->assignment_statement.exp;
 
 
            expld.dataseg.relro = exp_dataseg_relro_none;
            expld.dataseg.relro = exp_dataseg_relro_none;
 
 
            exp_fold_tree (tree,
            exp_fold_tree (tree,
                           output_section_statement->bfd_section,
                           output_section_statement->bfd_section,
                           &newdot);
                           &newdot);
 
 
            if (expld.dataseg.relro == exp_dataseg_relro_start)
            if (expld.dataseg.relro == exp_dataseg_relro_start)
              {
              {
                if (!expld.dataseg.relro_start_stat)
                if (!expld.dataseg.relro_start_stat)
                  expld.dataseg.relro_start_stat = s;
                  expld.dataseg.relro_start_stat = s;
                else
                else
                  {
                  {
                    ASSERT (expld.dataseg.relro_start_stat == s);
                    ASSERT (expld.dataseg.relro_start_stat == s);
                  }
                  }
              }
              }
            else if (expld.dataseg.relro == exp_dataseg_relro_end)
            else if (expld.dataseg.relro == exp_dataseg_relro_end)
              {
              {
                if (!expld.dataseg.relro_end_stat)
                if (!expld.dataseg.relro_end_stat)
                  expld.dataseg.relro_end_stat = s;
                  expld.dataseg.relro_end_stat = s;
                else
                else
                  {
                  {
                    ASSERT (expld.dataseg.relro_end_stat == s);
                    ASSERT (expld.dataseg.relro_end_stat == s);
                  }
                  }
              }
              }
            expld.dataseg.relro = exp_dataseg_relro_none;
            expld.dataseg.relro = exp_dataseg_relro_none;
 
 
            /* This symbol is relative to this section.  */
            /* This symbol is relative to this section.  */
            if ((tree->type.node_class == etree_provided
            if ((tree->type.node_class == etree_provided
                 || tree->type.node_class == etree_assign)
                 || tree->type.node_class == etree_assign)
                && (tree->assign.dst [0] != '.'
                && (tree->assign.dst [0] != '.'
                    || tree->assign.dst [1] != '\0'))
                    || tree->assign.dst [1] != '\0'))
              output_section_statement->section_relative_symbol = 1;
              output_section_statement->section_relative_symbol = 1;
 
 
            if (!output_section_statement->ignored)
            if (!output_section_statement->ignored)
              {
              {
                if (output_section_statement == abs_output_section)
                if (output_section_statement == abs_output_section)
                  {
                  {
                    /* If we don't have an output section, then just adjust
                    /* If we don't have an output section, then just adjust
                       the default memory address.  */
                       the default memory address.  */
                    lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
                    lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
                                               FALSE)->current = newdot;
                                               FALSE)->current = newdot;
                  }
                  }
                else if (newdot != dot)
                else if (newdot != dot)
                  {
                  {
                    /* Insert a pad after this statement.  We can't
                    /* Insert a pad after this statement.  We can't
                       put the pad before when relaxing, in case the
                       put the pad before when relaxing, in case the
                       assignment references dot.  */
                       assignment references dot.  */
                    insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
                    insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
                                output_section_statement->bfd_section, dot);
                                output_section_statement->bfd_section, dot);
 
 
                    /* Don't neuter the pad below when relaxing.  */
                    /* Don't neuter the pad below when relaxing.  */
                    s = s->header.next;
                    s = s->header.next;
 
 
                    /* If dot is advanced, this implies that the section
                    /* If dot is advanced, this implies that the section
                       should have space allocated to it, unless the
                       should have space allocated to it, unless the
                       user has explicitly stated that the section
                       user has explicitly stated that the section
                       should never be loaded.  */
                       should never be loaded.  */
                    if (!(output_section_statement->flags & SEC_NEVER_LOAD))
                    if (!(output_section_statement->flags & SEC_NEVER_LOAD))
                      output_section_statement->bfd_section->flags |= SEC_ALLOC;
                      output_section_statement->bfd_section->flags |= SEC_ALLOC;
                  }
                  }
                dot = newdot;
                dot = newdot;
              }
              }
          }
          }
          break;
          break;
 
 
        case lang_padding_statement_enum:
        case lang_padding_statement_enum:
          /* If this is the first time lang_size_sections is called,
          /* If this is the first time lang_size_sections is called,
             we won't have any padding statements.  If this is the
             we won't have any padding statements.  If this is the
             second or later passes when relaxing, we should allow
             second or later passes when relaxing, we should allow
             padding to shrink.  If padding is needed on this pass, it
             padding to shrink.  If padding is needed on this pass, it
             will be added back in.  */
             will be added back in.  */
          s->padding_statement.size = 0;
          s->padding_statement.size = 0;
 
 
          /* Make sure output_offset is valid.  If relaxation shrinks
          /* Make sure output_offset is valid.  If relaxation shrinks
             the section and this pad isn't needed, it's possible to
             the section and this pad isn't needed, it's possible to
             have output_offset larger than the final size of the
             have output_offset larger than the final size of the
             section.  bfd_set_section_contents will complain even for
             section.  bfd_set_section_contents will complain even for
             a pad size of zero.  */
             a pad size of zero.  */
          s->padding_statement.output_offset
          s->padding_statement.output_offset
            = dot - output_section_statement->bfd_section->vma;
            = dot - output_section_statement->bfd_section->vma;
          break;
          break;
 
 
        case lang_group_statement_enum:
        case lang_group_statement_enum:
          dot = lang_size_sections_1 (s->group_statement.children.head,
          dot = lang_size_sections_1 (s->group_statement.children.head,
                                      output_section_statement,
                                      output_section_statement,
                                      &s->group_statement.children.head,
                                      &s->group_statement.children.head,
                                      fill, dot, relax, check_regions);
                                      fill, dot, relax, check_regions);
          break;
          break;
 
 
        case lang_insert_statement_enum:
        case lang_insert_statement_enum:
          break;
          break;
 
 
          /* We can only get here when relaxing is turned on.  */
          /* We can only get here when relaxing is turned on.  */
        case lang_address_statement_enum:
        case lang_address_statement_enum:
          break;
          break;
 
 
        default:
        default:
          FAIL ();
          FAIL ();
          break;
          break;
        }
        }
      prev = &s->header.next;
      prev = &s->header.next;
    }
    }
  return dot;
  return dot;
}
}
 
 
/* Callback routine that is used in _bfd_elf_map_sections_to_segments.
/* Callback routine that is used in _bfd_elf_map_sections_to_segments.
   The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
   The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
   CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
   CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
   segments.  We are allowed an opportunity to override this decision.  */
   segments.  We are allowed an opportunity to override this decision.  */
 
 
bfd_boolean
bfd_boolean
ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,
ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,
                                    bfd * abfd ATTRIBUTE_UNUSED,
                                    bfd * abfd ATTRIBUTE_UNUSED,
                                    asection * current_section,
                                    asection * current_section,
                                    asection * previous_section,
                                    asection * previous_section,
                                    bfd_boolean new_segment)
                                    bfd_boolean new_segment)
{
{
  lang_output_section_statement_type * cur;
  lang_output_section_statement_type * cur;
  lang_output_section_statement_type * prev;
  lang_output_section_statement_type * prev;
 
 
  /* The checks below are only necessary when the BFD library has decided
  /* The checks below are only necessary when the BFD library has decided
     that the two sections ought to be placed into the same segment.  */
     that the two sections ought to be placed into the same segment.  */
  if (new_segment)
  if (new_segment)
    return TRUE;
    return TRUE;
 
 
  /* Paranoia checks.  */
  /* Paranoia checks.  */
  if (current_section == NULL || previous_section == NULL)
  if (current_section == NULL || previous_section == NULL)
    return new_segment;
    return new_segment;
 
 
  /* Find the memory regions associated with the two sections.
  /* Find the memory regions associated with the two sections.
     We call lang_output_section_find() here rather than scanning the list
     We call lang_output_section_find() here rather than scanning the list
     of output sections looking for a matching section pointer because if
     of output sections looking for a matching section pointer because if
     we have a large number of sections then a hash lookup is faster.  */
     we have a large number of sections then a hash lookup is faster.  */
  cur  = lang_output_section_find (current_section->name);
  cur  = lang_output_section_find (current_section->name);
  prev = lang_output_section_find (previous_section->name);
  prev = lang_output_section_find (previous_section->name);
 
 
  /* More paranoia.  */
  /* More paranoia.  */
  if (cur == NULL || prev == NULL)
  if (cur == NULL || prev == NULL)
    return new_segment;
    return new_segment;
 
 
  /* If the regions are different then force the sections to live in
  /* If the regions are different then force the sections to live in
     different segments.  See the email thread starting at the following
     different segments.  See the email thread starting at the following
     URL for the reasons why this is necessary:
     URL for the reasons why this is necessary:
     http://sourceware.org/ml/binutils/2007-02/msg00216.html  */
     http://sourceware.org/ml/binutils/2007-02/msg00216.html  */
  return cur->region != prev->region;
  return cur->region != prev->region;
}
}
 
 
void
void
one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
{
{
  lang_statement_iteration++;
  lang_statement_iteration++;
  lang_size_sections_1 (statement_list.head, abs_output_section,
  lang_size_sections_1 (statement_list.head, abs_output_section,
                        &statement_list.head, 0, 0, relax, check_regions);
                        &statement_list.head, 0, 0, relax, check_regions);
}
}
 
 
void
void
lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
{
{
  expld.phase = lang_allocating_phase_enum;
  expld.phase = lang_allocating_phase_enum;
  expld.dataseg.phase = exp_dataseg_none;
  expld.dataseg.phase = exp_dataseg_none;
 
 
  one_lang_size_sections_pass (relax, check_regions);
  one_lang_size_sections_pass (relax, check_regions);
  if (expld.dataseg.phase == exp_dataseg_end_seen
  if (expld.dataseg.phase == exp_dataseg_end_seen
      && link_info.relro && expld.dataseg.relro_end)
      && link_info.relro && expld.dataseg.relro_end)
    {
    {
      /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
      /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
         to put expld.dataseg.relro on a (common) page boundary.  */
         to put expld.dataseg.relro on a (common) page boundary.  */
      bfd_vma old_min_base, relro_end, maxpage;
      bfd_vma old_min_base, relro_end, maxpage;
 
 
      expld.dataseg.phase = exp_dataseg_relro_adjust;
      expld.dataseg.phase = exp_dataseg_relro_adjust;
      old_min_base = expld.dataseg.min_base;
      old_min_base = expld.dataseg.min_base;
      maxpage = expld.dataseg.maxpagesize;
      maxpage = expld.dataseg.maxpagesize;
      expld.dataseg.base += (-expld.dataseg.relro_end
      expld.dataseg.base += (-expld.dataseg.relro_end
                             & (expld.dataseg.pagesize - 1));
                             & (expld.dataseg.pagesize - 1));
      /* Compute the expected PT_GNU_RELRO segment end.  */
      /* Compute the expected PT_GNU_RELRO segment end.  */
      relro_end = (expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
      relro_end = (expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
                  & ~(expld.dataseg.pagesize - 1);
                  & ~(expld.dataseg.pagesize - 1);
      if (old_min_base + maxpage < expld.dataseg.base)
      if (old_min_base + maxpage < expld.dataseg.base)
        {
        {
          expld.dataseg.base -= maxpage;
          expld.dataseg.base -= maxpage;
          relro_end -= maxpage;
          relro_end -= maxpage;
        }
        }
      lang_reset_memory_regions ();
      lang_reset_memory_regions ();
      one_lang_size_sections_pass (relax, check_regions);
      one_lang_size_sections_pass (relax, check_regions);
      if (expld.dataseg.relro_end > relro_end)
      if (expld.dataseg.relro_end > relro_end)
        {
        {
          /* The alignment of sections between DATA_SEGMENT_ALIGN
          /* The alignment of sections between DATA_SEGMENT_ALIGN
             and DATA_SEGMENT_RELRO_END caused huge padding to be
             and DATA_SEGMENT_RELRO_END caused huge padding to be
             inserted at DATA_SEGMENT_RELRO_END.  Try some other base.  */
             inserted at DATA_SEGMENT_RELRO_END.  Try some other base.  */
          asection *sec;
          asection *sec;
          unsigned int max_alignment_power = 0;
          unsigned int max_alignment_power = 0;
 
 
          /* Find maximum alignment power of sections between
          /* Find maximum alignment power of sections between
             DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END.  */
             DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END.  */
          for (sec = link_info.output_bfd->sections; sec; sec = sec->next)
          for (sec = link_info.output_bfd->sections; sec; sec = sec->next)
            if (sec->vma >= expld.dataseg.base
            if (sec->vma >= expld.dataseg.base
                && sec->vma < expld.dataseg.relro_end
                && sec->vma < expld.dataseg.relro_end
                && sec->alignment_power > max_alignment_power)
                && sec->alignment_power > max_alignment_power)
              max_alignment_power = sec->alignment_power;
              max_alignment_power = sec->alignment_power;
 
 
          if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)
          if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)
            {
            {
              if (expld.dataseg.base - (1 << max_alignment_power)
              if (expld.dataseg.base - (1 << max_alignment_power)
                  < old_min_base)
                  < old_min_base)
                expld.dataseg.base += expld.dataseg.pagesize;
                expld.dataseg.base += expld.dataseg.pagesize;
              expld.dataseg.base -= (1 << max_alignment_power);
              expld.dataseg.base -= (1 << max_alignment_power);
              lang_reset_memory_regions ();
              lang_reset_memory_regions ();
              one_lang_size_sections_pass (relax, check_regions);
              one_lang_size_sections_pass (relax, check_regions);
            }
            }
        }
        }
      link_info.relro_start = expld.dataseg.base;
      link_info.relro_start = expld.dataseg.base;
      link_info.relro_end = expld.dataseg.relro_end;
      link_info.relro_end = expld.dataseg.relro_end;
    }
    }
  else if (expld.dataseg.phase == exp_dataseg_end_seen)
  else if (expld.dataseg.phase == exp_dataseg_end_seen)
    {
    {
      /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
      /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
         a page could be saved in the data segment.  */
         a page could be saved in the data segment.  */
      bfd_vma first, last;
      bfd_vma first, last;
 
 
      first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
      first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
      last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
      last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
      if (first && last
      if (first && last
          && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
          && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
              != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
              != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
          && first + last <= expld.dataseg.pagesize)
          && first + last <= expld.dataseg.pagesize)
        {
        {
          expld.dataseg.phase = exp_dataseg_adjust;
          expld.dataseg.phase = exp_dataseg_adjust;
          lang_reset_memory_regions ();
          lang_reset_memory_regions ();
          one_lang_size_sections_pass (relax, check_regions);
          one_lang_size_sections_pass (relax, check_regions);
        }
        }
    }
    }
 
 
  expld.phase = lang_final_phase_enum;
  expld.phase = lang_final_phase_enum;
}
}
 
 
/* Worker function for lang_do_assignments.  Recursiveness goes here.  */
/* Worker function for lang_do_assignments.  Recursiveness goes here.  */
 
 
static bfd_vma
static bfd_vma
lang_do_assignments_1 (lang_statement_union_type *s,
lang_do_assignments_1 (lang_statement_union_type *s,
                       lang_output_section_statement_type *current_os,
                       lang_output_section_statement_type *current_os,
                       fill_type *fill,
                       fill_type *fill,
                       bfd_vma dot)
                       bfd_vma dot)
{
{
  for (; s != NULL; s = s->header.next)
  for (; s != NULL; s = s->header.next)
    {
    {
      switch (s->header.type)
      switch (s->header.type)
        {
        {
        case lang_constructors_statement_enum:
        case lang_constructors_statement_enum:
          dot = lang_do_assignments_1 (constructor_list.head,
          dot = lang_do_assignments_1 (constructor_list.head,
                                       current_os, fill, dot);
                                       current_os, fill, dot);
          break;
          break;
 
 
        case lang_output_section_statement_enum:
        case lang_output_section_statement_enum:
          {
          {
            lang_output_section_statement_type *os;
            lang_output_section_statement_type *os;
 
 
            os = &(s->output_section_statement);
            os = &(s->output_section_statement);
            if (os->bfd_section != NULL && !os->ignored)
            if (os->bfd_section != NULL && !os->ignored)
              {
              {
                dot = os->bfd_section->vma;
                dot = os->bfd_section->vma;
 
 
                lang_do_assignments_1 (os->children.head, os, os->fill, dot);
                lang_do_assignments_1 (os->children.head, os, os->fill, dot);
 
 
                /* .tbss sections effectively have zero size.  */
                /* .tbss sections effectively have zero size.  */
                if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
                if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
                    || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
                    || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
                    || link_info.relocatable)
                    || link_info.relocatable)
                  dot += TO_ADDR (os->bfd_section->size);
                  dot += TO_ADDR (os->bfd_section->size);
              }
              }
          }
          }
          break;
          break;
 
 
        case lang_wild_statement_enum:
        case lang_wild_statement_enum:
 
 
          dot = lang_do_assignments_1 (s->wild_statement.children.head,
          dot = lang_do_assignments_1 (s->wild_statement.children.head,
                                       current_os, fill, dot);
                                       current_os, fill, dot);
          break;
          break;
 
 
        case lang_object_symbols_statement_enum:
        case lang_object_symbols_statement_enum:
        case lang_output_statement_enum:
        case lang_output_statement_enum:
        case lang_target_statement_enum:
        case lang_target_statement_enum:
          break;
          break;
 
 
        case lang_data_statement_enum:
        case lang_data_statement_enum:
          exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
          exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
          if (expld.result.valid_p)
          if (expld.result.valid_p)
            s->data_statement.value = (expld.result.value
            s->data_statement.value = (expld.result.value
                                       + expld.result.section->vma);
                                       + expld.result.section->vma);
          else
          else
            einfo (_("%F%P: invalid data statement\n"));
            einfo (_("%F%P: invalid data statement\n"));
          {
          {
            unsigned int size;
            unsigned int size;
            switch (s->data_statement.type)
            switch (s->data_statement.type)
              {
              {
              default:
              default:
                abort ();
                abort ();
              case QUAD:
              case QUAD:
              case SQUAD:
              case SQUAD:
                size = QUAD_SIZE;
                size = QUAD_SIZE;
                break;
                break;
              case LONG:
              case LONG:
                size = LONG_SIZE;
                size = LONG_SIZE;
                break;
                break;
              case SHORT:
              case SHORT:
                size = SHORT_SIZE;
                size = SHORT_SIZE;
                break;
                break;
              case BYTE:
              case BYTE:
                size = BYTE_SIZE;
                size = BYTE_SIZE;
                break;
                break;
              }
              }
            if (size < TO_SIZE ((unsigned) 1))
            if (size < TO_SIZE ((unsigned) 1))
              size = TO_SIZE ((unsigned) 1);
              size = TO_SIZE ((unsigned) 1);
            dot += TO_ADDR (size);
            dot += TO_ADDR (size);
          }
          }
          break;
          break;
 
 
        case lang_reloc_statement_enum:
        case lang_reloc_statement_enum:
          exp_fold_tree (s->reloc_statement.addend_exp,
          exp_fold_tree (s->reloc_statement.addend_exp,
                         bfd_abs_section_ptr, &dot);
                         bfd_abs_section_ptr, &dot);
          if (expld.result.valid_p)
          if (expld.result.valid_p)
            s->reloc_statement.addend_value = expld.result.value;
            s->reloc_statement.addend_value = expld.result.value;
          else
          else
            einfo (_("%F%P: invalid reloc statement\n"));
            einfo (_("%F%P: invalid reloc statement\n"));
          dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
          dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
          break;
          break;
 
 
        case lang_input_section_enum:
        case lang_input_section_enum:
          {
          {
            asection *in = s->input_section.section;
            asection *in = s->input_section.section;
 
 
            if ((in->flags & SEC_EXCLUDE) == 0)
            if ((in->flags & SEC_EXCLUDE) == 0)
              dot += TO_ADDR (in->size);
              dot += TO_ADDR (in->size);
          }
          }
          break;
          break;
 
 
        case lang_input_statement_enum:
        case lang_input_statement_enum:
          break;
          break;
 
 
        case lang_fill_statement_enum:
        case lang_fill_statement_enum:
          fill = s->fill_statement.fill;
          fill = s->fill_statement.fill;
          break;
          break;
 
 
        case lang_assignment_statement_enum:
        case lang_assignment_statement_enum:
          exp_fold_tree (s->assignment_statement.exp,
          exp_fold_tree (s->assignment_statement.exp,
                         current_os->bfd_section,
                         current_os->bfd_section,
                         &dot);
                         &dot);
          break;
          break;
 
 
        case lang_padding_statement_enum:
        case lang_padding_statement_enum:
          dot += TO_ADDR (s->padding_statement.size);
          dot += TO_ADDR (s->padding_statement.size);
          break;
          break;
 
 
        case lang_group_statement_enum:
        case lang_group_statement_enum:
          dot = lang_do_assignments_1 (s->group_statement.children.head,
          dot = lang_do_assignments_1 (s->group_statement.children.head,
                                       current_os, fill, dot);
                                       current_os, fill, dot);
          break;
          break;
 
 
        case lang_insert_statement_enum:
        case lang_insert_statement_enum:
          break;
          break;
 
 
        case lang_address_statement_enum:
        case lang_address_statement_enum:
          break;
          break;
 
 
        default:
        default:
          FAIL ();
          FAIL ();
          break;
          break;
        }
        }
    }
    }
  return dot;
  return dot;
}
}
 
 
void
void
lang_do_assignments (void)
lang_do_assignments (void)
{
{
  lang_statement_iteration++;
  lang_statement_iteration++;
  lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);
  lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);
}
}
 
 
/* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
/* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
   operator .startof. (section_name), it produces an undefined symbol
   operator .startof. (section_name), it produces an undefined symbol
   .startof.section_name.  Similarly, when it sees
   .startof.section_name.  Similarly, when it sees
   .sizeof. (section_name), it produces an undefined symbol
   .sizeof. (section_name), it produces an undefined symbol
   .sizeof.section_name.  For all the output sections, we look for
   .sizeof.section_name.  For all the output sections, we look for
   such symbols, and set them to the correct value.  */
   such symbols, and set them to the correct value.  */
 
 
static void
static void
lang_set_startof (void)
lang_set_startof (void)
{
{
  asection *s;
  asection *s;
 
 
  if (link_info.relocatable)
  if (link_info.relocatable)
    return;
    return;
 
 
  for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
  for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
    {
    {
      const char *secname;
      const char *secname;
      char *buf;
      char *buf;
      struct bfd_link_hash_entry *h;
      struct bfd_link_hash_entry *h;
 
 
      secname = bfd_get_section_name (link_info.output_bfd, s);
      secname = bfd_get_section_name (link_info.output_bfd, s);
      buf = xmalloc (10 + strlen (secname));
      buf = xmalloc (10 + strlen (secname));
 
 
      sprintf (buf, ".startof.%s", secname);
      sprintf (buf, ".startof.%s", secname);
      h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
      h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
      if (h != NULL && h->type == bfd_link_hash_undefined)
      if (h != NULL && h->type == bfd_link_hash_undefined)
        {
        {
          h->type = bfd_link_hash_defined;
          h->type = bfd_link_hash_defined;
          h->u.def.value = bfd_get_section_vma (link_info.output_bfd, s);
          h->u.def.value = bfd_get_section_vma (link_info.output_bfd, s);
          h->u.def.section = bfd_abs_section_ptr;
          h->u.def.section = bfd_abs_section_ptr;
        }
        }
 
 
      sprintf (buf, ".sizeof.%s", secname);
      sprintf (buf, ".sizeof.%s", secname);
      h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
      h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
      if (h != NULL && h->type == bfd_link_hash_undefined)
      if (h != NULL && h->type == bfd_link_hash_undefined)
        {
        {
          h->type = bfd_link_hash_defined;
          h->type = bfd_link_hash_defined;
          h->u.def.value = TO_ADDR (s->size);
          h->u.def.value = TO_ADDR (s->size);
          h->u.def.section = bfd_abs_section_ptr;
          h->u.def.section = bfd_abs_section_ptr;
        }
        }
 
 
      free (buf);
      free (buf);
    }
    }
}
}
 
 
static void
static void
lang_end (void)
lang_end (void)
{
{
  struct bfd_link_hash_entry *h;
  struct bfd_link_hash_entry *h;
  bfd_boolean warn;
  bfd_boolean warn;
 
 
  if ((link_info.relocatable && !link_info.gc_sections)
  if ((link_info.relocatable && !link_info.gc_sections)
      || link_info.shared)
      || link_info.shared)
    warn = entry_from_cmdline;
    warn = entry_from_cmdline;
  else
  else
    warn = TRUE;
    warn = TRUE;
 
 
  /* Force the user to specify a root when generating a relocatable with
  /* Force the user to specify a root when generating a relocatable with
     --gc-sections.  */
     --gc-sections.  */
  if (link_info.gc_sections && link_info.relocatable
  if (link_info.gc_sections && link_info.relocatable
      && (entry_symbol.name == NULL
      && (entry_symbol.name == NULL
          && ldlang_undef_chain_list_head == NULL))
          && ldlang_undef_chain_list_head == NULL))
    einfo (_("%P%F: gc-sections requires either an entry or "
    einfo (_("%P%F: gc-sections requires either an entry or "
             "an undefined symbol\n"));
             "an undefined symbol\n"));
 
 
  if (entry_symbol.name == NULL)
  if (entry_symbol.name == NULL)
    {
    {
      /* No entry has been specified.  Look for the default entry, but
      /* No entry has been specified.  Look for the default entry, but
         don't warn if we don't find it.  */
         don't warn if we don't find it.  */
      entry_symbol.name = entry_symbol_default;
      entry_symbol.name = entry_symbol_default;
      warn = FALSE;
      warn = FALSE;
    }
    }
 
 
  h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
  h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
                            FALSE, FALSE, TRUE);
                            FALSE, FALSE, TRUE);
  if (h != NULL
  if (h != NULL
      && (h->type == bfd_link_hash_defined
      && (h->type == bfd_link_hash_defined
          || h->type == bfd_link_hash_defweak)
          || h->type == bfd_link_hash_defweak)
      && h->u.def.section->output_section != NULL)
      && h->u.def.section->output_section != NULL)
    {
    {
      bfd_vma val;
      bfd_vma val;
 
 
      val = (h->u.def.value
      val = (h->u.def.value
             + bfd_get_section_vma (link_info.output_bfd,
             + bfd_get_section_vma (link_info.output_bfd,
                                    h->u.def.section->output_section)
                                    h->u.def.section->output_section)
             + h->u.def.section->output_offset);
             + h->u.def.section->output_offset);
      if (! bfd_set_start_address (link_info.output_bfd, val))
      if (! bfd_set_start_address (link_info.output_bfd, val))
        einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
        einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
    }
    }
  else
  else
    {
    {
      bfd_vma val;
      bfd_vma val;
      const char *send;
      const char *send;
 
 
      /* We couldn't find the entry symbol.  Try parsing it as a
      /* We couldn't find the entry symbol.  Try parsing it as a
         number.  */
         number.  */
      val = bfd_scan_vma (entry_symbol.name, &send, 0);
      val = bfd_scan_vma (entry_symbol.name, &send, 0);
      if (*send == '\0')
      if (*send == '\0')
        {
        {
          if (! bfd_set_start_address (link_info.output_bfd, val))
          if (! bfd_set_start_address (link_info.output_bfd, val))
            einfo (_("%P%F: can't set start address\n"));
            einfo (_("%P%F: can't set start address\n"));
        }
        }
      else
      else
        {
        {
          asection *ts;
          asection *ts;
 
 
          /* Can't find the entry symbol, and it's not a number.  Use
          /* Can't find the entry symbol, and it's not a number.  Use
             the first address in the text section.  */
             the first address in the text section.  */
          ts = bfd_get_section_by_name (link_info.output_bfd, entry_section);
          ts = bfd_get_section_by_name (link_info.output_bfd, entry_section);
          if (ts != NULL)
          if (ts != NULL)
            {
            {
              if (warn)
              if (warn)
                einfo (_("%P: warning: cannot find entry symbol %s;"
                einfo (_("%P: warning: cannot find entry symbol %s;"
                         " defaulting to %V\n"),
                         " defaulting to %V\n"),
                       entry_symbol.name,
                       entry_symbol.name,
                       bfd_get_section_vma (link_info.output_bfd, ts));
                       bfd_get_section_vma (link_info.output_bfd, ts));
              if (!(bfd_set_start_address
              if (!(bfd_set_start_address
                    (link_info.output_bfd,
                    (link_info.output_bfd,
                     bfd_get_section_vma (link_info.output_bfd, ts))))
                     bfd_get_section_vma (link_info.output_bfd, ts))))
                einfo (_("%P%F: can't set start address\n"));
                einfo (_("%P%F: can't set start address\n"));
            }
            }
          else
          else
            {
            {
              if (warn)
              if (warn)
                einfo (_("%P: warning: cannot find entry symbol %s;"
                einfo (_("%P: warning: cannot find entry symbol %s;"
                         " not setting start address\n"),
                         " not setting start address\n"),
                       entry_symbol.name);
                       entry_symbol.name);
            }
            }
        }
        }
    }
    }
 
 
  /* Don't bfd_hash_table_free (&lang_definedness_table);
  /* Don't bfd_hash_table_free (&lang_definedness_table);
     map file output may result in a call of lang_track_definedness.  */
     map file output may result in a call of lang_track_definedness.  */
}
}
 
 
/* This is a small function used when we want to ignore errors from
/* This is a small function used when we want to ignore errors from
   BFD.  */
   BFD.  */
 
 
static void
static void
ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
{
{
  /* Don't do anything.  */
  /* Don't do anything.  */
}
}
 
 
/* Check that the architecture of all the input files is compatible
/* Check that the architecture of all the input files is compatible
   with the output file.  Also call the backend to let it do any
   with the output file.  Also call the backend to let it do any
   other checking that is needed.  */
   other checking that is needed.  */
 
 
static void
static void
lang_check (void)
lang_check (void)
{
{
  lang_statement_union_type *file;
  lang_statement_union_type *file;
  bfd *input_bfd;
  bfd *input_bfd;
  const bfd_arch_info_type *compatible;
  const bfd_arch_info_type *compatible;
 
 
  for (file = file_chain.head; file != NULL; file = file->input_statement.next)
  for (file = file_chain.head; file != NULL; file = file->input_statement.next)
    {
    {
      input_bfd = file->input_statement.the_bfd;
      input_bfd = file->input_statement.the_bfd;
      compatible
      compatible
        = bfd_arch_get_compatible (input_bfd, link_info.output_bfd,
        = bfd_arch_get_compatible (input_bfd, link_info.output_bfd,
                                   command_line.accept_unknown_input_arch);
                                   command_line.accept_unknown_input_arch);
 
 
      /* In general it is not possible to perform a relocatable
      /* In general it is not possible to perform a relocatable
         link between differing object formats when the input
         link between differing object formats when the input
         file has relocations, because the relocations in the
         file has relocations, because the relocations in the
         input format may not have equivalent representations in
         input format may not have equivalent representations in
         the output format (and besides BFD does not translate
         the output format (and besides BFD does not translate
         relocs for other link purposes than a final link).  */
         relocs for other link purposes than a final link).  */
      if ((link_info.relocatable || link_info.emitrelocations)
      if ((link_info.relocatable || link_info.emitrelocations)
          && (compatible == NULL
          && (compatible == NULL
              || (bfd_get_flavour (input_bfd)
              || (bfd_get_flavour (input_bfd)
                  != bfd_get_flavour (link_info.output_bfd)))
                  != bfd_get_flavour (link_info.output_bfd)))
          && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
          && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
        {
        {
          einfo (_("%P%F: Relocatable linking with relocations from"
          einfo (_("%P%F: Relocatable linking with relocations from"
                   " format %s (%B) to format %s (%B) is not supported\n"),
                   " format %s (%B) to format %s (%B) is not supported\n"),
                 bfd_get_target (input_bfd), input_bfd,
                 bfd_get_target (input_bfd), input_bfd,
                 bfd_get_target (link_info.output_bfd), link_info.output_bfd);
                 bfd_get_target (link_info.output_bfd), link_info.output_bfd);
          /* einfo with %F exits.  */
          /* einfo with %F exits.  */
        }
        }
 
 
      if (compatible == NULL)
      if (compatible == NULL)
        {
        {
          if (command_line.warn_mismatch)
          if (command_line.warn_mismatch)
            einfo (_("%P%X: %s architecture of input file `%B'"
            einfo (_("%P%X: %s architecture of input file `%B'"
                     " is incompatible with %s output\n"),
                     " is incompatible with %s output\n"),
                   bfd_printable_name (input_bfd), input_bfd,
                   bfd_printable_name (input_bfd), input_bfd,
                   bfd_printable_name (link_info.output_bfd));
                   bfd_printable_name (link_info.output_bfd));
        }
        }
      else if (bfd_count_sections (input_bfd))
      else if (bfd_count_sections (input_bfd))
        {
        {
          /* If the input bfd has no contents, it shouldn't set the
          /* If the input bfd has no contents, it shouldn't set the
             private data of the output bfd.  */
             private data of the output bfd.  */
 
 
          bfd_error_handler_type pfn = NULL;
          bfd_error_handler_type pfn = NULL;
 
 
          /* If we aren't supposed to warn about mismatched input
          /* If we aren't supposed to warn about mismatched input
             files, temporarily set the BFD error handler to a
             files, temporarily set the BFD error handler to a
             function which will do nothing.  We still want to call
             function which will do nothing.  We still want to call
             bfd_merge_private_bfd_data, since it may set up
             bfd_merge_private_bfd_data, since it may set up
             information which is needed in the output file.  */
             information which is needed in the output file.  */
          if (! command_line.warn_mismatch)
          if (! command_line.warn_mismatch)
            pfn = bfd_set_error_handler (ignore_bfd_errors);
            pfn = bfd_set_error_handler (ignore_bfd_errors);
          if (! bfd_merge_private_bfd_data (input_bfd, link_info.output_bfd))
          if (! bfd_merge_private_bfd_data (input_bfd, link_info.output_bfd))
            {
            {
              if (command_line.warn_mismatch)
              if (command_line.warn_mismatch)
                einfo (_("%P%X: failed to merge target specific data"
                einfo (_("%P%X: failed to merge target specific data"
                         " of file %B\n"), input_bfd);
                         " of file %B\n"), input_bfd);
            }
            }
          if (! command_line.warn_mismatch)
          if (! command_line.warn_mismatch)
            bfd_set_error_handler (pfn);
            bfd_set_error_handler (pfn);
        }
        }
    }
    }
}
}
 
 
/* Look through all the global common symbols and attach them to the
/* Look through all the global common symbols and attach them to the
   correct section.  The -sort-common command line switch may be used
   correct section.  The -sort-common command line switch may be used
   to roughly sort the entries by size.  */
   to roughly sort the entries by size.  */
 
 
static void
static void
lang_common (void)
lang_common (void)
{
{
  if (command_line.inhibit_common_definition)
  if (command_line.inhibit_common_definition)
    return;
    return;
  if (link_info.relocatable
  if (link_info.relocatable
      && ! command_line.force_common_definition)
      && ! command_line.force_common_definition)
    return;
    return;
 
 
  if (! config.sort_common)
  if (! config.sort_common)
    bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
    bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
  else
  else
    {
    {
      int power;
      int power;
 
 
      for (power = 4; power >= 0; power--)
      for (power = 4; power >= 0; power--)
        bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
        bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
    }
    }
}
}
 
 
/* Place one common symbol in the correct section.  */
/* Place one common symbol in the correct section.  */
 
 
static bfd_boolean
static bfd_boolean
lang_one_common (struct bfd_link_hash_entry *h, void *info)
lang_one_common (struct bfd_link_hash_entry *h, void *info)
{
{
  unsigned int power_of_two;
  unsigned int power_of_two;
  bfd_vma size;
  bfd_vma size;
  asection *section;
  asection *section;
 
 
  if (h->type != bfd_link_hash_common)
  if (h->type != bfd_link_hash_common)
    return TRUE;
    return TRUE;
 
 
  size = h->u.c.size;
  size = h->u.c.size;
  power_of_two = h->u.c.p->alignment_power;
  power_of_two = h->u.c.p->alignment_power;
 
 
  if (config.sort_common
  if (config.sort_common
      && power_of_two < (unsigned int) *(int *) info)
      && power_of_two < (unsigned int) *(int *) info)
    return TRUE;
    return TRUE;
 
 
  section = h->u.c.p->section;
  section = h->u.c.p->section;
 
 
  /* Increase the size of the section to align the common sym.  */
  /* Increase the size of the section to align the common sym.  */
  section->size += ((bfd_vma) 1 << (power_of_two + opb_shift)) - 1;
  section->size += ((bfd_vma) 1 << (power_of_two + opb_shift)) - 1;
  section->size &= (- (bfd_vma) 1 << (power_of_two + opb_shift));
  section->size &= (- (bfd_vma) 1 << (power_of_two + opb_shift));
 
 
  /* Adjust the alignment if necessary.  */
  /* Adjust the alignment if necessary.  */
  if (power_of_two > section->alignment_power)
  if (power_of_two > section->alignment_power)
    section->alignment_power = power_of_two;
    section->alignment_power = power_of_two;
 
 
  /* Change the symbol from common to defined.  */
  /* Change the symbol from common to defined.  */
  h->type = bfd_link_hash_defined;
  h->type = bfd_link_hash_defined;
  h->u.def.section = section;
  h->u.def.section = section;
  h->u.def.value = section->size;
  h->u.def.value = section->size;
 
 
  /* Increase the size of the section.  */
  /* Increase the size of the section.  */
  section->size += size;
  section->size += size;
 
 
  /* Make sure the section is allocated in memory, and make sure that
  /* Make sure the section is allocated in memory, and make sure that
     it is no longer a common section.  */
     it is no longer a common section.  */
  section->flags |= SEC_ALLOC;
  section->flags |= SEC_ALLOC;
  section->flags &= ~SEC_IS_COMMON;
  section->flags &= ~SEC_IS_COMMON;
 
 
  if (config.map_file != NULL)
  if (config.map_file != NULL)
    {
    {
      static bfd_boolean header_printed;
      static bfd_boolean header_printed;
      int len;
      int len;
      char *name;
      char *name;
      char buf[50];
      char buf[50];
 
 
      if (! header_printed)
      if (! header_printed)
        {
        {
          minfo (_("\nAllocating common symbols\n"));
          minfo (_("\nAllocating common symbols\n"));
          minfo (_("Common symbol       size              file\n\n"));
          minfo (_("Common symbol       size              file\n\n"));
          header_printed = TRUE;
          header_printed = TRUE;
        }
        }
 
 
      name = bfd_demangle (link_info.output_bfd, h->root.string,
      name = bfd_demangle (link_info.output_bfd, h->root.string,
                           DMGL_ANSI | DMGL_PARAMS);
                           DMGL_ANSI | DMGL_PARAMS);
      if (name == NULL)
      if (name == NULL)
        {
        {
          minfo ("%s", h->root.string);
          minfo ("%s", h->root.string);
          len = strlen (h->root.string);
          len = strlen (h->root.string);
        }
        }
      else
      else
        {
        {
          minfo ("%s", name);
          minfo ("%s", name);
          len = strlen (name);
          len = strlen (name);
          free (name);
          free (name);
        }
        }
 
 
      if (len >= 19)
      if (len >= 19)
        {
        {
          print_nl ();
          print_nl ();
          len = 0;
          len = 0;
        }
        }
      while (len < 20)
      while (len < 20)
        {
        {
          print_space ();
          print_space ();
          ++len;
          ++len;
        }
        }
 
 
      minfo ("0x");
      minfo ("0x");
      if (size <= 0xffffffff)
      if (size <= 0xffffffff)
        sprintf (buf, "%lx", (unsigned long) size);
        sprintf (buf, "%lx", (unsigned long) size);
      else
      else
        sprintf_vma (buf, size);
        sprintf_vma (buf, size);
      minfo ("%s", buf);
      minfo ("%s", buf);
      len = strlen (buf);
      len = strlen (buf);
 
 
      while (len < 16)
      while (len < 16)
        {
        {
          print_space ();
          print_space ();
          ++len;
          ++len;
        }
        }
 
 
      minfo ("%B\n", section->owner);
      minfo ("%B\n", section->owner);
    }
    }
 
 
  return TRUE;
  return TRUE;
}
}
 
 
/* Run through the input files and ensure that every input section has
/* Run through the input files and ensure that every input section has
   somewhere to go.  If one is found without a destination then create
   somewhere to go.  If one is found without a destination then create
   an input request and place it into the statement tree.  */
   an input request and place it into the statement tree.  */
 
 
static void
static void
lang_place_orphans (void)
lang_place_orphans (void)
{
{
  LANG_FOR_EACH_INPUT_STATEMENT (file)
  LANG_FOR_EACH_INPUT_STATEMENT (file)
    {
    {
      asection *s;
      asection *s;
 
 
      for (s = file->the_bfd->sections; s != NULL; s = s->next)
      for (s = file->the_bfd->sections; s != NULL; s = s->next)
        {
        {
          if (s->output_section == NULL)
          if (s->output_section == NULL)
            {
            {
              /* This section of the file is not attached, root
              /* This section of the file is not attached, root
                 around for a sensible place for it to go.  */
                 around for a sensible place for it to go.  */
 
 
              if (file->just_syms_flag)
              if (file->just_syms_flag)
                bfd_link_just_syms (file->the_bfd, s, &link_info);
                bfd_link_just_syms (file->the_bfd, s, &link_info);
              else if ((s->flags & SEC_EXCLUDE) != 0)
              else if ((s->flags & SEC_EXCLUDE) != 0)
                s->output_section = bfd_abs_section_ptr;
                s->output_section = bfd_abs_section_ptr;
              else if (strcmp (s->name, "COMMON") == 0)
              else if (strcmp (s->name, "COMMON") == 0)
                {
                {
                  /* This is a lonely common section which must have
                  /* This is a lonely common section which must have
                     come from an archive.  We attach to the section
                     come from an archive.  We attach to the section
                     with the wildcard.  */
                     with the wildcard.  */
                  if (! link_info.relocatable
                  if (! link_info.relocatable
                      || command_line.force_common_definition)
                      || command_line.force_common_definition)
                    {
                    {
                      if (default_common_section == NULL)
                      if (default_common_section == NULL)
                        {
                        {
                          default_common_section =
                          default_common_section =
                            lang_output_section_statement_lookup (".bss");
                            lang_output_section_statement_lookup (".bss");
 
 
                        }
                        }
                      lang_add_section (&default_common_section->children, s,
                      lang_add_section (&default_common_section->children, s,
                                        default_common_section);
                                        default_common_section);
                    }
                    }
                }
                }
              else if (ldemul_place_orphan (s))
              else if (ldemul_place_orphan (s))
                ;
                ;
              else
              else
                {
                {
                  lang_output_section_statement_type *os;
                  lang_output_section_statement_type *os;
 
 
                  os = lang_output_section_statement_lookup (s->name);
                  os = lang_output_section_statement_lookup (s->name);
                  lang_add_section (&os->children, s, os);
                  lang_add_section (&os->children, s, os);
                }
                }
            }
            }
        }
        }
    }
    }
}
}
 
 
void
void
lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
{
{
  flagword *ptr_flags;
  flagword *ptr_flags;
 
 
  ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
  ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
  while (*flags)
  while (*flags)
    {
    {
      switch (*flags)
      switch (*flags)
        {
        {
        case 'A': case 'a':
        case 'A': case 'a':
          *ptr_flags |= SEC_ALLOC;
          *ptr_flags |= SEC_ALLOC;
          break;
          break;
 
 
        case 'R': case 'r':
        case 'R': case 'r':
          *ptr_flags |= SEC_READONLY;
          *ptr_flags |= SEC_READONLY;
          break;
          break;
 
 
        case 'W': case 'w':
        case 'W': case 'w':
          *ptr_flags |= SEC_DATA;
          *ptr_flags |= SEC_DATA;
          break;
          break;
 
 
        case 'X': case 'x':
        case 'X': case 'x':
          *ptr_flags |= SEC_CODE;
          *ptr_flags |= SEC_CODE;
          break;
          break;
 
 
        case 'L': case 'l':
        case 'L': case 'l':
        case 'I': case 'i':
        case 'I': case 'i':
          *ptr_flags |= SEC_LOAD;
          *ptr_flags |= SEC_LOAD;
          break;
          break;
 
 
        default:
        default:
          einfo (_("%P%F: invalid syntax in flags\n"));
          einfo (_("%P%F: invalid syntax in flags\n"));
          break;
          break;
        }
        }
      flags++;
      flags++;
    }
    }
}
}
 
 
/* Call a function on each input file.  This function will be called
/* Call a function on each input file.  This function will be called
   on an archive, but not on the elements.  */
   on an archive, but not on the elements.  */
 
 
void
void
lang_for_each_input_file (void (*func) (lang_input_statement_type *))
lang_for_each_input_file (void (*func) (lang_input_statement_type *))
{
{
  lang_input_statement_type *f;
  lang_input_statement_type *f;
 
 
  for (f = (lang_input_statement_type *) input_file_chain.head;
  for (f = (lang_input_statement_type *) input_file_chain.head;
       f != NULL;
       f != NULL;
       f = (lang_input_statement_type *) f->next_real_file)
       f = (lang_input_statement_type *) f->next_real_file)
    func (f);
    func (f);
}
}
 
 
/* Call a function on each file.  The function will be called on all
/* Call a function on each file.  The function will be called on all
   the elements of an archive which are included in the link, but will
   the elements of an archive which are included in the link, but will
   not be called on the archive file itself.  */
   not be called on the archive file itself.  */
 
 
void
void
lang_for_each_file (void (*func) (lang_input_statement_type *))
lang_for_each_file (void (*func) (lang_input_statement_type *))
{
{
  LANG_FOR_EACH_INPUT_STATEMENT (f)
  LANG_FOR_EACH_INPUT_STATEMENT (f)
    {
    {
      func (f);
      func (f);
    }
    }
}
}
 
 
void
void
ldlang_add_file (lang_input_statement_type *entry)
ldlang_add_file (lang_input_statement_type *entry)
{
{
  lang_statement_append (&file_chain,
  lang_statement_append (&file_chain,
                         (lang_statement_union_type *) entry,
                         (lang_statement_union_type *) entry,
                         &entry->next);
                         &entry->next);
 
 
  /* The BFD linker needs to have a list of all input BFDs involved in
  /* The BFD linker needs to have a list of all input BFDs involved in
     a link.  */
     a link.  */
  ASSERT (entry->the_bfd->link_next == NULL);
  ASSERT (entry->the_bfd->link_next == NULL);
  ASSERT (entry->the_bfd != link_info.output_bfd);
  ASSERT (entry->the_bfd != link_info.output_bfd);
 
 
  *link_info.input_bfds_tail = entry->the_bfd;
  *link_info.input_bfds_tail = entry->the_bfd;
  link_info.input_bfds_tail = &entry->the_bfd->link_next;
  link_info.input_bfds_tail = &entry->the_bfd->link_next;
  entry->the_bfd->usrdata = entry;
  entry->the_bfd->usrdata = entry;
  bfd_set_gp_size (entry->the_bfd, g_switch_value);
  bfd_set_gp_size (entry->the_bfd, g_switch_value);
 
 
  /* Look through the sections and check for any which should not be
  /* Look through the sections and check for any which should not be
     included in the link.  We need to do this now, so that we can
     included in the link.  We need to do this now, so that we can
     notice when the backend linker tries to report multiple
     notice when the backend linker tries to report multiple
     definition errors for symbols which are in sections we aren't
     definition errors for symbols which are in sections we aren't
     going to link.  FIXME: It might be better to entirely ignore
     going to link.  FIXME: It might be better to entirely ignore
     symbols which are defined in sections which are going to be
     symbols which are defined in sections which are going to be
     discarded.  This would require modifying the backend linker for
     discarded.  This would require modifying the backend linker for
     each backend which might set the SEC_LINK_ONCE flag.  If we do
     each backend which might set the SEC_LINK_ONCE flag.  If we do
     this, we should probably handle SEC_EXCLUDE in the same way.  */
     this, we should probably handle SEC_EXCLUDE in the same way.  */
 
 
  bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
  bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
}
}
 
 
void
void
lang_add_output (const char *name, int from_script)
lang_add_output (const char *name, int from_script)
{
{
  /* Make -o on command line override OUTPUT in script.  */
  /* Make -o on command line override OUTPUT in script.  */
  if (!had_output_filename || !from_script)
  if (!had_output_filename || !from_script)
    {
    {
      output_filename = name;
      output_filename = name;
      had_output_filename = TRUE;
      had_output_filename = TRUE;
    }
    }
}
}
 
 
static lang_output_section_statement_type *current_section;
static lang_output_section_statement_type *current_section;
 
 
static int
static int
topower (int x)
topower (int x)
{
{
  unsigned int i = 1;
  unsigned int i = 1;
  int l;
  int l;
 
 
  if (x < 0)
  if (x < 0)
    return -1;
    return -1;
 
 
  for (l = 0; l < 32; l++)
  for (l = 0; l < 32; l++)
    {
    {
      if (i >= (unsigned int) x)
      if (i >= (unsigned int) x)
        return l;
        return l;
      i <<= 1;
      i <<= 1;
    }
    }
 
 
  return 0;
  return 0;
}
}
 
 
lang_output_section_statement_type *
lang_output_section_statement_type *
lang_enter_output_section_statement (const char *output_section_statement_name,
lang_enter_output_section_statement (const char *output_section_statement_name,
                                     etree_type *address_exp,
                                     etree_type *address_exp,
                                     enum section_type sectype,
                                     enum section_type sectype,
                                     etree_type *align,
                                     etree_type *align,
                                     etree_type *subalign,
                                     etree_type *subalign,
                                     etree_type *ebase,
                                     etree_type *ebase,
                                     int constraint)
                                     int constraint)
{
{
  lang_output_section_statement_type *os;
  lang_output_section_statement_type *os;
 
 
   os = lang_output_section_statement_lookup_1 (output_section_statement_name,
   os = lang_output_section_statement_lookup_1 (output_section_statement_name,
                                                constraint);
                                                constraint);
   current_section = os;
   current_section = os;
 
 
  /* Make next things chain into subchain of this.  */
  /* Make next things chain into subchain of this.  */
 
 
  if (os->addr_tree == NULL)
  if (os->addr_tree == NULL)
    {
    {
      os->addr_tree = address_exp;
      os->addr_tree = address_exp;
    }
    }
  os->sectype = sectype;
  os->sectype = sectype;
  if (sectype != noload_section)
  if (sectype != noload_section)
    os->flags = SEC_NO_FLAGS;
    os->flags = SEC_NO_FLAGS;
  else
  else
    os->flags = SEC_NEVER_LOAD;
    os->flags = SEC_NEVER_LOAD;
  os->block_value = 1;
  os->block_value = 1;
  stat_ptr = &os->children;
  stat_ptr = &os->children;
 
 
  os->subsection_alignment =
  os->subsection_alignment =
    topower (exp_get_value_int (subalign, -1, "subsection alignment"));
    topower (exp_get_value_int (subalign, -1, "subsection alignment"));
  os->section_alignment =
  os->section_alignment =
    topower (exp_get_value_int (align, -1, "section alignment"));
    topower (exp_get_value_int (align, -1, "section alignment"));
 
 
  os->load_base = ebase;
  os->load_base = ebase;
  return os;
  return os;
}
}
 
 
void
void
lang_final (void)
lang_final (void)
{
{
  lang_output_statement_type *new;
  lang_output_statement_type *new;
 
 
  new = new_stat (lang_output_statement, stat_ptr);
  new = new_stat (lang_output_statement, stat_ptr);
  new->name = output_filename;
  new->name = output_filename;
}
}
 
 
/* Reset the current counters in the regions.  */
/* Reset the current counters in the regions.  */
 
 
void
void
lang_reset_memory_regions (void)
lang_reset_memory_regions (void)
{
{
  lang_memory_region_type *p = lang_memory_region_list;
  lang_memory_region_type *p = lang_memory_region_list;
  asection *o;
  asection *o;
  lang_output_section_statement_type *os;
  lang_output_section_statement_type *os;
 
 
  for (p = lang_memory_region_list; p != NULL; p = p->next)
  for (p = lang_memory_region_list; p != NULL; p = p->next)
    {
    {
      p->current = p->origin;
      p->current = p->origin;
      p->last_os = NULL;
      p->last_os = NULL;
    }
    }
 
 
  for (os = &lang_output_section_statement.head->output_section_statement;
  for (os = &lang_output_section_statement.head->output_section_statement;
       os != NULL;
       os != NULL;
       os = os->next)
       os = os->next)
    {
    {
      os->processed_vma = FALSE;
      os->processed_vma = FALSE;
      os->processed_lma = FALSE;
      os->processed_lma = FALSE;
    }
    }
 
 
  for (o = link_info.output_bfd->sections; o != NULL; o = o->next)
  for (o = link_info.output_bfd->sections; o != NULL; o = o->next)
    {
    {
      /* Save the last size for possible use by bfd_relax_section.  */
      /* Save the last size for possible use by bfd_relax_section.  */
      o->rawsize = o->size;
      o->rawsize = o->size;
      o->size = 0;
      o->size = 0;
    }
    }
}
}
 
 
/* Worker for lang_gc_sections_1.  */
/* Worker for lang_gc_sections_1.  */
 
 
static void
static void
gc_section_callback (lang_wild_statement_type *ptr,
gc_section_callback (lang_wild_statement_type *ptr,
                     struct wildcard_list *sec ATTRIBUTE_UNUSED,
                     struct wildcard_list *sec ATTRIBUTE_UNUSED,
                     asection *section,
                     asection *section,
                     lang_input_statement_type *file ATTRIBUTE_UNUSED,
                     lang_input_statement_type *file ATTRIBUTE_UNUSED,
                     void *data ATTRIBUTE_UNUSED)
                     void *data ATTRIBUTE_UNUSED)
{
{
  /* If the wild pattern was marked KEEP, the member sections
  /* If the wild pattern was marked KEEP, the member sections
     should be as well.  */
     should be as well.  */
  if (ptr->keep_sections)
  if (ptr->keep_sections)
    section->flags |= SEC_KEEP;
    section->flags |= SEC_KEEP;
}
}
 
 
/* Iterate over sections marking them against GC.  */
/* Iterate over sections marking them against GC.  */
 
 
static void
static void
lang_gc_sections_1 (lang_statement_union_type *s)
lang_gc_sections_1 (lang_statement_union_type *s)
{
{
  for (; s != NULL; s = s->header.next)
  for (; s != NULL; s = s->header.next)
    {
    {
      switch (s->header.type)
      switch (s->header.type)
        {
        {
        case lang_wild_statement_enum:
        case lang_wild_statement_enum:
          walk_wild (&s->wild_statement, gc_section_callback, NULL);
          walk_wild (&s->wild_statement, gc_section_callback, NULL);
          break;
          break;
        case lang_constructors_statement_enum:
        case lang_constructors_statement_enum:
          lang_gc_sections_1 (constructor_list.head);
          lang_gc_sections_1 (constructor_list.head);
          break;
          break;
        case lang_output_section_statement_enum:
        case lang_output_section_statement_enum:
          lang_gc_sections_1 (s->output_section_statement.children.head);
          lang_gc_sections_1 (s->output_section_statement.children.head);
          break;
          break;
        case lang_group_statement_enum:
        case lang_group_statement_enum:
          lang_gc_sections_1 (s->group_statement.children.head);
          lang_gc_sections_1 (s->group_statement.children.head);
          break;
          break;
        default:
        default:
          break;
          break;
        }
        }
    }
    }
}
}
 
 
static void
static void
lang_gc_sections (void)
lang_gc_sections (void)
{
{
  /* Keep all sections so marked in the link script.  */
  /* Keep all sections so marked in the link script.  */
 
 
  lang_gc_sections_1 (statement_list.head);
  lang_gc_sections_1 (statement_list.head);
 
 
  /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
  /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
     the special case of debug info.  (See bfd/stabs.c)
     the special case of debug info.  (See bfd/stabs.c)
     Twiddle the flag here, to simplify later linker code.  */
     Twiddle the flag here, to simplify later linker code.  */
  if (link_info.relocatable)
  if (link_info.relocatable)
    {
    {
      LANG_FOR_EACH_INPUT_STATEMENT (f)
      LANG_FOR_EACH_INPUT_STATEMENT (f)
        {
        {
          asection *sec;
          asection *sec;
          for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
          for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
            if ((sec->flags & SEC_DEBUGGING) == 0)
            if ((sec->flags & SEC_DEBUGGING) == 0)
              sec->flags &= ~SEC_EXCLUDE;
              sec->flags &= ~SEC_EXCLUDE;
        }
        }
    }
    }
 
 
  if (link_info.gc_sections)
  if (link_info.gc_sections)
    bfd_gc_sections (link_info.output_bfd, &link_info);
    bfd_gc_sections (link_info.output_bfd, &link_info);
}
}
 
 
/* Worker for lang_find_relro_sections_1.  */
/* Worker for lang_find_relro_sections_1.  */
 
 
static void
static void
find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
                             struct wildcard_list *sec ATTRIBUTE_UNUSED,
                             struct wildcard_list *sec ATTRIBUTE_UNUSED,
                             asection *section,
                             asection *section,
                             lang_input_statement_type *file ATTRIBUTE_UNUSED,
                             lang_input_statement_type *file ATTRIBUTE_UNUSED,
                             void *data)
                             void *data)
{
{
  /* Discarded, excluded and ignored sections effectively have zero
  /* Discarded, excluded and ignored sections effectively have zero
     size.  */
     size.  */
  if (section->output_section != NULL
  if (section->output_section != NULL
      && section->output_section->owner == link_info.output_bfd
      && section->output_section->owner == link_info.output_bfd
      && (section->output_section->flags & SEC_EXCLUDE) == 0
      && (section->output_section->flags & SEC_EXCLUDE) == 0
      && !IGNORE_SECTION (section)
      && !IGNORE_SECTION (section)
      && section->size != 0)
      && section->size != 0)
    {
    {
      bfd_boolean *has_relro_section = (bfd_boolean *) data;
      bfd_boolean *has_relro_section = (bfd_boolean *) data;
      *has_relro_section = TRUE;
      *has_relro_section = TRUE;
    }
    }
}
}
 
 
/* Iterate over sections for relro sections.  */
/* Iterate over sections for relro sections.  */
 
 
static void
static void
lang_find_relro_sections_1 (lang_statement_union_type *s,
lang_find_relro_sections_1 (lang_statement_union_type *s,
                            bfd_boolean *has_relro_section)
                            bfd_boolean *has_relro_section)
{
{
  if (*has_relro_section)
  if (*has_relro_section)
    return;
    return;
 
 
  for (; s != NULL; s = s->header.next)
  for (; s != NULL; s = s->header.next)
    {
    {
      if (s == expld.dataseg.relro_end_stat)
      if (s == expld.dataseg.relro_end_stat)
        break;
        break;
 
 
      switch (s->header.type)
      switch (s->header.type)
        {
        {
        case lang_wild_statement_enum:
        case lang_wild_statement_enum:
          walk_wild (&s->wild_statement,
          walk_wild (&s->wild_statement,
                     find_relro_section_callback,
                     find_relro_section_callback,
                     has_relro_section);
                     has_relro_section);
          break;
          break;
        case lang_constructors_statement_enum:
        case lang_constructors_statement_enum:
          lang_find_relro_sections_1 (constructor_list.head,
          lang_find_relro_sections_1 (constructor_list.head,
                                      has_relro_section);
                                      has_relro_section);
          break;
          break;
        case lang_output_section_statement_enum:
        case lang_output_section_statement_enum:
          lang_find_relro_sections_1 (s->output_section_statement.children.head,
          lang_find_relro_sections_1 (s->output_section_statement.children.head,
                                      has_relro_section);
                                      has_relro_section);
          break;
          break;
        case lang_group_statement_enum:
        case lang_group_statement_enum:
          lang_find_relro_sections_1 (s->group_statement.children.head,
          lang_find_relro_sections_1 (s->group_statement.children.head,
                                      has_relro_section);
                                      has_relro_section);
          break;
          break;
        default:
        default:
          break;
          break;
        }
        }
    }
    }
}
}
 
 
static void
static void
lang_find_relro_sections (void)
lang_find_relro_sections (void)
{
{
  bfd_boolean has_relro_section = FALSE;
  bfd_boolean has_relro_section = FALSE;
 
 
  /* Check all sections in the link script.  */
  /* Check all sections in the link script.  */
 
 
  lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,
  lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,
                              &has_relro_section);
                              &has_relro_section);
 
 
  if (!has_relro_section)
  if (!has_relro_section)
    link_info.relro = FALSE;
    link_info.relro = FALSE;
}
}
 
 
/* Relax all sections until bfd_relax_section gives up.  */
/* Relax all sections until bfd_relax_section gives up.  */
 
 
static void
static void
relax_sections (void)
relax_sections (void)
{
{
  /* Keep relaxing until bfd_relax_section gives up.  */
  /* Keep relaxing until bfd_relax_section gives up.  */
  bfd_boolean relax_again;
  bfd_boolean relax_again;
 
 
  link_info.relax_trip = -1;
  link_info.relax_trip = -1;
  do
  do
    {
    {
      relax_again = FALSE;
      relax_again = FALSE;
      link_info.relax_trip++;
      link_info.relax_trip++;
 
 
      /* Note: pe-dll.c does something like this also.  If you find
      /* Note: pe-dll.c does something like this also.  If you find
         you need to change this code, you probably need to change
         you need to change this code, you probably need to change
         pe-dll.c also.  DJ  */
         pe-dll.c also.  DJ  */
 
 
      /* Do all the assignments with our current guesses as to
      /* Do all the assignments with our current guesses as to
         section sizes.  */
         section sizes.  */
      lang_do_assignments ();
      lang_do_assignments ();
 
 
      /* We must do this after lang_do_assignments, because it uses
      /* We must do this after lang_do_assignments, because it uses
         size.  */
         size.  */
      lang_reset_memory_regions ();
      lang_reset_memory_regions ();
 
 
      /* Perform another relax pass - this time we know where the
      /* Perform another relax pass - this time we know where the
         globals are, so can make a better guess.  */
         globals are, so can make a better guess.  */
      lang_size_sections (&relax_again, FALSE);
      lang_size_sections (&relax_again, FALSE);
    }
    }
  while (relax_again);
  while (relax_again);
}
}
 
 
void
void
lang_process (void)
lang_process (void)
{
{
  /* Finalize dynamic list.  */
  /* Finalize dynamic list.  */
  if (link_info.dynamic_list)
  if (link_info.dynamic_list)
    lang_finalize_version_expr_head (&link_info.dynamic_list->head);
    lang_finalize_version_expr_head (&link_info.dynamic_list->head);
 
 
  current_target = default_target;
  current_target = default_target;
 
 
  /* Open the output file.  */
  /* Open the output file.  */
  lang_for_each_statement (ldlang_open_output);
  lang_for_each_statement (ldlang_open_output);
  init_opb ();
  init_opb ();
 
 
  ldemul_create_output_section_statements ();
  ldemul_create_output_section_statements ();
 
 
  /* Add to the hash table all undefineds on the command line.  */
  /* Add to the hash table all undefineds on the command line.  */
  lang_place_undefineds ();
  lang_place_undefineds ();
 
 
  if (!bfd_section_already_linked_table_init ())
  if (!bfd_section_already_linked_table_init ())
    einfo (_("%P%F: Failed to create hash table\n"));
    einfo (_("%P%F: Failed to create hash table\n"));
 
 
  /* Create a bfd for each input file.  */
  /* Create a bfd for each input file.  */
  current_target = default_target;
  current_target = default_target;
  open_input_bfds (statement_list.head, FALSE);
  open_input_bfds (statement_list.head, FALSE);
 
 
  link_info.gc_sym_list = &entry_symbol;
  link_info.gc_sym_list = &entry_symbol;
  if (entry_symbol.name == NULL)
  if (entry_symbol.name == NULL)
    link_info.gc_sym_list = ldlang_undef_chain_list_head;
    link_info.gc_sym_list = ldlang_undef_chain_list_head;
 
 
  ldemul_after_open ();
  ldemul_after_open ();
 
 
  bfd_section_already_linked_table_free ();
  bfd_section_already_linked_table_free ();
 
 
  /* Make sure that we're not mixing architectures.  We call this
  /* Make sure that we're not mixing architectures.  We call this
     after all the input files have been opened, but before we do any
     after all the input files have been opened, but before we do any
     other processing, so that any operations merge_private_bfd_data
     other processing, so that any operations merge_private_bfd_data
     does on the output file will be known during the rest of the
     does on the output file will be known during the rest of the
     link.  */
     link.  */
  lang_check ();
  lang_check ();
 
 
  /* Handle .exports instead of a version script if we're told to do so.  */
  /* Handle .exports instead of a version script if we're told to do so.  */
  if (command_line.version_exports_section)
  if (command_line.version_exports_section)
    lang_do_version_exports_section ();
    lang_do_version_exports_section ();
 
 
  /* Build all sets based on the information gathered from the input
  /* Build all sets based on the information gathered from the input
     files.  */
     files.  */
  ldctor_build_sets ();
  ldctor_build_sets ();
 
 
  /* Remove unreferenced sections if asked to.  */
  /* Remove unreferenced sections if asked to.  */
  lang_gc_sections ();
  lang_gc_sections ();
 
 
  /* Size up the common data.  */
  /* Size up the common data.  */
  lang_common ();
  lang_common ();
 
 
  /* Update wild statements.  */
  /* Update wild statements.  */
  update_wild_statements (statement_list.head);
  update_wild_statements (statement_list.head);
 
 
  /* Run through the contours of the script and attach input sections
  /* Run through the contours of the script and attach input sections
     to the correct output sections.  */
     to the correct output sections.  */
  map_input_to_output_sections (statement_list.head, NULL, NULL);
  map_input_to_output_sections (statement_list.head, NULL, NULL);
 
 
  process_insert_statements ();
  process_insert_statements ();
 
 
  /* Find any sections not attached explicitly and handle them.  */
  /* Find any sections not attached explicitly and handle them.  */
  lang_place_orphans ();
  lang_place_orphans ();
 
 
  if (! link_info.relocatable)
  if (! link_info.relocatable)
    {
    {
      asection *found;
      asection *found;
 
 
      /* Merge SEC_MERGE sections.  This has to be done after GC of
      /* Merge SEC_MERGE sections.  This has to be done after GC of
         sections, so that GCed sections are not merged, but before
         sections, so that GCed sections are not merged, but before
         assigning dynamic symbols, since removing whole input sections
         assigning dynamic symbols, since removing whole input sections
         is hard then.  */
         is hard then.  */
      bfd_merge_sections (link_info.output_bfd, &link_info);
      bfd_merge_sections (link_info.output_bfd, &link_info);
 
 
      /* Look for a text section and set the readonly attribute in it.  */
      /* Look for a text section and set the readonly attribute in it.  */
      found = bfd_get_section_by_name (link_info.output_bfd, ".text");
      found = bfd_get_section_by_name (link_info.output_bfd, ".text");
 
 
      if (found != NULL)
      if (found != NULL)
        {
        {
          if (config.text_read_only)
          if (config.text_read_only)
            found->flags |= SEC_READONLY;
            found->flags |= SEC_READONLY;
          else
          else
            found->flags &= ~SEC_READONLY;
            found->flags &= ~SEC_READONLY;
        }
        }
    }
    }
 
 
  /* Do anything special before sizing sections.  This is where ELF
  /* Do anything special before sizing sections.  This is where ELF
     and other back-ends size dynamic sections.  */
     and other back-ends size dynamic sections.  */
  ldemul_before_allocation ();
  ldemul_before_allocation ();
 
 
  /* We must record the program headers before we try to fix the
  /* We must record the program headers before we try to fix the
     section positions, since they will affect SIZEOF_HEADERS.  */
     section positions, since they will affect SIZEOF_HEADERS.  */
  lang_record_phdrs ();
  lang_record_phdrs ();
 
 
  /* Check relro sections.  */
  /* Check relro sections.  */
  if (link_info.relro && ! link_info.relocatable)
  if (link_info.relro && ! link_info.relocatable)
    lang_find_relro_sections ();
    lang_find_relro_sections ();
 
 
  /* Size up the sections.  */
  /* Size up the sections.  */
  lang_size_sections (NULL, !command_line.relax);
  lang_size_sections (NULL, !command_line.relax);
 
 
  /* Now run around and relax if we can.  */
  /* Now run around and relax if we can.  */
  if (command_line.relax)
  if (command_line.relax)
    {
    {
      /* We may need more than one relaxation pass.  */
      /* We may need more than one relaxation pass.  */
      int i = link_info.relax_pass;
      int i = link_info.relax_pass;
 
 
      /* The backend can use it to determine the current pass.  */
      /* The backend can use it to determine the current pass.  */
      link_info.relax_pass = 0;
      link_info.relax_pass = 0;
 
 
      while (i--)
      while (i--)
        {
        {
          relax_sections ();
          relax_sections ();
          link_info.relax_pass++;
          link_info.relax_pass++;
        }
        }
 
 
      /* Final extra sizing to report errors.  */
      /* Final extra sizing to report errors.  */
      lang_do_assignments ();
      lang_do_assignments ();
      lang_reset_memory_regions ();
      lang_reset_memory_regions ();
      lang_size_sections (NULL, TRUE);
      lang_size_sections (NULL, TRUE);
    }
    }
 
 
  /* See if anything special should be done now we know how big
  /* See if anything special should be done now we know how big
     everything is.  */
     everything is.  */
  ldemul_after_allocation ();
  ldemul_after_allocation ();
 
 
  /* Fix any .startof. or .sizeof. symbols.  */
  /* Fix any .startof. or .sizeof. symbols.  */
  lang_set_startof ();
  lang_set_startof ();
 
 
  /* Do all the assignments, now that we know the final resting places
  /* Do all the assignments, now that we know the final resting places
     of all the symbols.  */
     of all the symbols.  */
 
 
  lang_do_assignments ();
  lang_do_assignments ();
 
 
  ldemul_finish ();
  ldemul_finish ();
 
 
  /* Make sure that the section addresses make sense.  */
  /* Make sure that the section addresses make sense.  */
  if (! link_info.relocatable
  if (! link_info.relocatable
      && command_line.check_section_addresses)
      && command_line.check_section_addresses)
    lang_check_section_addresses ();
    lang_check_section_addresses ();
 
 
  lang_end ();
  lang_end ();
}
}
 
 
/* EXPORTED TO YACC */
/* EXPORTED TO YACC */
 
 
void
void
lang_add_wild (struct wildcard_spec *filespec,
lang_add_wild (struct wildcard_spec *filespec,
               struct wildcard_list *section_list,
               struct wildcard_list *section_list,
               bfd_boolean keep_sections)
               bfd_boolean keep_sections)
{
{
  struct wildcard_list *curr, *next;
  struct wildcard_list *curr, *next;
  lang_wild_statement_type *new;
  lang_wild_statement_type *new;
 
 
  /* Reverse the list as the parser puts it back to front.  */
  /* Reverse the list as the parser puts it back to front.  */
  for (curr = section_list, section_list = NULL;
  for (curr = section_list, section_list = NULL;
       curr != NULL;
       curr != NULL;
       section_list = curr, curr = next)
       section_list = curr, curr = next)
    {
    {
      if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
      if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
        placed_commons = TRUE;
        placed_commons = TRUE;
 
 
      next = curr->next;
      next = curr->next;
      curr->next = section_list;
      curr->next = section_list;
    }
    }
 
 
  if (filespec != NULL && filespec->name != NULL)
  if (filespec != NULL && filespec->name != NULL)
    {
    {
      if (strcmp (filespec->name, "*") == 0)
      if (strcmp (filespec->name, "*") == 0)
        filespec->name = NULL;
        filespec->name = NULL;
      else if (! wildcardp (filespec->name))
      else if (! wildcardp (filespec->name))
        lang_has_input_file = TRUE;
        lang_has_input_file = TRUE;
    }
    }
 
 
  new = new_stat (lang_wild_statement, stat_ptr);
  new = new_stat (lang_wild_statement, stat_ptr);
  new->filename = NULL;
  new->filename = NULL;
  new->filenames_sorted = FALSE;
  new->filenames_sorted = FALSE;
  if (filespec != NULL)
  if (filespec != NULL)
    {
    {
      new->filename = filespec->name;
      new->filename = filespec->name;
      new->filenames_sorted = filespec->sorted == by_name;
      new->filenames_sorted = filespec->sorted == by_name;
    }
    }
  new->section_list = section_list;
  new->section_list = section_list;
  new->keep_sections = keep_sections;
  new->keep_sections = keep_sections;
  lang_list_init (&new->children);
  lang_list_init (&new->children);
  analyze_walk_wild_section_handler (new);
  analyze_walk_wild_section_handler (new);
}
}
 
 
void
void
lang_section_start (const char *name, etree_type *address,
lang_section_start (const char *name, etree_type *address,
                    const segment_type *segment)
                    const segment_type *segment)
{
{
  lang_address_statement_type *ad;
  lang_address_statement_type *ad;
 
 
  ad = new_stat (lang_address_statement, stat_ptr);
  ad = new_stat (lang_address_statement, stat_ptr);
  ad->section_name = name;
  ad->section_name = name;
  ad->address = address;
  ad->address = address;
  ad->segment = segment;
  ad->segment = segment;
}
}
 
 
/* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
/* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
   because of a -e argument on the command line, or zero if this is
   because of a -e argument on the command line, or zero if this is
   called by ENTRY in a linker script.  Command line arguments take
   called by ENTRY in a linker script.  Command line arguments take
   precedence.  */
   precedence.  */
 
 
void
void
lang_add_entry (const char *name, bfd_boolean cmdline)
lang_add_entry (const char *name, bfd_boolean cmdline)
{
{
  if (entry_symbol.name == NULL
  if (entry_symbol.name == NULL
      || cmdline
      || cmdline
      || ! entry_from_cmdline)
      || ! entry_from_cmdline)
    {
    {
      entry_symbol.name = name;
      entry_symbol.name = name;
      entry_from_cmdline = cmdline;
      entry_from_cmdline = cmdline;
    }
    }
}
}
 
 
/* Set the default start symbol to NAME.  .em files should use this,
/* Set the default start symbol to NAME.  .em files should use this,
   not lang_add_entry, to override the use of "start" if neither the
   not lang_add_entry, to override the use of "start" if neither the
   linker script nor the command line specifies an entry point.  NAME
   linker script nor the command line specifies an entry point.  NAME
   must be permanently allocated.  */
   must be permanently allocated.  */
void
void
lang_default_entry (const char *name)
lang_default_entry (const char *name)
{
{
  entry_symbol_default = name;
  entry_symbol_default = name;
}
}
 
 
void
void
lang_add_target (const char *name)
lang_add_target (const char *name)
{
{
  lang_target_statement_type *new;
  lang_target_statement_type *new;
 
 
  new = new_stat (lang_target_statement, stat_ptr);
  new = new_stat (lang_target_statement, stat_ptr);
  new->target = name;
  new->target = name;
}
}
 
 
void
void
lang_add_map (const char *name)
lang_add_map (const char *name)
{
{
  while (*name)
  while (*name)
    {
    {
      switch (*name)
      switch (*name)
        {
        {
        case 'F':
        case 'F':
          map_option_f = TRUE;
          map_option_f = TRUE;
          break;
          break;
        }
        }
      name++;
      name++;
    }
    }
}
}
 
 
void
void
lang_add_fill (fill_type *fill)
lang_add_fill (fill_type *fill)
{
{
  lang_fill_statement_type *new;
  lang_fill_statement_type *new;
 
 
  new = new_stat (lang_fill_statement, stat_ptr);
  new = new_stat (lang_fill_statement, stat_ptr);
  new->fill = fill;
  new->fill = fill;
}
}
 
 
void
void
lang_add_data (int type, union etree_union *exp)
lang_add_data (int type, union etree_union *exp)
{
{
  lang_data_statement_type *new;
  lang_data_statement_type *new;
 
 
  new = new_stat (lang_data_statement, stat_ptr);
  new = new_stat (lang_data_statement, stat_ptr);
  new->exp = exp;
  new->exp = exp;
  new->type = type;
  new->type = type;
}
}
 
 
/* Create a new reloc statement.  RELOC is the BFD relocation type to
/* Create a new reloc statement.  RELOC is the BFD relocation type to
   generate.  HOWTO is the corresponding howto structure (we could
   generate.  HOWTO is the corresponding howto structure (we could
   look this up, but the caller has already done so).  SECTION is the
   look this up, but the caller has already done so).  SECTION is the
   section to generate a reloc against, or NAME is the name of the
   section to generate a reloc against, or NAME is the name of the
   symbol to generate a reloc against.  Exactly one of SECTION and
   symbol to generate a reloc against.  Exactly one of SECTION and
   NAME must be NULL.  ADDEND is an expression for the addend.  */
   NAME must be NULL.  ADDEND is an expression for the addend.  */
 
 
void
void
lang_add_reloc (bfd_reloc_code_real_type reloc,
lang_add_reloc (bfd_reloc_code_real_type reloc,
                reloc_howto_type *howto,
                reloc_howto_type *howto,
                asection *section,
                asection *section,
                const char *name,
                const char *name,
                union etree_union *addend)
                union etree_union *addend)
{
{
  lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
  lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
 
 
  p->reloc = reloc;
  p->reloc = reloc;
  p->howto = howto;
  p->howto = howto;
  p->section = section;
  p->section = section;
  p->name = name;
  p->name = name;
  p->addend_exp = addend;
  p->addend_exp = addend;
 
 
  p->addend_value = 0;
  p->addend_value = 0;
  p->output_section = NULL;
  p->output_section = NULL;
  p->output_offset = 0;
  p->output_offset = 0;
}
}
 
 
lang_assignment_statement_type *
lang_assignment_statement_type *
lang_add_assignment (etree_type *exp)
lang_add_assignment (etree_type *exp)
{
{
  lang_assignment_statement_type *new;
  lang_assignment_statement_type *new;
 
 
  new = new_stat (lang_assignment_statement, stat_ptr);
  new = new_stat (lang_assignment_statement, stat_ptr);
  new->exp = exp;
  new->exp = exp;
  return new;
  return new;
}
}
 
 
void
void
lang_add_attribute (enum statement_enum attribute)
lang_add_attribute (enum statement_enum attribute)
{
{
  new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
  new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
}
}
 
 
void
void
lang_startup (const char *name)
lang_startup (const char *name)
{
{
  if (startup_file != NULL)
  if (startup_file != NULL)
    {
    {
      einfo (_("%P%F: multiple STARTUP files\n"));
      einfo (_("%P%F: multiple STARTUP files\n"));
    }
    }
  first_file->filename = name;
  first_file->filename = name;
  first_file->local_sym_name = name;
  first_file->local_sym_name = name;
  first_file->real = TRUE;
  first_file->real = TRUE;
 
 
  startup_file = name;
  startup_file = name;
}
}
 
 
void
void
lang_float (bfd_boolean maybe)
lang_float (bfd_boolean maybe)
{
{
  lang_float_flag = maybe;
  lang_float_flag = maybe;
}
}
 
 
 
 
/* Work out the load- and run-time regions from a script statement, and
/* Work out the load- and run-time regions from a script statement, and
   store them in *LMA_REGION and *REGION respectively.
   store them in *LMA_REGION and *REGION respectively.
 
 
   MEMSPEC is the name of the run-time region, or the value of
   MEMSPEC is the name of the run-time region, or the value of
   DEFAULT_MEMORY_REGION if the statement didn't specify one.
   DEFAULT_MEMORY_REGION if the statement didn't specify one.
   LMA_MEMSPEC is the name of the load-time region, or null if the
   LMA_MEMSPEC is the name of the load-time region, or null if the
   statement didn't specify one.HAVE_LMA_P is TRUE if the statement
   statement didn't specify one.HAVE_LMA_P is TRUE if the statement
   had an explicit load address.
   had an explicit load address.
 
 
   It is an error to specify both a load region and a load address.  */
   It is an error to specify both a load region and a load address.  */
 
 
static void
static void
lang_get_regions (lang_memory_region_type **region,
lang_get_regions (lang_memory_region_type **region,
                  lang_memory_region_type **lma_region,
                  lang_memory_region_type **lma_region,
                  const char *memspec,
                  const char *memspec,
                  const char *lma_memspec,
                  const char *lma_memspec,
                  bfd_boolean have_lma,
                  bfd_boolean have_lma,
                  bfd_boolean have_vma)
                  bfd_boolean have_vma)
{
{
  *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
  *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
 
 
  /* If no runtime region or VMA has been specified, but the load region
  /* If no runtime region or VMA has been specified, but the load region
     has been specified, then use the load region for the runtime region
     has been specified, then use the load region for the runtime region
     as well.  */
     as well.  */
  if (lma_memspec != NULL
  if (lma_memspec != NULL
      && ! have_vma
      && ! have_vma
      && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
      && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
    *region = *lma_region;
    *region = *lma_region;
  else
  else
    *region = lang_memory_region_lookup (memspec, FALSE);
    *region = lang_memory_region_lookup (memspec, FALSE);
 
 
  if (have_lma && lma_memspec != 0)
  if (have_lma && lma_memspec != 0)
    einfo (_("%X%P:%S: section has both a load address and a load region\n"));
    einfo (_("%X%P:%S: section has both a load address and a load region\n"));
}
}
 
 
void
void
lang_leave_output_section_statement (fill_type *fill, const char *memspec,
lang_leave_output_section_statement (fill_type *fill, const char *memspec,
                                     lang_output_section_phdr_list *phdrs,
                                     lang_output_section_phdr_list *phdrs,
                                     const char *lma_memspec)
                                     const char *lma_memspec)
{
{
  lang_get_regions (&current_section->region,
  lang_get_regions (&current_section->region,
                    &current_section->lma_region,
                    &current_section->lma_region,
                    memspec, lma_memspec,
                    memspec, lma_memspec,
                    current_section->load_base != NULL,
                    current_section->load_base != NULL,
                    current_section->addr_tree != NULL);
                    current_section->addr_tree != NULL);
  current_section->fill = fill;
  current_section->fill = fill;
  current_section->phdrs = phdrs;
  current_section->phdrs = phdrs;
  stat_ptr = &statement_list;
  stat_ptr = &statement_list;
}
}
 
 
/* Create an absolute symbol with the given name with the value of the
/* Create an absolute symbol with the given name with the value of the
   address of first byte of the section named.
   address of first byte of the section named.
 
 
   If the symbol already exists, then do nothing.  */
   If the symbol already exists, then do nothing.  */
 
 
void
void
lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
{
{
  struct bfd_link_hash_entry *h;
  struct bfd_link_hash_entry *h;
 
 
  h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
  h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
  if (h == NULL)
  if (h == NULL)
    einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
    einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
 
 
  if (h->type == bfd_link_hash_new
  if (h->type == bfd_link_hash_new
      || h->type == bfd_link_hash_undefined)
      || h->type == bfd_link_hash_undefined)
    {
    {
      asection *sec;
      asection *sec;
 
 
      h->type = bfd_link_hash_defined;
      h->type = bfd_link_hash_defined;
 
 
      sec = bfd_get_section_by_name (link_info.output_bfd, secname);
      sec = bfd_get_section_by_name (link_info.output_bfd, secname);
      if (sec == NULL)
      if (sec == NULL)
        h->u.def.value = 0;
        h->u.def.value = 0;
      else
      else
        h->u.def.value = bfd_get_section_vma (link_info.output_bfd, sec);
        h->u.def.value = bfd_get_section_vma (link_info.output_bfd, sec);
 
 
      h->u.def.section = bfd_abs_section_ptr;
      h->u.def.section = bfd_abs_section_ptr;
    }
    }
}
}
 
 
/* Create an absolute symbol with the given name with the value of the
/* Create an absolute symbol with the given name with the value of the
   address of the first byte after the end of the section named.
   address of the first byte after the end of the section named.
 
 
   If the symbol already exists, then do nothing.  */
   If the symbol already exists, then do nothing.  */
 
 
void
void
lang_abs_symbol_at_end_of (const char *secname, const char *name)
lang_abs_symbol_at_end_of (const char *secname, const char *name)
{
{
  struct bfd_link_hash_entry *h;
  struct bfd_link_hash_entry *h;
 
 
  h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
  h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
  if (h == NULL)
  if (h == NULL)
    einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
    einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
 
 
  if (h->type == bfd_link_hash_new
  if (h->type == bfd_link_hash_new
      || h->type == bfd_link_hash_undefined)
      || h->type == bfd_link_hash_undefined)
    {
    {
      asection *sec;
      asection *sec;
 
 
      h->type = bfd_link_hash_defined;
      h->type = bfd_link_hash_defined;
 
 
      sec = bfd_get_section_by_name (link_info.output_bfd, secname);
      sec = bfd_get_section_by_name (link_info.output_bfd, secname);
      if (sec == NULL)
      if (sec == NULL)
        h->u.def.value = 0;
        h->u.def.value = 0;
      else
      else
        h->u.def.value = (bfd_get_section_vma (link_info.output_bfd, sec)
        h->u.def.value = (bfd_get_section_vma (link_info.output_bfd, sec)
                          + TO_ADDR (sec->size));
                          + TO_ADDR (sec->size));
 
 
      h->u.def.section = bfd_abs_section_ptr;
      h->u.def.section = bfd_abs_section_ptr;
    }
    }
}
}
 
 
void
void
lang_statement_append (lang_statement_list_type *list,
lang_statement_append (lang_statement_list_type *list,
                       lang_statement_union_type *element,
                       lang_statement_union_type *element,
                       lang_statement_union_type **field)
                       lang_statement_union_type **field)
{
{
  *(list->tail) = element;
  *(list->tail) = element;
  list->tail = field;
  list->tail = field;
}
}
 
 
/* Set the output format type.  -oformat overrides scripts.  */
/* Set the output format type.  -oformat overrides scripts.  */
 
 
void
void
lang_add_output_format (const char *format,
lang_add_output_format (const char *format,
                        const char *big,
                        const char *big,
                        const char *little,
                        const char *little,
                        int from_script)
                        int from_script)
{
{
  if (output_target == NULL || !from_script)
  if (output_target == NULL || !from_script)
    {
    {
      if (command_line.endian == ENDIAN_BIG
      if (command_line.endian == ENDIAN_BIG
          && big != NULL)
          && big != NULL)
        format = big;
        format = big;
      else if (command_line.endian == ENDIAN_LITTLE
      else if (command_line.endian == ENDIAN_LITTLE
               && little != NULL)
               && little != NULL)
        format = little;
        format = little;
 
 
      output_target = format;
      output_target = format;
    }
    }
}
}
 
 
void
void
lang_add_insert (const char *where, int is_before)
lang_add_insert (const char *where, int is_before)
{
{
  lang_insert_statement_type *new;
  lang_insert_statement_type *new;
 
 
  new = new_stat (lang_insert_statement, stat_ptr);
  new = new_stat (lang_insert_statement, stat_ptr);
  new->where = where;
  new->where = where;
  new->is_before = is_before;
  new->is_before = is_before;
  saved_script_handle = previous_script_handle;
  saved_script_handle = previous_script_handle;
}
}
 
 
/* Enter a group.  This creates a new lang_group_statement, and sets
/* Enter a group.  This creates a new lang_group_statement, and sets
   stat_ptr to build new statements within the group.  */
   stat_ptr to build new statements within the group.  */
 
 
void
void
lang_enter_group (void)
lang_enter_group (void)
{
{
  lang_group_statement_type *g;
  lang_group_statement_type *g;
 
 
  g = new_stat (lang_group_statement, stat_ptr);
  g = new_stat (lang_group_statement, stat_ptr);
  lang_list_init (&g->children);
  lang_list_init (&g->children);
  stat_ptr = &g->children;
  stat_ptr = &g->children;
}
}
 
 
/* Leave a group.  This just resets stat_ptr to start writing to the
/* Leave a group.  This just resets stat_ptr to start writing to the
   regular list of statements again.  Note that this will not work if
   regular list of statements again.  Note that this will not work if
   groups can occur inside anything else which can adjust stat_ptr,
   groups can occur inside anything else which can adjust stat_ptr,
   but currently they can't.  */
   but currently they can't.  */
 
 
void
void
lang_leave_group (void)
lang_leave_group (void)
{
{
  stat_ptr = &statement_list;
  stat_ptr = &statement_list;
}
}
 
 
/* Add a new program header.  This is called for each entry in a PHDRS
/* Add a new program header.  This is called for each entry in a PHDRS
   command in a linker script.  */
   command in a linker script.  */
 
 
void
void
lang_new_phdr (const char *name,
lang_new_phdr (const char *name,
               etree_type *type,
               etree_type *type,
               bfd_boolean filehdr,
               bfd_boolean filehdr,
               bfd_boolean phdrs,
               bfd_boolean phdrs,
               etree_type *at,
               etree_type *at,
               etree_type *flags)
               etree_type *flags)
{
{
  struct lang_phdr *n, **pp;
  struct lang_phdr *n, **pp;
 
 
  n = stat_alloc (sizeof (struct lang_phdr));
  n = stat_alloc (sizeof (struct lang_phdr));
  n->next = NULL;
  n->next = NULL;
  n->name = name;
  n->name = name;
  n->type = exp_get_value_int (type, 0, "program header type");
  n->type = exp_get_value_int (type, 0, "program header type");
  n->filehdr = filehdr;
  n->filehdr = filehdr;
  n->phdrs = phdrs;
  n->phdrs = phdrs;
  n->at = at;
  n->at = at;
  n->flags = flags;
  n->flags = flags;
 
 
  for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
  for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
    ;
    ;
  *pp = n;
  *pp = n;
}
}
 
 
/* Record the program header information in the output BFD.  FIXME: We
/* Record the program header information in the output BFD.  FIXME: We
   should not be calling an ELF specific function here.  */
   should not be calling an ELF specific function here.  */
 
 
static void
static void
lang_record_phdrs (void)
lang_record_phdrs (void)
{
{
  unsigned int alc;
  unsigned int alc;
  asection **secs;
  asection **secs;
  lang_output_section_phdr_list *last;
  lang_output_section_phdr_list *last;
  struct lang_phdr *l;
  struct lang_phdr *l;
  lang_output_section_statement_type *os;
  lang_output_section_statement_type *os;
 
 
  alc = 10;
  alc = 10;
  secs = xmalloc (alc * sizeof (asection *));
  secs = xmalloc (alc * sizeof (asection *));
  last = NULL;
  last = NULL;
 
 
  for (l = lang_phdr_list; l != NULL; l = l->next)
  for (l = lang_phdr_list; l != NULL; l = l->next)
    {
    {
      unsigned int c;
      unsigned int c;
      flagword flags;
      flagword flags;
      bfd_vma at;
      bfd_vma at;
 
 
      c = 0;
      c = 0;
      for (os = &lang_output_section_statement.head->output_section_statement;
      for (os = &lang_output_section_statement.head->output_section_statement;
           os != NULL;
           os != NULL;
           os = os->next)
           os = os->next)
        {
        {
          lang_output_section_phdr_list *pl;
          lang_output_section_phdr_list *pl;
 
 
          if (os->constraint == -1)
          if (os->constraint == -1)
            continue;
            continue;
 
 
          pl = os->phdrs;
          pl = os->phdrs;
          if (pl != NULL)
          if (pl != NULL)
            last = pl;
            last = pl;
          else
          else
            {
            {
              if (os->sectype == noload_section
              if (os->sectype == noload_section
                  || os->bfd_section == NULL
                  || os->bfd_section == NULL
                  || (os->bfd_section->flags & SEC_ALLOC) == 0)
                  || (os->bfd_section->flags & SEC_ALLOC) == 0)
                continue;
                continue;
 
 
              if (last == NULL)
              if (last == NULL)
                {
                {
                  lang_output_section_statement_type * tmp_os;
                  lang_output_section_statement_type * tmp_os;
 
 
                  /* If we have not run across a section with a program
                  /* If we have not run across a section with a program
                     header assigned to it yet, then scan forwards to find
                     header assigned to it yet, then scan forwards to find
                     one.  This prevents inconsistencies in the linker's
                     one.  This prevents inconsistencies in the linker's
                     behaviour when a script has specified just a single
                     behaviour when a script has specified just a single
                     header and there are sections in that script which are
                     header and there are sections in that script which are
                     not assigned to it, and which occur before the first
                     not assigned to it, and which occur before the first
                     use of that header. See here for more details:
                     use of that header. See here for more details:
                     http://sourceware.org/ml/binutils/2007-02/msg00291.html  */
                     http://sourceware.org/ml/binutils/2007-02/msg00291.html  */
                  for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)
                  for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)
                    if (tmp_os->phdrs)
                    if (tmp_os->phdrs)
                      {
                      {
                        last = tmp_os->phdrs;
                        last = tmp_os->phdrs;
                        break;
                        break;
                      }
                      }
                  if (last == NULL)
                  if (last == NULL)
                    einfo (_("%F%P: no sections assigned to phdrs\n"));
                    einfo (_("%F%P: no sections assigned to phdrs\n"));
                }
                }
              pl = last;
              pl = last;
            }
            }
 
 
          if (os->bfd_section == NULL)
          if (os->bfd_section == NULL)
            continue;
            continue;
 
 
          for (; pl != NULL; pl = pl->next)
          for (; pl != NULL; pl = pl->next)
            {
            {
              if (strcmp (pl->name, l->name) == 0)
              if (strcmp (pl->name, l->name) == 0)
                {
                {
                  if (c >= alc)
                  if (c >= alc)
                    {
                    {
                      alc *= 2;
                      alc *= 2;
                      secs = xrealloc (secs, alc * sizeof (asection *));
                      secs = xrealloc (secs, alc * sizeof (asection *));
                    }
                    }
                  secs[c] = os->bfd_section;
                  secs[c] = os->bfd_section;
                  ++c;
                  ++c;
                  pl->used = TRUE;
                  pl->used = TRUE;
                }
                }
            }
            }
        }
        }
 
 
      if (l->flags == NULL)
      if (l->flags == NULL)
        flags = 0;
        flags = 0;
      else
      else
        flags = exp_get_vma (l->flags, 0, "phdr flags");
        flags = exp_get_vma (l->flags, 0, "phdr flags");
 
 
      if (l->at == NULL)
      if (l->at == NULL)
        at = 0;
        at = 0;
      else
      else
        at = exp_get_vma (l->at, 0, "phdr load address");
        at = exp_get_vma (l->at, 0, "phdr load address");
 
 
      if (! bfd_record_phdr (link_info.output_bfd, l->type,
      if (! bfd_record_phdr (link_info.output_bfd, l->type,
                             l->flags != NULL, flags, l->at != NULL,
                             l->flags != NULL, flags, l->at != NULL,
                             at, l->filehdr, l->phdrs, c, secs))
                             at, l->filehdr, l->phdrs, c, secs))
        einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
        einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
    }
    }
 
 
  free (secs);
  free (secs);
 
 
  /* Make sure all the phdr assignments succeeded.  */
  /* Make sure all the phdr assignments succeeded.  */
  for (os = &lang_output_section_statement.head->output_section_statement;
  for (os = &lang_output_section_statement.head->output_section_statement;
       os != NULL;
       os != NULL;
       os = os->next)
       os = os->next)
    {
    {
      lang_output_section_phdr_list *pl;
      lang_output_section_phdr_list *pl;
 
 
      if (os->constraint == -1
      if (os->constraint == -1
          || os->bfd_section == NULL)
          || os->bfd_section == NULL)
        continue;
        continue;
 
 
      for (pl = os->phdrs;
      for (pl = os->phdrs;
           pl != NULL;
           pl != NULL;
           pl = pl->next)
           pl = pl->next)
        if (! pl->used && strcmp (pl->name, "NONE") != 0)
        if (! pl->used && strcmp (pl->name, "NONE") != 0)
          einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
          einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
                 os->name, pl->name);
                 os->name, pl->name);
    }
    }
}
}
 
 
/* Record a list of sections which may not be cross referenced.  */
/* Record a list of sections which may not be cross referenced.  */
 
 
void
void
lang_add_nocrossref (lang_nocrossref_type *l)
lang_add_nocrossref (lang_nocrossref_type *l)
{
{
  struct lang_nocrossrefs *n;
  struct lang_nocrossrefs *n;
 
 
  n = xmalloc (sizeof *n);
  n = xmalloc (sizeof *n);
  n->next = nocrossref_list;
  n->next = nocrossref_list;
  n->list = l;
  n->list = l;
  nocrossref_list = n;
  nocrossref_list = n;
 
 
  /* Set notice_all so that we get informed about all symbols.  */
  /* Set notice_all so that we get informed about all symbols.  */
  link_info.notice_all = TRUE;
  link_info.notice_all = TRUE;
}
}


/* Overlay handling.  We handle overlays with some static variables.  */
/* Overlay handling.  We handle overlays with some static variables.  */
 
 
/* The overlay virtual address.  */
/* The overlay virtual address.  */
static etree_type *overlay_vma;
static etree_type *overlay_vma;
/* And subsection alignment.  */
/* And subsection alignment.  */
static etree_type *overlay_subalign;
static etree_type *overlay_subalign;
 
 
/* An expression for the maximum section size seen so far.  */
/* An expression for the maximum section size seen so far.  */
static etree_type *overlay_max;
static etree_type *overlay_max;
 
 
/* A list of all the sections in this overlay.  */
/* A list of all the sections in this overlay.  */
 
 
struct overlay_list {
struct overlay_list {
  struct overlay_list *next;
  struct overlay_list *next;
  lang_output_section_statement_type *os;
  lang_output_section_statement_type *os;
};
};
 
 
static struct overlay_list *overlay_list;
static struct overlay_list *overlay_list;
 
 
/* Start handling an overlay.  */
/* Start handling an overlay.  */
 
 
void
void
lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
{
{
  /* The grammar should prevent nested overlays from occurring.  */
  /* The grammar should prevent nested overlays from occurring.  */
  ASSERT (overlay_vma == NULL
  ASSERT (overlay_vma == NULL
          && overlay_subalign == NULL
          && overlay_subalign == NULL
          && overlay_max == NULL);
          && overlay_max == NULL);
 
 
  overlay_vma = vma_expr;
  overlay_vma = vma_expr;
  overlay_subalign = subalign;
  overlay_subalign = subalign;
}
}
 
 
/* Start a section in an overlay.  We handle this by calling
/* Start a section in an overlay.  We handle this by calling
   lang_enter_output_section_statement with the correct VMA.
   lang_enter_output_section_statement with the correct VMA.
   lang_leave_overlay sets up the LMA and memory regions.  */
   lang_leave_overlay sets up the LMA and memory regions.  */
 
 
void
void
lang_enter_overlay_section (const char *name)
lang_enter_overlay_section (const char *name)
{
{
  struct overlay_list *n;
  struct overlay_list *n;
  etree_type *size;
  etree_type *size;
 
 
  lang_enter_output_section_statement (name, overlay_vma, overlay_section,
  lang_enter_output_section_statement (name, overlay_vma, overlay_section,
                                       0, overlay_subalign, 0, 0);
                                       0, overlay_subalign, 0, 0);
 
 
  /* If this is the first section, then base the VMA of future
  /* If this is the first section, then base the VMA of future
     sections on this one.  This will work correctly even if `.' is
     sections on this one.  This will work correctly even if `.' is
     used in the addresses.  */
     used in the addresses.  */
  if (overlay_list == NULL)
  if (overlay_list == NULL)
    overlay_vma = exp_nameop (ADDR, name);
    overlay_vma = exp_nameop (ADDR, name);
 
 
  /* Remember the section.  */
  /* Remember the section.  */
  n = xmalloc (sizeof *n);
  n = xmalloc (sizeof *n);
  n->os = current_section;
  n->os = current_section;
  n->next = overlay_list;
  n->next = overlay_list;
  overlay_list = n;
  overlay_list = n;
 
 
  size = exp_nameop (SIZEOF, name);
  size = exp_nameop (SIZEOF, name);
 
 
  /* Arrange to work out the maximum section end address.  */
  /* Arrange to work out the maximum section end address.  */
  if (overlay_max == NULL)
  if (overlay_max == NULL)
    overlay_max = size;
    overlay_max = size;
  else
  else
    overlay_max = exp_binop (MAX_K, overlay_max, size);
    overlay_max = exp_binop (MAX_K, overlay_max, size);
}
}
 
 
/* Finish a section in an overlay.  There isn't any special to do
/* Finish a section in an overlay.  There isn't any special to do
   here.  */
   here.  */
 
 
void
void
lang_leave_overlay_section (fill_type *fill,
lang_leave_overlay_section (fill_type *fill,
                            lang_output_section_phdr_list *phdrs)
                            lang_output_section_phdr_list *phdrs)
{
{
  const char *name;
  const char *name;
  char *clean, *s2;
  char *clean, *s2;
  const char *s1;
  const char *s1;
  char *buf;
  char *buf;
 
 
  name = current_section->name;
  name = current_section->name;
 
 
  /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
  /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
     region and that no load-time region has been specified.  It doesn't
     region and that no load-time region has been specified.  It doesn't
     really matter what we say here, since lang_leave_overlay will
     really matter what we say here, since lang_leave_overlay will
     override it.  */
     override it.  */
  lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
  lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
 
 
  /* Define the magic symbols.  */
  /* Define the magic symbols.  */
 
 
  clean = xmalloc (strlen (name) + 1);
  clean = xmalloc (strlen (name) + 1);
  s2 = clean;
  s2 = clean;
  for (s1 = name; *s1 != '\0'; s1++)
  for (s1 = name; *s1 != '\0'; s1++)
    if (ISALNUM (*s1) || *s1 == '_')
    if (ISALNUM (*s1) || *s1 == '_')
      *s2++ = *s1;
      *s2++ = *s1;
  *s2 = '\0';
  *s2 = '\0';
 
 
  buf = xmalloc (strlen (clean) + sizeof "__load_start_");
  buf = xmalloc (strlen (clean) + sizeof "__load_start_");
  sprintf (buf, "__load_start_%s", clean);
  sprintf (buf, "__load_start_%s", clean);
  lang_add_assignment (exp_provide (buf,
  lang_add_assignment (exp_provide (buf,
                                    exp_nameop (LOADADDR, name),
                                    exp_nameop (LOADADDR, name),
                                    FALSE));
                                    FALSE));
 
 
  buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
  buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
  sprintf (buf, "__load_stop_%s", clean);
  sprintf (buf, "__load_stop_%s", clean);
  lang_add_assignment (exp_provide (buf,
  lang_add_assignment (exp_provide (buf,
                                    exp_binop ('+',
                                    exp_binop ('+',
                                               exp_nameop (LOADADDR, name),
                                               exp_nameop (LOADADDR, name),
                                               exp_nameop (SIZEOF, name)),
                                               exp_nameop (SIZEOF, name)),
                                    FALSE));
                                    FALSE));
 
 
  free (clean);
  free (clean);
}
}
 
 
/* Finish an overlay.  If there are any overlay wide settings, this
/* Finish an overlay.  If there are any overlay wide settings, this
   looks through all the sections in the overlay and sets them.  */
   looks through all the sections in the overlay and sets them.  */
 
 
void
void
lang_leave_overlay (etree_type *lma_expr,
lang_leave_overlay (etree_type *lma_expr,
                    int nocrossrefs,
                    int nocrossrefs,
                    fill_type *fill,
                    fill_type *fill,
                    const char *memspec,
                    const char *memspec,
                    lang_output_section_phdr_list *phdrs,
                    lang_output_section_phdr_list *phdrs,
                    const char *lma_memspec)
                    const char *lma_memspec)
{
{
  lang_memory_region_type *region;
  lang_memory_region_type *region;
  lang_memory_region_type *lma_region;
  lang_memory_region_type *lma_region;
  struct overlay_list *l;
  struct overlay_list *l;
  lang_nocrossref_type *nocrossref;
  lang_nocrossref_type *nocrossref;
 
 
  lang_get_regions (&region, &lma_region,
  lang_get_regions (&region, &lma_region,
                    memspec, lma_memspec,
                    memspec, lma_memspec,
                    lma_expr != NULL, FALSE);
                    lma_expr != NULL, FALSE);
 
 
  nocrossref = NULL;
  nocrossref = NULL;
 
 
  /* After setting the size of the last section, set '.' to end of the
  /* After setting the size of the last section, set '.' to end of the
     overlay region.  */
     overlay region.  */
  if (overlay_list != NULL)
  if (overlay_list != NULL)
    overlay_list->os->update_dot_tree
    overlay_list->os->update_dot_tree
      = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
      = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
 
 
  l = overlay_list;
  l = overlay_list;
  while (l != NULL)
  while (l != NULL)
    {
    {
      struct overlay_list *next;
      struct overlay_list *next;
 
 
      if (fill != NULL && l->os->fill == NULL)
      if (fill != NULL && l->os->fill == NULL)
        l->os->fill = fill;
        l->os->fill = fill;
 
 
      l->os->region = region;
      l->os->region = region;
      l->os->lma_region = lma_region;
      l->os->lma_region = lma_region;
 
 
      /* The first section has the load address specified in the
      /* The first section has the load address specified in the
         OVERLAY statement.  The rest are worked out from that.
         OVERLAY statement.  The rest are worked out from that.
         The base address is not needed (and should be null) if
         The base address is not needed (and should be null) if
         an LMA region was specified.  */
         an LMA region was specified.  */
      if (l->next == 0)
      if (l->next == 0)
        {
        {
          l->os->load_base = lma_expr;
          l->os->load_base = lma_expr;
          l->os->sectype = normal_section;
          l->os->sectype = normal_section;
        }
        }
      if (phdrs != NULL && l->os->phdrs == NULL)
      if (phdrs != NULL && l->os->phdrs == NULL)
        l->os->phdrs = phdrs;
        l->os->phdrs = phdrs;
 
 
      if (nocrossrefs)
      if (nocrossrefs)
        {
        {
          lang_nocrossref_type *nc;
          lang_nocrossref_type *nc;
 
 
          nc = xmalloc (sizeof *nc);
          nc = xmalloc (sizeof *nc);
          nc->name = l->os->name;
          nc->name = l->os->name;
          nc->next = nocrossref;
          nc->next = nocrossref;
          nocrossref = nc;
          nocrossref = nc;
        }
        }
 
 
      next = l->next;
      next = l->next;
      free (l);
      free (l);
      l = next;
      l = next;
    }
    }
 
 
  if (nocrossref != NULL)
  if (nocrossref != NULL)
    lang_add_nocrossref (nocrossref);
    lang_add_nocrossref (nocrossref);
 
 
  overlay_vma = NULL;
  overlay_vma = NULL;
  overlay_list = NULL;
  overlay_list = NULL;
  overlay_max = NULL;
  overlay_max = NULL;
}
}


/* Version handling.  This is only useful for ELF.  */
/* Version handling.  This is only useful for ELF.  */
 
 
/* This global variable holds the version tree that we build.  */
/* This global variable holds the version tree that we build.  */
 
 
struct bfd_elf_version_tree *lang_elf_version_info;
struct bfd_elf_version_tree *lang_elf_version_info;
 
 
/* If PREV is NULL, return first version pattern matching particular symbol.
/* If PREV is NULL, return first version pattern matching particular symbol.
   If PREV is non-NULL, return first version pattern matching particular
   If PREV is non-NULL, return first version pattern matching particular
   symbol after PREV (previously returned by lang_vers_match).  */
   symbol after PREV (previously returned by lang_vers_match).  */
 
 
static struct bfd_elf_version_expr *
static struct bfd_elf_version_expr *
lang_vers_match (struct bfd_elf_version_expr_head *head,
lang_vers_match (struct bfd_elf_version_expr_head *head,
                 struct bfd_elf_version_expr *prev,
                 struct bfd_elf_version_expr *prev,
                 const char *sym)
                 const char *sym)
{
{
  const char *cxx_sym = sym;
  const char *cxx_sym = sym;
  const char *java_sym = sym;
  const char *java_sym = sym;
  struct bfd_elf_version_expr *expr = NULL;
  struct bfd_elf_version_expr *expr = NULL;
 
 
  if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
  if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
    {
    {
      cxx_sym = cplus_demangle (sym, DMGL_PARAMS | DMGL_ANSI);
      cxx_sym = cplus_demangle (sym, DMGL_PARAMS | DMGL_ANSI);
      if (!cxx_sym)
      if (!cxx_sym)
        cxx_sym = sym;
        cxx_sym = sym;
    }
    }
  if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
  if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
    {
    {
      java_sym = cplus_demangle (sym, DMGL_JAVA);
      java_sym = cplus_demangle (sym, DMGL_JAVA);
      if (!java_sym)
      if (!java_sym)
        java_sym = sym;
        java_sym = sym;
    }
    }
 
 
  if (head->htab && (prev == NULL || prev->symbol))
  if (head->htab && (prev == NULL || prev->symbol))
    {
    {
      struct bfd_elf_version_expr e;
      struct bfd_elf_version_expr e;
 
 
      switch (prev ? prev->mask : 0)
      switch (prev ? prev->mask : 0)
        {
        {
          case 0:
          case 0:
            if (head->mask & BFD_ELF_VERSION_C_TYPE)
            if (head->mask & BFD_ELF_VERSION_C_TYPE)
              {
              {
                e.symbol = sym;
                e.symbol = sym;
                expr = htab_find (head->htab, &e);
                expr = htab_find (head->htab, &e);
                while (expr && strcmp (expr->symbol, sym) == 0)
                while (expr && strcmp (expr->symbol, sym) == 0)
                  if (expr->mask == BFD_ELF_VERSION_C_TYPE)
                  if (expr->mask == BFD_ELF_VERSION_C_TYPE)
                    goto out_ret;
                    goto out_ret;
                  else
                  else
                    expr = expr->next;
                    expr = expr->next;
              }
              }
            /* Fallthrough */
            /* Fallthrough */
          case BFD_ELF_VERSION_C_TYPE:
          case BFD_ELF_VERSION_C_TYPE:
            if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
            if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
              {
              {
                e.symbol = cxx_sym;
                e.symbol = cxx_sym;
                expr = htab_find (head->htab, &e);
                expr = htab_find (head->htab, &e);
                while (expr && strcmp (expr->symbol, cxx_sym) == 0)
                while (expr && strcmp (expr->symbol, cxx_sym) == 0)
                  if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
                  if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
                    goto out_ret;
                    goto out_ret;
                  else
                  else
                    expr = expr->next;
                    expr = expr->next;
              }
              }
            /* Fallthrough */
            /* Fallthrough */
          case BFD_ELF_VERSION_CXX_TYPE:
          case BFD_ELF_VERSION_CXX_TYPE:
            if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
            if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
              {
              {
                e.symbol = java_sym;
                e.symbol = java_sym;
                expr = htab_find (head->htab, &e);
                expr = htab_find (head->htab, &e);
                while (expr && strcmp (expr->symbol, java_sym) == 0)
                while (expr && strcmp (expr->symbol, java_sym) == 0)
                  if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
                  if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
                    goto out_ret;
                    goto out_ret;
                  else
                  else
                    expr = expr->next;
                    expr = expr->next;
              }
              }
            /* Fallthrough */
            /* Fallthrough */
          default:
          default:
            break;
            break;
        }
        }
    }
    }
 
 
  /* Finally, try the wildcards.  */
  /* Finally, try the wildcards.  */
  if (prev == NULL || prev->symbol)
  if (prev == NULL || prev->symbol)
    expr = head->remaining;
    expr = head->remaining;
  else
  else
    expr = prev->next;
    expr = prev->next;
  for (; expr; expr = expr->next)
  for (; expr; expr = expr->next)
    {
    {
      const char *s;
      const char *s;
 
 
      if (!expr->pattern)
      if (!expr->pattern)
        continue;
        continue;
 
 
      if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
      if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
        break;
        break;
 
 
      if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
      if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
        s = java_sym;
        s = java_sym;
      else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
      else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
        s = cxx_sym;
        s = cxx_sym;
      else
      else
        s = sym;
        s = sym;
      if (fnmatch (expr->pattern, s, 0) == 0)
      if (fnmatch (expr->pattern, s, 0) == 0)
        break;
        break;
    }
    }
 
 
out_ret:
out_ret:
  if (cxx_sym != sym)
  if (cxx_sym != sym)
    free ((char *) cxx_sym);
    free ((char *) cxx_sym);
  if (java_sym != sym)
  if (java_sym != sym)
    free ((char *) java_sym);
    free ((char *) java_sym);
  return expr;
  return expr;
}
}
 
 
/* Return NULL if the PATTERN argument is a glob pattern, otherwise,
/* Return NULL if the PATTERN argument is a glob pattern, otherwise,
   return a string pointing to the symbol name.  */
   return a string pointing to the symbol name.  */
 
 
static const char *
static const char *
realsymbol (const char *pattern)
realsymbol (const char *pattern)
{
{
  const char *p;
  const char *p;
  bfd_boolean changed = FALSE, backslash = FALSE;
  bfd_boolean changed = FALSE, backslash = FALSE;
  char *s, *symbol = xmalloc (strlen (pattern) + 1);
  char *s, *symbol = xmalloc (strlen (pattern) + 1);
 
 
  for (p = pattern, s = symbol; *p != '\0'; ++p)
  for (p = pattern, s = symbol; *p != '\0'; ++p)
    {
    {
      /* It is a glob pattern only if there is no preceding
      /* It is a glob pattern only if there is no preceding
         backslash.  */
         backslash.  */
      if (! backslash && (*p == '?' || *p == '*' || *p == '['))
      if (! backslash && (*p == '?' || *p == '*' || *p == '['))
        {
        {
          free (symbol);
          free (symbol);
          return NULL;
          return NULL;
        }
        }
 
 
      if (backslash)
      if (backslash)
        {
        {
          /* Remove the preceding backslash.  */
          /* Remove the preceding backslash.  */
          *(s - 1) = *p;
          *(s - 1) = *p;
          changed = TRUE;
          changed = TRUE;
        }
        }
      else
      else
        *s++ = *p;
        *s++ = *p;
 
 
      backslash = *p == '\\';
      backslash = *p == '\\';
    }
    }
 
 
  if (changed)
  if (changed)
    {
    {
      *s = '\0';
      *s = '\0';
      return symbol;
      return symbol;
    }
    }
  else
  else
    {
    {
      free (symbol);
      free (symbol);
      return pattern;
      return pattern;
    }
    }
}
}
 
 
/* This is called for each variable name or match expression.  NEW is
/* This is called for each variable name or match expression.  NEW is
   the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
   the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
   pattern to be matched against symbol names.  */
   pattern to be matched against symbol names.  */
 
 
struct bfd_elf_version_expr *
struct bfd_elf_version_expr *
lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
                       const char *new,
                       const char *new,
                       const char *lang,
                       const char *lang,
                       bfd_boolean literal_p)
                       bfd_boolean literal_p)
{
{
  struct bfd_elf_version_expr *ret;
  struct bfd_elf_version_expr *ret;
 
 
  ret = xmalloc (sizeof *ret);
  ret = xmalloc (sizeof *ret);
  ret->next = orig;
  ret->next = orig;
  ret->pattern = literal_p ? NULL : new;
  ret->pattern = literal_p ? NULL : new;
  ret->symver = 0;
  ret->symver = 0;
  ret->script = 0;
  ret->script = 0;
  ret->symbol = literal_p ? new : realsymbol (new);
  ret->symbol = literal_p ? new : realsymbol (new);
 
 
  if (lang == NULL || strcasecmp (lang, "C") == 0)
  if (lang == NULL || strcasecmp (lang, "C") == 0)
    ret->mask = BFD_ELF_VERSION_C_TYPE;
    ret->mask = BFD_ELF_VERSION_C_TYPE;
  else if (strcasecmp (lang, "C++") == 0)
  else if (strcasecmp (lang, "C++") == 0)
    ret->mask = BFD_ELF_VERSION_CXX_TYPE;
    ret->mask = BFD_ELF_VERSION_CXX_TYPE;
  else if (strcasecmp (lang, "Java") == 0)
  else if (strcasecmp (lang, "Java") == 0)
    ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
    ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
  else
  else
    {
    {
      einfo (_("%X%P: unknown language `%s' in version information\n"),
      einfo (_("%X%P: unknown language `%s' in version information\n"),
             lang);
             lang);
      ret->mask = BFD_ELF_VERSION_C_TYPE;
      ret->mask = BFD_ELF_VERSION_C_TYPE;
    }
    }
 
 
  return ldemul_new_vers_pattern (ret);
  return ldemul_new_vers_pattern (ret);
}
}
 
 
/* This is called for each set of variable names and match
/* This is called for each set of variable names and match
   expressions.  */
   expressions.  */
 
 
struct bfd_elf_version_tree *
struct bfd_elf_version_tree *
lang_new_vers_node (struct bfd_elf_version_expr *globals,
lang_new_vers_node (struct bfd_elf_version_expr *globals,
                    struct bfd_elf_version_expr *locals)
                    struct bfd_elf_version_expr *locals)
{
{
  struct bfd_elf_version_tree *ret;
  struct bfd_elf_version_tree *ret;
 
 
  ret = xcalloc (1, sizeof *ret);
  ret = xcalloc (1, sizeof *ret);
  ret->globals.list = globals;
  ret->globals.list = globals;
  ret->locals.list = locals;
  ret->locals.list = locals;
  ret->match = lang_vers_match;
  ret->match = lang_vers_match;
  ret->name_indx = (unsigned int) -1;
  ret->name_indx = (unsigned int) -1;
  return ret;
  return ret;
}
}
 
 
/* This static variable keeps track of version indices.  */
/* This static variable keeps track of version indices.  */
 
 
static int version_index;
static int version_index;
 
 
static hashval_t
static hashval_t
version_expr_head_hash (const void *p)
version_expr_head_hash (const void *p)
{
{
  const struct bfd_elf_version_expr *e = p;
  const struct bfd_elf_version_expr *e = p;
 
 
  return htab_hash_string (e->symbol);
  return htab_hash_string (e->symbol);
}
}
 
 
static int
static int
version_expr_head_eq (const void *p1, const void *p2)
version_expr_head_eq (const void *p1, const void *p2)
{
{
  const struct bfd_elf_version_expr *e1 = p1;
  const struct bfd_elf_version_expr *e1 = p1;
  const struct bfd_elf_version_expr *e2 = p2;
  const struct bfd_elf_version_expr *e2 = p2;
 
 
  return strcmp (e1->symbol, e2->symbol) == 0;
  return strcmp (e1->symbol, e2->symbol) == 0;
}
}
 
 
static void
static void
lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
{
{
  size_t count = 0;
  size_t count = 0;
  struct bfd_elf_version_expr *e, *next;
  struct bfd_elf_version_expr *e, *next;
  struct bfd_elf_version_expr **list_loc, **remaining_loc;
  struct bfd_elf_version_expr **list_loc, **remaining_loc;
 
 
  for (e = head->list; e; e = e->next)
  for (e = head->list; e; e = e->next)
    {
    {
      if (e->symbol)
      if (e->symbol)
        count++;
        count++;
      head->mask |= e->mask;
      head->mask |= e->mask;
    }
    }
 
 
  if (count)
  if (count)
    {
    {
      head->htab = htab_create (count * 2, version_expr_head_hash,
      head->htab = htab_create (count * 2, version_expr_head_hash,
                                version_expr_head_eq, NULL);
                                version_expr_head_eq, NULL);
      list_loc = &head->list;
      list_loc = &head->list;
      remaining_loc = &head->remaining;
      remaining_loc = &head->remaining;
      for (e = head->list; e; e = next)
      for (e = head->list; e; e = next)
        {
        {
          next = e->next;
          next = e->next;
          if (!e->symbol)
          if (!e->symbol)
            {
            {
              *remaining_loc = e;
              *remaining_loc = e;
              remaining_loc = &e->next;
              remaining_loc = &e->next;
            }
            }
          else
          else
            {
            {
              void **loc = htab_find_slot (head->htab, e, INSERT);
              void **loc = htab_find_slot (head->htab, e, INSERT);
 
 
              if (*loc)
              if (*loc)
                {
                {
                  struct bfd_elf_version_expr *e1, *last;
                  struct bfd_elf_version_expr *e1, *last;
 
 
                  e1 = *loc;
                  e1 = *loc;
                  last = NULL;
                  last = NULL;
                  do
                  do
                    {
                    {
                      if (e1->mask == e->mask)
                      if (e1->mask == e->mask)
                        {
                        {
                          last = NULL;
                          last = NULL;
                          break;
                          break;
                        }
                        }
                      last = e1;
                      last = e1;
                      e1 = e1->next;
                      e1 = e1->next;
                    }
                    }
                  while (e1 && strcmp (e1->symbol, e->symbol) == 0);
                  while (e1 && strcmp (e1->symbol, e->symbol) == 0);
 
 
                  if (last == NULL)
                  if (last == NULL)
                    {
                    {
                      /* This is a duplicate.  */
                      /* This is a duplicate.  */
                      /* FIXME: Memory leak.  Sometimes pattern is not
                      /* FIXME: Memory leak.  Sometimes pattern is not
                         xmalloced alone, but in larger chunk of memory.  */
                         xmalloced alone, but in larger chunk of memory.  */
                      /* free (e->symbol); */
                      /* free (e->symbol); */
                      free (e);
                      free (e);
                    }
                    }
                  else
                  else
                    {
                    {
                      e->next = last->next;
                      e->next = last->next;
                      last->next = e;
                      last->next = e;
                    }
                    }
                }
                }
              else
              else
                {
                {
                  *loc = e;
                  *loc = e;
                  *list_loc = e;
                  *list_loc = e;
                  list_loc = &e->next;
                  list_loc = &e->next;
                }
                }
            }
            }
        }
        }
      *remaining_loc = NULL;
      *remaining_loc = NULL;
      *list_loc = head->remaining;
      *list_loc = head->remaining;
    }
    }
  else
  else
    head->remaining = head->list;
    head->remaining = head->list;
}
}
 
 
/* This is called when we know the name and dependencies of the
/* This is called when we know the name and dependencies of the
   version.  */
   version.  */
 
 
void
void
lang_register_vers_node (const char *name,
lang_register_vers_node (const char *name,
                         struct bfd_elf_version_tree *version,
                         struct bfd_elf_version_tree *version,
                         struct bfd_elf_version_deps *deps)
                         struct bfd_elf_version_deps *deps)
{
{
  struct bfd_elf_version_tree *t, **pp;
  struct bfd_elf_version_tree *t, **pp;
  struct bfd_elf_version_expr *e1;
  struct bfd_elf_version_expr *e1;
 
 
  if (name == NULL)
  if (name == NULL)
    name = "";
    name = "";
 
 
  if ((name[0] == '\0' && lang_elf_version_info != NULL)
  if ((name[0] == '\0' && lang_elf_version_info != NULL)
      || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
      || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
    {
    {
      einfo (_("%X%P: anonymous version tag cannot be combined"
      einfo (_("%X%P: anonymous version tag cannot be combined"
               " with other version tags\n"));
               " with other version tags\n"));
      free (version);
      free (version);
      return;
      return;
    }
    }
 
 
  /* Make sure this node has a unique name.  */
  /* Make sure this node has a unique name.  */
  for (t = lang_elf_version_info; t != NULL; t = t->next)
  for (t = lang_elf_version_info; t != NULL; t = t->next)
    if (strcmp (t->name, name) == 0)
    if (strcmp (t->name, name) == 0)
      einfo (_("%X%P: duplicate version tag `%s'\n"), name);
      einfo (_("%X%P: duplicate version tag `%s'\n"), name);
 
 
  lang_finalize_version_expr_head (&version->globals);
  lang_finalize_version_expr_head (&version->globals);
  lang_finalize_version_expr_head (&version->locals);
  lang_finalize_version_expr_head (&version->locals);
 
 
  /* Check the global and local match names, and make sure there
  /* Check the global and local match names, and make sure there
     aren't any duplicates.  */
     aren't any duplicates.  */
 
 
  for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
  for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
    {
    {
      for (t = lang_elf_version_info; t != NULL; t = t->next)
      for (t = lang_elf_version_info; t != NULL; t = t->next)
        {
        {
          struct bfd_elf_version_expr *e2;
          struct bfd_elf_version_expr *e2;
 
 
          if (t->locals.htab && e1->symbol)
          if (t->locals.htab && e1->symbol)
            {
            {
              e2 = htab_find (t->locals.htab, e1);
              e2 = htab_find (t->locals.htab, e1);
              while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
              while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
                {
                {
                  if (e1->mask == e2->mask)
                  if (e1->mask == e2->mask)
                    einfo (_("%X%P: duplicate expression `%s'"
                    einfo (_("%X%P: duplicate expression `%s'"
                             " in version information\n"), e1->symbol);
                             " in version information\n"), e1->symbol);
                  e2 = e2->next;
                  e2 = e2->next;
                }
                }
            }
            }
          else if (!e1->symbol)
          else if (!e1->symbol)
            for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
            for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
              if (strcmp (e1->pattern, e2->pattern) == 0
              if (strcmp (e1->pattern, e2->pattern) == 0
                  && e1->mask == e2->mask)
                  && e1->mask == e2->mask)
                einfo (_("%X%P: duplicate expression `%s'"
                einfo (_("%X%P: duplicate expression `%s'"
                         " in version information\n"), e1->pattern);
                         " in version information\n"), e1->pattern);
        }
        }
    }
    }
 
 
  for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
  for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
    {
    {
      for (t = lang_elf_version_info; t != NULL; t = t->next)
      for (t = lang_elf_version_info; t != NULL; t = t->next)
        {
        {
          struct bfd_elf_version_expr *e2;
          struct bfd_elf_version_expr *e2;
 
 
          if (t->globals.htab && e1->symbol)
          if (t->globals.htab && e1->symbol)
            {
            {
              e2 = htab_find (t->globals.htab, e1);
              e2 = htab_find (t->globals.htab, e1);
              while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
              while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
                {
                {
                  if (e1->mask == e2->mask)
                  if (e1->mask == e2->mask)
                    einfo (_("%X%P: duplicate expression `%s'"
                    einfo (_("%X%P: duplicate expression `%s'"
                             " in version information\n"),
                             " in version information\n"),
                           e1->symbol);
                           e1->symbol);
                  e2 = e2->next;
                  e2 = e2->next;
                }
                }
            }
            }
          else if (!e1->symbol)
          else if (!e1->symbol)
            for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
            for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
              if (strcmp (e1->pattern, e2->pattern) == 0
              if (strcmp (e1->pattern, e2->pattern) == 0
                  && e1->mask == e2->mask)
                  && e1->mask == e2->mask)
                einfo (_("%X%P: duplicate expression `%s'"
                einfo (_("%X%P: duplicate expression `%s'"
                         " in version information\n"), e1->pattern);
                         " in version information\n"), e1->pattern);
        }
        }
    }
    }
 
 
  version->deps = deps;
  version->deps = deps;
  version->name = name;
  version->name = name;
  if (name[0] != '\0')
  if (name[0] != '\0')
    {
    {
      ++version_index;
      ++version_index;
      version->vernum = version_index;
      version->vernum = version_index;
    }
    }
  else
  else
    version->vernum = 0;
    version->vernum = 0;
 
 
  for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
  for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
    ;
    ;
  *pp = version;
  *pp = version;
}
}
 
 
/* This is called when we see a version dependency.  */
/* This is called when we see a version dependency.  */
 
 
struct bfd_elf_version_deps *
struct bfd_elf_version_deps *
lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
{
{
  struct bfd_elf_version_deps *ret;
  struct bfd_elf_version_deps *ret;
  struct bfd_elf_version_tree *t;
  struct bfd_elf_version_tree *t;
 
 
  ret = xmalloc (sizeof *ret);
  ret = xmalloc (sizeof *ret);
  ret->next = list;
  ret->next = list;
 
 
  for (t = lang_elf_version_info; t != NULL; t = t->next)
  for (t = lang_elf_version_info; t != NULL; t = t->next)
    {
    {
      if (strcmp (t->name, name) == 0)
      if (strcmp (t->name, name) == 0)
        {
        {
          ret->version_needed = t;
          ret->version_needed = t;
          return ret;
          return ret;
        }
        }
    }
    }
 
 
  einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
  einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
 
 
  return ret;
  return ret;
}
}
 
 
static void
static void
lang_do_version_exports_section (void)
lang_do_version_exports_section (void)
{
{
  struct bfd_elf_version_expr *greg = NULL, *lreg;
  struct bfd_elf_version_expr *greg = NULL, *lreg;
 
 
  LANG_FOR_EACH_INPUT_STATEMENT (is)
  LANG_FOR_EACH_INPUT_STATEMENT (is)
    {
    {
      asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
      asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
      char *contents, *p;
      char *contents, *p;
      bfd_size_type len;
      bfd_size_type len;
 
 
      if (sec == NULL)
      if (sec == NULL)
        continue;
        continue;
 
 
      len = sec->size;
      len = sec->size;
      contents = xmalloc (len);
      contents = xmalloc (len);
      if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
      if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
        einfo (_("%X%P: unable to read .exports section contents\n"), sec);
        einfo (_("%X%P: unable to read .exports section contents\n"), sec);
 
 
      p = contents;
      p = contents;
      while (p < contents + len)
      while (p < contents + len)
        {
        {
          greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
          greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
          p = strchr (p, '\0') + 1;
          p = strchr (p, '\0') + 1;
        }
        }
 
 
      /* Do not free the contents, as we used them creating the regex.  */
      /* Do not free the contents, as we used them creating the regex.  */
 
 
      /* Do not include this section in the link.  */
      /* Do not include this section in the link.  */
      sec->flags |= SEC_EXCLUDE | SEC_KEEP;
      sec->flags |= SEC_EXCLUDE | SEC_KEEP;
    }
    }
 
 
  lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
  lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
  lang_register_vers_node (command_line.version_exports_section,
  lang_register_vers_node (command_line.version_exports_section,
                           lang_new_vers_node (greg, lreg), NULL);
                           lang_new_vers_node (greg, lreg), NULL);
}
}
 
 
void
void
lang_add_unique (const char *name)
lang_add_unique (const char *name)
{
{
  struct unique_sections *ent;
  struct unique_sections *ent;
 
 
  for (ent = unique_section_list; ent; ent = ent->next)
  for (ent = unique_section_list; ent; ent = ent->next)
    if (strcmp (ent->name, name) == 0)
    if (strcmp (ent->name, name) == 0)
      return;
      return;
 
 
  ent = xmalloc (sizeof *ent);
  ent = xmalloc (sizeof *ent);
  ent->name = xstrdup (name);
  ent->name = xstrdup (name);
  ent->next = unique_section_list;
  ent->next = unique_section_list;
  unique_section_list = ent;
  unique_section_list = ent;
}
}
 
 
/* Append the list of dynamic symbols to the existing one.  */
/* Append the list of dynamic symbols to the existing one.  */
 
 
void
void
lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
{
{
  if (link_info.dynamic_list)
  if (link_info.dynamic_list)
    {
    {
      struct bfd_elf_version_expr *tail;
      struct bfd_elf_version_expr *tail;
      for (tail = dynamic; tail->next != NULL; tail = tail->next)
      for (tail = dynamic; tail->next != NULL; tail = tail->next)
        ;
        ;
      tail->next = link_info.dynamic_list->head.list;
      tail->next = link_info.dynamic_list->head.list;
      link_info.dynamic_list->head.list = dynamic;
      link_info.dynamic_list->head.list = dynamic;
    }
    }
  else
  else
    {
    {
      struct bfd_elf_dynamic_list *d;
      struct bfd_elf_dynamic_list *d;
 
 
      d = xcalloc (1, sizeof *d);
      d = xcalloc (1, sizeof *d);
      d->head.list = dynamic;
      d->head.list = dynamic;
      d->match = lang_vers_match;
      d->match = lang_vers_match;
      link_info.dynamic_list = d;
      link_info.dynamic_list = d;
    }
    }
}
}
 
 
/* Append the list of C++ typeinfo dynamic symbols to the existing
/* Append the list of C++ typeinfo dynamic symbols to the existing
   one.  */
   one.  */
 
 
void
void
lang_append_dynamic_list_cpp_typeinfo (void)
lang_append_dynamic_list_cpp_typeinfo (void)
{
{
  const char * symbols [] =
  const char * symbols [] =
    {
    {
      "typeinfo name for*",
      "typeinfo name for*",
      "typeinfo for*"
      "typeinfo for*"
    };
    };
  struct bfd_elf_version_expr *dynamic = NULL;
  struct bfd_elf_version_expr *dynamic = NULL;
  unsigned int i;
  unsigned int i;
 
 
  for (i = 0; i < ARRAY_SIZE (symbols); i++)
  for (i = 0; i < ARRAY_SIZE (symbols); i++)
    dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
    dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
                                     FALSE);
                                     FALSE);
 
 
  lang_append_dynamic_list (dynamic);
  lang_append_dynamic_list (dynamic);
}
}
 
 
/* Append the list of C++ operator new and delete dynamic symbols to the
/* Append the list of C++ operator new and delete dynamic symbols to the
   existing one.  */
   existing one.  */
 
 
void
void
lang_append_dynamic_list_cpp_new (void)
lang_append_dynamic_list_cpp_new (void)
{
{
  const char * symbols [] =
  const char * symbols [] =
    {
    {
      "operator new*",
      "operator new*",
      "operator delete*"
      "operator delete*"
    };
    };
  struct bfd_elf_version_expr *dynamic = NULL;
  struct bfd_elf_version_expr *dynamic = NULL;
  unsigned int i;
  unsigned int i;
 
 
  for (i = 0; i < ARRAY_SIZE (symbols); i++)
  for (i = 0; i < ARRAY_SIZE (symbols); i++)
    dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
    dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
                                     FALSE);
                                     FALSE);
 
 
  lang_append_dynamic_list (dynamic);
  lang_append_dynamic_list (dynamic);
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.