Changeset 609 for branches/GNU/src/binutils/ld/ldlang.c

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/ld/ldlang.c (modified) (170 diffs, 1 prop)

branches/GNU/src/binutils/ld/ldlang.c

@@ -1 +1 @@
 /* Linker command language support.
    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-   2001
+   2001, 2002, 2003
    Free Software Foundation, Inc.
 
-This file is part of GLD, the Gnu Linker.
-
-GLD is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
-
-GLD is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GLD; see the file COPYING.  If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+   This file is part of GLD, the Gnu Linker.
+
+   GLD is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   GLD is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GLD; see the file COPYING.  If not, write to the Free
+   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
 
 #include "bfd.h"
 #include "sysdep.h"
 #include "libiberty.h"
+#include "safe-ctype.h"
 #include "obstack.h"
 #include "bfdlink.h"
@@ -29 +30 @@
 #include "ld.h"
 #include "ldmain.h"
-#include "ldgram.h"
 #include "ldexp.h"
 #include "ldlang.h"
+#include <ldgram.h>
 #include "ldlex.h"
 #include "ldmisc.h"
@@ -40 +41 @@
 #include "demangle.h"
 
-#include <ctype.h>
-
-/* FORWARDS */
-static lang_statement_union_type *new_statement
-  PARAMS ((enum statement_enum, size_t, lang_statement_list_type *));
-
-/* LOCALS */
+#ifndef offsetof
+#define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
+#endif
+
+/* Locals variables.  */
 static struct obstack stat_obstack;
 
@@ -53 +52 @@
 static const char *startup_file;
 static lang_statement_list_type input_file_chain;
-static boolean placed_commons = false;
+static bfd_boolean placed_commons = FALSE;
 static lang_output_section_statement_type *default_common_section;
-static boolean map_option_f;
+static bfd_boolean map_option_f;
 static bfd_vma print_dot;
 static lang_input_statement_type *first_file;
@@ -63 +62 @@
 static struct lang_phdr *lang_phdr_list;
 
+/* Forward declarations.  */
+static lang_statement_union_type *new_statement
+  PARAMS ((enum statement_enum, size_t, lang_statement_list_type *));
 static void lang_for_each_statement_worker
   PARAMS ((void (*) (lang_statement_union_type *),
            lang_statement_union_type *));
 static lang_input_statement_type *new_afile
-  PARAMS ((const char *, lang_input_file_enum_type, const char *, boolean));
-static lang_memory_region_type *lang_memory_default PARAMS ((asection *));
-static void lang_map_flags PARAMS ((flagword));
-static void init_os PARAMS ((lang_output_section_statement_type *));
-static void exp_init_os PARAMS ((etree_type *));
-static void section_already_linked PARAMS ((bfd *, asection *, PTR));
+  PARAMS ((const char *, lang_input_file_enum_type, const char *,
+           bfd_boolean));
+static lang_memory_region_type *lang_memory_default
+  PARAMS ((asection *));
+static void lang_map_flags
+  PARAMS ((flagword));
+static void init_os
+  PARAMS ((lang_output_section_statement_type *));
+static void exp_init_os
+  PARAMS ((etree_type *));
+static void section_already_linked
+  PARAMS ((bfd *, asection *, PTR));
 static struct bfd_hash_entry *already_linked_newfunc
   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
-static void already_linked_table_init PARAMS ((void));
-static void already_linked_table_free PARAMS ((void));
-static boolean wildcardp PARAMS ((const char *));
+static void already_linked_table_init
+  PARAMS ((void));
+static void already_linked_table_free
+  PARAMS ((void));
+static bfd_boolean wildcardp
+  PARAMS ((const char *));
 static lang_statement_union_type *wild_sort
-  PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
-           asection *));
+  PARAMS ((lang_wild_statement_type *, struct wildcard_list *,
+           lang_input_statement_type *, asection *));
 static void output_section_callback
-  PARAMS ((lang_wild_statement_type *, asection *,
+  PARAMS ((lang_wild_statement_type *, struct wildcard_list *, asection *,
            lang_input_statement_type *, PTR));
-static lang_input_statement_type *lookup_name PARAMS ((const char *));
-static void load_symbols
+static lang_input_statement_type *lookup_name
+  PARAMS ((const char *));
+static bfd_boolean load_symbols
   PARAMS ((lang_input_statement_type *, lang_statement_list_type *));
 static void wild
-  PARAMS ((lang_wild_statement_type *, const char *, const char *,
+  PARAMS ((lang_wild_statement_type *,
            const char *, lang_output_section_statement_type *));
-static bfd *open_output PARAMS ((const char *));
-static void ldlang_open_output PARAMS ((lang_statement_union_type *));
-static void open_input_bfds PARAMS ((lang_statement_union_type *, boolean));
-static void lang_reasonable_defaults PARAMS ((void));
-static void lang_place_undefineds PARAMS ((void));
+static bfd *open_output
+  PARAMS ((const char *));
+static void ldlang_open_output
+  PARAMS ((lang_statement_union_type *));
+static void open_input_bfds
+  PARAMS ((lang_statement_union_type *, bfd_boolean));
+static void lang_reasonable_defaults
+  PARAMS ((void));
+static void insert_undefined
+  PARAMS ((const char *));
+static void lang_place_undefineds
+  PARAMS ((void));
 static void map_input_to_output_sections
   PARAMS ((lang_statement_union_type *, const char *,
            lang_output_section_statement_type *));
+static void strip_excluded_output_sections
+  PARAMS ((void));
 static void print_output_section_statement
   PARAMS ((lang_output_section_statement_type *));
@@ -103 +124 @@
   PARAMS ((lang_assignment_statement_type *,
            lang_output_section_statement_type *));
-static void print_input_statement PARAMS ((lang_input_statement_type *));
-static boolean print_one_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));
-static void print_input_section PARAMS ((lang_input_section_type *));
-static void print_fill_statement PARAMS ((lang_fill_statement_type *));
-static void print_data_statement PARAMS ((lang_data_statement_type *));
-static void print_address_statement PARAMS ((lang_address_statement_type *));
-static void print_reloc_statement PARAMS ((lang_reloc_statement_type *));
-static void print_padding_statement PARAMS ((lang_padding_statement_type *));
+static void print_input_statement
+  PARAMS ((lang_input_statement_type *));
+static bfd_boolean print_one_symbol
+  PARAMS ((struct bfd_link_hash_entry *, PTR));
+static void print_input_section
+  PARAMS ((lang_input_section_type *));
+static void print_fill_statement
+  PARAMS ((lang_fill_statement_type *));
+static void print_data_statement
+  PARAMS ((lang_data_statement_type *));
+static void print_address_statement
+  PARAMS ((lang_address_statement_type *));
+static void print_reloc_statement
+  PARAMS ((lang_reloc_statement_type *));
+static void print_padding_statement
+  PARAMS ((lang_padding_statement_type *));
 static void print_wild_statement
   PARAMS ((lang_wild_statement_type *, lang_output_section_statement_type *));
@@ -119 +148 @@
 static void print_statement_list
   PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *));
-static void print_statements PARAMS ((void));
-static bfd_vma insert_pad
-  PARAMS ((lang_statement_union_type **, fill_type,
+static void print_statements
+  PARAMS ((void));
+static void insert_pad
+  PARAMS ((lang_statement_union_type **, fill_type *,
            unsigned int, asection *, bfd_vma));
 static bfd_vma size_input_section
   PARAMS ((lang_statement_union_type **, lang_output_section_statement_type *,
-           fill_type, bfd_vma, boolean));
-static void lang_finish PARAMS ((void));
-static void ignore_bfd_errors PARAMS ((const char *, ...));
-static void lang_check PARAMS ((void));
-static void lang_common PARAMS ((void));
-static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR));
-static void lang_place_orphans PARAMS ((void));
-static int topower PARAMS ((int));
-static void lang_set_startof PARAMS ((void));
-static void reset_memory_regions PARAMS ((void));
+           fill_type *, bfd_vma));
+static void lang_finish
+  PARAMS ((void));
+static void ignore_bfd_errors
+  PARAMS ((const char *, ...));
+static void lang_check
+  PARAMS ((void));
+static void lang_common
+  PARAMS ((void));
+static bfd_boolean lang_one_common
+  PARAMS ((struct bfd_link_hash_entry *, PTR));
+static void lang_place_orphans
+  PARAMS ((void));
+static int topower
+  PARAMS ((int));
+static void lang_set_startof
+  PARAMS ((void));
 static void gc_section_callback
-  PARAMS ((lang_wild_statement_type *, asection *,
+  PARAMS ((lang_wild_statement_type *, struct wildcard_list *, asection *,
            lang_input_statement_type *, PTR));
-static void lang_record_phdrs PARAMS ((void));
+static void lang_get_regions
+  PARAMS ((struct memory_region_struct **, struct memory_region_struct **,
+           const char *, const char *, int));
+static void lang_record_phdrs
+  PARAMS ((void));
 static void lang_gc_wild
-  PARAMS ((lang_wild_statement_type *, const char *, const char *));
-static void lang_gc_sections_1 PARAMS ((lang_statement_union_type *));
-static void lang_gc_sections PARAMS ((void));
+  PARAMS ((lang_wild_statement_type *));
+static void lang_gc_sections_1
+  PARAMS ((lang_statement_union_type *));
+static void lang_gc_sections
+  PARAMS ((void));
 static int lang_vers_match_lang_c
   PARAMS ((struct bfd_elf_version_expr *, const char *));
@@ -149 +192 @@
 static int lang_vers_match_lang_java
   PARAMS ((struct bfd_elf_version_expr *, const char *));
-static void lang_do_version_exports_section PARAMS ((void));
-static void lang_check_section_addresses PARAMS ((void));
+static void lang_do_version_exports_section
+  PARAMS ((void));
+static void lang_check_section_addresses
+  PARAMS ((void));
 static void os_region_check
   PARAMS ((lang_output_section_statement_type *,
            struct memory_region_struct *, etree_type *, bfd_vma));
-
-typedef void (*callback_t) PARAMS ((lang_wild_statement_type *,
-                                    asection *, lang_input_statement_type *,
-                                    PTR));
+static bfd_vma lang_size_sections_1
+  PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *,
+           lang_statement_union_type **, fill_type *, bfd_vma, bfd_boolean *,
+           bfd_boolean));
+typedef void (*callback_t)
+  PARAMS ((lang_wild_statement_type *, struct wildcard_list *, asection *,
+           lang_input_statement_type *, PTR));
 static void walk_wild
-  PARAMS ((lang_wild_statement_type *, const char *, const char *,
-         callback_t, PTR));
+  PARAMS ((lang_wild_statement_type *, callback_t, PTR));
 static void walk_wild_section
-  PARAMS ((lang_wild_statement_type *, const char *,
-           lang_input_statement_type *, callback_t, PTR));
+  PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
+           callback_t, PTR));
 static void walk_wild_file
-  PARAMS ((lang_wild_statement_type *, const char *,
-           lang_input_statement_type *, callback_t, PTR));
-
-static int    get_target PARAMS ((const bfd_target *, PTR));
-static void   stricpy PARAMS ((char *, char *));
-static void   strcut PARAMS ((char *, char *));
-static int    name_compare PARAMS ((char *, char *));
-static int    closest_target_match PARAMS ((const bfd_target *, PTR));
-static char * get_first_input_target PARAMS ((void));
-
-/* EXPORTS */
+  PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
+           callback_t, PTR));
+static int get_target
+  PARAMS ((const bfd_target *, PTR));
+static void stricpy
+  PARAMS ((char *, char *));
+static void strcut
+  PARAMS ((char *, char *));
+static int name_compare
+  PARAMS ((char *, char *));
+static int closest_target_match
+  PARAMS ((const bfd_target *, PTR));
+static char * get_first_input_target
+  PARAMS ((void));
+
+/* Exported variables.  */
 lang_output_section_statement_type *abs_output_section;
 lang_statement_list_type lang_output_section_statement;
 lang_statement_list_type *stat_ptr = &statement_list;
 lang_statement_list_type file_chain = { NULL, NULL };
-const char *entry_symbol = NULL;
-boolean entry_from_cmdline;
-boolean lang_has_input_file = false;
-boolean had_output_filename = false;
-boolean lang_float_flag = false;
-boolean delete_output_file_on_failure = false;
+struct bfd_sym_chain entry_symbol = { NULL, NULL };
+const char *entry_section = ".text";
+bfd_boolean entry_from_cmdline;
+bfd_boolean lang_has_input_file = FALSE;
+bfd_boolean had_output_filename = FALSE;
+bfd_boolean lang_float_flag = FALSE;
+bfd_boolean delete_output_file_on_failure = FALSE;
 struct lang_nocrossrefs *nocrossref_list;
 struct unique_sections *unique_section_list;
+static bfd_boolean ldlang_sysrooted_script = FALSE;
 
 etree_type *base; /* Relocation base - or null */
@@ -217 +271 @@
 }
 
-boolean
+bfd_boolean
 unique_section_p (secnam)
      const char *secnam;
@@ -228 +282 @@
         : strcmp (unam->name, secnam) == 0)
       {
-        return true;
+        return TRUE;
       }
 
-  return false;
+  return FALSE;
 }
 
@@ -237 +291 @@
 
 static void
-walk_wild_section (ptr, section, file, callback, data)
+walk_wild_section (ptr, file, callback, data)
      lang_wild_statement_type *ptr;
-     const char *section;
      lang_input_statement_type *file;
      callback_t callback;
      PTR data;
 {
-  /* Don't process sections from files which were excluded.  */
-  if (ptr->exclude_filename_list != NULL)
-    {
-      struct name_list *list_tmp;
-      for (list_tmp = ptr->exclude_filename_list;
-           list_tmp;
-           list_tmp = list_tmp->next)
-        {
-          boolean match;
-
-          if (wildcardp (list_tmp->name))
-            match = fnmatch (list_tmp->name, file->filename, 0) == 0;
-          else
-            match = strcmp (list_tmp->name, file->filename) == 0;
-
-          if (match)
-            return;
-        }
-    }
-
-  if (file->just_syms_flag == false)
-    {
-      register asection *s;
-      boolean wildcard = false;
-
-      if (section != NULL)
-        wildcard = wildcardp (section);
-
-      for (s = file->the_bfd->sections; s != NULL; s = s->next)
-        {
-          boolean match;
-          const char *sname = bfd_get_section_name (file->the_bfd, s);
-
-          if (section == NULL)
-            match = true;
-          else if (wildcard)
-            match = fnmatch (section, sname, 0) == 0;
-          else
-            match = strcmp (section, sname) == 0;
-
-          /* If this is a wild-card output section statement, exclude
-             sections that match UNIQUE_SECTION_LIST.  */
-          if (match && (data == NULL || !unique_section_p (sname)))
-            (*callback) (ptr, s, file, data);
+  asection *s;
+
+  if (file->just_syms_flag)
+    return;
+
+  for (s = file->the_bfd->sections; s != NULL; s = s->next)
+    {
+      struct wildcard_list *sec;
+
+      sec = ptr->section_list;
+      if (sec == NULL)
+        (*callback) (ptr, sec, s, file, data);
+
+      while (sec != NULL)
+        {
+          bfd_boolean skip = FALSE;
+          struct name_list *list_tmp;
+
+          /* Don't process sections from files which were
+             excluded.  */
+          for (list_tmp = sec->spec.exclude_name_list;
+               list_tmp;
+               list_tmp = list_tmp->next)
+            {
+              if (wildcardp (list_tmp->name))
+                skip = fnmatch (list_tmp->name, file->filename, 0) == 0;
+              else
+                skip = strcmp (list_tmp->name, file->filename) == 0;
+
+              /* If this file is part of an archive, and the archive is
+                 excluded, exclude this file.  */
+              if (! skip && file->the_bfd != NULL
+                  && file->the_bfd->my_archive != NULL
+                  && file->the_bfd->my_archive->filename != NULL)
+                {
+                  if (wildcardp (list_tmp->name))
+                    skip = fnmatch (list_tmp->name,
+                                    file->the_bfd->my_archive->filename,
+                                    0) == 0;
+                  else
+                    skip = strcmp (list_tmp->name,
+                                   file->the_bfd->my_archive->filename) == 0;
+                }
+
+              if (skip)
+                break;
+            }
+
+          if (!skip && sec->spec.name != NULL)
+            {
+              const char *sname = bfd_get_section_name (file->the_bfd, s);
+
+              if (wildcardp (sec->spec.name))
+                skip = fnmatch (sec->spec.name, sname, 0) != 0;
+              else
+                skip = strcmp (sec->spec.name, sname) != 0;
+            }
+
+          if (!skip)
+            (*callback) (ptr, sec, s, file, data);
+
+          sec = sec->next;
         }
     }
@@ -295 +366 @@
 
 static void
-walk_wild_file (s, section, f, callback, data)
+walk_wild_file (s, f, callback, data)
      lang_wild_statement_type *s;
-     const char *section;
      lang_input_statement_type *f;
      callback_t callback;
@@ -304 +374 @@
   if (f->the_bfd == NULL
       || ! bfd_check_format (f->the_bfd, bfd_archive))
-    walk_wild_section (s, section, f, callback, data);
+    walk_wild_section (s, f, callback, data);
   else
     {
@@ -321 +391 @@
           if (member->usrdata != NULL)
             {
-              walk_wild_section (s, section,
+              walk_wild_section (s,
                                  (lang_input_statement_type *) member->usrdata,
                                  callback, data);
@@ -332 +402 @@
 
 static void
-walk_wild (s, section, file, callback, data)
+walk_wild (s, callback, data)
      lang_wild_statement_type *s;
-     const char *section;
-     const char *file;
      callback_t callback;
      PTR data;
 {
-  if (file == (char *) NULL)
+  const char *file_spec = s->filename;
+
+  if (file_spec == NULL)
     {
       /* Perform the iteration over all files in the list.  */
       LANG_FOR_EACH_INPUT_STATEMENT (f)
         {
-          walk_wild_file (s, section, f, callback, data);
-        }
-    }
-  else if (wildcardp (file))
+          walk_wild_file (s, f, callback, data);
+        }
+    }
+  else if (wildcardp (file_spec))
     {
       LANG_FOR_EACH_INPUT_STATEMENT (f)
         {
-          if (fnmatch (file, f->filename, FNM_FILE_NAME) == 0)
-            walk_wild_file (s, section, f, callback, data);
+          if (fnmatch (file_spec, f->filename, FNM_FILE_NAME) == 0)
+            walk_wild_file (s, f, callback, data);
         }
     }
@@ -360 +430 @@
 
       /* Perform the iteration over a single file.  */
-      f = lookup_name (file);
-      walk_wild_file (s, section, f, callback, data);
+      f = lookup_name (file_spec);
+      if (f)
+        walk_wild_file (s, f, callback, data);
     }
 }
@@ -373 +444 @@
      lang_statement_union_type *s;
 {
-  for (; s != (lang_statement_union_type *) NULL; s = s->next)
+  for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
     {
       func (s);
@@ -454 +525 @@
 
    We can be supplied with requests for input files more than once;
-   they may, for example be split over serveral 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
    got it already so we don't duplicate the bfd.  */
@@ -463 +534 @@
      lang_input_file_enum_type file_type;
      const char *target;
-     boolean add_to_list;
+     bfd_boolean add_to_list;
 {
   lang_input_statement_type *p;
@@ -476 +547 @@
     }
 
-  lang_has_input_file = true;
+  lang_has_input_file = TRUE;
   p->target = target;
+  p->sysrooted = FALSE;
   switch (file_type)
     {
     case lang_input_file_is_symbols_only_enum:
       p->filename = name;
-      p->is_archive = false;
-      p->real = true;
+      p->is_archive = FALSE;
+      p->real = TRUE;
       p->local_sym_name = name;
-      p->just_syms_flag = true;
-      p->search_dirs_flag = false;
+      p->just_syms_flag = TRUE;
+      p->search_dirs_flag = FALSE;
       break;
     case lang_input_file_is_fake_enum:
       p->filename = name;
-      p->is_archive = false;
-      p->real = false;
+      p->is_archive = FALSE;
+      p->real = FALSE;
       p->local_sym_name = name;
-      p->just_syms_flag = false;
-      p->search_dirs_flag = false;
+      p->just_syms_flag = FALSE;
+      p->search_dirs_flag = FALSE;
       break;
     case lang_input_file_is_l_enum:
-      p->is_archive = true;
+      p->is_archive = TRUE;
       p->filename = name;
-      p->real = true;
+      p->real = TRUE;
       p->local_sym_name = concat ("-l", name, (const char *) NULL);
-      p->just_syms_flag = false;
-      p->search_dirs_flag = true;
+      p->just_syms_flag = FALSE;
+      p->search_dirs_flag = TRUE;
       break;
     case lang_input_file_is_marker_enum:
       p->filename = name;
-      p->is_archive = false;
-      p->real = false;
+      p->is_archive = FALSE;
+      p->real = FALSE;
       p->local_sym_name = name;
-      p->just_syms_flag = false;
-      p->search_dirs_flag = true;
+      p->just_syms_flag = FALSE;
+      p->search_dirs_flag = TRUE;
       break;
     case lang_input_file_is_search_file_enum:
+      p->sysrooted = ldlang_sysrooted_script;
       p->filename = name;
-      p->is_archive = false;
-      p->real = true;
+      p->is_archive = FALSE;
+      p->real = TRUE;
       p->local_sym_name = name;
-      p->just_syms_flag = false;
-      p->search_dirs_flag = true;
+      p->just_syms_flag = FALSE;
+      p->search_dirs_flag = TRUE;
       break;
     case lang_input_file_is_file_enum:
       p->filename = name;
-      p->is_archive = false;
-      p->real = true;
+      p->is_archive = FALSE;
+      p->real = TRUE;
       p->local_sym_name = name;
-      p->just_syms_flag = false;
-      p->search_dirs_flag = false;
+      p->just_syms_flag = FALSE;
+      p->search_dirs_flag = FALSE;
       break;
     default:
@@ -538 +611 @@
   p->dynamic = config.dynamic_link;
   p->whole_archive = whole_archive;
-  p->loaded = false;
+  p->loaded = FALSE;
   lang_statement_append (&input_file_chain,
                          (lang_statement_union_type *) p,
@@ -551 +624 @@
      const char *target;
 {
-  lang_has_input_file = true;
-  return new_afile (name, file_type, target, true);
+  lang_has_input_file = TRUE;
+  return new_afile (name, file_type, target, TRUE);
 }
 
@@ -598 +671 @@
   lang_memory_region_type *p;
 
+  /* NAME is NULL for LMA memspecs if no region was specified.  */
+  if (name == NULL)
+    return NULL;
+
   for (p = lang_memory_region_list;
        p != (lang_memory_region_type *) NULL;
@@ -638 +715 @@
     new->length = ~(bfd_size_type) 0;
     new->current = 0;
-    new->had_full_message = false;
+    new->had_full_message = FALSE;
 
     return new;
@@ -703 +780 @@
       lookup->region = (lang_memory_region_type *) NULL;
       lookup->lma_region = (lang_memory_region_type *) NULL;
-      lookup->fill = 0;
+      lookup->fill = (fill_type *) 0;
       lookup->block_value = 1;
       lookup->name = name;
@@ -709 +786 @@
       lookup->next = (lang_statement_union_type *) NULL;
       lookup->bfd_section = (asection *) NULL;
-      lookup->processed = false;
+      lookup->processed = FALSE;
       lookup->sectype = normal_section;
       lookup->addr_tree = (etree_type *) NULL;
@@ -719 +796 @@
       lookup->section_alignment = -1;
       lookup->load_base = (union etree_union *) NULL;
+      lookup->update_dot_tree = NULL;
       lookup->phdrs = NULL;
 
@@ -814 +892 @@
 
   if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
-    einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME);
+    einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
 
   new = ((section_userdata_type *)
@@ -838 +916 @@
   if (s->addr_tree != NULL)
     exp_init_os (s->addr_tree);
+
+  if (s->load_base != NULL)
+    exp_init_os (s->load_base);
 }
 
@@ -936 +1017 @@
   if (entry->just_syms_flag)
     {
-      sec->output_section = bfd_abs_section_ptr;
-      sec->output_offset = sec->vma;
+      bfd_link_just_syms (sec, &link_info);
       return;
     }
@@ -960 +1040 @@
 
      Also, not merging link once sections in a relocatable link
-     causes trouble for MIPS ELF, which relies in link once semantics
+     causes trouble for MIPS ELF, which relies on link once semantics
      to handle the .reginfo section correctly.  */
 
@@ -967 +1047 @@
   already_linked_list =
     ((struct already_linked_hash_entry *)
-     bfd_hash_lookup (&already_linked_table, name, true, false));
+     bfd_hash_lookup (&already_linked_table, name, TRUE, FALSE));
 
   for (l = already_linked_list->entry; l != NULL; l = l->next)
@@ -1009 +1089 @@
             }
 
-          /* Set the output_section field so that wild_doit does not
-             create a lang_input_section structure for this section.
-             Since there might be a symbol in the section being
-             discarded, we must retain a pointer to the section which
-             we are really going to use.  */
+          /* Set the output_section field so that lang_add_section
+             does not create a lang_input_section structure for this
+             section.  */
           sec->output_section = bfd_abs_section_ptr;
-          sec->kept_section = l->sec;
+
+          if (flags & SEC_GROUP)
+            bfd_discard_group (abfd, sec);
 
           return;
@@ -1071 +1151 @@
    foo.o(.text, .data).  */
 
-/* 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
    wildcards, we do not consider the mere presence of a backslash to
-   be enough to cause the 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.  */
 
-static boolean
+static bfd_boolean
 wildcardp (pattern)
      const char *pattern;
@@ -1087 +1167 @@
         || *s == '*'
         || *s == '[')
-      return true;
-  return false;
+      return TRUE;
+  return FALSE;
 }
 
@@ -1096 +1176 @@
 
 void
-wild_doit (ptr, section, output, file)
+lang_add_section (ptr, section, output, file)
      lang_statement_list_type *ptr;
      asection *section;
@@ -1103 +1183 @@
 {
   flagword flags;
-  boolean discard;
+  bfd_boolean discard;
 
   flags = bfd_get_section_flags (section->owner, section);
 
-  discard = false;
-
-  /* If we are doing a final link, discard sections marked with
-     SEC_EXCLUDE.  */
-  if (! link_info.relocateable
-      && (flags & SEC_EXCLUDE) != 0)
-    discard = true;
+  discard = FALSE;
+
+  /* Discard sections marked with SEC_EXCLUDE if we are doing a final
+     link.  Discard debugging sections marked with SEC_EXCLUDE on a
+     relocatable link too.  */
+  if ((flags & SEC_EXCLUDE) != 0
+      && ((flags & SEC_DEBUGGING) != 0 || !link_info.relocateable))
+    discard = TRUE;
 
   /* Discard input sections which are assigned to a section named
      DISCARD_SECTION_NAME.  */
   if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
-    discard = true;
+    discard = TRUE;
 
   /* Discard debugging sections if we are stripping debugging
@@ -1124 +1205 @@
   if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
       && (flags & SEC_DEBUGGING) != 0)
-    discard = true;
+    discard = TRUE;
 
   if (discard)
@@ -1138 +1219 @@
   if (section->output_section == NULL)
     {
-      boolean first;
+      bfd_boolean first;
       lang_input_section_type *new;
       flagword flags;
@@ -1181 +1262 @@
         flags &= ~ SEC_READONLY;
 
+      /* Keep SEC_MERGE and SEC_STRINGS only if they are the same.  */
+      if (! first
+          && ((section->output_section->flags & (SEC_MERGE | SEC_STRINGS))
+              != (flags & (SEC_MERGE | SEC_STRINGS))
+              || ((flags & SEC_MERGE)
+                  && section->output_section->entsize != section->entsize)))
+        {
+          section->output_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
+          flags &= ~ (SEC_MERGE | SEC_STRINGS);
+        }
+
+      /* For now make .tbss normal section.  */
+      if ((flags & SEC_THREAD_LOCAL) && ! link_info.relocateable)
+        flags |= SEC_LOAD;
+
       section->output_section->flags |= flags;
+
+      if (flags & SEC_MERGE)
+        section->output_section->entsize = section->entsize;
 
       /* If SEC_READONLY is not set in the input section, then clear
@@ -1211 +1310 @@
         output->bfd_section->alignment_power = section->alignment_power;
 
-      /* If supplied an aligment, then force it.  */
+      /* If supplied an alignment, then force it.  */
       if (output->section_alignment != -1)
         output->bfd_section->alignment_power = output->section_alignment;
@@ -1230 +1329 @@
 
 static lang_statement_union_type *
-wild_sort (wild, file, section)
+wild_sort (wild, sec, file, section)
      lang_wild_statement_type *wild;
+     struct wildcard_list *sec;
      lang_input_statement_type *file;
      asection *section;
@@ -1238 +1338 @@
   lang_statement_union_type *l;
 
-  if (! wild->filenames_sorted && ! wild->sections_sorted)
+  if (!wild->filenames_sorted && (sec == NULL || !sec->spec.sorted))
     return NULL;
 
   section_name = bfd_get_section_name (file->the_bfd, section);
-  for (l = wild->children.head; l != NULL; l = l->next)
+  for (l = wild->children.head; l != NULL; l = l->header.next)
     {
       lang_input_section_type *ls;
@@ -1256 +1356 @@
         {
           const char *fn, *ln;
-          boolean fa, la;
+          bfd_boolean fa, la;
           int i;
 
@@ -1268 +1368 @@
             {
               fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
-              fa = true;
+              fa = TRUE;
             }
           else
             {
               fn = file->filename;
-              fa = false;
+              fa = FALSE;
             }
 
@@ -1280 +1380 @@
             {
               ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
-              la = true;
+              la = TRUE;
             }
           else
             {
               ln = ls->ifile->filename;
-              la = false;
+              la = FALSE;
             }
 
@@ -1312 +1412 @@
          looking at the sections for this file.  */
 
-      if (wild->sections_sorted)
+      if (sec != NULL && sec->spec.sorted)
         {
           if (strcmp (section_name,
@@ -1329 +1429 @@
 
 static void
-output_section_callback (ptr, section, file, output)
+output_section_callback (ptr, sec, section, file, output)
      lang_wild_statement_type *ptr;
+     struct wildcard_list *sec;
      asection *section;
      lang_input_statement_type *file;
@@ -1336 +1437 @@
 {
   lang_statement_union_type *before;
+
+  /* Exclude sections that match UNIQUE_SECTION_LIST.  */
+  if (unique_section_p (bfd_get_section_name (file->the_bfd, section)))
+    return;
 
   /* If the wild pattern was marked KEEP, the member sections
@@ -1342 +1447 @@
     section->flags |= SEC_KEEP;
 
-  before = wild_sort (ptr, file, section);
+  before = wild_sort (ptr, sec, file, section);
 
   /* Here BEFORE points to the lang_input_section which
@@ -1350 +1455 @@
 
   if (before == NULL)
-    wild_doit (&ptr->children, section,
-               (lang_output_section_statement_type *) output,
-               file);
+    lang_add_section (&ptr->children, section,
+                      (lang_output_section_statement_type *) output,
+                      file);
   else
     {
@@ -1359 +1464 @@
 
       lang_list_init (&list);
-      wild_doit (&list, section,
-                 (lang_output_section_statement_type *) output,
-                 file);
+      lang_add_section (&list, section,
+                        (lang_output_section_statement_type *) output,
+                        file);
 
       /* If we are discarding the section, LIST.HEAD will
@@ -1367 +1472 @@
       if (list.head != NULL)
         {
-          ASSERT (list.head->next == NULL);
+          ASSERT (list.head->header.next == NULL);
 
           for (pp = &ptr->children.head;
                *pp != before;
-               pp = &(*pp)->next)
+               pp = &(*pp)->header.next)
             ASSERT (*pp != NULL);
 
-          list.head->next = *pp;
+          list.head->header.next = *pp;
           *pp = list.head;
         }
@@ -1404 +1509 @@
   if (search == (lang_input_statement_type *) NULL)
     search = new_afile (name, lang_input_file_is_file_enum, default_target,
-                        false);
+                        FALSE);
 
   /* If we have already added this file, or this file is not real
@@ -1414 +1519 @@
     return search;
 
-  load_symbols (search, (lang_statement_list_type *) NULL);
+  if (! load_symbols (search, (lang_statement_list_type *) NULL))
+    return NULL;
 
   return search;
@@ -1421 +1527 @@
 /* Get the symbols for an input file.  */
 
-static void
+static bfd_boolean
 load_symbols (entry, place)
      lang_input_statement_type *entry;
@@ -1429 +1535 @@
 
   if (entry->loaded)
-    return;
+    return TRUE;
 
   ldfile_open_file (entry);
@@ -1438 +1544 @@
       bfd_error_type err;
       lang_statement_list_type *hold;
+      bfd_boolean bad_load = TRUE;
+      bfd_boolean save_ldlang_sysrooted_script;
 
       err = bfd_get_error ();
@@ -1443 +1551 @@
       /* See if the emulation has some special knowledge.  */
       if (ldemul_unrecognized_file (entry))
-        return;
+        return TRUE;
 
       if (err == bfd_error_file_ambiguously_recognized)
@@ -1457 +1565 @@
       else if (err != bfd_error_file_not_recognized
                || 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
+        bad_load = FALSE;
 
       bfd_close (entry->the_bfd);
@@ -1467 +1577 @@
       hold = stat_ptr;
       stat_ptr = place;
-
-      ldfile_assumed_script = true;
+      save_ldlang_sysrooted_script = ldlang_sysrooted_script;
+      ldlang_sysrooted_script = entry->sysrooted;
+
+      ldfile_assumed_script = TRUE;
       parser_input = input_script;
       yyparse ();
-      ldfile_assumed_script = false;
-
+      ldfile_assumed_script = FALSE;
+
+      ldlang_sysrooted_script = save_ldlang_sysrooted_script;
       stat_ptr = hold;
 
-      return;
+      return ! bad_load;
     }
 
   if (ldemul_recognized_file (entry))
-    return;
+    return TRUE;
 
   /* We don't call ldlang_add_file for an archive.  Instead, the
@@ -1499 +1612 @@
       if (entry->whole_archive)
         {
-          bfd *member = bfd_openr_next_archived_file (entry->the_bfd,
-                                                      (bfd *) NULL);
-          while (member != NULL)
+          bfd *member = NULL;
+          bfd_boolean loaded = TRUE;
+
+          for (;;)
             {
+              member = bfd_openr_next_archived_file (entry->the_bfd, member);
+
+              if (member == NULL)
+                break;
+
               if (! bfd_check_format (member, bfd_object))
-                einfo (_("%F%B: object %B in archive is not object\n"),
-                       entry->the_bfd, member);
+                {
+                  einfo (_("%F%B: member %B in archive is not an object\n"),
+                         entry->the_bfd, member);
+                  loaded = FALSE;
+                }
+
               if (! ((*link_info.callbacks->add_archive_element)
                      (&link_info, member, "--whole-archive")))
                 abort ();
+
               if (! bfd_link_add_symbols (member, &link_info))
-                einfo (_("%F%B: could not read symbols: %E\n"), member);
-              member = bfd_openr_next_archived_file (entry->the_bfd,
-                                                     member);
+                {
+                  einfo (_("%F%B: could not read symbols: %E\n"), member);
+                  loaded = FALSE;
+                }
             }
 
-          entry->loaded = true;
-
-          return;
-        }
-    }
-
-  if (! bfd_link_add_symbols (entry->the_bfd, &link_info))
+          entry->loaded = loaded;
+          return loaded;
+        }
+      break;
+    }
+
+  if (bfd_link_add_symbols (entry->the_bfd, &link_info))
+    entry->loaded = TRUE;
+  else
     einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
 
-  entry->loaded = true;
-}
-
-/* Handle a wild statement.  SECTION or FILE or both may be NULL,
-   indicating that it is a wildcard.  Separate lang_input_section
-   statements are created for each part of the expansion; they are
-   added after the wild statement S.  OUTPUT is the output section.  */
+  return entry->loaded;
+}
+
+/* Handle a wild statement.  S->FILENAME or S->SECTION_LIST or both
+   may be NULL, indicating that it is a wildcard.  Separate
+   lang_input_section statements are created for each part of the
+   expansion; they are added after the wild statement S.  OUTPUT is
+   the output section.  */
 
 static void
-wild (s, section, file, target, output)
+wild (s, target, output)
      lang_wild_statement_type *s;
-     const char *section;
-     const char *file;
      const char *target ATTRIBUTE_UNUSED;
      lang_output_section_statement_type *output;
 {
-  walk_wild (s, section, file, output_section_callback, (PTR) output);
-
-  if (section != (char *) NULL
-      && strcmp (section, "COMMON") == 0
-      && default_common_section == NULL)
-    {
-      /* Remember the section that common is going to in case we later
-         get something which doesn't know where to put it.  */
-      default_common_section = output;
-    }
-}
-
-/* Return true iff target is the sought target.  */
+  struct wildcard_list *sec;
+
+  walk_wild (s, output_section_callback, (PTR) output);
+
+  for (sec = s->section_list; sec != NULL; sec = sec->next)
+    {
+      if (default_common_section != NULL)
+        break;
+      if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
+        {
+          /* Remember the section that common is going to in case we
+             later get something which doesn't know where to put it.  */
+          default_common_section = output;
+        }
+    }
+}
+
+/* Return TRUE iff target is the sought target.  */
 
 static int
@@ -1574 +1705 @@
 
   while ((c = *src++) != 0)
-    {
-      if (isupper ((unsigned char) c))
-        c = tolower (c);
-
-      *dest++ = c;
-    }
+    *dest++ = TOLOWER (c);
 
   *dest = 0;
 }
 
-/* Remove the first occurance of needle (if any) in haystack
+/* Remove the first occurrence of needle (if any) in haystack
    from haystack.  */
 
@@ -1717 +1843 @@
 }
 
+const char *
+lang_get_output_target ()
+{
+  const char *target;
+
+  /* Has the user told us which output format to use?  */
+  if (output_target != (char *) NULL)
+    return output_target;
+
+  /* No - has the current target been set to something other than
+     the default?  */
+  if (current_target != default_target)
+    return current_target;
+
+  /* No - can we determine the format of the first input file?  */
+  target = get_first_input_target ();
+  if (target != NULL)
+    return target;
+
+  /* Failed - use the default output target.  */
+  return default_target;
+}
+
 /* Open the output file.  */
 
@@ -1725 +1874 @@
   bfd *output;
 
-  /* Has the user told us which output format to use?  */
-  if (output_target == (char *) NULL)
-    {
-      /* No - has the current target been set to something other than
-         the default?  */
-      if (current_target != default_target)
-        output_target = current_target;
-
-      /* No - can we determine the format of the first input file?  */
-      else
-        {
-          output_target = get_first_input_target ();
-
-          /* Failed - use the default output target.  */
-          if (output_target == NULL)
-            output_target = default_target;
-        }
-    }
+  output_target = lang_get_output_target ();
 
   /* Has the user requested a particular endianness on the command
@@ -1802 +1934 @@
     }
 
-  delete_output_file_on_failure = true;
+  delete_output_file_on_failure = TRUE;
 
 #if 0
@@ -1860 +1992 @@
 open_input_bfds (s, force)
      lang_statement_union_type *s;
-     boolean force;
-{
-  for (; s != (lang_statement_union_type *) NULL; s = s->next)
+     bfd_boolean force;
+{
+  for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
     {
       switch (s->header.type)
@@ -1890 +2022 @@
               {
                 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);
@@ -1914 +2046 @@
                   && bfd_check_format (s->input_statement.the_bfd,
                                        bfd_archive))
-                s->input_statement.loaded = false;
+                s->input_statement.loaded = FALSE;
 
               lang_list_init (&add);
 
-              load_symbols (&s->input_statement, &add);
+              if (! load_symbols (&s->input_statement, &add))
+                config.make_executable = FALSE;
 
               if (add.head != NULL)
                 {
-                  *add.tail = s->next;
-                  s->next = add.head;
+                  *add.tail = s->header.next;
+                  s->header.next = add.head;
                 }
             }
@@ -1945 +2078 @@
   default_common_section = lang_output_section_statement_lookup (".bss");
 
-  if (placed_commons == false)
+  if (!placed_commons)
     {
       lang_wild_statement_type *new =
@@ -1959 +2092 @@
 
 /* Add the supplied name to the symbol table as an undefined reference.
-   Remove items from the chain as we open input bfds.  */
-typedef struct ldlang_undef_chain_list
-{
-  struct ldlang_undef_chain_list *next;
-  char *name;
-}                       ldlang_undef_chain_list_type;
-
-static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
+   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
+   on a list, then, once the output file has been opened, transfer the
+   name to the symbol table.  */
+
+typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
+
+#define ldlang_undef_chain_list_head entry_symbol.next
 
 void
@@ -1980 +2113 @@
 
   new->name = xstrdup (name);
+
+  if (output_bfd != NULL)
+    insert_undefined (new->name);
+}
+
+/* Insert NAME as undefined in the symbol table.  */
+
+static void
+insert_undefined (name)
+     const char *name;
+{
+  struct bfd_link_hash_entry *h;
+
+  h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
+  if (h == (struct bfd_link_hash_entry *) NULL)
+    einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
+  if (h->type == bfd_link_hash_new)
+    {
+      h->type = bfd_link_hash_undefined;
+      h->u.undef.abfd = NULL;
+      bfd_link_add_undef (link_info.hash, h);
+    }
 }
 
@@ -1995 +2150 @@
        ptr = ptr->next)
     {
-      struct bfd_link_hash_entry *h;
-
-      h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
-      if (h == (struct bfd_link_hash_entry *) NULL)
-        einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
-      if (h->type == bfd_link_hash_new)
-        {
-          h->type = bfd_link_hash_undefined;
-          h->u.undef.abfd = NULL;
-          bfd_link_add_undef (link_info.hash, h);
-        }
-    }
-}
-
-/* Open input files and attatch to output sections.  */
+      insert_undefined (ptr->name);
+    }
+}
+
+/* Open input files and attach to output sections.  */
 
 static void
@@ -2017 +2162 @@
      lang_output_section_statement_type *output_section_statement;
 {
-  for (; s != (lang_statement_union_type *) NULL; s = s->next)
+  for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
     {
       switch (s->header.type)
         {
-
         case lang_wild_statement_enum:
-          wild (&s->wild_statement, s->wild_statement.section_name,
-                s->wild_statement.filename, target,
-                output_section_statement);
-
+          wild (&s->wild_statement, target, output_section_statement);
           break;
         case lang_constructors_statement_enum:
@@ -2083 +2224 @@
           }
           break;
+        }
+    }
+}
+
+/* An output section might have been removed after its statement was
+   added.  For example, ldemul_before_allocation can remove dynamic
+   sections if they turn out to be not needed.  Clean them up here.  */
+
+static void
+strip_excluded_output_sections ()
+{
+  lang_statement_union_type *u;
+
+  for (u = lang_output_section_statement.head;
+       u != NULL;
+       u = u->output_section_statement.next)
+    {
+      lang_output_section_statement_type *os;
+      asection *s;
+
+      os = &u->output_section_statement;
+      s = os->bfd_section;
+      if (s != NULL && (s->flags & SEC_EXCLUDE) != 0)
+        {
+          asection **p;
+
+          os->bfd_section = NULL;
+
+          for (p = &output_bfd->sections; *p; p = &(*p)->next)
+            if (*p == s)
+              {
+                bfd_section_list_remove (output_bfd, p);
+                output_bfd->section_count--;
+                break;
+              }
         }
     }
@@ -2147 +2323 @@
                           lang_final_phase_enum, print_dot, &print_dot);
   if (result.valid_p)
-    minfo ("0x%V", result.value + result.section->bfd_section->vma);
+    {
+      const char *dst;
+      bfd_vma value;
+
+      value = result.value + result.section->bfd_section->vma;
+      dst = assignment->exp->assign.dst;
+
+      minfo ("0x%V", value);
+      if (dst[0] == '.' && dst[1] == 0)
+        print_dot = value;
+    }
   else
     {
@@ -2176 +2362 @@
    via bfd_link_hash_traverse.  */
 
-static boolean
+static bfd_boolean
 print_one_symbol (hash_entry, ptr)
      struct bfd_link_hash_entry *hash_entry;
@@ -2199 +2385 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -2266 +2452 @@
      lang_fill_statement_type *fill;
 {
-  fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill);
+  size_t size;
+  unsigned char *p;
+  fputs (" FILL mask 0x", config.map_file);
+  for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
+    fprintf (config.map_file, "%02x", *p);
+  fputs ("\n", config.map_file);
 }
 
@@ -2395 +2586 @@
   if (s->output_section != NULL)
     addr += s->output_section->vma;
-  minfo ("0x%V %W", addr, s->size);
-
-  if (s->fill != 0)
-    minfo (" %u", s->fill);
+  minfo ("0x%V %W ", addr, s->size);
+
+  if (s->fill->size != 0)
+    {
+      size_t size;
+      unsigned char *p;
+      for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
+        fprintf (config.map_file, "%02x", *p);
+    }
 
   print_nl ();
@@ -2410 +2606 @@
      lang_output_section_statement_type *os;
 {
+  struct wildcard_list *sec;
+
   print_space ();
 
   if (w->filenames_sorted)
     minfo ("SORT(");
-  if (w->exclude_filename_list != NULL)
-    {
-      name_list *tmp;
-      minfo ("EXCLUDE_FILE ( %s", w->exclude_filename_list->name);
-      for (tmp = w->exclude_filename_list->next; tmp; tmp = tmp->next)
-        minfo (", %s", tmp->name);
-      minfo (")");
-    }
   if (w->filename != NULL)
     minfo ("%s", w->filename);
@@ -2430 +2620 @@
 
   minfo ("(");
-  if (w->sections_sorted)
-    minfo ("SORT(");
-  if (w->section_name != NULL)
-    minfo ("%s", w->section_name);
-  else
-    minfo ("*");
-  if (w->sections_sorted)
-    minfo (")");
+  for (sec = w->section_list; sec; sec = sec->next)
+    {
+      if (sec->spec.sorted)
+        minfo ("SORT(");
+      if (sec->spec.exclude_name_list != NULL)
+        {
+          name_list *tmp;
+          minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
+          for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
+            minfo (" %s", tmp->name);
+          minfo (") ");
+        }
+      if (sec->spec.name != NULL)
+        minfo ("%s", sec->spec.name);
+      else
+        minfo ("*");
+      if (sec->spec.sorted)
+        minfo (")");
+      if (sec->next)
+        minfo (" ");
+    }
   minfo (")");
 
@@ -2468 +2671 @@
     {
       print_statement (s, os);
-      s = s->next;
+      s = s->header.next;
     }
 }
@@ -2574 +2777 @@
         {
           print_statement (s, abs_output_section);
-          s = s->next;
+          s = s->header.next;
         }
     }
@@ -2581 +2784 @@
 }
 
+static void
+insert_pad (ptr, fill, alignment_needed, output_section, dot)
+     lang_statement_union_type **ptr;
+     fill_type *fill;
+     unsigned int alignment_needed;
+     asection *output_section;
+     bfd_vma dot;
+{
+  static fill_type zero_fill = { 1, { 0 } };
+  lang_statement_union_type *pad;
+
+  pad = ((lang_statement_union_type *)
+         ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
+  if (ptr != &statement_list.head
+      && pad->header.type == lang_padding_statement_enum
+      && pad->padding_statement.output_section == output_section)
+    {
+      /* Use the existing pad statement.  The above test on output
+         section is probably redundant, but it doesn't hurt to check.  */
+    }
+  else
+    {
+      /* Make a new padding statement, linked into existing chain.  */
+      pad = ((lang_statement_union_type *)
+             stat_alloc (sizeof (lang_padding_statement_type)));
+      pad->header.next = *ptr;
+      *ptr = pad;
+      pad->header.type = lang_padding_statement_enum;
+      pad->padding_statement.output_section = output_section;
+      if (fill == (fill_type *) 0)
+        fill = &zero_fill;
+      pad->padding_statement.fill = fill;
+    }
+  pad->padding_statement.output_offset = dot - output_section->vma;
+  pad->padding_statement.size = alignment_needed;
+  output_section->_raw_size += alignment_needed;
+}
+
+/* Work out how much this section will move the dot point.  */
+
 static bfd_vma
-insert_pad (this_ptr, fill, power, output_section_statement, dot)
-     lang_statement_union_type **this_ptr;
-     fill_type fill;
-     unsigned int power;
-     asection *output_section_statement;
-     bfd_vma dot;
-{
-  /* Align this section first to the
-     input sections requirement, then
-     to the output section's requirement.
-     If this alignment is > than any seen before,
-     then record it too. Perform the alignment by
-     inserting a magic 'padding' statement.  */
-
-  unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
-                                                ldfile_output_machine);
-  unsigned int alignment_needed = align_power (dot, power) - dot;
-
-  if (alignment_needed != 0)
-    {
-      lang_statement_union_type *new =
-        ((lang_statement_union_type *)
-         stat_alloc (sizeof (lang_padding_statement_type)));
-
-      /* Link into existing chain.  */
-      new->header.next = *this_ptr;
-      *this_ptr = new;
-      new->header.type = lang_padding_statement_enum;
-      new->padding_statement.output_section = output_section_statement;
-      new->padding_statement.output_offset =
-        dot - output_section_statement->vma;
-      new->padding_statement.fill = fill;
-      new->padding_statement.size = alignment_needed * opb;
-    }
-
-  /* Remember the most restrictive alignment.  */
-  if (power > output_section_statement->alignment_power)
-    {
-      output_section_statement->alignment_power = power;
-    }
-  output_section_statement->_raw_size += alignment_needed * opb;
-
-  return dot + alignment_needed;
-}
-
-/* Work out how much this section will move the dot point.  */
-
-static bfd_vma
-size_input_section (this_ptr, output_section_statement, fill, dot, relax)
+size_input_section (this_ptr, output_section_statement, fill, dot)
      lang_statement_union_type **this_ptr;
      lang_output_section_statement_type *output_section_statement;
-     fill_type fill;
+     fill_type *fill;
      bfd_vma dot;
-     boolean relax ATTRIBUTE_UNUSED;
 {
   lang_input_section_type *is = &((*this_ptr)->input_section);
   asection *i = is->section;
-  unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
-                                                ldfile_output_machine);
-
-  if (is->ifile->just_syms_flag == false)
-    {
+
+  if (!is->ifile->just_syms_flag)
+    {
+      unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
+                                                    ldfile_output_machine);
+      unsigned int alignment_needed;
+      asection *o;
+
+      /* Align this section first to the input sections requirement,
+         then to the output section's requirement.  If this alignment
+         is greater than any seen before, then record it too.  Perform
+         the alignment by inserting a magic 'padding' statement.  */
+
       if (output_section_statement->subsection_alignment != -1)
-       i->alignment_power =
-        output_section_statement->subsection_alignment;
-
-      dot = insert_pad (this_ptr, fill, i->alignment_power,
-                        output_section_statement->bfd_section, dot);
+        i->alignment_power = output_section_statement->subsection_alignment;
+
+      o = output_section_statement->bfd_section;
+      if (o->alignment_power < i->alignment_power)
+        o->alignment_power = i->alignment_power;
+
+      alignment_needed = align_power (dot, i->alignment_power) - dot;
+
+      if (alignment_needed != 0)
+        {
+          insert_pad (this_ptr, fill, alignment_needed * opb, o, dot);
+          dot += alignment_needed;
+        }
 
       /* Remember where in the output section this input section goes.  */
 
-      i->output_offset = dot - output_section_statement->bfd_section->vma;
+      i->output_offset = dot - o->vma;
 
       /* Mark how big the output section must be to contain this now.  */
@@ -2660 +2870 @@
       else
         dot += i->_raw_size / opb;
-      output_section_statement->bfd_section->_raw_size =
-        (dot - output_section_statement->bfd_section->vma) * opb;
+      o->_raw_size = (dot - o->vma) * opb;
     }
   else
@@ -2732 +2941 @@
 }
 
-/* This variable indicates whether bfd_relax_section should be called
-   again.  */
-
-static boolean relax_again;
-
 /* 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
@@ -2752 +2956 @@
        || (region->current - region->origin > region->length))
       && ((region->current != region->origin + region->length)
-           || base == 0))
+          || base == 0))
     {
       if (tree != (etree_type *) NULL)
-        {
-          einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
-                 region->current,
-                 os->bfd_section->owner,
-                 os->bfd_section->name,
-                 region->name);
-        }
+        {
+          einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
+                 region->current,
+                 os->bfd_section->owner,
+                 os->bfd_section->name,
+                 region->name);
+        }
       else
-        {
-          einfo (_("%X%P: region %s is full (%B section %s)\n"),
-                 region->name,
-                 os->bfd_section->owner,
-                 os->bfd_section->name);
-        }
+        {
+          einfo (_("%X%P: region %s is full (%B section %s)\n"),
+                 region->name,
+                 os->bfd_section->owner,
+                 os->bfd_section->name);
+        }
       /* Reset the region pointer.  */
       region->current = region->origin;
@@ -2776 +2980 @@
 /* Set the sizes for all the output sections.  */
 
-bfd_vma
-lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
+static bfd_vma
+lang_size_sections_1 (s, output_section_statement, prev, fill, dot, relax,
+                      check_regions)
      lang_statement_union_type *s;
      lang_output_section_statement_type *output_section_statement;
      lang_statement_union_type **prev;
-     fill_type fill;
+     fill_type *fill;
      bfd_vma dot;
-     boolean relax;
+     bfd_boolean *relax;
+     bfd_boolean check_regions;
 {
   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
@@ -2789 +2995 @@
 
   /* Size up the sections from their constituent parts.  */
-  for (; s != (lang_statement_union_type *) NULL; s = s->next)
+  for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
     {
       switch (s->header.type)
@@ -2812 +3018 @@
 
                 if (os->children.head == NULL
-                    || os->children.head->next != NULL
+                    || os->children.head->header.next != NULL
                     || os->children.head->header.type != lang_input_section_enum)
                   einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
@@ -2850 +3056 @@
                     if ((bfd_get_section_flags (output_bfd, os->bfd_section)
                          & (SEC_ALLOC | SEC_LOAD)) != 0
+                        && (bfd_get_section_flags (output_bfd, os->bfd_section)
+                            & SEC_NEVER_LOAD) == 0
                         && ! link_info.relocateable
+                        && check_regions
                         && strcmp (os->region->name, "*default*") == 0
                         && lang_memory_region_list != NULL
@@ -2883 +3092 @@
                                        lang_allocating_phase_enum,
                                        dot, &dot);
-                    if (r.valid_p == false)
-                      {
-                        einfo (_("%F%S: non constant address expression for section %s\n"),
-                               os->name);
-                      }
+                    if (!r.valid_p)
+                      einfo (_("%F%S: non constant address expression for section %s\n"),
+                             os->name);
+
                     dot = r.value + r.section->bfd_section->vma;
                   }
@@ -2902 +3110 @@
               }
 
-            (void) lang_size_sections (os->children.head, os,
-                                       &os->children.head,
-                                       os->fill, dot, relax);
+            lang_size_sections_1 (os->children.head, os, &os->children.head,
+                                  os->fill, dot, relax, check_regions);
 
             /* Put the section within the requested block size, or
                align at the block boundary.  */
-            after = ALIGN_N (os->bfd_section->vma
+            after = align_n (os->bfd_section->vma
                              + os->bfd_section->_raw_size / opb,
-                             /* The coercion here is important, see ld.h.  */
                              (bfd_vma) os->block_value);
 
             if (bfd_is_abs_section (os->bfd_section))
               ASSERT (after == os->bfd_section->vma);
+            else if ((os->bfd_section->flags & SEC_HAS_CONTENTS) == 0
+                     && (os->bfd_section->flags & SEC_THREAD_LOCAL)
+                     && ! link_info.relocateable)
+              os->bfd_section->_raw_size = 0;
             else
               os->bfd_section->_raw_size =
                 (after - os->bfd_section->vma) * opb;
+
             dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
-            os->processed = true;
+            os->processed = TRUE;
+
+            if (os->update_dot_tree != 0)
+              exp_fold_tree (os->update_dot_tree, abs_output_section,
+                             lang_allocating_phase_enum, dot, &dot);
 
             /* Update dot in the region ?
@@ -2937 +3152 @@
                 os->region->current = dot;
 
-                /* Make sure the new address is within the region.  */
-                os_region_check (os, os->region, os->addr_tree,
-                                 os->bfd_section->vma);
+                if (check_regions)
+                  /* Make sure the new address is within the region.  */
+                  os_region_check (os, os->region, os->addr_tree,
+                                   os->bfd_section->vma);
 
                 /* If there's no load address specified, use the run
@@ -2946 +3162 @@
                   os->lma_region = os->region;
 
-                if (os->lma_region != NULL)
+                if (os->lma_region != NULL && os->lma_region != os->region)
                   {
-                    if (os->load_base != NULL)
-                      {
-                        einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
-                      }
-                    else
-                      {
-                        /* Don't allocate twice.  */
-                        if (os->lma_region != os->region)
-                          {
-                            /* Set load_base, which will be handled later.  */
-                            os->load_base =
-                              exp_intop (os->lma_region->current);
-                            os->lma_region->current +=
-                              os->bfd_section->_raw_size / opb;
-                            os_region_check (os, os->lma_region, NULL,
-                                             os->bfd_section->lma);
-                          }
-                      }
+                    /* Set load_base, which will be handled later.  */
+                    os->load_base = exp_intop (os->lma_region->current);
+                    os->lma_region->current +=
+                      os->bfd_section->_raw_size / opb;
+                    if (check_regions)
+                      os_region_check (os, os->lma_region, NULL,
+                                       os->bfd_section->lma);
                   }
               }
@@ -2972 +3177 @@
 
         case lang_constructors_statement_enum:
-          dot = lang_size_sections (constructor_list.head,
-                                    output_section_statement,
-                                    &s->wild_statement.children.head,
-                                    fill,
-                                    dot, relax);
+          dot = lang_size_sections_1 (constructor_list.head,
+                                      output_section_statement,
+                                      &s->wild_statement.children.head,
+                                      fill, dot, relax, check_regions);
           break;
 
@@ -3037 +3241 @@
         case lang_wild_statement_enum:
 
-          dot = lang_size_sections (s->wild_statement.children.head,
-                                    output_section_statement,
-                                    &s->wild_statement.children.head,
-                                    fill, dot, relax);
+          dot = lang_size_sections_1 (s->wild_statement.children.head,
+                                      output_section_statement,
+                                      &s->wild_statement.children.head,
+                                      fill, dot, relax, check_regions);
 
           break;
@@ -3063 +3267 @@
             else
               {
-                boolean again;
+                bfd_boolean again;
 
                 if (! bfd_relax_section (i->owner, i, &link_info, &again))
                   einfo (_("%P%F: can't relax section: %E\n"));
                 if (again)
-                  relax_again = true;
+                  *relax = TRUE;
               }
-            dot = size_input_section (prev,
-                                      output_section_statement,
-                                      output_section_statement->fill,
-                                      dot, relax);
+            dot = size_input_section (prev, output_section_statement,
+                                      output_section_statement->fill, dot);
           }
           break;
@@ -3096 +3298 @@
             if (newdot != dot)
               {
-                /* The assignment changed dot.  Insert a pad.  */
                 if (output_section_statement == abs_output_section)
                   {
@@ -3103 +3304 @@
                     lang_memory_region_lookup ("*default*")->current = newdot;
                   }
-                else if (!relax)
+                else
                   {
-                    lang_statement_union_type *new =
-                      ((lang_statement_union_type *)
-                       stat_alloc (sizeof (lang_padding_statement_type)));
-
-                    /* Link into existing chain.  */
-                    new->header.next = *prev;
-                    *prev = new;
-                    new->header.type = lang_padding_statement_enum;
-                    new->padding_statement.output_section =
-                      output_section_statement->bfd_section;
-                    new->padding_statement.output_offset =
-                      dot - output_section_statement->bfd_section->vma;
-                    new->padding_statement.fill = fill;
-                    new->padding_statement.size = (newdot - dot) * opb;
-                    output_section_statement->bfd_section->_raw_size +=
-                      new->padding_statement.size;
+                    /* Insert a pad after this statement.  We can't
+                       put the pad before when relaxing, in case the
+                       assignment references dot.  */
+                    insert_pad (&s->header.next, fill, (newdot - dot) * opb,
+                                output_section_statement->bfd_section, dot);
+
+                    /* Don't neuter the pad below when relaxing.  */
+                    s = s->header.next;
                   }
 
@@ -3129 +3322 @@
 
         case lang_padding_statement_enum:
-          /* If we are relaxing, and this is not the first pass, some
-             padding statements may have been inserted during previous
-             passes.  We may have to move the padding statement to a new
-             location if dot has a different value at this point in this
-             pass than it did at this point in the previous pass.  */
-          s->padding_statement.output_offset =
-            dot - output_section_statement->bfd_section->vma;
-          dot += s->padding_statement.size / opb;
-          output_section_statement->bfd_section->_raw_size +=
-            s->padding_statement.size;
+          /* If this is the first time lang_size_sections is called,
+             we won't have any padding statements.  If this is the
+             second or later passes when relaxing, we should allow
+             padding to shrink.  If padding is needed on this pass, it
+             will be added back in.  */
+          s->padding_statement.size = 0;
+
+          /* Make sure output_offset is valid.  If relaxation shrinks
+             the section and this pad isn't needed, it's possible to
+             have output_offset larger than the final size of the
+             section.  bfd_set_section_contents will complain even for
+             a pad size of zero.  */
+          s->padding_statement.output_offset
+            = dot - output_section_statement->bfd_section->vma;
           break;
 
         case lang_group_statement_enum:
-          dot = lang_size_sections (s->group_statement.children.head,
-                                    output_section_statement,
-                                    &s->group_statement.children.head,
-                                    fill, dot, relax);
+          dot = lang_size_sections_1 (s->group_statement.children.head,
+                                      output_section_statement,
+                                      &s->group_statement.children.head,
+                                      fill, dot, relax, check_regions);
           break;
 
@@ -3152 +3349 @@
           break;
 
-          /* This can only get here when relaxing is turned on.  */
-
+          /* We can only get here when relaxing is turned on.  */
         case lang_address_statement_enum:
           break;
@@ -3160 +3356 @@
     }
   return dot;
+}
+
+bfd_vma
+lang_size_sections (s, output_section_statement, prev, fill, dot, relax,
+                    check_regions)
+     lang_statement_union_type *s;
+     lang_output_section_statement_type *output_section_statement;
+     lang_statement_union_type **prev;
+     fill_type *fill;
+     bfd_vma dot;
+     bfd_boolean *relax;
+     bfd_boolean check_regions;
+{
+  bfd_vma result;
+
+  exp_data_seg.phase = exp_dataseg_none;
+  result = lang_size_sections_1 (s, output_section_statement, prev, fill,
+                                 dot, relax, check_regions);
+  if (exp_data_seg.phase == exp_dataseg_end_seen)
+    {
+      /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
+         a page could be saved in the data segment.  */
+      bfd_vma first, last;
+
+      first = -exp_data_seg.base & (exp_data_seg.pagesize - 1);
+      last = exp_data_seg.end & (exp_data_seg.pagesize - 1);
+      if (first && last
+          && ((exp_data_seg.base & ~(exp_data_seg.pagesize - 1))
+              != (exp_data_seg.end & ~(exp_data_seg.pagesize - 1)))
+          && first + last <= exp_data_seg.pagesize)
+        {
+          exp_data_seg.phase = exp_dataseg_adjust;
+          result = lang_size_sections_1 (s, output_section_statement, prev,
+                                         fill, dot, relax, check_regions);
+        }
+    }
+
+  return result;
 }
 
@@ -3166 +3400 @@
      lang_statement_union_type *s;
      lang_output_section_statement_type *output_section_statement;
-     fill_type fill;
+     fill_type *fill;
      bfd_vma dot;
 {
@@ -3172 +3406 @@
                                                 ldfile_output_machine);
 
-  for (; s != (lang_statement_union_type *) NULL; s = s->next)
+  for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
     {
       switch (s->header.type)
@@ -3232 +3466 @@
                                    lang_final_phase_enum, dot, &dot);
             s->data_statement.value = value.value;
-            if (value.valid_p == false)
+            if (!value.valid_p)
               einfo (_("%F%P: invalid data statement\n"));
           }
-          {
-            unsigned int size;
+          {
+            unsigned int size;
             switch (s->data_statement.type)
               {
@@ -3269 +3503 @@
                                    lang_final_phase_enum, dot, &dot);
             s->reloc_statement.addend_value = value.value;
-            if (value.valid_p == false)
+            if (!value.valid_p)
               einfo (_("%F%P: invalid reloc statement\n"));
           }
@@ -3348 +3582 @@
 
       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)
         {
@@ -3357 +3591 @@
 
       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)
         {
-          unsigned opb;
-
-          opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
+          unsigned opb;
+
+          opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
                                                ldfile_output_machine);
           h->type = bfd_link_hash_defined;
@@ -3380 +3614 @@
 {
   struct bfd_link_hash_entry *h;
-  boolean warn;
+  bfd_boolean warn;
 
   if (link_info.relocateable || link_info.shared)
-    warn = false;
+    warn = FALSE;
   else
-    warn = true;
-
-  if (entry_symbol == (char *) NULL)
+    warn = TRUE;
+
+  if (entry_symbol.name == (const char *) NULL)
     {
       /* No entry has been specified.  Look for start, but don't warn
          if we don't find it.  */
-      entry_symbol = "start";
-      warn = false;
-    }
-
-  h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
+      entry_symbol.name = "start";
+      warn = FALSE;
+    }
+
+  h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
+                            FALSE, FALSE, TRUE);
   if (h != (struct bfd_link_hash_entry *) NULL
       && (h->type == bfd_link_hash_defined
@@ -3408 +3643 @@
              + h->u.def.section->output_offset);
       if (! bfd_set_start_address (output_bfd, val))
-        einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
+        einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
     }
   else
@@ -3417 +3652 @@
       /* We couldn't find the entry symbol.  Try parsing it as a
          number.  */
-      val = bfd_scan_vma (entry_symbol, &send, 0);
+      val = bfd_scan_vma (entry_symbol.name, &send, 0);
       if (*send == '\0')
         {
@@ -3429 +3664 @@
           /* Can't find the entry symbol, and it's not a number.  Use
              the first address in the text section.  */
-          ts = bfd_get_section_by_name (output_bfd, ".text");
+          ts = bfd_get_section_by_name (output_bfd, entry_section);
           if (ts != (asection *) NULL)
             {
               if (warn)
                 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
-                       entry_symbol, bfd_get_section_vma (output_bfd, ts));
+                       entry_symbol.name,
+                       bfd_get_section_vma (output_bfd, ts));
               if (! bfd_set_start_address (output_bfd,
                                            bfd_get_section_vma (output_bfd,
@@ -3444 +3680 @@
               if (warn)
                 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
-                       entry_symbol);
+                       entry_symbol.name);
             }
         }
@@ -3480 +3716 @@
     {
       input_bfd = file->input_statement.the_bfd;
-      compatible = bfd_arch_get_compatible (input_bfd,
-                                            output_bfd);
+      compatible = bfd_arch_get_compatible (input_bfd, output_bfd,
+                                            command_line.accept_unknown_input_arch);
+
+      /* In general it is not possible to perform a relocatable
+         link between differing object formats when the input
+         file has relocations, because the relocations in the
+         input format may not have equivalent representations in
+         the output format (and besides BFD does not translate
+         relocs for other link purposes than a final link).  */
+      if ((link_info.relocateable || link_info.emitrelocations)
+          && (compatible == NULL
+              || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
+          && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
+        {
+          einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
+                 bfd_get_target (input_bfd), input_bfd,
+                 bfd_get_target (output_bfd), output_bfd);
+          /* einfo with %F exits.  */
+        }
+
       if (compatible == NULL)
         {
@@ -3492 +3746 @@
         {
           /* 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;
@@ -3522 +3776 @@
 lang_common ()
 {
+  if (command_line.inhibit_common_definition)
+    return;
   if (link_info.relocateable
       && ! command_line.force_common_definition)
@@ -3540 +3796 @@
 /* Place one common symbol in the correct section.  */
 
-static boolean
+static bfd_boolean
 lang_one_common (h, info)
      struct bfd_link_hash_entry *h;
@@ -3552 +3808 @@
 
   if (h->type != bfd_link_hash_common)
-    return true;
+    return TRUE;
 
   size = h->u.c.size;
@@ -3559 +3815 @@
   if (config.sort_common
       && power_of_two < (unsigned int) *(int *) info)
-    return true;
+    return TRUE;
 
   section = h->u.c.p->section;
 
   /* Increase the size of the section.  */
-  section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb,
-                                   (bfd_size_type) (1 << power_of_two)) * opb;
+  section->_cooked_size = align_n ((section->_cooked_size + opb - 1) / opb,
+                                   (bfd_vma) 1 << power_of_two) * opb;
 
   /* Adjust the alignment if necessary.  */
@@ -3586 +3842 @@
   if (config.map_file != NULL)
     {
-      static boolean header_printed;
+      static bfd_boolean header_printed;
       int len;
       char *name;
@@ -3595 +3851 @@
           minfo (_("\nAllocating common symbols\n"));
           minfo (_("Common symbol       size              file\n\n"));
-          header_printed = true;
+          header_printed = TRUE;
         }
 
@@ -3631 +3887 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -3651 +3907 @@
           if (s->output_section == (asection *) NULL)
             {
-              /* This section of the file is not attatched, root
+              /* This section of the file is not attached, root
                  around for a sensible place for it to go.  */
 
               if (file->just_syms_flag)
                 {
-                  /* We are only retrieving symbol values from this
-                     file.  We want the symbols to act as though the
-                     values in the file are absolute.  */
-                  s->output_section = bfd_abs_section_ptr;
-                  s->output_offset = s->vma;
+                  abort ();
                 }
               else if (strcmp (s->name, "COMMON") == 0)
@@ -3682 +3934 @@
 
                         }
-                      wild_doit (&default_common_section->children, s,
-                                 default_common_section, file);
+                      lang_add_section (&default_common_section->children, s,
+                                        default_common_section, file);
                     }
                 }
@@ -3690 +3942 @@
               else
                 {
-                  lang_output_section_statement_type *os =
-                  lang_output_section_statement_lookup (s->name);
-
-                  wild_doit (&os->children, s, os, file);
+                  lang_output_section_statement_type *os;
+
+                  os = lang_output_section_statement_lookup (s->name);
+                  lang_add_section (&os->children, s, os, file);
                 }
             }
@@ -3835 +4087 @@
 {
   /* Make -o on command line override OUTPUT in script.  */
-  if (had_output_filename == false || !from_script)
+  if (!had_output_filename || !from_script)
     {
       output_filename = name;
-      had_output_filename = true;
+      had_output_filename = TRUE;
     }
 }
@@ -3921 +4173 @@
 /* Reset the current counters in the regions.  */
 
-static void
-reset_memory_regions ()
+void
+lang_reset_memory_regions ()
 {
   lang_memory_region_type *p = lang_memory_region_list;
+  asection *o;
 
   for (p = lang_memory_region_list;
@@ -3933 +4186 @@
       p->current = p->origin;
     }
-}
-
-/* Expand a wild statement for a particular FILE, marking its sections KEEP
-   as needed.  SECTION may be NULL, in which case it is a wild card.  */
+
+  for (o = output_bfd->sections; o != NULL; o = o->next)
+    o->_raw_size = 0;
+}
+
+/* If the wild pattern was marked KEEP, the member sections
+   should be as well.  */
 
 static void
-gc_section_callback (ptr, section, file, data)
+gc_section_callback (ptr, sec, section, file, data)
      lang_wild_statement_type *ptr;
+     struct wildcard_list *sec ATTRIBUTE_UNUSED;
      asection *section;
      lang_input_statement_type *file ATTRIBUTE_UNUSED;
      PTR data ATTRIBUTE_UNUSED;
 {
-  /* If the wild pattern was marked KEEP, the member sections
-     should be as well.  */
   if (ptr->keep_sections)
     section->flags |= SEC_KEEP;
 }
 
-/* Handle a wild statement, marking it against GC.  SECTION or FILE or both
-   may be NULL, indicating that it is a wildcard.  */
+/* Handle a wild statement, marking it against GC.  */
 
 static void
-lang_gc_wild (s, section, file)
+lang_gc_wild (s)
      lang_wild_statement_type *s;
-     const char *section;
-     const char *file;
-{
-  walk_wild (s, section, file, gc_section_callback, NULL);
+{
+  walk_wild (s, gc_section_callback, NULL);
 }
 
@@ -3969 +4221 @@
      lang_statement_union_type *s;
 {
-  for (; s != (lang_statement_union_type *) NULL; s = s->next)
+  for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
     {
       switch (s->header.type)
         {
         case lang_wild_statement_enum:
-          lang_gc_wild (&s->wild_statement,
-                        s->wild_statement.section_name,
-                        s->wild_statement.filename);
+          lang_gc_wild (&s->wild_statement);
           break;
         case lang_constructors_statement_enum:
@@ -3997 +4247 @@
 {
   struct bfd_link_hash_entry *h;
-  ldlang_undef_chain_list_type *ulist, fake_list_start;
+  ldlang_undef_chain_list_type *ulist;
 
   /* Keep all sections so marked in the link script.  */
@@ -4003 +4253 @@
   lang_gc_sections_1 (statement_list.head);
 
-  /* Keep all sections containing symbols undefined on the command-line.
-     Handle the entry symbol at the same time.  */
-
-  if (entry_symbol != NULL)
-    {
-      fake_list_start.next = ldlang_undef_chain_list_head;
-      fake_list_start.name = (char *) entry_symbol;
-      ulist = &fake_list_start;
-    }
-  else
-    ulist = ldlang_undef_chain_list_head;
-
-  for (; ulist; ulist = ulist->next)
+  /* Keep all sections containing symbols undefined on the command-line,
+     and the section containing the entry symbol.  */
+
+  for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
     {
       h = bfd_link_hash_lookup (link_info.hash, ulist->name,
-                                false, false, false);
+                                FALSE, FALSE, FALSE);
 
       if (h != (struct bfd_link_hash_entry *) NULL
@@ -4050 +4291 @@
   /* Create a bfd for each input file.  */
   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;
+  if (entry_symbol.name == NULL)
+    link_info.gc_sym_list = ldlang_undef_chain_list_head;
 
   ldemul_after_open ();
@@ -4075 +4320 @@
     lang_gc_sections ();
 
+  /* If there were any SEC_MERGE sections, finish their merging, so that
+     section sizes can be computed.  This has to be done after GC of sections,
+     so that GCed sections are not merged, but before assigning output
+     sections, since removing whole input sections is hard then.  */
+  bfd_merge_sections (output_bfd, &link_info);
+
   /* Size up the common data.  */
   lang_common ();
@@ -4086 +4337 @@
   lang_place_orphans ();
 
+  if (! link_info.relocateable)
+    {
+      /* Look for a text section and set the readonly attribute in it.  */
+      asection *found = bfd_get_section_by_name (output_bfd, ".text");
+
+      if (found != (asection *) NULL)
+        {
+          if (config.text_read_only)
+            found->flags |= SEC_READONLY;
+          else
+            found->flags &= ~SEC_READONLY;
+        }
+    }
+
+  /* Do anything special before sizing sections.  This is where ELF
+     and other back-ends size dynamic sections.  */
   ldemul_before_allocation ();
+
+  if (!link_info.relocateable)
+    strip_excluded_output_sections ();
 
   /* We must record the program headers before we try to fix the
@@ -4092 +4362 @@
   lang_record_phdrs ();
 
+  /* Size up the sections.  */
+  lang_size_sections (statement_list.head,
+                      abs_output_section,
+                      &statement_list.head, 0, (bfd_vma) 0, NULL,
+                      command_line.relax ? FALSE : TRUE);
+
   /* Now run around and relax if we can.  */
   if (command_line.relax)
     {
-      /* First time round is a trial run to get the 'worst case'
-         addresses of the objects if there was no relaxing.  */
-      lang_size_sections (statement_list.head,
-                          abs_output_section,
-                          &(statement_list.head), 0, (bfd_vma) 0, false);
-
       /* Keep relaxing until bfd_relax_section gives up.  */
+      bfd_boolean relax_again;
+
       do
         {
-          reset_memory_regions ();
-
-          relax_again = false;
+          lang_reset_memory_regions ();
+
+          relax_again = FALSE;
 
           /* Note: pe-dll.c does something like this also.  If you find
@@ -4116 +4388 @@
           lang_do_assignments (statement_list.head,
                                abs_output_section,
-                               (fill_type) 0, (bfd_vma) 0);
+                               (fill_type *) 0, (bfd_vma) 0);
 
           /* Perform another relax pass - this time we know where the
-             globals are, so can make better guess.  */
+             globals are, so can make a better guess.  */
           lang_size_sections (statement_list.head,
                               abs_output_section,
-                              &(statement_list.head), 0, (bfd_vma) 0, true);
+                              &statement_list.head, 0, (bfd_vma) 0,
+                              &relax_again, FALSE);
+
+          /* If the normal relax is done and the relax finalize pass
+             is not performed yet, we perform another relax pass.  */
+          if (!relax_again && !link_info.relax_finalizing)
+            {
+              link_info.relax_finalizing = TRUE;
+              relax_again = TRUE;
+            }
         }
       while (relax_again);
-    }
-  else
-    {
-      /* Size up the sections.  */
+
+      /* Final extra sizing to report errors.  */
+      lang_reset_memory_regions ();
+      lang_do_assignments (statement_list.head,
+                           abs_output_section,
+                           (fill_type *) 0, (bfd_vma) 0);
       lang_size_sections (statement_list.head,
                           abs_output_section,
-                          &(statement_list.head), 0, (bfd_vma) 0, false);
+                          & statement_list.head, 0, (bfd_vma) 0, 
+                          NULL, TRUE);
     }
 
@@ -4146 +4430 @@
   lang_do_assignments (statement_list.head,
                        abs_output_section,
-                       (fill_type) 0, (bfd_vma) 0);
+                       (fill_type *) 0, (bfd_vma) 0);
 
   /* Make sure that the section addresses make sense.  */
@@ -4162 +4446 @@
 
 void
-lang_add_wild (section_name, sections_sorted, filename, filenames_sorted,
-               keep_sections, exclude_filename_list)
-     const char *const section_name;
-     boolean sections_sorted;
-     const char *const filename;
-     boolean filenames_sorted;
-     boolean keep_sections;
-     struct name_list *exclude_filename_list;
-{
-  lang_wild_statement_type *new = new_stat (lang_wild_statement,
-                                            stat_ptr);
-
-  if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
-    {
-      placed_commons = true;
-    }
-  if (filename != NULL && ! wildcardp (filename))
-    {
-      lang_has_input_file = true;
-    }
-  new->section_name = section_name;
-  new->sections_sorted = sections_sorted;
-  new->filename = filename;
-  new->filenames_sorted = filenames_sorted;
+lang_add_wild (filespec, section_list, keep_sections)
+     struct wildcard_spec *filespec;
+     struct wildcard_list *section_list;
+     bfd_boolean keep_sections;
+{
+  struct wildcard_list *curr, *next;
+  lang_wild_statement_type *new;
+
+  /* Reverse the list as the parser puts it back to front.  */
+  for (curr = section_list, section_list = NULL;
+       curr != NULL;
+       section_list = curr, curr = next)
+    {
+      if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
+        placed_commons = TRUE;
+
+      next = curr->next;
+      curr->next = section_list;
+    }
+
+  if (filespec != NULL && filespec->name != NULL)
+    {
+      if (strcmp (filespec->name, "*") == 0)
+        filespec->name = NULL;
+      else if (! wildcardp (filespec->name))
+        lang_has_input_file = TRUE;
+    }
+
+  new = new_stat (lang_wild_statement, stat_ptr);
+  new->filename = NULL;
+  new->filenames_sorted = FALSE;
+  if (filespec != NULL)
+    {
+      new->filename = filespec->name;
+      new->filenames_sorted = filespec->sorted;
+    }
+  new->section_list = section_list;
   new->keep_sections = keep_sections;
-  new->exclude_filename_list = exclude_filename_list;
   lang_list_init (&new->children);
 }
@@ -4211 +4507 @@
 lang_add_entry (name, cmdline)
      const char *name;
-     boolean cmdline;
-{
-  if (entry_symbol == NULL
+     bfd_boolean cmdline;
+{
+  if (entry_symbol.name == NULL
       || cmdline
       || ! entry_from_cmdline)
     {
-      entry_symbol = name;
+      entry_symbol.name = name;
       entry_from_cmdline = cmdline;
     }
@@ -4242 +4538 @@
         {
         case 'F':
-          map_option_f = true;
+          map_option_f = TRUE;
           break;
         }
@@ -4250 +4546 @@
 
 void
-lang_add_fill (exp)
-     int exp;
+lang_add_fill (fill)
+     fill_type *fill;
 {
   lang_fill_statement_type *new = new_stat (lang_fill_statement,
                                             stat_ptr);
 
-  new->fill = exp;
+  new->fill = fill;
 }
 
@@ -4329 +4625 @@
   first_file->filename = name;
   first_file->local_sym_name = name;
-  first_file->real = true;
+  first_file->real = TRUE;
 
   startup_file = name;
@@ -4336 +4632 @@
 void
 lang_float (maybe)
-     boolean maybe;
+     bfd_boolean maybe;
 {
   lang_float_flag = maybe;
+}
+
+
+/* Work out the load- and run-time regions from a script statement, and
+   store them in *LMA_REGION and *REGION respectively.
+
+   MEMSPEC is the name of the run-time region, or "*default*" if the
+   statement didn't specify one.  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 had an explicit load address.
+
+   It is an error to specify both a load region and a load address.  */
+
+static void
+lang_get_regions (region, lma_region, memspec, lma_memspec, have_lma_p)
+     struct memory_region_struct **region, **lma_region;
+     const char *memspec, *lma_memspec;
+     int have_lma_p;
+{
+  *lma_region = lang_memory_region_lookup (lma_memspec);
+
+  /* If no runtime region has been given, but the load region has
+     been, use the load region.  */
+  if (lma_memspec != 0 && strcmp (memspec, "*default*") == 0)
+    *region = *lma_region;
+  else
+    *region = lang_memory_region_lookup (memspec);
+
+  if (have_lma_p && lma_memspec != 0)
+    einfo (_("%X%P:%S: section has both a load address and a load region\n"));
 }
 
 void
 lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
-     bfd_vma fill;
+     fill_type *fill;
      const char *memspec;
      struct lang_output_section_phdr_list *phdrs;
      const char *lma_memspec;
 {
+  lang_get_regions (&current_section->region,
+                    &current_section->lma_region,
+                    memspec, lma_memspec,
+                    current_section->load_base != 0);
   current_section->fill = fill;
-  current_section->region = lang_memory_region_lookup (memspec);
-  if (strcmp (lma_memspec, "*default*") != 0)
-    {
-      current_section->lma_region = lang_memory_region_lookup (lma_memspec);
-      /* If no runtime region has been given, but the load region has
-         been, use the load region.  */
-      if (strcmp (memspec, "*default*") == 0)
-        current_section->region = lang_memory_region_lookup (lma_memspec);
-    }
   current_section->phdrs = phdrs;
   stat_ptr = &statement_list;
@@ -4374 +4695 @@
   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 == (struct bfd_link_hash_entry *) NULL)
     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
@@ -4407 +4728 @@
   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 == (struct bfd_link_hash_entry *) NULL)
     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
@@ -4493 +4814 @@
      const char *name;
      etree_type *type;
-     boolean filehdr;
-     boolean phdrs;
+     bfd_boolean filehdr;
+     bfd_boolean phdrs;
      etree_type *at;
      etree_type *flags;
@@ -4573 +4894 @@
                   secs[c] = os->bfd_section;
                   ++c;
-                  pl->used = true;
+                  pl->used = TRUE;
                 }
             }
@@ -4631 +4952 @@
 
   /* Set notice_all so that we get informed about all symbols.  */
-  link_info.notice_all = true;
+  link_info.notice_all = TRUE;
 }
 
@@ -4639 +4960 @@
 /* The overlay virtual address.  */
 static etree_type *overlay_vma;
-
-/* The overlay load address.  */
-static etree_type *overlay_lma;
-
-/* Whether nocrossrefs is set for this overlay.  */
-static int overlay_nocrossrefs;
 
 /* An expression for the maximum section size seen so far.  */
@@ -4661 +4976 @@
 
 void
-lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
+lang_enter_overlay (vma_expr)
      etree_type *vma_expr;
-     etree_type *lma_expr;
-     int nocrossrefs;
 {
   /* The grammar should prevent nested overlays from occurring.  */
-  ASSERT (overlay_vma == NULL
-          && overlay_lma == NULL
-          && overlay_list == NULL
-          && overlay_max == NULL);
+  ASSERT (overlay_vma == NULL && overlay_max == NULL);
 
   overlay_vma = vma_expr;
-  overlay_lma = lma_expr;
-  overlay_nocrossrefs = nocrossrefs;
 }
 
 /* Start a section in an overlay.  We handle this by calling
-   lang_enter_output_section_statement with the correct VMA and LMA.  */
+   lang_enter_output_section_statement with the correct VMA.
+   lang_leave_overlay sets up the LMA and memory regions.  */
 
 void
@@ -4688 +4997 @@
 
   lang_enter_output_section_statement (name, overlay_vma, normal_section,
-                                       0, 0, 0, overlay_lma);
-
-  /* If this is the first section, then base the VMA and LMA of future
+                                       0, 0, 0, 0);
+
+  /* If this is the first section, then base the VMA of future
      sections on this one.  This will work correctly even if `.' is
      used in the addresses.  */
   if (overlay_list == NULL)
-    {
-      overlay_vma = exp_nameop (ADDR, name);
-      overlay_lma = exp_nameop (LOADADDR, name);
-    }
+    overlay_vma = exp_nameop (ADDR, name);
 
   /* Remember the section.  */
@@ -4707 +5013 @@
   size = exp_nameop (SIZEOF, name);
 
-  /* Adjust the LMA for the next section.  */
-  overlay_lma = exp_binop ('+', overlay_lma, size);
-
   /* Arrange to work out the maximum section end address.  */
   if (overlay_max == NULL)
@@ -4722 +5025 @@
 void
 lang_leave_overlay_section (fill, phdrs)
-     bfd_vma fill;
+     fill_type *fill;
      struct lang_output_section_phdr_list *phdrs;
 {
@@ -4732 +5035 @@
   name = current_section->name;
 
-  lang_leave_output_section_statement (fill, "*default*",
-                                       phdrs, "*default*");
+  /* For now, assume that "*default*" is the run-time memory region and
+     that no load-time region has been specified.  It doesn't really
+     matter what we say here, since lang_leave_overlay will override it.  */
+  lang_leave_output_section_statement (fill, "*default*", phdrs, 0);
 
   /* Define the magic symbols.  */
@@ -4740 +5045 @@
   s2 = clean;
   for (s1 = name; *s1 != '\0'; s1++)
-    if (isalnum ((unsigned char) *s1) || *s1 == '_')
+    if (ISALNUM (*s1) || *s1 == '_')
       *s2++ = *s1;
   *s2 = '\0';
@@ -4763 +5068 @@
 
 void
-lang_leave_overlay (fill, memspec, phdrs, lma_memspec)
-     bfd_vma fill;
+lang_leave_overlay (lma_expr, nocrossrefs, fill, memspec, phdrs, lma_memspec)
+     etree_type *lma_expr;
+     int nocrossrefs;
+     fill_type *fill;
      const char *memspec;
      struct lang_output_section_phdr_list *phdrs;
@@ -4774 +5081 @@
   struct lang_nocrossref *nocrossref;
 
-  if (memspec == NULL)
-    region = NULL;
-  else
-    region = lang_memory_region_lookup (memspec);
-
-  if (lma_memspec == NULL)
-    lma_region = NULL;
-  else
-    lma_region = lang_memory_region_lookup (lma_memspec);
+  lang_get_regions (&region, &lma_region,
+                    memspec, lma_memspec,
+                    lma_expr != 0);
 
   nocrossref = NULL;
+
+  /* After setting the size of the last section, set '.' to end of the
+     overlay region.  */
+  if (overlay_list != NULL)
+    overlay_list->os->update_dot_tree
+      = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
 
   l = overlay_list;
@@ -4791 +5098 @@
       struct overlay_list *next;
 
-      if (fill != 0 && l->os->fill == 0)
+      if (fill != (fill_type *) 0 && l->os->fill == (fill_type *) 0)
         l->os->fill = fill;
-      if (region != NULL && l->os->region == NULL)
-        l->os->region = region;
-      /* We only set lma_region for the first overlay section, as
-         subsequent overlay sections will have load_base set relative
-         to the first section.  Also, don't set lma_region if
-         load_base is specified.  FIXME:  There should really be a test
-         that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
-         rather than letting LDADDR simply override LMA_REGION.  */
-      if (lma_region != NULL && l->os->lma_region == NULL
-          && l->next == NULL && l->os->load_base == NULL)
-        l->os->lma_region = lma_region;
+
+      l->os->region = region;
+      l->os->lma_region = lma_region;
+
+      /* The first section has the load address specified in the
+         OVERLAY statement.  The rest are worked out from that.
+         The base address is not needed (and should be null) if
+         an LMA region was specified.  */
+      if (l->next == 0)
+        l->os->load_base = lma_expr;
+      else if (lma_region == 0)
+        l->os->load_base = exp_binop ('+',
+                                      exp_nameop (LOADADDR, l->next->os->name),
+                                      exp_nameop (SIZEOF, l->next->os->name));
+
       if (phdrs != NULL && l->os->phdrs == NULL)
         l->os->phdrs = phdrs;
 
-      if (overlay_nocrossrefs)
+      if (nocrossrefs)
         {
           struct lang_nocrossref *nc;
@@ -4825 +5136 @@
     lang_add_nocrossref (nocrossref);
 
-  /* Update . for the end of the overlay.  */
-  lang_add_assignment (exp_assop ('=', ".",
-                                  exp_binop ('+', overlay_vma, overlay_max)));
-
   overlay_vma = NULL;
-  overlay_lma = NULL;
-  overlay_nocrossrefs = 0;
   overlay_list = NULL;
   overlay_max = NULL;
@@ -4868 +5173 @@
     {
       /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
-         Should we early out false in this case?  */
+         Should we early out FALSE in this case?  */
       result = fnmatch (expr->pattern, sym, 0) == 0;
     }
@@ -4895 +5200 @@
     {
       /* cplus_demangle (also) returns NULL when it is not a Java symbol.
-         Should we early out false in this case?  */
+         Should we early out FALSE in this case?  */
       result = fnmatch (expr->pattern, sym, 0) == 0;
     }
@@ -4910 +5215 @@
 
 struct bfd_elf_version_expr *
-lang_new_vers_regex (orig, new, lang)
+lang_new_vers_pattern (orig, new, lang)
      struct bfd_elf_version_expr *orig;
      const char *new;
@@ -4920 +5225 @@
   ret->next = orig;
   ret->pattern = new;
+  ret->symver = 0;
+  ret->script = 0;
 
   if (lang == NULL || strcasecmp (lang, "C") == 0)
@@ -4934 +5241 @@
     }
 
-  return ret;
+  return ldemul_new_vers_pattern (ret);
 }
 
@@ -4975 +5282 @@
   struct bfd_elf_version_expr *e1;
 
+  if (name == NULL)
+    name = "";
+
+  if ((name[0] == '\0' && lang_elf_version_info != NULL)
+      || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
+    {
+      einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
+      free (version);
+      return;
+    }
+
   /* Make sure this node has a unique name.  */
   for (t = lang_elf_version_info; t != NULL; t = t->next)
@@ -5011 +5329 @@
   version->deps = deps;
   version->name = name;
-  ++version_index;
-  version->vernum = version_index;
+  if (name[0] != '\0')
+    {
+      ++version_index;
+      version->vernum = version_index;
+    }
+  else
+    version->vernum = 0;
 
   for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
@@ -5058 +5381 @@
 
       if (sec == NULL)
-        continue;
+        continue;
 
       len = bfd_section_size (is->the_bfd, sec);
       contents = xmalloc (len);
       if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
-        einfo (_("%X%P: unable to read .exports section contents"), sec);
+        einfo (_("%X%P: unable to read .exports section contents\n"), sec);
 
       p = contents;
       while (p < contents + len)
         {
-          greg = lang_new_vers_regex (greg, p, NULL);
+          greg = lang_new_vers_pattern (greg, p, NULL);
           p = strchr (p, '\0') + 1;
         }
@@ -5079 +5402 @@
     }
 
-  lreg = lang_new_vers_regex (NULL, "*", NULL);
+  lreg = lang_new_vers_pattern (NULL, "*", NULL);
   lang_register_vers_node (command_line.version_exports_section,
                            lang_new_vers_node (greg, lreg), NULL);