ld/ldlang.c

   1 /* Linker command language support.
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
   4    Free Software Foundation, Inc.
   5
   6    This file is part of the GNU Binutils.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "libiberty.h"
  26 #include "safe-ctype.h"
  27 #include "obstack.h"
  28 #include "bfdlink.h"
  29
  30 #include "ld.h"
  31 #include "ldmain.h"
  32 #include "ldexp.h"
  33 #include "ldlang.h"
  34 #include <ldgram.h>
  35 #include "ldlex.h"
  36 #include "ldmisc.h"
  37 #include "ldctor.h"
  38 #include "ldfile.h"
  39 #include "ldemul.h"
  40 #include "fnmatch.h"
  41 #include "demangle.h"
  42 #include "hashtab.h"
  43
  44 #ifndef offsetof
  45 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
  46 #endif
  47
  48 /* Locals variables.  */
  49 static struct obstack stat_obstack;
  50 static struct obstack map_obstack;
  51
  52 #define obstack_chunk_alloc xmalloc
  53 #define obstack_chunk_free free
  54 static const char *startup_file;
  55 static bfd_boolean placed_commons = FALSE;
  56 static bfd_boolean stripped_excluded_sections = FALSE;
  57 static lang_output_section_statement_type *default_common_section;
  58 static bfd_boolean map_option_f;
  59 static bfd_vma print_dot;
  60 static lang_input_statement_type *first_file;
  61 static const char *current_target;
  62 static const char *output_target;
  63 static lang_statement_list_type statement_list;
  64 static struct bfd_hash_table lang_definedness_table;
  65
  66 /* Forward declarations.  */
  67 static void exp_init_os (etree_type *);
  68 static void init_map_userdata (bfd *, asection *, void *);
  69 static lang_input_statement_type *lookup_name (const char *);
  70 static struct bfd_hash_entry *lang_definedness_newfunc
  71  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
  72 static void insert_undefined (const char *);
  73 static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
  74 static void print_statement (lang_statement_union_type *,
  75                              lang_output_section_statement_type *);
  76 static void print_statement_list (lang_statement_union_type *,
  77                                   lang_output_section_statement_type *);
  78 static void print_statements (void);
  79 static void print_input_section (asection *);
  80 static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
  81 static void lang_record_phdrs (void);
  82 static void lang_do_version_exports_section (void);
  83 static void lang_finalize_version_expr_head
  84   (struct bfd_elf_version_expr_head *);
  85
  86 /* Exported variables.  */
  87 lang_output_section_statement_type *abs_output_section;
  88 lang_statement_list_type lang_output_section_statement;
  89 lang_statement_list_type *stat_ptr = &statement_list;
  90 lang_statement_list_type file_chain = { NULL, NULL };
  91 lang_statement_list_type input_file_chain;
  92 struct bfd_sym_chain entry_symbol = { NULL, NULL };
  93 static const char *entry_symbol_default = "start";
  94 const char *entry_section = ".text";
  95 bfd_boolean entry_from_cmdline;
  96 bfd_boolean lang_has_input_file = FALSE;
  97 bfd_boolean had_output_filename = FALSE;
  98 bfd_boolean lang_float_flag = FALSE;
  99 bfd_boolean delete_output_file_on_failure = FALSE;
 100 struct lang_phdr *lang_phdr_list;
 101 struct lang_nocrossrefs *nocrossref_list;
 102 static struct unique_sections *unique_section_list;
 103 static bfd_boolean ldlang_sysrooted_script = FALSE;
 104
 105  /* Functions that traverse the linker script and might evaluate
 106     DEFINED() need to increment this.  */
 107 int lang_statement_iteration = 0;
 108
 109 etree_type *base; /* Relocation base - or null */
 110
 111 /* Return TRUE if the PATTERN argument is a wildcard pattern.
 112    Although backslashes are treated specially if a pattern contains
 113    wildcards, we do not consider the mere presence of a backslash to
 114    be enough to cause the pattern to be treated as a wildcard.
 115    That lets us handle DOS filenames more naturally.  */
 116 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
 117
 118 #define new_stat(x, y) \
 119   (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
 120
 121 #define outside_section_address(q) \
 122   ((q)->output_offset + (q)->output_section->vma)
 123
 124 #define outside_symbol_address(q) \
 125   ((q)->value + outside_section_address (q->section))
 126
 127 #define SECTION_NAME_MAP_LENGTH (16)
 128
 129 void *
 130 stat_alloc (size_t size)
 131 {
 132   return obstack_alloc (&stat_obstack, size);
 133 }
 134
 135 bfd_boolean
 136 unique_section_p (const asection *sec)
 137 {
 138   struct unique_sections *unam;
 139   const char *secnam;
 140
 141   if (link_info.relocatable
 142       && sec->owner != NULL
 143       && bfd_is_group_section (sec->owner, sec))
 144     return TRUE;
 145
 146   secnam = sec->name;
 147   for (unam = unique_section_list; unam; unam = unam->next)
 148     if (wildcardp (unam->name)
 149         ? fnmatch (unam->name, secnam, 0) == 0
 150         : strcmp (unam->name, secnam) == 0)
 151       {
 152         return TRUE;
 153       }
 154
 155   return FALSE;
 156 }
 157
 158 /* Generic traversal routines for finding matching sections.  */
 159
 160 /* Try processing a section against a wildcard.  This just calls
 161    the callback unless the filename exclusion list is present
 162    and excludes the file.  It's hardly ever present so this
 163    function is very fast.  */
 164
 165 static void
 166 walk_wild_consider_section (lang_wild_statement_type *ptr,
 167                             lang_input_statement_type *file,
 168                             asection *s,
 169                             struct wildcard_list *sec,
 170                             callback_t callback,
 171                             void *data)
 172 {
 173   bfd_boolean skip = FALSE;
 174   struct name_list *list_tmp;
 175
 176   /* Don't process sections from files which were
 177      excluded.  */
 178   for (list_tmp = sec->spec.exclude_name_list;
 179        list_tmp;
 180        list_tmp = list_tmp->next)
 181     {
 182       bfd_boolean is_wildcard = wildcardp (list_tmp->name);
 183       if (is_wildcard)
 184         skip = fnmatch (list_tmp->name, file->filename, 0) == 0;
 185       else
 186         skip = strcmp (list_tmp->name, file->filename) == 0;
 187
 188       /* If this file is part of an archive, and the archive is
 189          excluded, exclude this file.  */
 190       if (! skip && file->the_bfd != NULL
 191           && file->the_bfd->my_archive != NULL
 192           && file->the_bfd->my_archive->filename != NULL)
 193         {
 194           if (is_wildcard)
 195             skip = fnmatch (list_tmp->name,
 196                             file->the_bfd->my_archive->filename,
 197                             0) == 0;
 198           else
 199             skip = strcmp (list_tmp->name,
 200                            file->the_bfd->my_archive->filename) == 0;
 201         }
 202
 203       if (skip)
 204         break;
 205     }
 206
 207   if (!skip)
 208     (*callback) (ptr, sec, s, file, data);
 209 }
 210
 211 /* Lowest common denominator routine that can handle everything correctly,
 212    but slowly.  */
 213
 214 static void
 215 walk_wild_section_general (lang_wild_statement_type *ptr,
 216                            lang_input_statement_type *file,
 217                            callback_t callback,
 218                            void *data)
 219 {
 220   asection *s;
 221   struct wildcard_list *sec;
 222
 223   for (s = file->the_bfd->sections; s != NULL; s = s->next)
 224     {
 225       sec = ptr->section_list;
 226       if (sec == NULL)
 227         (*callback) (ptr, sec, s, file, data);
 228
 229       while (sec != NULL)
 230         {
 231           bfd_boolean skip = FALSE;
 232
 233           if (sec->spec.name != NULL)
 234             {
 235               const char *sname = bfd_get_section_name (file->the_bfd, s);
 236
 237               if (wildcardp (sec->spec.name))
 238                 skip = fnmatch (sec->spec.name, sname, 0) != 0;
 239               else
 240                 skip = strcmp (sec->spec.name, sname) != 0;
 241             }
 242
 243           if (!skip)
 244             walk_wild_consider_section (ptr, file, s, sec, callback, data);
 245
 246           sec = sec->next;
 247         }
 248     }
 249 }
 250
 251 /* Routines to find a single section given its name.  If there's more
 252    than one section with that name, we report that.  */
 253
 254 typedef struct
 255 {
 256   asection *found_section;
 257   bfd_boolean multiple_sections_found;
 258 } section_iterator_callback_data;
 259
 260 static bfd_boolean
 261 section_iterator_callback (bfd *bfd ATTRIBUTE_UNUSED, asection *s, void *data)
 262 {
 263   section_iterator_callback_data *d = data;
 264
 265   if (d->found_section != NULL)
 266     {
 267       d->multiple_sections_found = TRUE;
 268       return TRUE;
 269     }
 270
 271   d->found_section = s;
 272   return FALSE;
 273 }
 274
 275 static asection *
 276 find_section (lang_input_statement_type *file,
 277               struct wildcard_list *sec,
 278               bfd_boolean *multiple_sections_found)
 279 {
 280   section_iterator_callback_data cb_data = { NULL, FALSE };
 281
 282   bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,
 283                               section_iterator_callback, &cb_data);
 284   *multiple_sections_found = cb_data.multiple_sections_found;
 285   return cb_data.found_section;
 286 }
 287
 288 /* Code for handling simple wildcards without going through fnmatch,
 289    which can be expensive because of charset translations etc.  */
 290
 291 /* A simple wild is a literal string followed by a single '*',
 292    where the literal part is at least 4 characters long.  */
 293
 294 static bfd_boolean
 295 is_simple_wild (const char *name)
 296 {
 297   size_t len = strcspn (name, "*?[");
 298   return len >= 4 && name[len] == '*' && name[len + 1] == '\0';
 299 }
 300
 301 static bfd_boolean
 302 match_simple_wild (const char *pattern, const char *name)
 303 {
 304   /* The first four characters of the pattern are guaranteed valid
 305      non-wildcard characters.  So we can go faster.  */
 306   if (pattern[0] != name[0] || pattern[1] != name[1]
 307       || pattern[2] != name[2] || pattern[3] != name[3])
 308     return FALSE;
 309
 310   pattern += 4;
 311   name += 4;
 312   while (*pattern != '*')
 313     if (*name++ != *pattern++)
 314       return FALSE;
 315
 316   return TRUE;
 317 }
 318
 319 /* Compare sections ASEC and BSEC according to SORT.  */
 320
 321 static int
 322 compare_section (sort_type sort, asection *asec, asection *bsec)
 323 {
 324   int ret;
 325
 326   switch (sort)
 327     {
 328     default:
 329       abort ();
 330
 331     case by_alignment_name:
 332       ret = (bfd_section_alignment (bsec->owner, bsec)
 333              - bfd_section_alignment (asec->owner, asec));
 334       if (ret)
 335         break;
 336       /* Fall through.  */
 337
 338     case by_name:
 339       ret = strcmp (bfd_get_section_name (asec->owner, asec),
 340                     bfd_get_section_name (bsec->owner, bsec));
 341       break;
 342
 343     case by_name_alignment:
 344       ret = strcmp (bfd_get_section_name (asec->owner, asec),
 345                     bfd_get_section_name (bsec->owner, bsec));
 346       if (ret)
 347         break;
 348       /* Fall through.  */
 349
 350     case by_alignment:
 351       ret = (bfd_section_alignment (bsec->owner, bsec)
 352              - bfd_section_alignment (asec->owner, asec));
 353       break;
 354     }
 355
 356   return ret;
 357 }
 358
 359 /* Build a Binary Search Tree to sort sections, unlike insertion sort
 360    used in wild_sort(). BST is considerably faster if the number of
 361    of sections are large.  */
 362
 363 static lang_section_bst_type **
 364 wild_sort_fast (lang_wild_statement_type *wild,
 365                 struct wildcard_list *sec,
 366                 lang_input_statement_type *file ATTRIBUTE_UNUSED,
 367                 asection *section)
 368 {
 369   lang_section_bst_type **tree;
 370
 371   tree = &wild->tree;
 372   if (!wild->filenames_sorted
 373       && (sec == NULL || sec->spec.sorted == none))
 374     {
 375       /* Append at the right end of tree.  */
 376       while (*tree)
 377         tree = &((*tree)->right);
 378       return tree;
 379     }
 380
 381   while (*tree)
 382     {
 383       /* Find the correct node to append this section.  */
 384       if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)
 385         tree = &((*tree)->left);
 386       else
 387         tree = &((*tree)->right);
 388     }
 389
 390   return tree;
 391 }
 392
 393 /* Use wild_sort_fast to build a BST to sort sections.  */
 394
 395 static void
 396 output_section_callback_fast (lang_wild_statement_type *ptr,
 397                               struct wildcard_list *sec,
 398                               asection *section,
 399                               lang_input_statement_type *file,
 400                               void *output ATTRIBUTE_UNUSED)
 401 {
 402   lang_section_bst_type *node;
 403   lang_section_bst_type **tree;
 404
 405   if (unique_section_p (section))
 406     return;
 407
 408   node = xmalloc (sizeof (lang_section_bst_type));
 409   node->left = 0;
 410   node->right = 0;
 411   node->section = section;
 412
 413   tree = wild_sort_fast (ptr, sec, file, section);
 414   if (tree != NULL)
 415     *tree = node;
 416 }
 417
 418 /* Convert a sorted sections' BST back to list form.  */
 419
 420 static void
 421 output_section_callback_tree_to_list (lang_wild_statement_type *ptr,
 422                                       lang_section_bst_type *tree,
 423                                       void *output)
 424 {
 425   if (tree->left)
 426     output_section_callback_tree_to_list (ptr, tree->left, output);
 427
 428   lang_add_section (&ptr->children, tree->section,
 429                     (lang_output_section_statement_type *) output);
 430
 431   if (tree->right)
 432     output_section_callback_tree_to_list (ptr, tree->right, output);
 433
 434   free (tree);
 435 }
 436
 437 /* Specialized, optimized routines for handling different kinds of
 438    wildcards */
 439
 440 static void
 441 walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
 442                                 lang_input_statement_type *file,
 443                                 callback_t callback,
 444                                 void *data)
 445 {
 446   /* We can just do a hash lookup for the section with the right name.
 447      But if that lookup discovers more than one section with the name
 448      (should be rare), we fall back to the general algorithm because
 449      we would otherwise have to sort the sections to make sure they
 450      get processed in the bfd's order.  */
 451   bfd_boolean multiple_sections_found;
 452   struct wildcard_list *sec0 = ptr->handler_data[0];
 453   asection *s0 = find_section (file, sec0, &multiple_sections_found);
 454
 455   if (multiple_sections_found)
 456     walk_wild_section_general (ptr, file, callback, data);
 457   else if (s0)
 458     walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
 459 }
 460
 461 static void
 462 walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
 463                                 lang_input_statement_type *file,
 464                                 callback_t callback,
 465                                 void *data)
 466 {
 467   asection *s;
 468   struct wildcard_list *wildsec0 = ptr->handler_data[0];
 469
 470   for (s = file->the_bfd->sections; s != NULL; s = s->next)
 471     {
 472       const char *sname = bfd_get_section_name (file->the_bfd, s);
 473       bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);
 474
 475       if (!skip)
 476         walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
 477     }
 478 }
 479
 480 static void
 481 walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
 482                                 lang_input_statement_type *file,
 483                                 callback_t callback,
 484                                 void *data)
 485 {
 486   asection *s;
 487   struct wildcard_list *sec0 = ptr->handler_data[0];
 488   struct wildcard_list *wildsec1 = ptr->handler_data[1];
 489   bfd_boolean multiple_sections_found;
 490   asection *s0 = find_section (file, sec0, &multiple_sections_found);
 491
 492   if (multiple_sections_found)
 493     {
 494       walk_wild_section_general (ptr, file, callback, data);
 495       return;
 496     }
 497
 498   /* Note that if the section was not found, s0 is NULL and
 499      we'll simply never succeed the s == s0 test below.  */
 500   for (s = file->the_bfd->sections; s != NULL; s = s->next)
 501     {
 502       /* Recall that in this code path, a section cannot satisfy more
 503          than one spec, so if s == s0 then it cannot match
 504          wildspec1.  */
 505       if (s == s0)
 506         walk_wild_consider_section (ptr, file, s, sec0, callback, data);
 507       else
 508         {
 509           const char *sname = bfd_get_section_name (file->the_bfd, s);
 510           bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
 511
 512           if (!skip)
 513             walk_wild_consider_section (ptr, file, s, wildsec1, callback,
 514                                         data);
 515         }
 516     }
 517 }
 518
 519 static void
 520 walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
 521                                 lang_input_statement_type *file,
 522                                 callback_t callback,
 523                                 void *data)
 524 {
 525   asection *s;
 526   struct wildcard_list *sec0 = ptr->handler_data[0];
 527   struct wildcard_list *wildsec1 = ptr->handler_data[1];
 528   struct wildcard_list *wildsec2 = ptr->handler_data[2];
 529   bfd_boolean multiple_sections_found;
 530   asection *s0 = find_section (file, sec0, &multiple_sections_found);
 531
 532   if (multiple_sections_found)
 533     {
 534       walk_wild_section_general (ptr, file, callback, data);
 535       return;
 536     }
 537
 538   for (s = file->the_bfd->sections; s != NULL; s = s->next)
 539     {
 540       if (s == s0)
 541         walk_wild_consider_section (ptr, file, s, sec0, callback, data);
 542       else
 543         {
 544           const char *sname = bfd_get_section_name (file->the_bfd, s);
 545           bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
 546
 547           if (!skip)
 548             walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
 549           else
 550             {
 551               skip = !match_simple_wild (wildsec2->spec.name, sname);
 552               if (!skip)
 553                 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
 554                                             data);
 555             }
 556         }
 557     }
 558 }
 559
 560 static void
 561 walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
 562                                 lang_input_statement_type *file,
 563                                 callback_t callback,
 564                                 void *data)
 565 {
 566   asection *s;
 567   struct wildcard_list *sec0 = ptr->handler_data[0];
 568   struct wildcard_list *sec1 = ptr->handler_data[1];
 569   struct wildcard_list *wildsec2 = ptr->handler_data[2];
 570   struct wildcard_list *wildsec3 = ptr->handler_data[3];
 571   bfd_boolean multiple_sections_found;
 572   asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1;
 573
 574   if (multiple_sections_found)
 575     {
 576       walk_wild_section_general (ptr, file, callback, data);
 577       return;
 578     }
 579
 580   s1 = find_section (file, sec1, &multiple_sections_found);
 581   if (multiple_sections_found)
 582     {
 583       walk_wild_section_general (ptr, file, callback, data);
 584       return;
 585     }
 586
 587   for (s = file->the_bfd->sections; s != NULL; s = s->next)
 588     {
 589       if (s == s0)
 590         walk_wild_consider_section (ptr, file, s, sec0, callback, data);
 591       else
 592         if (s == s1)
 593           walk_wild_consider_section (ptr, file, s, sec1, callback, data);
 594         else
 595           {
 596             const char *sname = bfd_get_section_name (file->the_bfd, s);
 597             bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,
 598                                                    sname);
 599
 600             if (!skip)
 601               walk_wild_consider_section (ptr, file, s, wildsec2, callback,
 602                                           data);
 603             else
 604               {
 605                 skip = !match_simple_wild (wildsec3->spec.name, sname);
 606                 if (!skip)
 607                   walk_wild_consider_section (ptr, file, s, wildsec3,
 608                                               callback, data);
 609               }
 610           }
 611     }
 612 }
 613
 614 static void
 615 walk_wild_section (lang_wild_statement_type *ptr,
 616                    lang_input_statement_type *file,
 617                    callback_t callback,
 618                    void *data)
 619 {
 620   if (file->just_syms_flag)
 621     return;
 622
 623   (*ptr->walk_wild_section_handler) (ptr, file, callback, data);
 624 }
 625
 626 /* Returns TRUE when name1 is a wildcard spec that might match
 627    something name2 can match.  We're conservative: we return FALSE
 628    only if the prefixes of name1 and name2 are different up to the
 629    first wildcard character.  */
 630
 631 static bfd_boolean
 632 wild_spec_can_overlap (const char *name1, const char *name2)
 633 {
 634   size_t prefix1_len = strcspn (name1, "?*[");
 635   size_t prefix2_len = strcspn (name2, "?*[");
 636   size_t min_prefix_len;
 637
 638   /* Note that if there is no wildcard character, then we treat the
 639      terminating 0 as part of the prefix.  Thus ".text" won't match
 640      ".text." or ".text.*", for example.  */
 641   if (name1[prefix1_len] == '\0')
 642     prefix1_len++;
 643   if (name2[prefix2_len] == '\0')
 644     prefix2_len++;
 645
 646   min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;
 647
 648   return memcmp (name1, name2, min_prefix_len) == 0;
 649 }
 650
 651 /* Select specialized code to handle various kinds of wildcard
 652    statements.  */
 653
 654 static void
 655 analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
 656 {
 657   int sec_count = 0;
 658   int wild_name_count = 0;
 659   struct wildcard_list *sec;
 660   int signature;
 661   int data_counter;
 662
 663   ptr->walk_wild_section_handler = walk_wild_section_general;
 664   ptr->handler_data[0] = NULL;
 665   ptr->handler_data[1] = NULL;
 666   ptr->handler_data[2] = NULL;
 667   ptr->handler_data[3] = NULL;
 668   ptr->tree = NULL;
 669
 670   /* Count how many wildcard_specs there are, and how many of those
 671      actually use wildcards in the name.  Also, bail out if any of the
 672      wildcard names are NULL. (Can this actually happen?
 673      walk_wild_section used to test for it.)  And bail out if any
 674      of the wildcards are more complex than a simple string
 675      ending in a single '*'.  */
 676   for (sec = ptr->section_list; sec != NULL; sec = sec->next)
 677     {
 678       ++sec_count;
 679       if (sec->spec.name == NULL)
 680         return;
 681       if (wildcardp (sec->spec.name))
 682         {
 683           ++wild_name_count;
 684           if (!is_simple_wild (sec->spec.name))
 685             return;
 686         }
 687     }
 688
 689   /* The zero-spec case would be easy to optimize but it doesn't
 690      happen in practice.  Likewise, more than 4 specs doesn't
 691      happen in practice.  */
 692   if (sec_count == 0 || sec_count > 4)
 693     return;
 694
 695   /* Check that no two specs can match the same section.  */
 696   for (sec = ptr->section_list; sec != NULL; sec = sec->next)
 697     {
 698       struct wildcard_list *sec2;
 699       for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)
 700         {
 701           if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))
 702             return;
 703         }
 704     }
 705
 706   signature = (sec_count << 8) + wild_name_count;
 707   switch (signature)
 708     {
 709     case 0x0100:
 710       ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
 711       break;
 712     case 0x0101:
 713       ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
 714       break;
 715     case 0x0201:
 716       ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
 717       break;
 718     case 0x0302:
 719       ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
 720       break;
 721     case 0x0402:
 722       ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
 723       break;
 724     default:
 725       return;
 726     }
 727
 728   /* Now fill the data array with pointers to the specs, first the
 729      specs with non-wildcard names, then the specs with wildcard
 730      names.  It's OK to process the specs in different order from the
 731      given order, because we've already determined that no section
 732      will match more than one spec.  */
 733   data_counter = 0;
 734   for (sec = ptr->section_list; sec != NULL; sec = sec->next)
 735     if (!wildcardp (sec->spec.name))
 736       ptr->handler_data[data_counter++] = sec;
 737   for (sec = ptr->section_list; sec != NULL; sec = sec->next)
 738     if (wildcardp (sec->spec.name))
 739       ptr->handler_data[data_counter++] = sec;
 740 }
 741
 742 /* Handle a wild statement for a single file F.  */
 743
 744 static void
 745 walk_wild_file (lang_wild_statement_type *s,
 746                 lang_input_statement_type *f,
 747                 callback_t callback,
 748                 void *data)
 749 {
 750   if (f->the_bfd == NULL
 751       || ! bfd_check_format (f->the_bfd, bfd_archive))
 752     walk_wild_section (s, f, callback, data);
 753   else
 754     {
 755       bfd *member;
 756
 757       /* This is an archive file.  We must map each member of the
 758          archive separately.  */
 759       member = bfd_openr_next_archived_file (f->the_bfd, NULL);
 760       while (member != NULL)
 761         {
 762           /* When lookup_name is called, it will call the add_symbols
 763              entry point for the archive.  For each element of the
 764              archive which is included, BFD will call ldlang_add_file,
 765              which will set the usrdata field of the member to the
 766              lang_input_statement.  */
 767           if (member->usrdata != NULL)
 768             {
 769               walk_wild_section (s, member->usrdata, callback, data);
 770             }
 771
 772           member = bfd_openr_next_archived_file (f->the_bfd, member);
 773         }
 774     }
 775 }
 776
 777 static void
 778 walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
 779 {
 780   const char *file_spec = s->filename;
 781
 782   if (file_spec == NULL)
 783     {
 784       /* Perform the iteration over all files in the list.  */
 785       LANG_FOR_EACH_INPUT_STATEMENT (f)
 786         {
 787           walk_wild_file (s, f, callback, data);
 788         }
 789     }
 790   else if (wildcardp (file_spec))
 791     {
 792       LANG_FOR_EACH_INPUT_STATEMENT (f)
 793         {
 794           if (fnmatch (file_spec, f->filename, 0) == 0)
 795             walk_wild_file (s, f, callback, data);
 796         }
 797     }
 798   else
 799     {
 800       lang_input_statement_type *f;
 801
 802       /* Perform the iteration over a single file.  */
 803       f = lookup_name (file_spec);
 804       if (f)
 805         walk_wild_file (s, f, callback, data);
 806     }
 807 }
 808
 809 /* lang_for_each_statement walks the parse tree and calls the provided
 810    function for each node.  */
 811
 812 static void
 813 lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
 814                                 lang_statement_union_type *s)
 815 {
 816   for (; s != NULL; s = s->header.next)
 817     {
 818       func (s);
 819
 820       switch (s->header.type)
 821         {
 822         case lang_constructors_statement_enum:
 823           lang_for_each_statement_worker (func, constructor_list.head);
 824           break;
 825         case lang_output_section_statement_enum:
 826           lang_for_each_statement_worker
 827             (func, s->output_section_statement.children.head);
 828           break;
 829         case lang_wild_statement_enum:
 830           lang_for_each_statement_worker (func,
 831                                           s->wild_statement.children.head);
 832           break;
 833         case lang_group_statement_enum:
 834           lang_for_each_statement_worker (func,
 835                                           s->group_statement.children.head);
 836           break;
 837         case lang_data_statement_enum:
 838         case lang_reloc_statement_enum:
 839         case lang_object_symbols_statement_enum:
 840         case lang_output_statement_enum:
 841         case lang_target_statement_enum:
 842         case lang_input_section_enum:
 843         case lang_input_statement_enum:
 844         case lang_assignment_statement_enum:
 845         case lang_padding_statement_enum:
 846         case lang_address_statement_enum:
 847         case lang_fill_statement_enum:
 848         case lang_insert_statement_enum:
 849           break;
 850         default:
 851           FAIL ();
 852           break;
 853         }
 854     }
 855 }
 856
 857 void
 858 lang_for_each_statement (void (*func) (lang_statement_union_type *))
 859 {
 860   lang_for_each_statement_worker (func, statement_list.head);
 861 }
 862
 863 /*----------------------------------------------------------------------*/
 864
 865 void
 866 lang_list_init (lang_statement_list_type *list)
 867 {
 868   list->head = NULL;
 869   list->tail = &list->head;
 870 }
 871
 872 /* Build a new statement node for the parse tree.  */
 873
 874 static lang_statement_union_type *
 875 new_statement (enum statement_enum type,
 876                size_t size,
 877                lang_statement_list_type *list)
 878 {
 879   lang_statement_union_type *new;
 880
 881   new = stat_alloc (size);
 882   new->header.type = type;
 883   new->header.next = NULL;
 884   lang_statement_append (list, new, &new->header.next);
 885   return new;
 886 }
 887
 888 /* Build a new input file node for the language.  There are several
 889    ways in which we treat an input file, eg, we only look at symbols,
 890    or prefix it with a -l etc.
 891
 892    We can be supplied with requests for input files more than once;
 893    they may, for example be split over several lines like foo.o(.text)
 894    foo.o(.data) etc, so when asked for a file we check that we haven't
 895    got it already so we don't duplicate the bfd.  */
 896
 897 static lang_input_statement_type *
 898 new_afile (const char *name,
 899            lang_input_file_enum_type file_type,
 900            const char *target,
 901            bfd_boolean add_to_list)
 902 {
 903   lang_input_statement_type *p;
 904
 905   if (add_to_list)
 906     p = new_stat (lang_input_statement, stat_ptr);
 907   else
 908     {
 909       p = stat_alloc (sizeof (lang_input_statement_type));
 910       p->header.type = lang_input_statement_enum;
 911       p->header.next = NULL;
 912     }
 913
 914   lang_has_input_file = TRUE;
 915   p->target = target;
 916   p->sysrooted = FALSE;
 917
 918   if (file_type == lang_input_file_is_l_enum
 919       && name[0] == ':' && name[1] != '\0')
 920     {
 921       file_type = lang_input_file_is_search_file_enum;
 922       name = name + 1;
 923     }
 924
 925   switch (file_type)
 926     {
 927     case lang_input_file_is_symbols_only_enum:
 928       p->filename = name;
 929       p->is_archive = FALSE;
 930       p->real = TRUE;
 931       p->local_sym_name = name;
 932       p->just_syms_flag = TRUE;
 933       p->search_dirs_flag = FALSE;
 934       break;
 935     case lang_input_file_is_fake_enum:
 936       p->filename = name;
 937       p->is_archive = FALSE;
 938       p->real = FALSE;
 939       p->local_sym_name = name;
 940       p->just_syms_flag = FALSE;
 941       p->search_dirs_flag = FALSE;
 942       break;
 943     case lang_input_file_is_l_enum:
 944       p->is_archive = TRUE;
 945       p->filename = name;
 946       p->real = TRUE;
 947       p->local_sym_name = concat ("-l", name, (const char *) NULL);
 948       p->just_syms_flag = FALSE;
 949       p->search_dirs_flag = TRUE;
 950       break;
 951     case lang_input_file_is_marker_enum:
 952       p->filename = name;
 953       p->is_archive = FALSE;
 954       p->real = FALSE;
 955       p->local_sym_name = name;
 956       p->just_syms_flag = FALSE;
 957       p->search_dirs_flag = TRUE;
 958       break;
 959     case lang_input_file_is_search_file_enum:
 960       p->sysrooted = ldlang_sysrooted_script;
 961       p->filename = name;
 962       p->is_archive = FALSE;
 963       p->real = TRUE;
 964       p->local_sym_name = name;
 965       p->just_syms_flag = FALSE;
 966       p->search_dirs_flag = TRUE;
 967       break;
 968     case lang_input_file_is_file_enum:
 969       p->filename = name;
 970       p->is_archive = FALSE;
 971       p->real = TRUE;
 972       p->local_sym_name = name;
 973       p->just_syms_flag = FALSE;
 974       p->search_dirs_flag = FALSE;
 975       break;
 976     default:
 977       FAIL ();
 978     }
 979   p->the_bfd = NULL;
 980   p->asymbols = NULL;
 981   p->next_real_file = NULL;
 982   p->next = NULL;
 983   p->symbol_count = 0;
 984   p->dynamic = config.dynamic_link;
 985   p->add_needed = add_needed;
 986   p->as_needed = as_needed;
 987   p->whole_archive = whole_archive;
 988   p->loaded = FALSE;
 989   lang_statement_append (&input_file_chain,
 990                          (lang_statement_union_type *) p,
 991                          &p->next_real_file);
 992   return p;
 993 }
 994
 995 lang_input_statement_type *
 996 lang_add_input_file (const char *name,
 997                      lang_input_file_enum_type file_type,
 998                      const char *target)
 999 {
1000   return new_afile (name, file_type, target, TRUE);
1001 }
1002
1003 struct out_section_hash_entry
1004 {
1005   struct bfd_hash_entry root;
1006   lang_statement_union_type s;
1007 };
1008
1009 /* The hash table.  */
1010
1011 static struct bfd_hash_table output_section_statement_table;
1012
1013 /* Support routines for the hash table used by lang_output_section_find,
1014    initialize the table, fill in an entry and remove the table.  */
1015
1016 static struct bfd_hash_entry *
1017 output_section_statement_newfunc (struct bfd_hash_entry *entry,
1018                                   struct bfd_hash_table *table,
1019                                   const char *string)
1020 {
1021   lang_output_section_statement_type **nextp;
1022   struct out_section_hash_entry *ret;
1023
1024   if (entry == NULL)
1025     {
1026       entry = bfd_hash_allocate (table, sizeof (*ret));
1027       if (entry == NULL)
1028         return entry;
1029     }
1030
1031   entry = bfd_hash_newfunc (entry, table, string);
1032   if (entry == NULL)
1033     return entry;
1034
1035   ret = (struct out_section_hash_entry *) entry;
1036   memset (&ret->s, 0, sizeof (ret->s));
1037   ret->s.header.type = lang_output_section_statement_enum;
1038   ret->s.output_section_statement.subsection_alignment = -1;
1039   ret->s.output_section_statement.section_alignment = -1;
1040   ret->s.output_section_statement.block_value = 1;
1041   lang_list_init (&ret->s.output_section_statement.children);
1042   lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);
1043
1044   /* For every output section statement added to the list, except the
1045      first one, lang_output_section_statement.tail points to the "next"
1046      field of the last element of the list.  */
1047   if (lang_output_section_statement.head != NULL)
1048     ret->s.output_section_statement.prev
1049       = ((lang_output_section_statement_type *)
1050          ((char *) lang_output_section_statement.tail
1051           - offsetof (lang_output_section_statement_type, next)));
1052
1053   /* GCC's strict aliasing rules prevent us from just casting the
1054      address, so we store the pointer in a variable and cast that
1055      instead.  */
1056   nextp = &ret->s.output_section_statement.next;
1057   lang_statement_append (&lang_output_section_statement,
1058                          &ret->s,
1059                          (lang_statement_union_type **) nextp);
1060   return &ret->root;
1061 }
1062
1063 static void
1064 output_section_statement_table_init (void)
1065 {
1066   if (!bfd_hash_table_init_n (&output_section_statement_table,
1067                               output_section_statement_newfunc,
1068                               sizeof (struct out_section_hash_entry),
1069                               61))
1070     einfo (_("%P%F: can not create hash table: %E\n"));
1071 }
1072
1073 static void
1074 output_section_statement_table_free (void)
1075 {
1076   bfd_hash_table_free (&output_section_statement_table);
1077 }
1078
1079 /* Build enough state so that the parser can build its tree.  */
1080
1081 void
1082 lang_init (void)
1083 {
1084   obstack_begin (&stat_obstack, 1000);
1085
1086   stat_ptr = &statement_list;
1087
1088   output_section_statement_table_init ();
1089
1090   lang_list_init (stat_ptr);
1091
1092   lang_list_init (&input_file_chain);
1093   lang_list_init (&lang_output_section_statement);
1094   lang_list_init (&file_chain);
1095   first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
1096                                     NULL);
1097   abs_output_section =
1098     lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
1099
1100   abs_output_section->bfd_section = bfd_abs_section_ptr;
1101
1102   /* The value "3" is ad-hoc, somewhat related to the expected number of
1103      DEFINED expressions in a linker script.  For most default linker
1104      scripts, there are none.  Why a hash table then?  Well, it's somewhat
1105      simpler to re-use working machinery than using a linked list in terms
1106      of code-complexity here in ld, besides the initialization which just
1107      looks like other code here.  */
1108   if (!bfd_hash_table_init_n (&lang_definedness_table,
1109                               lang_definedness_newfunc,
1110                               sizeof (struct lang_definedness_hash_entry),
1111                               3))
1112     einfo (_("%P%F: can not create hash table: %E\n"));
1113 }
1114
1115 void
1116 lang_finish (void)
1117 {
1118   output_section_statement_table_free ();
1119 }
1120
1121 /*----------------------------------------------------------------------
1122   A region is an area of memory declared with the
1123   MEMORY {  name:org=exp, len=exp ... }
1124   syntax.
1125
1126   We maintain a list of all the regions here.
1127
1128   If no regions are specified in the script, then the default is used
1129   which is created when looked up to be the entire data space.
1130
1131   If create is true we are creating a region inside a MEMORY block.
1132   In this case it is probably an error to create a region that has
1133   already been created.  If we are not inside a MEMORY block it is
1134   dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1135   and so we issue a warning.  */
1136
1137 static lang_memory_region_type *lang_memory_region_list;
1138 static lang_memory_region_type **lang_memory_region_list_tail
1139   = &lang_memory_region_list;
1140
1141 lang_memory_region_type *
1142 lang_memory_region_lookup (const char *const name, bfd_boolean create)
1143 {
1144   lang_memory_region_type *p;
1145   lang_memory_region_type *new;
1146
1147   /* NAME is NULL for LMA memspecs if no region was specified.  */
1148   if (name == NULL)
1149     return NULL;
1150
1151   for (p = lang_memory_region_list; p != NULL; p = p->next)
1152     if (strcmp (p->name, name) == 0)
1153       {
1154         if (create)
1155           einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
1156                  name);
1157         return p;
1158       }
1159
1160   if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
1161     einfo (_("%P:%S: warning: memory region %s not declared\n"), name);
1162
1163   new = stat_alloc (sizeof (lang_memory_region_type));
1164
1165   new->name = xstrdup (name);
1166   new->next = NULL;
1167   new->origin = 0;
1168   new->length = ~(bfd_size_type) 0;
1169   new->current = 0;
1170   new->last_os = NULL;
1171   new->flags = 0;
1172   new->not_flags = 0;
1173   new->had_full_message = FALSE;
1174
1175   *lang_memory_region_list_tail = new;
1176   lang_memory_region_list_tail = &new->next;
1177
1178   return new;
1179 }
1180
1181 static lang_memory_region_type *
1182 lang_memory_default (asection *section)
1183 {
1184   lang_memory_region_type *p;
1185
1186   flagword sec_flags = section->flags;
1187
1188   /* Override SEC_DATA to mean a writable section.  */
1189   if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
1190     sec_flags |= SEC_DATA;
1191
1192   for (p = lang_memory_region_list; p != NULL; p = p->next)
1193     {
1194       if ((p->flags & sec_flags) != 0
1195           && (p->not_flags & sec_flags) == 0)
1196         {
1197           return p;
1198         }
1199     }
1200   return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
1201 }
1202
1203 lang_output_section_statement_type *
1204 lang_output_section_find (const char *const name)
1205 {
1206   struct out_section_hash_entry *entry;
1207   unsigned long hash;
1208
1209   entry = ((struct out_section_hash_entry *)
1210            bfd_hash_lookup (&output_section_statement_table, name,
1211                             FALSE, FALSE));
1212   if (entry == NULL)
1213     return NULL;
1214
1215   hash = entry->root.hash;
1216   do
1217     {
1218       if (entry->s.output_section_statement.constraint != -1)
1219         return &entry->s.output_section_statement;
1220       entry = (struct out_section_hash_entry *) entry->root.next;
1221     }
1222   while (entry != NULL
1223          && entry->root.hash == hash
1224          && strcmp (name, entry->s.output_section_statement.name) == 0);
1225
1226   return NULL;
1227 }
1228
1229 static lang_output_section_statement_type *
1230 lang_output_section_statement_lookup_1 (const char *const name, int constraint)
1231 {
1232   struct out_section_hash_entry *entry;
1233   struct out_section_hash_entry *last_ent;
1234   unsigned long hash;
1235
1236   entry = ((struct out_section_hash_entry *)
1237            bfd_hash_lookup (&output_section_statement_table, name,
1238                             TRUE, FALSE));
1239   if (entry == NULL)
1240     {
1241       einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1242       return NULL;
1243     }
1244
1245   if (entry->s.output_section_statement.name != NULL)
1246     {
1247       /* We have a section of this name, but it might not have the correct
1248          constraint.  */
1249       hash = entry->root.hash;
1250       do
1251         {
1252           if (entry->s.output_section_statement.constraint != -1
1253               && (constraint == 0
1254                   || (constraint == entry->s.output_section_statement.constraint
1255                       && constraint != SPECIAL)))
1256             return &entry->s.output_section_statement;
1257           last_ent = entry;
1258           entry = (struct out_section_hash_entry *) entry->root.next;
1259         }
1260       while (entry != NULL
1261              && entry->root.hash == hash
1262              && strcmp (name, entry->s.output_section_statement.name) == 0);
1263
1264       entry
1265         = ((struct out_section_hash_entry *)
1266            output_section_statement_newfunc (NULL,
1267                                              &output_section_statement_table,
1268                                              name));
1269       if (entry == NULL)
1270         {
1271           einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1272           return NULL;
1273         }
1274       entry->root = last_ent->root;
1275       last_ent->root.next = &entry->root;
1276     }
1277
1278   entry->s.output_section_statement.name = name;
1279   entry->s.output_section_statement.constraint = constraint;
1280   return &entry->s.output_section_statement;
1281 }
1282
1283 lang_output_section_statement_type *
1284 lang_output_section_statement_lookup (const char *const name)
1285 {
1286   return lang_output_section_statement_lookup_1 (name, 0);
1287 }
1288
1289 /* A variant of lang_output_section_find used by place_orphan.
1290    Returns the output statement that should precede a new output
1291    statement for SEC.  If an exact match is found on certain flags,
1292    sets *EXACT too.  */
1293
1294 lang_output_section_statement_type *
1295 lang_output_section_find_by_flags (const asection *sec,
1296                                    lang_output_section_statement_type **exact,
1297                                    lang_match_sec_type_func match_type)
1298 {
1299   lang_output_section_statement_type *first, *look, *found;
1300   flagword flags;
1301
1302   /* We know the first statement on this list is *ABS*.  May as well
1303      skip it.  */
1304   first = &lang_output_section_statement.head->output_section_statement;
1305   first = first->next;
1306
1307   /* First try for an exact match.  */
1308   found = NULL;
1309   for (look = first; look; look = look->next)
1310     {
1311       flags = look->flags;
1312       if (look->bfd_section != NULL)
1313         {
1314           flags = look->bfd_section->flags;
1315           if (match_type && !match_type (link_info.output_bfd,
1316                                          look->bfd_section,
1317                                          sec->owner, sec))
1318             continue;
1319         }
1320       flags ^= sec->flags;
1321       if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1322                      | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1323         found = look;
1324     }
1325   if (found != NULL)
1326     {
1327       if (exact != NULL)
1328         *exact = found;
1329       return found;
1330     }
1331
1332   if (sec->flags & SEC_CODE)
1333     {
1334       /* Try for a rw code section.  */
1335       for (look = first; look; look = look->next)
1336         {
1337           flags = look->flags;
1338           if (look->bfd_section != NULL)
1339             {
1340               flags = look->bfd_section->flags;
1341               if (match_type && !match_type (link_info.output_bfd,
1342                                              look->bfd_section,
1343                                              sec->owner, sec))
1344                 continue;
1345             }
1346           flags ^= sec->flags;
1347           if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1348                          | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1349             found = look;
1350         }
1351     }
1352   else if (sec->flags & (SEC_READONLY | SEC_THREAD_LOCAL))
1353     {
1354       /* .rodata can go after .text, .sdata2 after .rodata.  */
1355       for (look = first; look; look = look->next)
1356         {
1357           flags = look->flags;
1358           if (look->bfd_section != NULL)
1359             {
1360               flags = look->bfd_section->flags;
1361               if (match_type && !match_type (link_info.output_bfd,
1362                                              look->bfd_section,
1363                                              sec->owner, sec))
1364                 continue;
1365             }
1366           flags ^= sec->flags;
1367           if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1368                          | SEC_READONLY))
1369               && !(look->flags & (SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1370             found = look;
1371         }
1372     }
1373   else if (sec->flags & SEC_SMALL_DATA)
1374     {
1375       /* .sdata goes after .data, .sbss after .sdata.  */
1376       for (look = first; look; look = look->next)
1377         {
1378           flags = look->flags;
1379           if (look->bfd_section != NULL)
1380             {
1381               flags = look->bfd_section->flags;
1382               if (match_type && !match_type (link_info.output_bfd,
1383                                              look->bfd_section,
1384                                              sec->owner, sec))
1385                 continue;
1386             }
1387           flags ^= sec->flags;
1388           if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1389                          | SEC_THREAD_LOCAL))
1390               || ((look->flags & SEC_SMALL_DATA)
1391                   && !(sec->flags & SEC_HAS_CONTENTS)))
1392             found = look;
1393         }
1394     }
1395   else if (sec->flags & SEC_HAS_CONTENTS)
1396     {
1397       /* .data goes after .rodata.  */
1398       for (look = first; look; look = look->next)
1399         {
1400           flags = look->flags;
1401           if (look->bfd_section != NULL)
1402             {
1403               flags = look->bfd_section->flags;
1404               if (match_type && !match_type (link_info.output_bfd,
1405                                              look->bfd_section,
1406                                              sec->owner, sec))
1407                 continue;
1408             }
1409           flags ^= sec->flags;
1410           if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1411                          | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1412             found = look;
1413         }
1414     }
1415   else
1416     {
1417       /* .bss goes last.  */
1418       for (look = first; look; look = look->next)
1419         {
1420           flags = look->flags;
1421           if (look->bfd_section != NULL)
1422             {
1423               flags = look->bfd_section->flags;
1424               if (match_type && !match_type (link_info.output_bfd,
1425                                              look->bfd_section,
1426                                              sec->owner, sec))
1427                 continue;
1428             }
1429           flags ^= sec->flags;
1430           if (!(flags & SEC_ALLOC))
1431             found = look;
1432         }
1433     }
1434
1435   if (found || !match_type)
1436     return found;
1437
1438   return lang_output_section_find_by_flags (sec, NULL, NULL);
1439 }
1440
1441 /* Find the last output section before given output statement.
1442    Used by place_orphan.  */
1443
1444 static asection *
1445 output_prev_sec_find (lang_output_section_statement_type *os)
1446 {
1447   lang_output_section_statement_type *lookup;
1448
1449   for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)
1450     {
1451       if (lookup->constraint == -1)
1452         continue;
1453
1454       if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1455         return lookup->bfd_section;
1456     }
1457
1458   return NULL;
1459 }
1460
1461 /* Look for a suitable place for a new output section statement.  The
1462    idea is to skip over anything that might be inside a SECTIONS {}
1463    statement in a script, before we find another output section
1464    statement.  Assignments to "dot" before an output section statement
1465    are assumed to belong to it.  An exception to this rule is made for
1466    the first assignment to dot, otherwise we might put an orphan
1467    before . = . + SIZEOF_HEADERS or similar assignments that set the
1468    initial address.  */
1469
1470 static lang_statement_union_type **
1471 insert_os_after (lang_output_section_statement_type *after)
1472 {
1473   lang_statement_union_type **where;
1474   lang_statement_union_type **assign = NULL;
1475   bfd_boolean ignore_first;
1476
1477   ignore_first
1478     = after == &lang_output_section_statement.head->output_section_statement;
1479
1480   for (where = &after->header.next;
1481        *where != NULL;
1482        where = &(*where)->header.next)
1483     {
1484       switch ((*where)->header.type)
1485         {
1486         case lang_assignment_statement_enum:
1487           if (assign == NULL)
1488             {
1489               lang_assignment_statement_type *ass;
1490
1491               ass = &(*where)->assignment_statement;
1492               if (ass->exp->type.node_class != etree_assert
1493                   && ass->exp->assign.dst[0] == '.'
1494                   && ass->exp->assign.dst[1] == 0
1495                   && !ignore_first)
1496                 assign = where;
1497             }
1498           ignore_first = FALSE;
1499           continue;
1500         case lang_wild_statement_enum:
1501         case lang_input_section_enum:
1502         case lang_object_symbols_statement_enum:
1503         case lang_fill_statement_enum:
1504         case lang_data_statement_enum:
1505         case lang_reloc_statement_enum:
1506         case lang_padding_statement_enum:
1507         case lang_constructors_statement_enum:
1508           assign = NULL;
1509           continue;
1510         case lang_output_section_statement_enum:
1511           if (assign != NULL)
1512             where = assign;
1513           break;
1514         case lang_input_statement_enum:
1515         case lang_address_statement_enum:
1516         case lang_target_statement_enum:
1517         case lang_output_statement_enum:
1518         case lang_group_statement_enum:
1519         case lang_insert_statement_enum:
1520           continue;
1521         }
1522       break;
1523     }
1524
1525   return where;
1526 }
1527
1528 lang_output_section_statement_type *
1529 lang_insert_orphan (asection *s,
1530                     const char *secname,
1531                     lang_output_section_statement_type *after,
1532                     struct orphan_save *place,
1533                     etree_type *address,
1534                     lang_statement_list_type *add_child)
1535 {
1536   lang_statement_list_type *old;
1537   lang_statement_list_type add;
1538   const char *ps;
1539   lang_output_section_statement_type *os;
1540   lang_output_section_statement_type **os_tail;
1541
1542   /* Start building a list of statements for this section.
1543      First save the current statement pointer.  */
1544   old = stat_ptr;
1545
1546   /* If we have found an appropriate place for the output section
1547      statements for this orphan, add them to our own private list,
1548      inserting them later into the global statement list.  */
1549   if (after != NULL)
1550     {
1551       stat_ptr = &add;
1552       lang_list_init (stat_ptr);
1553     }
1554
1555   ps = NULL;
1556   if (config.build_constructors)
1557     {
1558       /* If the name of the section is representable in C, then create
1559          symbols to mark the start and the end of the section.  */
1560       for (ps = secname; *ps != '\0'; ps++)
1561         if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
1562           break;
1563       if (*ps == '\0')
1564         {
1565           char *symname;
1566           etree_type *e_align;
1567
1568           symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
1569           symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1570           sprintf (symname + (symname[0] != 0), "__start_%s", secname);
1571           e_align = exp_unop (ALIGN_K,
1572                               exp_intop ((bfd_vma) 1 << s->alignment_power));
1573           lang_add_assignment (exp_assop ('=', ".", e_align));
1574           lang_add_assignment (exp_provide (symname,
1575                                             exp_nameop (NAME, "."),
1576                                             FALSE));
1577         }
1578     }
1579
1580   if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1581     address = exp_intop (0);
1582
1583   os_tail = ((lang_output_section_statement_type **)
1584              lang_output_section_statement.tail);
1585   os = lang_enter_output_section_statement (secname, address, 0, NULL, NULL,
1586                                             NULL, 0);
1587
1588   if (add_child == NULL)
1589     add_child = &os->children;
1590   lang_add_section (add_child, s, os);
1591
1592   lang_leave_output_section_statement (0, "*default*", NULL, NULL);
1593
1594   if (config.build_constructors && *ps == '\0')
1595     {
1596       char *symname;
1597
1598       /* lang_leave_ouput_section_statement resets stat_ptr.
1599          Put stat_ptr back where we want it.  */
1600       if (after != NULL)
1601         stat_ptr = &add;
1602
1603       symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
1604       symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1605       sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
1606       lang_add_assignment (exp_provide (symname,
1607                                         exp_nameop (NAME, "."),
1608                                         FALSE));
1609     }
1610
1611   /* Restore the global list pointer.  */
1612   if (after != NULL)
1613     stat_ptr = old;
1614
1615   if (after != NULL && os->bfd_section != NULL)
1616     {
1617       asection *snew, *as;
1618
1619       snew = os->bfd_section;
1620
1621       /* Shuffle the bfd section list to make the output file look
1622          neater.  This is really only cosmetic.  */
1623       if (place->section == NULL
1624           && after != (&lang_output_section_statement.head
1625                        ->output_section_statement))
1626         {
1627           asection *bfd_section = after->bfd_section;
1628
1629           /* If the output statement hasn't been used to place any input
1630              sections (and thus doesn't have an output bfd_section),
1631              look for the closest prior output statement having an
1632              output section.  */
1633           if (bfd_section == NULL)
1634             bfd_section = output_prev_sec_find (after);
1635
1636           if (bfd_section != NULL && bfd_section != snew)
1637             place->section = &bfd_section->next;
1638         }
1639
1640       if (place->section == NULL)
1641         place->section = &link_info.output_bfd->sections;
1642
1643       as = *place->section;
1644
1645       if (!as)
1646         {
1647           /* Put the section at the end of the list.  */
1648
1649           /* Unlink the section.  */
1650           bfd_section_list_remove (link_info.output_bfd, snew);
1651
1652           /* Now tack it back on in the right place.  */
1653           bfd_section_list_append (link_info.output_bfd, snew);
1654         }
1655       else if (as != snew && as->prev != snew)
1656         {
1657           /* Unlink the section.  */
1658           bfd_section_list_remove (link_info.output_bfd, snew);
1659
1660           /* Now tack it back on in the right place.  */
1661           bfd_section_list_insert_before (link_info.output_bfd, as, snew);
1662         }
1663
1664       /* Save the end of this list.  Further ophans of this type will
1665          follow the one we've just added.  */
1666       place->section = &snew->next;
1667
1668       /* The following is non-cosmetic.  We try to put the output
1669          statements in some sort of reasonable order here, because they
1670          determine the final load addresses of the orphan sections.
1671          In addition, placing output statements in the wrong order may
1672          require extra segments.  For instance, given a typical
1673          situation of all read-only sections placed in one segment and
1674          following that a segment containing all the read-write
1675          sections, we wouldn't want to place an orphan read/write
1676          section before or amongst the read-only ones.  */
1677       if (add.head != NULL)
1678         {
1679           lang_output_section_statement_type *newly_added_os;
1680
1681           if (place->stmt == NULL)
1682             {
1683               lang_statement_union_type **where = insert_os_after (after);
1684
1685               *add.tail = *where;
1686               *where = add.head;
1687
1688               place->os_tail = &after->next;
1689             }
1690           else
1691             {
1692               /* Put it after the last orphan statement we added.  */
1693               *add.tail = *place->stmt;
1694               *place->stmt = add.head;
1695             }
1696
1697           /* Fix the global list pointer if we happened to tack our
1698              new list at the tail.  */
1699           if (*old->tail == add.head)
1700             old->tail = add.tail;
1701
1702           /* Save the end of this list.  */
1703           place->stmt = add.tail;
1704
1705           /* Do the same for the list of output section statements.  */
1706           newly_added_os = *os_tail;
1707           *os_tail = NULL;
1708           newly_added_os->prev = (lang_output_section_statement_type *)
1709             ((char *) place->os_tail
1710              - offsetof (lang_output_section_statement_type, next));
1711           newly_added_os->next = *place->os_tail;
1712           if (newly_added_os->next != NULL)
1713             newly_added_os->next->prev = newly_added_os;
1714           *place->os_tail = newly_added_os;
1715           place->os_tail = &newly_added_os->next;
1716
1717           /* Fixing the global list pointer here is a little different.
1718              We added to the list in lang_enter_output_section_statement,
1719              trimmed off the new output_section_statment above when
1720              assigning *os_tail = NULL, but possibly added it back in
1721              the same place when assigning *place->os_tail.  */
1722           if (*os_tail == NULL)
1723             lang_output_section_statement.tail
1724               = (lang_statement_union_type **) os_tail;
1725         }
1726     }
1727   return os;
1728 }
1729
1730 static void
1731 lang_map_flags (flagword flag)
1732 {
1733   if (flag & SEC_ALLOC)
1734     minfo ("a");
1735
1736   if (flag & SEC_CODE)
1737     minfo ("x");
1738
1739   if (flag & SEC_READONLY)
1740     minfo ("r");
1741
1742   if (flag & SEC_DATA)
1743     minfo ("w");
1744
1745   if (flag & SEC_LOAD)
1746     minfo ("l");
1747 }
1748
1749 void
1750 lang_map (void)
1751 {
1752   lang_memory_region_type *m;
1753   bfd_boolean dis_header_printed = FALSE;
1754   bfd *p;
1755
1756   LANG_FOR_EACH_INPUT_STATEMENT (file)
1757     {
1758       asection *s;
1759
1760       if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
1761           || file->just_syms_flag)
1762         continue;
1763
1764       for (s = file->the_bfd->sections; s != NULL; s = s->next)
1765         if ((s->output_section == NULL
1766              || s->output_section->owner != link_info.output_bfd)
1767             && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0)
1768           {
1769             if (! dis_header_printed)
1770               {
1771                 fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
1772                 dis_header_printed = TRUE;
1773               }
1774
1775             print_input_section (s);
1776           }
1777     }
1778
1779   minfo (_("\nMemory Configuration\n\n"));
1780   fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
1781            _("Name"), _("Origin"), _("Length"), _("Attributes"));
1782
1783   for (m = lang_memory_region_list; m != NULL; m = m->next)
1784     {
1785       char buf[100];
1786       int len;
1787
1788       fprintf (config.map_file, "%-16s ", m->name);
1789
1790       sprintf_vma (buf, m->origin);
1791       minfo ("0x%s ", buf);
1792       len = strlen (buf);
1793       while (len < 16)
1794         {
1795           print_space ();
1796           ++len;
1797         }
1798
1799       minfo ("0x%V", m->length);
1800       if (m->flags || m->not_flags)
1801         {
1802 #ifndef BFD64
1803           minfo ("        ");
1804 #endif
1805           if (m->flags)
1806             {
1807               print_space ();
1808               lang_map_flags (m->flags);
1809             }
1810
1811           if (m->not_flags)
1812             {
1813               minfo (" !");
1814               lang_map_flags (m->not_flags);
1815             }
1816         }
1817
1818       print_nl ();
1819     }
1820
1821   fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
1822
1823   if (! link_info.reduce_memory_overheads)
1824     {
1825       obstack_begin (&map_obstack, 1000);
1826       for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
1827         bfd_map_over_sections (p, init_map_userdata, 0);
1828       bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
1829     }
1830   lang_statement_iteration ++;
1831   print_statements ();
1832 }
1833
1834 static void
1835 init_map_userdata (abfd, sec, data)
1836      bfd *abfd ATTRIBUTE_UNUSED;
1837      asection *sec;
1838      void *data ATTRIBUTE_UNUSED;
1839 {
1840   fat_section_userdata_type *new_data
1841     = ((fat_section_userdata_type *) (stat_alloc
1842                                       (sizeof (fat_section_userdata_type))));
1843
1844   ASSERT (get_userdata (sec) == NULL);
1845   get_userdata (sec) = new_data;
1846   new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
1847 }
1848
1849 static bfd_boolean
1850 sort_def_symbol (hash_entry, info)
1851      struct bfd_link_hash_entry *hash_entry;
1852      void *info ATTRIBUTE_UNUSED;
1853 {
1854   if (hash_entry->type == bfd_link_hash_defined
1855       || hash_entry->type == bfd_link_hash_defweak)
1856     {
1857       struct fat_user_section_struct *ud;
1858       struct map_symbol_def *def;
1859
1860       ud = get_userdata (hash_entry->u.def.section);
1861       if  (! ud)
1862         {
1863           /* ??? What do we have to do to initialize this beforehand?  */
1864           /* The first time we get here is bfd_abs_section...  */
1865           init_map_userdata (0, hash_entry->u.def.section, 0);
1866           ud = get_userdata (hash_entry->u.def.section);
1867         }
1868       else if  (!ud->map_symbol_def_tail)
1869         ud->map_symbol_def_tail = &ud->map_symbol_def_head;
1870
1871       def = obstack_alloc (&map_obstack, sizeof *def);
1872       def->entry = hash_entry;
1873       *(ud->map_symbol_def_tail) = def;
1874       ud->map_symbol_def_tail = &def->next;
1875     }
1876   return TRUE;
1877 }
1878
1879 /* Initialize an output section.  */
1880
1881 static void
1882 init_os (lang_output_section_statement_type *s, asection *isec,
1883          flagword flags)
1884 {
1885   if (s->bfd_section != NULL)
1886     return;
1887
1888   if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
1889     einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
1890
1891   s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);
1892   if (s->bfd_section == NULL)
1893     s->bfd_section = bfd_make_section_with_flags (link_info.output_bfd,
1894                                                   s->name, flags);
1895   if (s->bfd_section == NULL)
1896     {
1897       einfo (_("%P%F: output format %s cannot represent section called %s\n"),
1898              link_info.output_bfd->xvec->name, s->name);
1899     }
1900   s->bfd_section->output_section = s->bfd_section;
1901   s->bfd_section->output_offset = 0;
1902
1903   if (!link_info.reduce_memory_overheads)
1904     {
1905       fat_section_userdata_type *new
1906         = stat_alloc (sizeof (fat_section_userdata_type));
1907       memset (new, 0, sizeof (fat_section_userdata_type));
1908       get_userdata (s->bfd_section) = new;
1909     }
1910
1911   /* If there is a base address, make sure that any sections it might
1912      mention are initialized.  */
1913   if (s->addr_tree != NULL)
1914     exp_init_os (s->addr_tree);
1915
1916   if (s->load_base != NULL)
1917     exp_init_os (s->load_base);
1918
1919   /* If supplied an alignment, set it.  */
1920   if (s->section_alignment != -1)
1921     s->bfd_section->alignment_power = s->section_alignment;
1922
1923   if (isec)
1924     bfd_init_private_section_data (isec->owner, isec,
1925                                    link_info.output_bfd, s->bfd_section,
1926                                    &link_info);
1927 }
1928
1929 /* Make sure that all output sections mentioned in an expression are
1930    initialized.  */
1931
1932 static void
1933 exp_init_os (etree_type *exp)
1934 {
1935   switch (exp->type.node_class)
1936     {
1937     case etree_assign:
1938     case etree_provide:
1939       exp_init_os (exp->assign.src);
1940       break;
1941
1942     case etree_binary:
1943       exp_init_os (exp->binary.lhs);
1944       exp_init_os (exp->binary.rhs);
1945       break;
1946
1947     case etree_trinary:
1948       exp_init_os (exp->trinary.cond);
1949       exp_init_os (exp->trinary.lhs);
1950       exp_init_os (exp->trinary.rhs);
1951       break;
1952
1953     case etree_assert:
1954       exp_init_os (exp->assert_s.child);
1955       break;
1956
1957     case etree_unary:
1958       exp_init_os (exp->unary.child);
1959       break;
1960
1961     case etree_name:
1962       switch (exp->type.node_code)
1963         {
1964         case ADDR:
1965         case LOADADDR:
1966         case SIZEOF:
1967           {
1968             lang_output_section_statement_type *os;
1969
1970             os = lang_output_section_find (exp->name.name);
1971             if (os != NULL && os->bfd_section == NULL)
1972               init_os (os, NULL, 0);
1973           }
1974         }
1975       break;
1976
1977     default:
1978       break;
1979     }
1980 }
1981 \f
1982 static void
1983 section_already_linked (bfd *abfd, asection *sec, void *data)
1984 {
1985   lang_input_statement_type *entry = data;
1986
1987   /* If we are only reading symbols from this object, then we want to
1988      discard all sections.  */
1989   if (entry->just_syms_flag)
1990     {
1991       bfd_link_just_syms (abfd, sec, &link_info);
1992       return;
1993     }
1994
1995   if (!(abfd->flags & DYNAMIC))
1996     bfd_section_already_linked (abfd, sec, &link_info);
1997 }
1998 \f
1999 /* The wild routines.
2000
2001    These expand statements like *(.text) and foo.o to a list of
2002    explicit actions, like foo.o(.text), bar.o(.text) and
2003    foo.o(.text, .data).  */
2004
2005 /* Add SECTION to the output section OUTPUT.  Do this by creating a
2006    lang_input_section statement which is placed at PTR.  FILE is the
2007    input file which holds SECTION.  */
2008
2009 void
2010 lang_add_section (lang_statement_list_type *ptr,
2011                   asection *section,
2012                   lang_output_section_statement_type *output)
2013 {
2014   flagword flags = section->flags;
2015   bfd_boolean discard;
2016
2017   /* Discard sections marked with SEC_EXCLUDE.  */
2018   discard = (flags & SEC_EXCLUDE) != 0;
2019
2020   /* Discard input sections which are assigned to a section named
2021      DISCARD_SECTION_NAME.  */
2022   if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
2023     discard = TRUE;
2024
2025   /* Discard debugging sections if we are stripping debugging
2026      information.  */
2027   if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
2028       && (flags & SEC_DEBUGGING) != 0)
2029     discard = TRUE;
2030
2031   if (discard)
2032     {
2033       if (section->output_section == NULL)
2034         {
2035           /* This prevents future calls from assigning this section.  */
2036           section->output_section = bfd_abs_section_ptr;
2037         }
2038       return;
2039     }
2040
2041   if (section->output_section == NULL)
2042     {
2043       bfd_boolean first;
2044       lang_input_section_type *new;
2045       flagword flags;
2046
2047       flags = section->flags;
2048
2049       /* We don't copy the SEC_NEVER_LOAD flag from an input section
2050          to an output section, because we want to be able to include a
2051          SEC_NEVER_LOAD section in the middle of an otherwise loaded
2052          section (I don't know why we want to do this, but we do).
2053          build_link_order in ldwrite.c handles this case by turning
2054          the embedded SEC_NEVER_LOAD section into a fill.  */
2055
2056       flags &= ~ SEC_NEVER_LOAD;
2057
2058       switch (output->sectype)
2059         {
2060         case normal_section:
2061         case overlay_section:
2062           break;
2063         case noalloc_section:
2064           flags &= ~SEC_ALLOC;
2065           break;
2066         case noload_section:
2067           flags &= ~SEC_LOAD;
2068           flags |= SEC_NEVER_LOAD;
2069           break;
2070         }
2071
2072       if (output->bfd_section == NULL)
2073         init_os (output, section, flags);
2074
2075       first = ! output->bfd_section->linker_has_input;
2076       output->bfd_section->linker_has_input = 1;
2077
2078       if (!link_info.relocatable
2079           && !stripped_excluded_sections)
2080         {
2081           asection *s = output->bfd_section->map_tail.s;
2082           output->bfd_section->map_tail.s = section;
2083           section->map_head.s = NULL;
2084           section->map_tail.s = s;
2085           if (s != NULL)
2086             s->map_head.s = section;
2087           else
2088             output->bfd_section->map_head.s = section;
2089         }
2090
2091       /* Add a section reference to the list.  */
2092       new = new_stat (lang_input_section, ptr);
2093
2094       new->section = section;
2095       section->output_section = output->bfd_section;
2096
2097       /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2098          already been processed.  One reason to do this is that on pe
2099          format targets, .text$foo sections go into .text and it's odd
2100          to see .text with SEC_LINK_ONCE set.  */
2101
2102       if (! link_info.relocatable)
2103         flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
2104
2105       /* If this is not the first input section, and the SEC_READONLY
2106          flag is not currently set, then don't set it just because the
2107          input section has it set.  */
2108
2109       if (! first && (output->bfd_section->flags & SEC_READONLY) == 0)
2110         flags &= ~ SEC_READONLY;
2111
2112       /* Keep SEC_MERGE and SEC_STRINGS only if they are the same.  */
2113       if (! first
2114           && ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
2115               != (flags & (SEC_MERGE | SEC_STRINGS))
2116               || ((flags & SEC_MERGE)
2117                   && output->bfd_section->entsize != section->entsize)))
2118         {
2119           output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
2120           flags &= ~ (SEC_MERGE | SEC_STRINGS);
2121         }
2122
2123       output->bfd_section->flags |= flags;
2124
2125       if (flags & SEC_MERGE)
2126         output->bfd_section->entsize = section->entsize;
2127
2128       /* If SEC_READONLY is not set in the input section, then clear
2129          it from the output section.  */
2130       if ((section->flags & SEC_READONLY) == 0)
2131         output->bfd_section->flags &= ~SEC_READONLY;
2132
2133       /* Copy over SEC_SMALL_DATA.  */
2134       if (section->flags & SEC_SMALL_DATA)
2135         output->bfd_section->flags |= SEC_SMALL_DATA;
2136
2137       if (section->alignment_power > output->bfd_section->alignment_power)
2138         output->bfd_section->alignment_power = section->alignment_power;
2139
2140       if (bfd_get_arch (section->owner) == bfd_arch_tic54x
2141           && (section->flags & SEC_TIC54X_BLOCK) != 0)
2142         {
2143           output->bfd_section->flags |= SEC_TIC54X_BLOCK;
2144           /* FIXME: This value should really be obtained from the bfd...  */
2145           output->block_value = 128;
2146         }
2147     }
2148 }
2149
2150 /* Handle wildcard sorting.  This returns the lang_input_section which
2151    should follow the one we are going to create for SECTION and FILE,
2152    based on the sorting requirements of WILD.  It returns NULL if the
2153    new section should just go at the end of the current list.  */
2154
2155 static lang_statement_union_type *
2156 wild_sort (lang_wild_statement_type *wild,
2157            struct wildcard_list *sec,
2158            lang_input_statement_type *file,
2159            asection *section)
2160 {
2161   const char *section_name;
2162   lang_statement_union_type *l;
2163
2164   if (!wild->filenames_sorted
2165       && (sec == NULL || sec->spec.sorted == none))
2166     return NULL;
2167
2168   section_name = bfd_get_section_name (file->the_bfd, section);
2169   for (l = wild->children.head; l != NULL; l = l->header.next)
2170     {
2171       lang_input_section_type *ls;
2172
2173       if (l->header.type != lang_input_section_enum)
2174         continue;
2175       ls = &l->input_section;
2176
2177       /* Sorting by filename takes precedence over sorting by section
2178          name.  */
2179
2180       if (wild->filenames_sorted)
2181         {
2182           const char *fn, *ln;
2183           bfd_boolean fa, la;
2184           int i;
2185
2186           /* The PE support for the .idata section as generated by
2187              dlltool assumes that files will be sorted by the name of
2188              the archive and then the name of the file within the
2189              archive.  */
2190
2191           if (file->the_bfd != NULL
2192               && bfd_my_archive (file->the_bfd) != NULL)
2193             {
2194               fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
2195               fa = TRUE;
2196             }
2197           else
2198             {
2199               fn = file->filename;
2200               fa = FALSE;
2201             }
2202
2203           if (bfd_my_archive (ls->section->owner) != NULL)
2204             {
2205               ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
2206               la = TRUE;
2207             }
2208           else
2209             {
2210               ln = ls->section->owner->filename;
2211               la = FALSE;
2212             }
2213
2214           i = strcmp (fn, ln);
2215           if (i > 0)
2216             continue;
2217           else if (i < 0)
2218             break;
2219
2220           if (fa || la)
2221             {
2222               if (fa)
2223                 fn = file->filename;
2224               if (la)
2225                 ln = ls->section->owner->filename;
2226
2227               i = strcmp (fn, ln);
2228               if (i > 0)
2229                 continue;
2230               else if (i < 0)
2231                 break;
2232             }
2233         }
2234
2235       /* Here either the files are not sorted by name, or we are
2236          looking at the sections for this file.  */
2237
2238       if (sec != NULL && sec->spec.sorted != none)
2239         if (compare_section (sec->spec.sorted, section, ls->section) < 0)
2240           break;
2241     }
2242
2243   return l;
2244 }
2245
2246 /* Expand a wild statement for a particular FILE.  SECTION may be
2247    NULL, in which case it is a wild card.  */
2248
2249 static void
2250 output_section_callback (lang_wild_statement_type *ptr,
2251                          struct wildcard_list *sec,
2252                          asection *section,
2253                          lang_input_statement_type *file,
2254                          void *output)
2255 {
2256   lang_statement_union_type *before;
2257
2258   /* Exclude sections that match UNIQUE_SECTION_LIST.  */
2259   if (unique_section_p (section))
2260     return;
2261
2262   before = wild_sort (ptr, sec, file, section);
2263
2264   /* Here BEFORE points to the lang_input_section which
2265      should follow the one we are about to add.  If BEFORE
2266      is NULL, then the section should just go at the end
2267      of the current list.  */
2268
2269   if (before == NULL)
2270     lang_add_section (&ptr->children, section,
2271                       (lang_output_section_statement_type *) output);
2272   else
2273     {
2274       lang_statement_list_type list;
2275       lang_statement_union_type **pp;
2276
2277       lang_list_init (&list);
2278       lang_add_section (&list, section,
2279                         (lang_output_section_statement_type *) output);
2280
2281       /* If we are discarding the section, LIST.HEAD will
2282          be NULL.  */
2283       if (list.head != NULL)
2284         {
2285           ASSERT (list.head->header.next == NULL);
2286
2287           for (pp = &ptr->children.head;
2288                *pp != before;
2289                pp = &(*pp)->header.next)
2290             ASSERT (*pp != NULL);
2291
2292           list.head->header.next = *pp;
2293           *pp = list.head;
2294         }
2295     }
2296 }
2297
2298 /* Check if all sections in a wild statement for a particular FILE
2299    are readonly.  */
2300
2301 static void
2302 check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
2303                         struct wildcard_list *sec ATTRIBUTE_UNUSED,
2304                         asection *section,
2305                         lang_input_statement_type *file ATTRIBUTE_UNUSED,
2306                         void *data)
2307 {
2308   /* Exclude sections that match UNIQUE_SECTION_LIST.  */
2309   if (unique_section_p (section))
2310     return;
2311
2312   if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
2313     ((lang_output_section_statement_type *) data)->all_input_readonly = FALSE;
2314 }
2315
2316 /* This is passed a file name which must have been seen already and
2317    added to the statement tree.  We will see if it has been opened
2318    already and had its symbols read.  If not then we'll read it.  */
2319
2320 static lang_input_statement_type *
2321 lookup_name (const char *name)
2322 {
2323   lang_input_statement_type *search;
2324
2325   for (search = (lang_input_statement_type *) input_file_chain.head;
2326        search != NULL;
2327        search = (lang_input_statement_type *) search->next_real_file)
2328     {
2329       /* Use the local_sym_name as the name of the file that has
2330          already been loaded as filename might have been transformed
2331          via the search directory lookup mechanism.  */
2332       const char *filename = search->local_sym_name;
2333
2334       if (filename != NULL
2335           && strcmp (filename, name) == 0)
2336         break;
2337     }
2338
2339   if (search == NULL)
2340     search = new_afile (name, lang_input_file_is_search_file_enum,
2341                         default_target, FALSE);
2342
2343   /* If we have already added this file, or this file is not real
2344      don't add this file.  */
2345   if (search->loaded || !search->real)
2346     return search;
2347
2348   if (! load_symbols (search, NULL))
2349     return NULL;
2350
2351   return search;
2352 }
2353
2354 /* Save LIST as a list of libraries whose symbols should not be exported.  */
2355
2356 struct excluded_lib
2357 {
2358   char *name;
2359   struct excluded_lib *next;
2360 };
2361 static struct excluded_lib *excluded_libs;
2362
2363 void
2364 add_excluded_libs (const char *list)
2365 {
2366   const char *p = list, *end;
2367
2368   while (*p != '\0')
2369     {
2370       struct excluded_lib *entry;
2371       end = strpbrk (p, ",:");
2372       if (end == NULL)
2373         end = p + strlen (p);
2374       entry = xmalloc (sizeof (*entry));
2375       entry->next = excluded_libs;
2376       entry->name = xmalloc (end - p + 1);
2377       memcpy (entry->name, p, end - p);
2378       entry->name[end - p] = '\0';
2379       excluded_libs = entry;
2380       if (*end == '\0')
2381         break;
2382       p = end + 1;
2383     }
2384 }
2385
2386 static void
2387 check_excluded_libs (bfd *abfd)
2388 {
2389   struct excluded_lib *lib = excluded_libs;
2390
2391   while (lib)
2392     {
2393       int len = strlen (lib->name);
2394       const char *filename = lbasename (abfd->filename);
2395
2396       if (strcmp (lib->name, "ALL") == 0)
2397         {
2398           abfd->no_export = TRUE;
2399           return;
2400         }
2401
2402       if (strncmp (lib->name, filename, len) == 0
2403           && (filename[len] == '\0'
2404               || (filename[len] == '.' && filename[len + 1] == 'a'
2405                   && filename[len + 2] == '\0')))
2406         {
2407           abfd->no_export = TRUE;
2408           return;
2409         }
2410
2411       lib = lib->next;
2412     }
2413 }
2414
2415 /* Get the symbols for an input file.  */
2416
2417 bfd_boolean
2418 load_symbols (lang_input_statement_type *entry,
2419               lang_statement_list_type *place)
2420 {
2421   char **matching;
2422
2423   if (entry->loaded)
2424     return TRUE;
2425
2426   ldfile_open_file (entry);
2427
2428   if (! bfd_check_format (entry->the_bfd, bfd_archive)
2429       && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
2430     {
2431       bfd_error_type err;
2432       lang_statement_list_type *hold;
2433       bfd_boolean bad_load = TRUE;
2434       bfd_boolean save_ldlang_sysrooted_script;
2435       bfd_boolean save_as_needed, save_add_needed;
2436
2437       err = bfd_get_error ();
2438
2439       /* See if the emulation has some special knowledge.  */
2440       if (ldemul_unrecognized_file (entry))
2441         return TRUE;
2442
2443       if (err == bfd_error_file_ambiguously_recognized)
2444         {
2445           char **p;
2446
2447           einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
2448           einfo (_("%B: matching formats:"), entry->the_bfd);
2449           for (p = matching; *p != NULL; p++)
2450             einfo (" %s", *p);
2451           einfo ("%F\n");
2452         }
2453       else if (err != bfd_error_file_not_recognized
2454                || place == NULL)
2455           einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
2456       else
2457         bad_load = FALSE;
2458
2459       bfd_close (entry->the_bfd);
2460       entry->the_bfd = NULL;
2461
2462       /* Try to interpret the file as a linker script.  */
2463       ldfile_open_command_file (entry->filename);
2464
2465       hold = stat_ptr;
2466       stat_ptr = place;
2467       save_ldlang_sysrooted_script = ldlang_sysrooted_script;
2468       ldlang_sysrooted_script = entry->sysrooted;
2469       save_as_needed = as_needed;
2470       as_needed = entry->as_needed;
2471       save_add_needed = add_needed;
2472       add_needed = entry->add_needed;
2473
2474       ldfile_assumed_script = TRUE;
2475       parser_input = input_script;
2476       /* We want to use the same -Bdynamic/-Bstatic as the one for
2477          ENTRY.  */
2478       config.dynamic_link = entry->dynamic;
2479       yyparse ();
2480       ldfile_assumed_script = FALSE;
2481
2482       ldlang_sysrooted_script = save_ldlang_sysrooted_script;
2483       as_needed = save_as_needed;
2484       add_needed = save_add_needed;
2485       stat_ptr = hold;
2486
2487       return ! bad_load;
2488     }
2489
2490   if (ldemul_recognized_file (entry))
2491     return TRUE;
2492
2493   /* We don't call ldlang_add_file for an archive.  Instead, the
2494      add_symbols entry point will call ldlang_add_file, via the
2495      add_archive_element callback, for each element of the archive
2496      which is used.  */
2497   switch (bfd_get_format (entry->the_bfd))
2498     {
2499     default:
2500       break;
2501
2502     case bfd_object:
2503       ldlang_add_file (entry);
2504       if (trace_files || trace_file_tries)
2505         info_msg ("%I\n", entry);
2506       break;
2507
2508     case bfd_archive:
2509       check_excluded_libs (entry->the_bfd);
2510
2511       if (entry->whole_archive)
2512         {
2513           bfd *member = NULL;
2514           bfd_boolean loaded = TRUE;
2515
2516           for (;;)
2517             {
2518               member = bfd_openr_next_archived_file (entry->the_bfd, member);
2519
2520               if (member == NULL)
2521                 break;
2522
2523               if (! bfd_check_format (member, bfd_object))
2524                 {
2525                   einfo (_("%F%B: member %B in archive is not an object\n"),
2526                          entry->the_bfd, member);
2527                   loaded = FALSE;
2528                 }
2529
2530               if (! ((*link_info.callbacks->add_archive_element)
2531                      (&link_info, member, "--whole-archive")))
2532                 abort ();
2533
2534               if (! bfd_link_add_symbols (member, &link_info))
2535                 {
2536                   einfo (_("%F%B: could not read symbols: %E\n"), member);
2537                   loaded = FALSE;
2538                 }
2539             }
2540
2541           entry->loaded = loaded;
2542           return loaded;
2543         }
2544       break;
2545     }
2546
2547   if (bfd_link_add_symbols (entry->the_bfd, &link_info))
2548     entry->loaded = TRUE;
2549   else
2550     einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
2551
2552   return entry->loaded;
2553 }
2554
2555 /* Handle a wild statement.  S->FILENAME or S->SECTION_LIST or both
2556    may be NULL, indicating that it is a wildcard.  Separate
2557    lang_input_section statements are created for each part of the
2558    expansion; they are added after the wild statement S.  OUTPUT is
2559    the output section.  */
2560
2561 static void
2562 wild (lang_wild_statement_type *s,
2563       const char *target ATTRIBUTE_UNUSED,
2564       lang_output_section_statement_type *output)
2565 {
2566   struct wildcard_list *sec;
2567
2568   if (s->handler_data[0]
2569       && s->handler_data[0]->spec.sorted == by_name
2570       && !s->filenames_sorted)
2571     {
2572       lang_section_bst_type *tree;
2573
2574       walk_wild (s, output_section_callback_fast, output);
2575
2576       tree = s->tree;
2577       if (tree)
2578         {
2579           output_section_callback_tree_to_list (s, tree, output);
2580           s->tree = NULL;
2581         }
2582     }
2583   else
2584     walk_wild (s, output_section_callback, output);
2585
2586   if (default_common_section == NULL)
2587     for (sec = s->section_list; sec != NULL; sec = sec->next)
2588       if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
2589         {
2590           /* Remember the section that common is going to in case we
2591              later get something which doesn't know where to put it.  */
2592           default_common_section = output;
2593           break;
2594         }
2595 }
2596
2597 /* Return TRUE iff target is the sought target.  */
2598
2599 static int
2600 get_target (const bfd_target *target, void *data)
2601 {
2602   const char *sought = data;
2603
2604   return strcmp (target->name, sought) == 0;
2605 }
2606
2607 /* Like strcpy() but convert to lower case as well.  */
2608
2609 static void
2610 stricpy (char *dest, char *src)
2611 {
2612   char c;
2613
2614   while ((c = *src++) != 0)
2615     *dest++ = TOLOWER (c);
2616
2617   *dest = 0;
2618 }
2619
2620 /* Remove the first occurrence of needle (if any) in haystack
2621    from haystack.  */
2622
2623 static void
2624 strcut (char *haystack, char *needle)
2625 {
2626   haystack = strstr (haystack, needle);
2627
2628   if (haystack)
2629     {
2630       char *src;
2631
2632       for (src = haystack + strlen (needle); *src;)
2633         *haystack++ = *src++;
2634
2635       *haystack = 0;
2636     }
2637 }
2638
2639 /* Compare two target format name strings.
2640    Return a value indicating how "similar" they are.  */
2641
2642 static int
2643 name_compare (char *first, char *second)
2644 {
2645   char *copy1;
2646   char *copy2;
2647   int result;
2648
2649   copy1 = xmalloc (strlen (first) + 1);
2650   copy2 = xmalloc (strlen (second) + 1);
2651
2652   /* Convert the names to lower case.  */
2653   stricpy (copy1, first);
2654   stricpy (copy2, second);
2655
2656   /* Remove size and endian strings from the name.  */
2657   strcut (copy1, "big");
2658   strcut (copy1, "little");
2659   strcut (copy2, "big");
2660   strcut (copy2, "little");
2661
2662   /* Return a value based on how many characters match,
2663      starting from the beginning.   If both strings are
2664      the same then return 10 * their length.  */
2665   for (result = 0; copy1[result] == copy2[result]; result++)
2666     if (copy1[result] == 0)
2667       {
2668         result *= 10;
2669         break;
2670       }
2671
2672   free (copy1);
2673   free (copy2);
2674
2675   return result;
2676 }
2677
2678 /* Set by closest_target_match() below.  */
2679 static const bfd_target *winner;
2680
2681 /* Scan all the valid bfd targets looking for one that has the endianness
2682    requirement that was specified on the command line, and is the nearest
2683    match to the original output target.  */
2684
2685 static int
2686 closest_target_match (const bfd_target *target, void *data)
2687 {
2688   const bfd_target *original = data;
2689
2690   if (command_line.endian == ENDIAN_BIG
2691       && target->byteorder != BFD_ENDIAN_BIG)
2692     return 0;
2693
2694   if (command_line.endian == ENDIAN_LITTLE
2695       && target->byteorder != BFD_ENDIAN_LITTLE)
2696     return 0;
2697
2698   /* Must be the same flavour.  */
2699   if (target->flavour != original->flavour)
2700     return 0;
2701
2702   /* If we have not found a potential winner yet, then record this one.  */
2703   if (winner == NULL)
2704     {
2705       winner = target;
2706       return 0;
2707     }
2708
2709   /* Oh dear, we now have two potential candidates for a successful match.
2710      Compare their names and choose the better one.  */
2711   if (name_compare (target->name, original->name)
2712       > name_compare (winner->name, original->name))
2713     winner = target;
2714
2715   /* Keep on searching until wqe have checked them all.  */
2716   return 0;
2717 }
2718
2719 /* Return the BFD target format of the first input file.  */
2720
2721 static char *
2722 get_first_input_target (void)
2723 {
2724   char *target = NULL;
2725
2726   LANG_FOR_EACH_INPUT_STATEMENT (s)
2727     {
2728       if (s->header.type == lang_input_statement_enum
2729           && s->real)
2730         {
2731           ldfile_open_file (s);
2732
2733           if (s->the_bfd != NULL
2734               && bfd_check_format (s->the_bfd, bfd_object))
2735             {
2736               target = bfd_get_target (s->the_bfd);
2737
2738               if (target != NULL)
2739                 break;
2740             }
2741         }
2742     }
2743
2744   return target;
2745 }
2746
2747 const char *
2748 lang_get_output_target (void)
2749 {
2750   const char *target;
2751
2752   /* Has the user told us which output format to use?  */
2753   if (output_target != NULL)
2754     return output_target;
2755
2756   /* No - has the current target been set to something other than
2757      the default?  */
2758   if (current_target != default_target)
2759     return current_target;
2760
2761   /* No - can we determine the format of the first input file?  */
2762   target = get_first_input_target ();
2763   if (target != NULL)
2764     return target;
2765
2766   /* Failed - use the default output target.  */
2767   return default_target;
2768 }
2769
2770 /* Open the output file.  */
2771
2772 static void
2773 open_output (const char *name)
2774 {
2775   output_target = lang_get_output_target ();
2776
2777   /* Has the user requested a particular endianness on the command
2778      line?  */
2779   if (command_line.endian != ENDIAN_UNSET)
2780     {
2781       const bfd_target *target;
2782       enum bfd_endian desired_endian;
2783
2784       /* Get the chosen target.  */
2785       target = bfd_search_for_target (get_target, (void *) output_target);
2786
2787       /* If the target is not supported, we cannot do anything.  */
2788       if (target != NULL)
2789         {
2790           if (command_line.endian == ENDIAN_BIG)
2791             desired_endian = BFD_ENDIAN_BIG;
2792           else
2793             desired_endian = BFD_ENDIAN_LITTLE;
2794
2795           /* See if the target has the wrong endianness.  This should
2796              not happen if the linker script has provided big and
2797              little endian alternatives, but some scrips don't do
2798              this.  */
2799           if (target->byteorder != desired_endian)
2800             {
2801               /* If it does, then see if the target provides
2802                  an alternative with the correct endianness.  */
2803               if (target->alternative_target != NULL
2804                   && (target->alternative_target->byteorder == desired_endian))
2805                 output_target = target->alternative_target->name;
2806               else
2807                 {
2808                   /* Try to find a target as similar as possible to
2809                      the default target, but which has the desired
2810                      endian characteristic.  */
2811                   bfd_search_for_target (closest_target_match,
2812                                          (void *) target);
2813
2814                   /* Oh dear - we could not find any targets that
2815                      satisfy our requirements.  */
2816                   if (winner == NULL)
2817                     einfo (_("%P: warning: could not find any targets"
2818                              " that match endianness requirement\n"));
2819                   else
2820                     output_target = winner->name;
2821                 }
2822             }
2823         }
2824     }
2825
2826   link_info.output_bfd = bfd_openw (name, output_target);
2827
2828   if (link_info.output_bfd == NULL)
2829     {
2830       if (bfd_get_error () == bfd_error_invalid_target)
2831         einfo (_("%P%F: target %s not found\n"), output_target);
2832
2833       einfo (_("%P%F: cannot open output file %s: %E\n"), name);
2834     }
2835
2836   delete_output_file_on_failure = TRUE;
2837
2838   if (! bfd_set_format (link_info.output_bfd, bfd_object))
2839     einfo (_("%P%F:%s: can not make object file: %E\n"), name);
2840   if (! bfd_set_arch_mach (link_info.output_bfd,
2841                            ldfile_output_architecture,
2842                            ldfile_output_machine))
2843     einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
2844
2845   link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);
2846   if (link_info.hash == NULL)
2847     einfo (_("%P%F: can not create hash table: %E\n"));
2848
2849   bfd_set_gp_size (link_info.output_bfd, g_switch_value);
2850 }
2851
2852 static void
2853 ldlang_open_output (lang_statement_union_type *statement)
2854 {
2855   switch (statement->header.type)
2856     {
2857     case lang_output_statement_enum:
2858       ASSERT (link_info.output_bfd == NULL);
2859       open_output (statement->output_statement.name);
2860       ldemul_set_output_arch ();
2861       if (config.magic_demand_paged && !link_info.relocatable)
2862         link_info.output_bfd->flags |= D_PAGED;
2863       else
2864         link_info.output_bfd->flags &= ~D_PAGED;
2865       if (config.text_read_only)
2866         link_info.output_bfd->flags |= WP_TEXT;
2867       else
2868         link_info.output_bfd->flags &= ~WP_TEXT;
2869       if (link_info.traditional_format)
2870         link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
2871       else
2872         link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
2873       break;
2874
2875     case lang_target_statement_enum:
2876       current_target = statement->target_statement.target;
2877       break;
2878     default:
2879       break;
2880     }
2881 }
2882
2883 /* Convert between addresses in bytes and sizes in octets.
2884    For currently supported targets, octets_per_byte is always a power
2885    of two, so we can use shifts.  */
2886 #define TO_ADDR(X) ((X) >> opb_shift)
2887 #define TO_SIZE(X) ((X) << opb_shift)
2888
2889 /* Support the above.  */
2890 static unsigned int opb_shift = 0;
2891
2892 static void
2893 init_opb (void)
2894 {
2895   unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2896                                               ldfile_output_machine);
2897   opb_shift = 0;
2898   if (x > 1)
2899     while ((x & 1) == 0)
2900       {
2901         x >>= 1;
2902         ++opb_shift;
2903       }
2904   ASSERT (x == 1);
2905 }
2906
2907 /* Open all the input files.  */
2908
2909 static void
2910 open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
2911 {
2912   for (; s != NULL; s = s->header.next)
2913     {
2914       switch (s->header.type)
2915         {
2916         case lang_constructors_statement_enum:
2917           open_input_bfds (constructor_list.head, force);
2918           break;
2919         case lang_output_section_statement_enum:
2920           open_input_bfds (s->output_section_statement.children.head, force);
2921           break;
2922         case lang_wild_statement_enum:
2923           /* Maybe we should load the file's symbols.  */
2924           if (s->wild_statement.filename
2925               && ! wildcardp (s->wild_statement.filename))
2926             lookup_name (s->wild_statement.filename);
2927           open_input_bfds (s->wild_statement.children.head, force);
2928           break;
2929         case lang_group_statement_enum:
2930           {
2931             struct bfd_link_hash_entry *undefs;
2932
2933             /* We must continually search the entries in the group
2934                until no new symbols are added to the list of undefined
2935                symbols.  */
2936
2937             do
2938               {
2939                 undefs = link_info.hash->undefs_tail;
2940                 open_input_bfds (s->group_statement.children.head, TRUE);
2941               }
2942             while (undefs != link_info.hash->undefs_tail);
2943           }
2944           break;
2945         case lang_target_statement_enum:
2946           current_target = s->target_statement.target;
2947           break;
2948         case lang_input_statement_enum:
2949           if (s->input_statement.real)
2950             {
2951               lang_statement_list_type add;
2952
2953               s->input_statement.target = current_target;
2954
2955               /* If we are being called from within a group, and this
2956                  is an archive which has already been searched, then
2957                  force it to be researched unless the whole archive
2958                  has been loaded already.  */
2959               if (force
2960                   && !s->input_statement.whole_archive
2961                   && s->input_statement.loaded
2962                   && bfd_check_format (s->input_statement.the_bfd,
2963                                        bfd_archive))
2964                 s->input_statement.loaded = FALSE;
2965
2966               lang_list_init (&add);
2967
2968               if (! load_symbols (&s->input_statement, &add))
2969                 config.make_executable = FALSE;
2970
2971               if (add.head != NULL)
2972                 {
2973                   *add.tail = s->header.next;
2974                   s->header.next = add.head;
2975                 }
2976             }
2977           break;
2978         default:
2979           break;
2980         }
2981     }
2982 }
2983
2984 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions.  */
2985
2986 void
2987 lang_track_definedness (const char *name)
2988 {
2989   if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
2990     einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
2991 }
2992
2993 /* New-function for the definedness hash table.  */
2994
2995 static struct bfd_hash_entry *
2996 lang_definedness_newfunc (struct bfd_hash_entry *entry,
2997                           struct bfd_hash_table *table ATTRIBUTE_UNUSED,
2998                           const char *name ATTRIBUTE_UNUSED)
2999 {
3000   struct lang_definedness_hash_entry *ret
3001     = (struct lang_definedness_hash_entry *) entry;
3002
3003   if (ret == NULL)
3004     ret = (struct lang_definedness_hash_entry *)
3005       bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
3006
3007   if (ret == NULL)
3008     einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
3009
3010   ret->iteration = -1;
3011   return &ret->root;
3012 }
3013
3014 /* Return the iteration when the definition of NAME was last updated.  A
3015    value of -1 means that the symbol is not defined in the linker script
3016    or the command line, but may be defined in the linker symbol table.  */
3017
3018 int
3019 lang_symbol_definition_iteration (const char *name)
3020 {
3021   struct lang_definedness_hash_entry *defentry
3022     = (struct lang_definedness_hash_entry *)
3023     bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3024
3025   /* We've already created this one on the presence of DEFINED in the
3026      script, so it can't be NULL unless something is borked elsewhere in
3027      the code.  */
3028   if (defentry == NULL)
3029     FAIL ();
3030
3031   return defentry->iteration;
3032 }
3033
3034 /* Update the definedness state of NAME.  */
3035
3036 void
3037 lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
3038 {
3039   struct lang_definedness_hash_entry *defentry
3040     = (struct lang_definedness_hash_entry *)
3041     bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3042
3043   /* We don't keep track of symbols not tested with DEFINED.  */
3044   if (defentry == NULL)
3045     return;
3046
3047   /* If the symbol was already defined, and not from an earlier statement
3048      iteration, don't update the definedness iteration, because that'd
3049      make the symbol seem defined in the linker script at this point, and
3050      it wasn't; it was defined in some object.  If we do anyway, DEFINED
3051      would start to yield false before this point and the construct "sym =
3052      DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3053      in an object.  */
3054   if (h->type != bfd_link_hash_undefined
3055       && h->type != bfd_link_hash_common
3056       && h->type != bfd_link_hash_new
3057       && defentry->iteration == -1)
3058     return;
3059
3060   defentry->iteration = lang_statement_iteration;
3061 }
3062
3063 /* Add the supplied name to the symbol table as an undefined reference.
3064    This is a two step process as the symbol table doesn't even exist at
3065    the time the ld command line is processed.  First we put the name
3066    on a list, then, once the output file has been opened, transfer the
3067    name to the symbol table.  */
3068
3069 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
3070
3071 #define ldlang_undef_chain_list_head entry_symbol.next
3072
3073 void
3074 ldlang_add_undef (const char *const name)
3075 {
3076   ldlang_undef_chain_list_type *new =
3077     stat_alloc (sizeof (ldlang_undef_chain_list_type));
3078
3079   new->next = ldlang_undef_chain_list_head;
3080   ldlang_undef_chain_list_head = new;
3081
3082   new->name = xstrdup (name);
3083
3084   if (link_info.output_bfd != NULL)
3085     insert_undefined (new->name);
3086 }
3087
3088 /* Insert NAME as undefined in the symbol table.  */
3089
3090 static void
3091 insert_undefined (const char *name)
3092 {
3093   struct bfd_link_hash_entry *h;
3094
3095   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
3096   if (h == NULL)
3097     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3098   if (h->type == bfd_link_hash_new)
3099     {
3100       h->type = bfd_link_hash_undefined;
3101       h->u.undef.abfd = NULL;
3102       bfd_link_add_undef (link_info.hash, h);
3103     }
3104 }
3105
3106 /* Run through the list of undefineds created above and place them
3107    into the linker hash table as undefined symbols belonging to the
3108    script file.  */
3109
3110 static void
3111 lang_place_undefineds (void)
3112 {
3113   ldlang_undef_chain_list_type *ptr;
3114
3115   for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
3116     insert_undefined (ptr->name);
3117 }
3118
3119 /* Check for all readonly or some readwrite sections.  */
3120
3121 static void
3122 check_input_sections
3123   (lang_statement_union_type *s,
3124    lang_output_section_statement_type *output_section_statement)
3125 {
3126   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3127     {
3128       switch (s->header.type)
3129       {
3130       case lang_wild_statement_enum:
3131         walk_wild (&s->wild_statement, check_section_callback,
3132                    output_section_statement);
3133         if (! output_section_statement->all_input_readonly)
3134           return;
3135         break;
3136       case lang_constructors_statement_enum:
3137         check_input_sections (constructor_list.head,
3138                               output_section_statement);
3139         if (! output_section_statement->all_input_readonly)
3140           return;
3141         break;
3142       case lang_group_statement_enum:
3143         check_input_sections (s->group_statement.children.head,
3144                               output_section_statement);
3145         if (! output_section_statement->all_input_readonly)
3146           return;
3147         break;
3148       default:
3149         break;
3150       }
3151     }
3152 }
3153
3154 /* Update wildcard statements if needed.  */
3155
3156 static void
3157 update_wild_statements (lang_statement_union_type *s)
3158 {
3159   struct wildcard_list *sec;
3160
3161   switch (sort_section)
3162     {
3163     default:
3164       FAIL ();
3165
3166     case none:
3167       break;
3168
3169     case by_name:
3170     case by_alignment:
3171       for (; s != NULL; s = s->header.next)
3172         {
3173           switch (s->header.type)
3174             {
3175             default:
3176               break;
3177
3178             case lang_wild_statement_enum:
3179               sec = s->wild_statement.section_list;
3180               for (sec = s->wild_statement.section_list; sec != NULL;
3181                    sec = sec->next)
3182                 {
3183                   switch (sec->spec.sorted)
3184                     {
3185                     case none:
3186                       sec->spec.sorted = sort_section;
3187                       break;
3188                     case by_name:
3189                       if (sort_section == by_alignment)
3190                         sec->spec.sorted = by_name_alignment;
3191                       break;
3192                     case by_alignment:
3193                       if (sort_section == by_name)
3194                         sec->spec.sorted = by_alignment_name;
3195                       break;
3196                     default:
3197                       break;
3198                     }
3199                 }
3200               break;
3201
3202             case lang_constructors_statement_enum:
3203               update_wild_statements (constructor_list.head);
3204               break;
3205
3206             case lang_output_section_statement_enum:
3207               update_wild_statements
3208                 (s->output_section_statement.children.head);
3209               break;
3210
3211             case lang_group_statement_enum:
3212               update_wild_statements (s->group_statement.children.head);
3213               break;
3214             }
3215         }
3216       break;
3217     }
3218 }
3219
3220 /* Open input files and attach to output sections.  */
3221
3222 static void
3223 map_input_to_output_sections
3224   (lang_statement_union_type *s, const char *target,
3225    lang_output_section_statement_type *os)
3226 {
3227   flagword flags;
3228
3229   for (; s != NULL; s = s->header.next)
3230     {
3231       switch (s->header.type)
3232         {
3233         case lang_wild_statement_enum:
3234           wild (&s->wild_statement, target, os);
3235           break;
3236         case lang_constructors_statement_enum:
3237           map_input_to_output_sections (constructor_list.head,
3238                                         target,
3239                                         os);
3240           break;
3241         case lang_output_section_statement_enum:
3242           if (s->output_section_statement.constraint)
3243             {
3244               if (s->output_section_statement.constraint != ONLY_IF_RW
3245                   && s->output_section_statement.constraint != ONLY_IF_RO)
3246                 break;
3247               s->output_section_statement.all_input_readonly = TRUE;
3248               check_input_sections (s->output_section_statement.children.head,
3249                                     &s->output_section_statement);
3250               if ((s->output_section_statement.all_input_readonly
3251                    && s->output_section_statement.constraint == ONLY_IF_RW)
3252                   || (!s->output_section_statement.all_input_readonly
3253                       && s->output_section_statement.constraint == ONLY_IF_RO))
3254                 {
3255                   s->output_section_statement.constraint = -1;
3256                   break;
3257                 }
3258             }
3259
3260           map_input_to_output_sections (s->output_section_statement.children.head,
3261                                         target,
3262                                         &s->output_section_statement);
3263           break;
3264         case lang_output_statement_enum:
3265           break;
3266         case lang_target_statement_enum:
3267           target = s->target_statement.target;
3268           break;
3269         case lang_group_statement_enum:
3270           map_input_to_output_sections (s->group_statement.children.head,
3271                                         target,
3272                                         os);
3273           break;
3274         case lang_data_statement_enum:
3275           /* Make sure that any sections mentioned in the expression
3276              are initialized.  */
3277           exp_init_os (s->data_statement.exp);
3278           flags = SEC_HAS_CONTENTS;
3279           /* The output section gets contents, and then we inspect for
3280              any flags set in the input script which override any ALLOC.  */
3281           if (!(os->flags & SEC_NEVER_LOAD))
3282             flags |= SEC_ALLOC | SEC_LOAD;
3283           if (os->bfd_section == NULL)
3284             init_os (os, NULL, flags);
3285           else
3286             os->bfd_section->flags |= flags;
3287           break;
3288         case lang_input_section_enum:
3289           break;
3290         case lang_fill_statement_enum:
3291         case lang_object_symbols_statement_enum:
3292         case lang_reloc_statement_enum:
3293         case lang_padding_statement_enum:
3294         case lang_input_statement_enum:
3295           if (os != NULL && os->bfd_section == NULL)
3296             init_os (os, NULL, 0);
3297           break;
3298         case lang_assignment_statement_enum:
3299           if (os != NULL && os->bfd_section == NULL)
3300             init_os (os, NULL, 0);
3301
3302           /* Make sure that any sections mentioned in the assignment
3303              are initialized.  */
3304           exp_init_os (s->assignment_statement.exp);
3305           break;
3306         case lang_address_statement_enum:
3307           /* Mark the specified section with the supplied address.
3308
3309              If this section was actually a segment marker, then the
3310              directive is ignored if the linker script explicitly
3311              processed the segment marker.  Originally, the linker
3312              treated segment directives (like -Ttext on the
3313              command-line) as section directives.  We honor the
3314              section directive semantics for backwards compatibilty;
3315              linker scripts that do not specifically check for
3316              SEGMENT_START automatically get the old semantics.  */
3317           if (!s->address_statement.segment
3318               || !s->address_statement.segment->used)
3319             {
3320               lang_output_section_statement_type *aos
3321                 = (lang_output_section_statement_lookup
3322                    (s->address_statement.section_name));
3323
3324               if (aos->bfd_section == NULL)
3325                 init_os (aos, NULL, 0);
3326               aos->addr_tree = s->address_statement.address;
3327             }
3328           break;
3329         case lang_insert_statement_enum:
3330           break;
3331         }
3332     }
3333 }
3334
3335 /* An insert statement snips out all the linker statements from the
3336    start of the list and places them after the output section
3337    statement specified by the insert.  This operation is complicated
3338    by the fact that we keep a doubly linked list of output section
3339    statements as well as the singly linked list of all statements.  */
3340
3341 static void
3342 process_insert_statements (void)
3343 {
3344   lang_statement_union_type **s;
3345   lang_output_section_statement_type *first_os = NULL;
3346   lang_output_section_statement_type *last_os = NULL;
3347
3348   /* "start of list" is actually the statement immediately after
3349      the special abs_section output statement, so that it isn't
3350      reordered.  */
3351   s = &lang_output_section_statement.head;
3352   while (*(s = &(*s)->header.next) != NULL)
3353     {
3354       if ((*s)->header.type == lang_output_section_statement_enum)
3355         {
3356           /* Keep pointers to the first and last output section
3357              statement in the sequence we may be about to move.  */
3358           last_os = &(*s)->output_section_statement;
3359           if (first_os == NULL)
3360             first_os = last_os;
3361         }
3362       else if ((*s)->header.type == lang_insert_statement_enum)
3363         {
3364           lang_insert_statement_type *i = &(*s)->insert_statement;
3365           lang_output_section_statement_type *where;
3366           lang_output_section_statement_type *os;
3367           lang_statement_union_type **ptr;
3368           lang_statement_union_type *first;
3369
3370           where = lang_output_section_find (i->where);
3371           if (where != NULL && i->is_before)
3372             {
3373               do
3374                 where = where->prev;
3375               while (where != NULL && where->constraint == -1);
3376             }
3377           if (where == NULL)
3378             {
3379               einfo (_("%X%P: %s not found for insert\n"), i->where);
3380               continue;
3381             }
3382           /* You can't insert into the list you are moving.  */
3383           for (os = first_os; os != NULL; os = os->next)
3384             if (os == where || os == last_os)
3385               break;
3386           if (os == where)
3387             {
3388               einfo (_("%X%P: %s not found for insert\n"), i->where);
3389               continue;
3390             }
3391
3392           /* Deal with reordering the output section statement list.  */
3393           if (last_os != NULL)
3394             {
3395               asection *first_sec, *last_sec;
3396               struct lang_output_section_statement_struct **next;
3397
3398               /* Snip out the output sections we are moving.  */
3399               first_os->prev->next = last_os->next;
3400               if (last_os->next == NULL)
3401                 {
3402                   next = &first_os->prev->next;
3403                   lang_output_section_statement.tail
3404                     = (lang_statement_union_type **) next;
3405                 }
3406               else
3407                 last_os->next->prev = first_os->prev;
3408               /* Add them in at the new position.  */
3409               last_os->next = where->next;
3410               if (where->next == NULL)
3411                 {
3412                   next = &last_os->next;
3413                   lang_output_section_statement.tail
3414                     = (lang_statement_union_type **) next;
3415                 }
3416               else
3417                 where->next->prev = last_os;
3418               first_os->prev = where;
3419               where->next = first_os;
3420
3421               /* Move the bfd sections in the same way.  */
3422               first_sec = NULL;
3423               last_sec = NULL;
3424               for (os = first_os; os != NULL; os = os->next)
3425                 {
3426                   if (os->bfd_section != NULL
3427                       && os->bfd_section->owner != NULL)
3428                     {
3429                       last_sec = os->bfd_section;
3430                       if (first_sec == NULL)
3431                         first_sec = last_sec;
3432                     }
3433                   if (os == last_os)
3434                     break;
3435                 }
3436               if (last_sec != NULL)
3437                 {
3438                   asection *sec = where->bfd_section;
3439                   if (sec == NULL)
3440                     sec = output_prev_sec_find (where);
3441
3442                   /* The place we want to insert must come after the
3443                      sections we are moving.  So if we find no
3444                      section or if the section is the same as our
3445                      last section, then no move is needed.  */
3446                   if (sec != NULL && sec != last_sec)
3447                     {
3448                       /* Trim them off.  */
3449                       if (first_sec->prev != NULL)
3450                         first_sec->prev->next = last_sec->next;
3451                       else
3452                         link_info.output_bfd->sections = last_sec->next;
3453                       if (last_sec->next != NULL)
3454                         last_sec->next->prev = first_sec->prev;
3455                       else
3456                         link_info.output_bfd->section_last = first_sec->prev;
3457                       /* Add back.  */
3458                       last_sec->next = sec->next;
3459                       if (sec->next != NULL)
3460                         sec->next->prev = last_sec;
3461                       else
3462                         link_info.output_bfd->section_last = last_sec;
3463                       first_sec->prev = sec;
3464                       sec->next = first_sec;
3465                     }
3466                 }
3467
3468               first_os = NULL;
3469               last_os = NULL;
3470             }
3471
3472           ptr = insert_os_after (where);
3473           /* Snip everything after the abs_section output statement we
3474              know is at the start of the list, up to and including
3475              the insert statement we are currently processing.  */
3476           first = lang_output_section_statement.head->header.next;
3477           lang_output_section_statement.head->header.next = (*s)->header.next;
3478           /* Add them back where they belong.  */
3479           *s = *ptr;
3480           if (*s == NULL)
3481             statement_list.tail = s;
3482           *ptr = first;
3483           s = &lang_output_section_statement.head;
3484         }
3485     }
3486 }
3487
3488 /* An output section might have been removed after its statement was
3489    added.  For example, ldemul_before_allocation can remove dynamic
3490    sections if they turn out to be not needed.  Clean them up here.  */
3491
3492 void
3493 strip_excluded_output_sections (void)
3494 {
3495   lang_output_section_statement_type *os;
3496
3497   /* Run lang_size_sections (if not already done).  */
3498   if (expld.phase != lang_mark_phase_enum)
3499     {
3500       expld.phase = lang_mark_phase_enum;
3501       expld.dataseg.phase = exp_dataseg_none;
3502       one_lang_size_sections_pass (NULL, FALSE);
3503       lang_reset_memory_regions ();
3504     }
3505
3506   for (os = &lang_output_section_statement.head->output_section_statement;
3507        os != NULL;
3508        os = os->next)
3509     {
3510       asection *output_section;
3511       bfd_boolean exclude;
3512
3513       if (os->constraint == -1)
3514         continue;
3515
3516       output_section = os->bfd_section;
3517       if (output_section == NULL)
3518         continue;
3519
3520       exclude = (output_section->rawsize == 0
3521                  && (output_section->flags & SEC_KEEP) == 0
3522                  && !bfd_section_removed_from_list (link_info.output_bfd,
3523                                                     output_section));
3524
3525       /* Some sections have not yet been sized, notably .gnu.version,
3526          .dynsym, .dynstr and .hash.  These all have SEC_LINKER_CREATED
3527          input sections, so don't drop output sections that have such
3528          input sections unless they are also marked SEC_EXCLUDE.  */
3529       if (exclude && output_section->map_head.s != NULL)
3530         {
3531           asection *s;
3532
3533           for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
3534             if ((s->flags & SEC_LINKER_CREATED) != 0
3535                 && (s->flags & SEC_EXCLUDE) == 0)
3536               {
3537                 exclude = FALSE;
3538                 break;
3539               }
3540         }
3541
3542       /* TODO: Don't just junk map_head.s, turn them into link_orders.  */
3543       output_section->map_head.link_order = NULL;
3544       output_section->map_tail.link_order = NULL;
3545
3546       if (exclude)
3547         {
3548           /* We don't set bfd_section to NULL since bfd_section of the
3549              removed output section statement may still be used.  */
3550           if (!os->section_relative_symbol
3551               && !os->update_dot_tree)
3552             os->ignored = TRUE;
3553           output_section->flags |= SEC_EXCLUDE;
3554           bfd_section_list_remove (link_info.output_bfd, output_section);
3555           link_info.output_bfd->section_count--;
3556         }
3557     }
3558
3559   /* Stop future calls to lang_add_section from messing with map_head
3560      and map_tail link_order fields.  */
3561   stripped_excluded_sections = TRUE;
3562 }
3563
3564 static void
3565 print_output_section_statement
3566   (lang_output_section_statement_type *output_section_statement)
3567 {
3568   asection *section = output_section_statement->bfd_section;
3569   int len;
3570
3571   if (output_section_statement != abs_output_section)
3572     {
3573       minfo ("\n%s", output_section_statement->name);
3574
3575       if (section != NULL)
3576         {
3577           print_dot = section->vma;
3578
3579           len = strlen (output_section_statement->name);
3580           if (len >= SECTION_NAME_MAP_LENGTH - 1)
3581             {
3582               print_nl ();
3583               len = 0;
3584             }
3585           while (len < SECTION_NAME_MAP_LENGTH)
3586             {
3587               print_space ();
3588               ++len;
3589             }
3590
3591           minfo ("0x%V %W", section->vma, section->size);
3592
3593           if (section->vma != section->lma)
3594             minfo (_(" load address 0x%V"), section->lma);
3595         }
3596
3597       print_nl ();
3598     }
3599
3600   print_statement_list (output_section_statement->children.head,
3601                         output_section_statement);
3602 }
3603
3604 /* Scan for the use of the destination in the right hand side
3605    of an expression.  In such cases we will not compute the
3606    correct expression, since the value of DST that is used on
3607    the right hand side will be its final value, not its value
3608    just before this expression is evaluated.  */
3609
3610 static bfd_boolean
3611 scan_for_self_assignment (const char * dst, etree_type * rhs)
3612 {
3613   if (rhs == NULL || dst == NULL)
3614     return FALSE;
3615
3616   switch (rhs->type.node_class)
3617     {
3618     case etree_binary:
3619       return scan_for_self_assignment (dst, rhs->binary.lhs)
3620         ||   scan_for_self_assignment (dst, rhs->binary.rhs);
3621
3622     case etree_trinary:
3623       return scan_for_self_assignment (dst, rhs->trinary.lhs)
3624         ||   scan_for_self_assignment (dst, rhs->trinary.rhs);
3625
3626     case etree_assign:
3627     case etree_provided:
3628     case etree_provide:
3629       if (strcmp (dst, rhs->assign.dst) == 0)
3630         return TRUE;
3631       return scan_for_self_assignment (dst, rhs->assign.src);
3632
3633     case etree_unary:
3634       return scan_for_self_assignment (dst, rhs->unary.child);
3635
3636     case etree_value:
3637       if (rhs->value.str)
3638         return strcmp (dst, rhs->value.str) == 0;
3639       return FALSE;
3640
3641     case etree_name:
3642       if (rhs->name.name)
3643         return strcmp (dst, rhs->name.name) == 0;
3644       return FALSE;
3645
3646     default:
3647       break;
3648     }
3649
3650   return FALSE;
3651 }
3652
3653
3654 static void
3655 print_assignment (lang_assignment_statement_type *assignment,
3656                   lang_output_section_statement_type *output_section)
3657 {
3658   unsigned int i;
3659   bfd_boolean is_dot;
3660   bfd_boolean computation_is_valid = TRUE;
3661   etree_type *tree;
3662
3663   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3664     print_space ();
3665
3666   if (assignment->exp->type.node_class == etree_assert)
3667     {
3668       is_dot = FALSE;
3669       tree = assignment->exp->assert_s.child;
3670       computation_is_valid = TRUE;
3671     }
3672   else
3673     {
3674       const char *dst = assignment->exp->assign.dst;
3675
3676       is_dot = (dst[0] == '.' && dst[1] == 0);
3677       tree = assignment->exp->assign.src;
3678       computation_is_valid = is_dot || (scan_for_self_assignment (dst, tree) == FALSE);
3679     }
3680
3681   exp_fold_tree (tree, output_section->bfd_section, &print_dot);
3682   if (expld.result.valid_p)
3683     {
3684       bfd_vma value;
3685
3686       if (computation_is_valid)
3687         {
3688           value = expld.result.value;
3689
3690           if (expld.result.section)
3691             value += expld.result.section->vma;
3692
3693           minfo ("0x%V", value);
3694           if (is_dot)
3695             print_dot = value;
3696         }
3697       else
3698         {
3699           struct bfd_link_hash_entry *h;
3700
3701           h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
3702                                     FALSE, FALSE, TRUE);
3703           if (h)
3704             {
3705               value = h->u.def.value;
3706
3707               if (expld.result.section)
3708                 value += expld.result.section->vma;
3709
3710               minfo ("[0x%V]", value);
3711             }
3712           else
3713             minfo ("[unresolved]");
3714         }
3715     }
3716   else
3717     {
3718       minfo ("*undef*   ");
3719 #ifdef BFD64
3720       minfo ("        ");
3721 #endif
3722     }
3723
3724   minfo ("                ");
3725   exp_print_tree (assignment->exp);
3726   print_nl ();
3727 }
3728
3729 static void
3730 print_input_statement (lang_input_statement_type *statm)
3731 {
3732   if ((statm->filename != NULL)
3733        && ((statm->the_bfd == NULL)
3734            ||
3735            ((statm->the_bfd->flags & BFD_LINKER_CREATED) == 0)))
3736     fprintf (config.map_file, "LOAD %s\n", statm->filename);
3737 }
3738
3739 /* Print all symbols defined in a particular section.  This is called
3740    via bfd_link_hash_traverse, or by print_all_symbols.  */
3741
3742 static bfd_boolean
3743 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
3744 {
3745   asection *sec = ptr;
3746
3747   if ((hash_entry->type == bfd_link_hash_defined
3748        || hash_entry->type == bfd_link_hash_defweak)
3749       && sec == hash_entry->u.def.section)
3750     {
3751       int i;
3752
3753       for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3754         print_space ();
3755       minfo ("0x%V   ",
3756              (hash_entry->u.def.value
3757               + hash_entry->u.def.section->output_offset
3758               + hash_entry->u.def.section->output_section->vma));
3759
3760       minfo ("             %T\n", hash_entry->root.string);
3761     }
3762
3763   return TRUE;
3764 }
3765
3766 static void
3767 print_all_symbols (asection *sec)
3768 {
3769   struct fat_user_section_struct *ud = get_userdata (sec);
3770   struct map_symbol_def *def;
3771
3772   if (!ud)
3773     return;
3774
3775   *ud->map_symbol_def_tail = 0;
3776   for (def = ud->map_symbol_def_head; def; def = def->next)
3777     print_one_symbol (def->entry, sec);
3778 }
3779
3780 /* Print information about an input section to the map file.  */
3781
3782 static void
3783 print_input_section (asection *i)
3784 {
3785   bfd_size_type size = i->size;
3786   int len;
3787   bfd_vma addr;
3788
3789   init_opb ();
3790
3791   print_space ();
3792   minfo ("%s", i->name);
3793
3794   len = 1 + strlen (i->name);
3795   if (len >= SECTION_NAME_MAP_LENGTH - 1)
3796     {
3797       print_nl ();
3798       len = 0;
3799     }
3800   while (len < SECTION_NAME_MAP_LENGTH)
3801     {
3802       print_space ();
3803       ++len;
3804     }
3805
3806   if (i->output_section != NULL
3807       && i->output_section->owner == link_info.output_bfd)
3808     addr = i->output_section->vma + i->output_offset;
3809   else
3810     {
3811       addr = print_dot;
3812       size = 0;
3813     }
3814
3815   minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
3816
3817   if (size != i->rawsize && i->rawsize != 0)
3818     {
3819       len = SECTION_NAME_MAP_LENGTH + 3;
3820 #ifdef BFD64
3821       len += 16;
3822 #else
3823       len += 8;
3824 #endif
3825       while (len > 0)
3826         {
3827           print_space ();
3828           --len;
3829         }
3830
3831       minfo (_("%W (size before relaxing)\n"), i->rawsize);
3832     }
3833
3834   if (i->output_section != NULL
3835       && i->output_section->owner == link_info.output_bfd)
3836     {
3837       if (link_info.reduce_memory_overheads)
3838         bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
3839       else
3840         print_all_symbols (i);
3841
3842       print_dot = addr + TO_ADDR (size);
3843     }
3844 }
3845
3846 static void
3847 print_fill_statement (lang_fill_statement_type *fill)
3848 {
3849   size_t size;
3850   unsigned char *p;
3851   fputs (" FILL mask 0x", config.map_file);
3852   for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
3853     fprintf (config.map_file, "%02x", *p);
3854   fputs ("\n", config.map_file);
3855 }
3856
3857 static void
3858 print_data_statement (lang_data_statement_type *data)
3859 {
3860   int i;
3861   bfd_vma addr;
3862   bfd_size_type size;
3863   const char *name;
3864
3865   init_opb ();
3866   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3867     print_space ();
3868
3869   addr = data->output_offset;
3870   if (data->output_section != NULL)
3871     addr += data->output_section->vma;
3872
3873   switch (data->type)
3874     {
3875     default:
3876       abort ();
3877     case BYTE:
3878       size = BYTE_SIZE;
3879       name = "BYTE";
3880       break;
3881     case SHORT:
3882       size = SHORT_SIZE;
3883       name = "SHORT";
3884       break;
3885     case LONG:
3886       size = LONG_SIZE;
3887       name = "LONG";
3888       break;
3889     case QUAD:
3890       size = QUAD_SIZE;
3891       name = "QUAD";
3892       break;
3893     case SQUAD:
3894       size = QUAD_SIZE;
3895       name = "SQUAD";
3896       break;
3897     }
3898
3899   minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
3900
3901   if (data->exp->type.node_class != etree_value)
3902     {
3903       print_space ();
3904       exp_print_tree (data->exp);
3905     }
3906
3907   print_nl ();
3908
3909   print_dot = addr + TO_ADDR (size);
3910 }
3911
3912 /* Print an address statement.  These are generated by options like
3913    -Ttext.  */
3914
3915 static void
3916 print_address_statement (lang_address_statement_type *address)
3917 {
3918   minfo (_("Address of section %s set to "), address->section_name);
3919   exp_print_tree (address->address);
3920   print_nl ();
3921 }
3922
3923 /* Print a reloc statement.  */
3924
3925 static void
3926 print_reloc_statement (lang_reloc_statement_type *reloc)
3927 {
3928   int i;
3929   bfd_vma addr;
3930   bfd_size_type size;
3931
3932   init_opb ();
3933   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3934     print_space ();
3935
3936   addr = reloc->output_offset;
3937   if (reloc->output_section != NULL)
3938     addr += reloc->output_section->vma;
3939
3940   size = bfd_get_reloc_size (reloc->howto);
3941
3942   minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
3943
3944   if (reloc->name != NULL)
3945     minfo ("%s+", reloc->name);
3946   else
3947     minfo ("%s+", reloc->section->name);
3948
3949   exp_print_tree (reloc->addend_exp);
3950
3951   print_nl ();
3952
3953   print_dot = addr + TO_ADDR (size);
3954 }
3955
3956 static void
3957 print_padding_statement (lang_padding_statement_type *s)
3958 {
3959   int len;
3960   bfd_vma addr;
3961
3962   init_opb ();
3963   minfo (" *fill*");
3964
3965   len = sizeof " *fill*" - 1;
3966   while (len < SECTION_NAME_MAP_LENGTH)
3967     {
3968       print_space ();
3969       ++len;
3970     }
3971
3972   addr = s->output_offset;
3973   if (s->output_section != NULL)
3974     addr += s->output_section->vma;
3975   minfo ("0x%V %W ", addr, (bfd_vma) s->size);
3976
3977   if (s->fill->size != 0)
3978     {
3979       size_t size;
3980       unsigned char *p;
3981       for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
3982         fprintf (config.map_file, "%02x", *p);
3983     }
3984
3985   print_nl ();
3986
3987   print_dot = addr + TO_ADDR (s->size);
3988 }
3989
3990 static void
3991 print_wild_statement (lang_wild_statement_type *w,
3992                       lang_output_section_statement_type *os)
3993 {
3994   struct wildcard_list *sec;
3995
3996   print_space ();
3997
3998   if (w->filenames_sorted)
3999     minfo ("SORT(");
4000   if (w->filename != NULL)
4001     minfo ("%s", w->filename);
4002   else
4003     minfo ("*");
4004   if (w->filenames_sorted)
4005     minfo (")");
4006
4007   minfo ("(");
4008   for (sec = w->section_list; sec; sec = sec->next)
4009     {
4010       if (sec->spec.sorted)
4011         minfo ("SORT(");
4012       if (sec->spec.exclude_name_list != NULL)
4013         {
4014           name_list *tmp;
4015           minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
4016           for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
4017             minfo (" %s", tmp->name);
4018           minfo (") ");
4019         }
4020       if (sec->spec.name != NULL)
4021         minfo ("%s", sec->spec.name);
4022       else
4023         minfo ("*");
4024       if (sec->spec.sorted)
4025         minfo (")");
4026       if (sec->next)
4027         minfo (" ");
4028     }
4029   minfo (")");
4030
4031   print_nl ();
4032
4033   print_statement_list (w->children.head, os);
4034 }
4035
4036 /* Print a group statement.  */
4037
4038 static void
4039 print_group (lang_group_statement_type *s,
4040              lang_output_section_statement_type *os)
4041 {
4042   fprintf (config.map_file, "START GROUP\n");
4043   print_statement_list (s->children.head, os);
4044   fprintf (config.map_file, "END GROUP\n");
4045 }
4046
4047 /* Print the list of statements in S.
4048    This can be called for any statement type.  */
4049
4050 static void
4051 print_statement_list (lang_statement_union_type *s,
4052                       lang_output_section_statement_type *os)
4053 {
4054   while (s != NULL)
4055     {
4056       print_statement (s, os);
4057       s = s->header.next;
4058     }
4059 }
4060
4061 /* Print the first statement in statement list S.
4062    This can be called for any statement type.  */
4063
4064 static void
4065 print_statement (lang_statement_union_type *s,
4066                  lang_output_section_statement_type *os)
4067 {
4068   switch (s->header.type)
4069     {
4070     default:
4071       fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
4072       FAIL ();
4073       break;
4074     case lang_constructors_statement_enum:
4075       if (constructor_list.head != NULL)
4076         {
4077           if (constructors_sorted)
4078             minfo (" SORT (CONSTRUCTORS)\n");
4079           else
4080             minfo (" CONSTRUCTORS\n");
4081           print_statement_list (constructor_list.head, os);
4082         }
4083       break;
4084     case lang_wild_statement_enum:
4085       print_wild_statement (&s->wild_statement, os);
4086       break;
4087     case lang_address_statement_enum:
4088       print_address_statement (&s->address_statement);
4089       break;
4090     case lang_object_symbols_statement_enum:
4091       minfo (" CREATE_OBJECT_SYMBOLS\n");
4092       break;
4093     case lang_fill_statement_enum:
4094       print_fill_statement (&s->fill_statement);
4095       break;
4096     case lang_data_statement_enum:
4097       print_data_statement (&s->data_statement);
4098       break;
4099     case lang_reloc_statement_enum:
4100       print_reloc_statement (&s->reloc_statement);
4101       break;
4102     case lang_input_section_enum:
4103       print_input_section (s->input_section.section);
4104       break;
4105     case lang_padding_statement_enum:
4106       print_padding_statement (&s->padding_statement);
4107       break;
4108     case lang_output_section_statement_enum:
4109       print_output_section_statement (&s->output_section_statement);
4110       break;
4111     case lang_assignment_statement_enum:
4112       print_assignment (&s->assignment_statement, os);
4113       break;
4114     case lang_target_statement_enum:
4115       fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
4116       break;
4117     case lang_output_statement_enum:
4118       minfo ("OUTPUT(%s", s->output_statement.name);
4119       if (output_target != NULL)
4120         minfo (" %s", output_target);
4121       minfo (")\n");
4122       break;
4123     case lang_input_statement_enum:
4124       print_input_statement (&s->input_statement);
4125       break;
4126     case lang_group_statement_enum:
4127       print_group (&s->group_statement, os);
4128       break;
4129     case lang_insert_statement_enum:
4130       minfo ("INSERT %s %s\n",
4131              s->insert_statement.is_before ? "BEFORE" : "AFTER",
4132              s->insert_statement.where);
4133       break;
4134     }
4135 }
4136
4137 static void
4138 print_statements (void)
4139 {
4140   print_statement_list (statement_list.head, abs_output_section);
4141 }
4142
4143 /* Print the first N statements in statement list S to STDERR.
4144    If N == 0, nothing is printed.
4145    If N < 0, the entire list is printed.
4146    Intended to be called from GDB.  */
4147
4148 void
4149 dprint_statement (lang_statement_union_type *s, int n)
4150 {
4151   FILE *map_save = config.map_file;
4152
4153   config.map_file = stderr;
4154
4155   if (n < 0)
4156     print_statement_list (s, abs_output_section);
4157   else
4158     {
4159       while (s && --n >= 0)
4160         {
4161           print_statement (s, abs_output_section);
4162           s = s->header.next;
4163         }
4164     }
4165
4166   config.map_file = map_save;
4167 }
4168
4169 static void
4170 insert_pad (lang_statement_union_type **ptr,
4171             fill_type *fill,
4172             unsigned int alignment_needed,
4173             asection *output_section,
4174             bfd_vma dot)
4175 {
4176   static fill_type zero_fill = { 1, { 0 } };
4177   lang_statement_union_type *pad = NULL;
4178
4179   if (ptr != &statement_list.head)
4180     pad = ((lang_statement_union_type *)
4181            ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
4182   if (pad != NULL
4183       && pad->header.type == lang_padding_statement_enum
4184       && pad->padding_statement.output_section == output_section)
4185     {
4186       /* Use the existing pad statement.  */
4187     }
4188   else if ((pad = *ptr) != NULL
4189            && pad->header.type == lang_padding_statement_enum
4190            && pad->padding_statement.output_section == output_section)
4191     {
4192       /* Use the existing pad statement.  */
4193     }
4194   else
4195     {
4196       /* Make a new padding statement, linked into existing chain.  */
4197       pad = stat_alloc (sizeof (lang_padding_statement_type));
4198       pad->header.next = *ptr;
4199       *ptr = pad;
4200       pad->header.type = lang_padding_statement_enum;
4201       pad->padding_statement.output_section = output_section;
4202       if (fill == NULL)
4203         fill = &zero_fill;
4204       pad->padding_statement.fill = fill;
4205     }
4206   pad->padding_statement.output_offset = dot - output_section->vma;
4207   pad->padding_statement.size = alignment_needed;
4208   output_section->size += alignment_needed;
4209 }
4210
4211 /* Work out how much this section will move the dot point.  */
4212
4213 static bfd_vma
4214 size_input_section
4215   (lang_statement_union_type **this_ptr,
4216    lang_output_section_statement_type *output_section_statement,
4217    fill_type *fill,
4218    bfd_vma dot)
4219 {
4220   lang_input_section_type *is = &((*this_ptr)->input_section);
4221   asection *i = is->section;
4222
4223   if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
4224       && (i->flags & SEC_EXCLUDE) == 0)
4225     {
4226       unsigned int alignment_needed;
4227       asection *o;
4228
4229       /* Align this section first to the input sections requirement,
4230          then to the output section's requirement.  If this alignment
4231          is greater than any seen before, then record it too.  Perform
4232          the alignment by inserting a magic 'padding' statement.  */
4233
4234       if (output_section_statement->subsection_alignment != -1)
4235         i->alignment_power = output_section_statement->subsection_alignment;
4236
4237       o = output_section_statement->bfd_section;
4238       if (o->alignment_power < i->alignment_power)
4239         o->alignment_power = i->alignment_power;
4240
4241       alignment_needed = align_power (dot, i->alignment_power) - dot;
4242
4243       if (alignment_needed != 0)
4244         {
4245           insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
4246           dot += alignment_needed;
4247         }
4248
4249       /* Remember where in the output section this input section goes.  */
4250
4251       i->output_offset = dot - o->vma;
4252
4253       /* Mark how big the output section must be to contain this now.  */
4254       dot += TO_ADDR (i->size);
4255       o->size = TO_SIZE (dot - o->vma);
4256     }
4257   else
4258     {
4259       i->output_offset = i->vma - output_section_statement->bfd_section->vma;
4260     }
4261
4262   return dot;
4263 }
4264
4265 static int
4266 sort_sections_by_lma (const void *arg1, const void *arg2)
4267 {
4268   const asection *sec1 = *(const asection **) arg1;
4269   const asection *sec2 = *(const asection **) arg2;
4270
4271   if (bfd_section_lma (sec1->owner, sec1)
4272       < bfd_section_lma (sec2->owner, sec2))
4273     return -1;
4274   else if (bfd_section_lma (sec1->owner, sec1)
4275            > bfd_section_lma (sec2->owner, sec2))
4276     return 1;
4277   else if (sec1->id < sec2->id)
4278     return -1;
4279   else if (sec1->id > sec2->id)
4280     return 1;
4281
4282   return 0;
4283 }
4284
4285 #define IGNORE_SECTION(s) \
4286   ((s->flags & SEC_NEVER_LOAD) != 0                             \
4287    || (s->flags & SEC_ALLOC) == 0                               \
4288    || ((s->flags & SEC_THREAD_LOCAL) != 0                       \
4289         && (s->flags & SEC_LOAD) == 0))
4290
4291 /* Check to see if any allocated sections overlap with other allocated
4292    sections.  This can happen if a linker script specifies the output
4293    section addresses of the two sections.  Also check whether any memory
4294    region has overflowed.  */
4295
4296 static void
4297 lang_check_section_addresses (void)
4298 {
4299   asection *s, *os;
4300   asection **sections, **spp;
4301   unsigned int count;
4302   bfd_vma s_start;
4303   bfd_vma s_end;
4304   bfd_vma os_start;
4305   bfd_vma os_end;
4306   bfd_size_type amt;
4307   lang_memory_region_type *m;
4308
4309   if (bfd_count_sections (link_info.output_bfd) <= 1)
4310     return;
4311
4312   amt = bfd_count_sections (link_info.output_bfd) * sizeof (asection *);
4313   sections = xmalloc (amt);
4314
4315   /* Scan all sections in the output list.  */
4316   count = 0;
4317   for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
4318     {
4319       /* Only consider loadable sections with real contents.  */
4320       if (IGNORE_SECTION (s) || s->size == 0)
4321         continue;
4322
4323       sections[count] = s;
4324       count++;
4325     }
4326
4327   if (count <= 1)
4328     return;
4329
4330   qsort (sections, (size_t) count, sizeof (asection *),
4331          sort_sections_by_lma);
4332
4333   spp = sections;
4334   s = *spp++;
4335   s_start = bfd_section_lma (link_info.output_bfd, s);
4336   s_end = s_start + TO_ADDR (s->size) - 1;
4337   for (count--; count; count--)
4338     {
4339       /* We must check the sections' LMA addresses not their VMA
4340          addresses because overlay sections can have overlapping VMAs
4341          but they must have distinct LMAs.  */
4342       os = s;
4343       os_start = s_start;
4344       os_end = s_end;
4345       s = *spp++;
4346       s_start = bfd_section_lma (link_info.output_bfd, s);
4347       s_end = s_start + TO_ADDR (s->size) - 1;
4348
4349       /* Look for an overlap.  */
4350       if (s_end >= os_start && s_start <= os_end)
4351         einfo (_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
4352                s->name, s_start, s_end, os->name, os_start, os_end);
4353     }
4354
4355   free (sections);
4356
4357   /* If any memory region has overflowed, report by how much.
4358      We do not issue this diagnostic for regions that had sections
4359      explicitly placed outside their bounds; os_region_check's
4360      diagnostics are adequate for that case.
4361
4362      FIXME: It is conceivable that m->current - (m->origin + m->length)
4363      might overflow a 32-bit integer.  There is, alas, no way to print
4364      a bfd_vma quantity in decimal.  */
4365   for (m = lang_memory_region_list; m; m = m->next)
4366     if (m->had_full_message)
4367       einfo (_("%X%P: region %s overflowed by %ld bytes\n"),
4368              m->name, (long)(m->current - (m->origin + m->length)));
4369
4370 }
4371
4372 /* Make sure the new address is within the region.  We explicitly permit the
4373    current address to be at the exact end of the region when the address is
4374    non-zero, in case the region is at the end of addressable memory and the
4375    calculation wraps around.  */
4376
4377 static void
4378 os_region_check (lang_output_section_statement_type *os,
4379                  lang_memory_region_type *region,
4380                  etree_type *tree,
4381                  bfd_vma base)
4382 {
4383   if ((region->current < region->origin
4384        || (region->current - region->origin > region->length))
4385       && ((region->current != region->origin + region->length)
4386           || base == 0))
4387     {
4388       if (tree != NULL)
4389         {
4390           einfo (_("%X%P: address 0x%v of %B section %s"
4391                    " is not within region %s\n"),
4392                  region->current,
4393                  os->bfd_section->owner,
4394                  os->bfd_section->name,
4395                  region->name);
4396         }
4397       else if (!region->had_full_message)
4398         {
4399           region->had_full_message = TRUE;
4400
4401           einfo (_("%X%P: %B section %s will not fit in region %s\n"),
4402                  os->bfd_section->owner,
4403                  os->bfd_section->name,
4404                  region->name);
4405         }
4406     }
4407 }
4408
4409 /* Set the sizes for all the output sections.  */
4410
4411 static bfd_vma
4412 lang_size_sections_1
4413   (lang_statement_union_type *s,
4414    lang_output_section_statement_type *output_section_statement,
4415    lang_statement_union_type **prev,
4416    fill_type *fill,
4417    bfd_vma dot,
4418    bfd_boolean *relax,
4419    bfd_boolean check_regions)
4420 {
4421   /* Size up the sections from their constituent parts.  */
4422   for (; s != NULL; s = s->header.next)
4423     {
4424       switch (s->header.type)
4425         {
4426         case lang_output_section_statement_enum:
4427           {
4428             bfd_vma newdot, after;
4429             lang_output_section_statement_type *os;
4430             lang_memory_region_type *r;
4431
4432             os = &s->output_section_statement;
4433             if (os->addr_tree != NULL)
4434               {
4435                 os->processed_vma = FALSE;
4436                 exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
4437
4438                 if (expld.result.valid_p)
4439                   dot = expld.result.value + expld.result.section->vma;
4440                 else if (expld.phase != lang_mark_phase_enum)
4441                   einfo (_("%F%S: non constant or forward reference"
4442                            " address expression for section %s\n"),
4443                          os->name);
4444               }
4445
4446             if (os->bfd_section == NULL)
4447               /* This section was removed or never actually created.  */
4448               break;
4449
4450             /* If this is a COFF shared library section, use the size and
4451                address from the input section.  FIXME: This is COFF
4452                specific; it would be cleaner if there were some other way
4453                to do this, but nothing simple comes to mind.  */
4454             if (((bfd_get_flavour (link_info.output_bfd)
4455                   == bfd_target_ecoff_flavour)
4456                  || (bfd_get_flavour (link_info.output_bfd)
4457                      == bfd_target_coff_flavour))
4458                 && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
4459               {
4460                 asection *input;
4461
4462                 if (os->children.head == NULL
4463                     || os->children.head->header.next != NULL
4464                     || (os->children.head->header.type
4465                         != lang_input_section_enum))
4466                   einfo (_("%P%X: Internal error on COFF shared library"
4467                            " section %s\n"), os->name);
4468
4469                 input = os->children.head->input_section.section;
4470                 bfd_set_section_vma (os->bfd_section->owner,
4471                                      os->bfd_section,
4472                                      bfd_section_vma (input->owner, input));
4473                 os->bfd_section->size = input->size;
4474                 break;
4475               }
4476
4477             newdot = dot;
4478             if (bfd_is_abs_section (os->bfd_section))
4479               {
4480                 /* No matter what happens, an abs section starts at zero.  */
4481                 ASSERT (os->bfd_section->vma == 0);
4482               }
4483             else
4484               {
4485                 int align;
4486
4487                 if (os->addr_tree == NULL)
4488                   {
4489                     /* No address specified for this section, get one
4490                        from the region specification.  */
4491                     if (os->region == NULL
4492                         || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
4493                             && os->region->name[0] == '*'
4494                             && strcmp (os->region->name,
4495                                        DEFAULT_MEMORY_REGION) == 0))
4496                       {
4497                         os->region = lang_memory_default (os->bfd_section);
4498                       }
4499
4500                     /* If a loadable section is using the default memory
4501                        region, and some non default memory regions were
4502                        defined, issue an error message.  */
4503                     if (!os->ignored
4504                         && !IGNORE_SECTION (os->bfd_section)
4505                         && ! link_info.relocatable
4506                         && check_regions
4507                         && strcmp (os->region->name,
4508                                    DEFAULT_MEMORY_REGION) == 0
4509                         && lang_memory_region_list != NULL
4510                         && (strcmp (lang_memory_region_list->name,
4511                                     DEFAULT_MEMORY_REGION) != 0
4512                             || lang_memory_region_list->next != NULL)
4513                         && expld.phase != lang_mark_phase_enum)
4514                       {
4515                         /* By default this is an error rather than just a
4516                            warning because if we allocate the section to the
4517                            default memory region we can end up creating an
4518                            excessively large binary, or even seg faulting when
4519                            attempting to perform a negative seek.  See
4520                            sources.redhat.com/ml/binutils/2003-04/msg00423.html
4521                            for an example of this.  This behaviour can be
4522                            overridden by the using the --no-check-sections
4523                            switch.  */
4524                         if (command_line.check_section_addresses)
4525                           einfo (_("%P%F: error: no memory region specified"
4526                                    " for loadable section `%s'\n"),
4527                                  bfd_get_section_name (link_info.output_bfd,
4528                                                        os->bfd_section));
4529                         else
4530                           einfo (_("%P: warning: no memory region specified"
4531                                    " for loadable section `%s'\n"),
4532                                  bfd_get_section_name (link_info.output_bfd,
4533                                                        os->bfd_section));
4534                       }
4535
4536                     newdot = os->region->current;
4537                     align = os->bfd_section->alignment_power;
4538                   }
4539                 else
4540                   align = os->section_alignment;
4541
4542                 /* Align to what the section needs.  */
4543                 if (align > 0)
4544                   {
4545                     bfd_vma savedot = newdot;
4546                     newdot = align_power (newdot, align);
4547
4548                     if (newdot != savedot
4549                         && (config.warn_section_align
4550                             || os->addr_tree != NULL)
4551                         && expld.phase != lang_mark_phase_enum)
4552                       einfo (_("%P: warning: changing start of section"
4553                                " %s by %lu bytes\n"),
4554                              os->name, (unsigned long) (newdot - savedot));
4555                   }
4556
4557                 bfd_set_section_vma (0, os->bfd_section, newdot);
4558
4559                 os->bfd_section->output_offset = 0;
4560               }
4561
4562             lang_size_sections_1 (os->children.head, os, &os->children.head,
4563                                   os->fill, newdot, relax, check_regions);
4564
4565             os->processed_vma = TRUE;
4566
4567             if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4568               /* Except for some special linker created sections,
4569                  no output section should change from zero size
4570                  after strip_excluded_output_sections.  A non-zero
4571                  size on an ignored section indicates that some
4572                  input section was not sized early enough.  */
4573               ASSERT (os->bfd_section->size == 0);
4574             else
4575               {
4576                 dot = os->bfd_section->vma;
4577
4578                 /* Put the section within the requested block size, or
4579                    align at the block boundary.  */
4580                 after = ((dot
4581                           + TO_ADDR (os->bfd_section->size)
4582                           + os->block_value - 1)
4583                          & - (bfd_vma) os->block_value);
4584
4585                 os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
4586               }
4587
4588             /* Set section lma.  */
4589             r = os->region;
4590             if (r == NULL)
4591               r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
4592
4593             if (os->load_base)
4594               {
4595                 bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
4596                 os->bfd_section->lma = lma;
4597               }
4598             else if (os->lma_region != NULL)
4599               {
4600                 bfd_vma lma = os->lma_region->current;
4601
4602                 if (os->section_alignment != -1)
4603                   lma = align_power (lma, os->section_alignment);
4604                 os->bfd_section->lma = lma;
4605               }
4606             else if (r->last_os != NULL
4607                      && (os->bfd_section->flags & SEC_ALLOC) != 0)
4608               {
4609                 bfd_vma lma;
4610                 asection *last;
4611
4612                 last = r->last_os->output_section_statement.bfd_section;
4613
4614                 /* A backwards move of dot should be accompanied by
4615                    an explicit assignment to the section LMA (ie.
4616                    os->load_base set) because backwards moves can
4617                    create overlapping LMAs.  */
4618                 if (dot < last->vma
4619                     && os->bfd_section->size != 0
4620                     && dot + os->bfd_section->size <= last->vma)
4621                   {
4622                     /* If dot moved backwards then leave lma equal to
4623                        vma.  This is the old default lma, which might
4624                        just happen to work when the backwards move is
4625                        sufficiently large.  Nag if this changes anything,
4626                        so people can fix their linker scripts.  */
4627
4628                     if (last->vma != last->lma)
4629                       einfo (_("%P: warning: dot moved backwards before `%s'\n"),
4630                              os->name);
4631                   }
4632                 else
4633                   {
4634                     /* If this is an overlay, set the current lma to that
4635                        at the end of the previous section.  */
4636                     if (os->sectype == overlay_section)
4637                       lma = last->lma + last->size;
4638
4639                     /* Otherwise, keep the same lma to vma relationship
4640                        as the previous section.  */
4641                     else
4642                       lma = dot + last->lma - last->vma;
4643
4644                     if (os->section_alignment != -1)
4645                       lma = align_power (lma, os->section_alignment);
4646                     os->bfd_section->lma = lma;
4647                   }
4648               }
4649             os->processed_lma = TRUE;
4650
4651             if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4652               break;
4653
4654             /* Keep track of normal sections using the default
4655                lma region.  We use this to set the lma for
4656                following sections.  Overlays or other linker
4657                script assignment to lma might mean that the
4658                default lma == vma is incorrect.
4659                To avoid warnings about dot moving backwards when using
4660                -Ttext, don't start tracking sections until we find one
4661                of non-zero size or with lma set differently to vma.  */
4662             if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4663                  || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)
4664                 && (os->bfd_section->flags & SEC_ALLOC) != 0
4665                 && (os->bfd_section->size != 0
4666                     || (r->last_os == NULL
4667                         && os->bfd_section->vma != os->bfd_section->lma)
4668                     || (r->last_os != NULL
4669                         && dot >= (r->last_os->output_section_statement
4670                                    .bfd_section->vma)))
4671                 && os->lma_region == NULL
4672                 && !link_info.relocatable)
4673               r->last_os = s;
4674
4675             /* .tbss sections effectively have zero size.  */
4676             if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4677                 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
4678                 || link_info.relocatable)
4679               dot += TO_ADDR (os->bfd_section->size);
4680
4681             if (os->update_dot_tree != 0)
4682               exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
4683
4684             /* Update dot in the region ?
4685                We only do this if the section is going to be allocated,
4686                since unallocated sections do not contribute to the region's
4687                overall size in memory.
4688
4689                If the SEC_NEVER_LOAD bit is not set, it will affect the
4690                addresses of sections after it. We have to update
4691                dot.  */
4692             if (os->region != NULL
4693                 && ((os->bfd_section->flags & SEC_NEVER_LOAD) == 0
4694                     || (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))))
4695               {
4696                 os->region->current = dot;
4697
4698                 if (check_regions)
4699                   /* Make sure the new address is within the region.  */
4700                   os_region_check (os, os->region, os->addr_tree,
4701                                    os->bfd_section->vma);
4702
4703                 if (os->lma_region != NULL && os->lma_region != os->region
4704                     && (os->bfd_section->flags & SEC_LOAD))
4705                   {
4706                     os->lma_region->current
4707                       = os->bfd_section->lma + TO_ADDR (os->bfd_section->size);
4708
4709                     if (check_regions)
4710                       os_region_check (os, os->lma_region, NULL,
4711                                        os->bfd_section->lma);
4712                   }
4713               }
4714           }
4715           break;
4716
4717         case lang_constructors_statement_enum:
4718           dot = lang_size_sections_1 (constructor_list.head,
4719                                       output_section_statement,
4720                                       &s->wild_statement.children.head,
4721                                       fill, dot, relax, check_regions);
4722           break;
4723
4724         case lang_data_statement_enum:
4725           {
4726             unsigned int size = 0;
4727
4728             s->data_statement.output_offset =
4729               dot - output_section_statement->bfd_section->vma;
4730             s->data_statement.output_section =
4731               output_section_statement->bfd_section;
4732
4733             /* We might refer to provided symbols in the expression, and
4734                need to mark them as needed.  */
4735             exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
4736
4737             switch (s->data_statement.type)
4738               {
4739               default:
4740                 abort ();
4741               case QUAD:
4742               case SQUAD:
4743                 size = QUAD_SIZE;
4744                 break;
4745               case LONG:
4746                 size = LONG_SIZE;
4747                 break;
4748               case SHORT:
4749                 size = SHORT_SIZE;
4750                 break;
4751               case BYTE:
4752                 size = BYTE_SIZE;
4753                 break;
4754               }
4755             if (size < TO_SIZE ((unsigned) 1))
4756               size = TO_SIZE ((unsigned) 1);
4757             dot += TO_ADDR (size);
4758             output_section_statement->bfd_section->size += size;
4759           }
4760           break;
4761
4762         case lang_reloc_statement_enum:
4763           {
4764             int size;
4765
4766             s->reloc_statement.output_offset =
4767               dot - output_section_statement->bfd_section->vma;
4768             s->reloc_statement.output_section =
4769               output_section_statement->bfd_section;
4770             size = bfd_get_reloc_size (s->reloc_statement.howto);
4771             dot += TO_ADDR (size);
4772             output_section_statement->bfd_section->size += size;
4773           }
4774           break;
4775
4776         case lang_wild_statement_enum:
4777           dot = lang_size_sections_1 (s->wild_statement.children.head,
4778                                       output_section_statement,
4779                                       &s->wild_statement.children.head,
4780                                       fill, dot, relax, check_regions);
4781           break;
4782
4783         case lang_object_symbols_statement_enum:
4784           link_info.create_object_symbols_section =
4785             output_section_statement->bfd_section;
4786           break;
4787
4788         case lang_output_statement_enum:
4789         case lang_target_statement_enum:
4790           break;
4791
4792         case lang_input_section_enum:
4793           {
4794             asection *i;
4795
4796             i = (*prev)->input_section.section;
4797             if (relax)
4798               {
4799                 bfd_boolean again;
4800
4801                 if (! bfd_relax_section (i->owner, i, &link_info, &again))
4802                   einfo (_("%P%F: can't relax section: %E\n"));
4803                 if (again)
4804                   *relax = TRUE;
4805               }
4806             dot = size_input_section (prev, output_section_statement,
4807                                       output_section_statement->fill, dot);
4808           }
4809           break;
4810
4811         case lang_input_statement_enum:
4812           break;
4813
4814         case lang_fill_statement_enum:
4815           s->fill_statement.output_section =
4816             output_section_statement->bfd_section;
4817
4818           fill = s->fill_statement.fill;
4819           break;
4820
4821         case lang_assignment_statement_enum:
4822           {
4823             bfd_vma newdot = dot;
4824             etree_type *tree = s->assignment_statement.exp;
4825
4826             expld.dataseg.relro = exp_dataseg_relro_none;
4827
4828             exp_fold_tree (tree,
4829                            output_section_statement->bfd_section,
4830                            &newdot);
4831
4832             if (expld.dataseg.relro == exp_dataseg_relro_start)
4833               {
4834                 if (!expld.dataseg.relro_start_stat)
4835                   expld.dataseg.relro_start_stat = s;
4836                 else
4837                   {
4838                     ASSERT (expld.dataseg.relro_start_stat == s);
4839                   }
4840               }
4841             else if (expld.dataseg.relro == exp_dataseg_relro_end)
4842               {
4843                 if (!expld.dataseg.relro_end_stat)
4844                   expld.dataseg.relro_end_stat = s;
4845                 else
4846                   {
4847                     ASSERT (expld.dataseg.relro_end_stat == s);
4848                   }
4849               }
4850             expld.dataseg.relro = exp_dataseg_relro_none;
4851
4852             /* This symbol is relative to this section.  */
4853             if ((tree->type.node_class == etree_provided
4854                  || tree->type.node_class == etree_assign)
4855                 && (tree->assign.dst [0] != '.'
4856                     || tree->assign.dst [1] != '\0'))
4857               output_section_statement->section_relative_symbol = 1;
4858
4859             if (!output_section_statement->ignored)
4860               {
4861                 if (output_section_statement == abs_output_section)
4862                   {
4863                     /* If we don't have an output section, then just adjust
4864                        the default memory address.  */
4865                     lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
4866                                                FALSE)->current = newdot;
4867                   }
4868                 else if (newdot != dot)
4869                   {
4870                     /* Insert a pad after this statement.  We can't
4871                        put the pad before when relaxing, in case the
4872                        assignment references dot.  */
4873                     insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
4874                                 output_section_statement->bfd_section, dot);
4875
4876                     /* Don't neuter the pad below when relaxing.  */
4877                     s = s->header.next;
4878
4879                     /* If dot is advanced, this implies that the section
4880                        should have space allocated to it, unless the
4881                        user has explicitly stated that the section
4882                        should never be loaded.  */
4883                     if (!(output_section_statement->flags & SEC_NEVER_LOAD))
4884                       output_section_statement->bfd_section->flags |= SEC_ALLOC;
4885                   }
4886                 dot = newdot;
4887               }
4888           }
4889           break;
4890
4891         case lang_padding_statement_enum:
4892           /* If this is the first time lang_size_sections is called,
4893              we won't have any padding statements.  If this is the
4894              second or later passes when relaxing, we should allow
4895              padding to shrink.  If padding is needed on this pass, it
4896              will be added back in.  */
4897           s->padding_statement.size = 0;
4898
4899           /* Make sure output_offset is valid.  If relaxation shrinks
4900              the section and this pad isn't needed, it's possible to
4901              have output_offset larger than the final size of the
4902              section.  bfd_set_section_contents will complain even for
4903              a pad size of zero.  */
4904           s->padding_statement.output_offset
4905             = dot - output_section_statement->bfd_section->vma;
4906           break;
4907
4908         case lang_group_statement_enum:
4909           dot = lang_size_sections_1 (s->group_statement.children.head,
4910                                       output_section_statement,
4911                                       &s->group_statement.children.head,
4912                                       fill, dot, relax, check_regions);
4913           break;
4914
4915         case lang_insert_statement_enum:
4916           break;
4917
4918           /* We can only get here when relaxing is turned on.  */
4919         case lang_address_statement_enum:
4920           break;
4921
4922         default:
4923           FAIL ();
4924           break;
4925         }
4926       prev = &s->header.next;
4927     }
4928   return dot;
4929 }
4930
4931 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
4932    The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
4933    CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
4934    segments.  We are allowed an opportunity to override this decision.  */
4935
4936 bfd_boolean
4937 ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,
4938                                     bfd * abfd ATTRIBUTE_UNUSED,
4939                                     asection * current_section,
4940                                     asection * previous_section,
4941                                     bfd_boolean new_segment)
4942 {
4943   lang_output_section_statement_type * cur;
4944   lang_output_section_statement_type * prev;
4945
4946   /* The checks below are only necessary when the BFD library has decided
4947      that the two sections ought to be placed into the same segment.  */
4948   if (new_segment)
4949     return TRUE;
4950
4951   /* Paranoia checks.  */
4952   if (current_section == NULL || previous_section == NULL)
4953     return new_segment;
4954
4955   /* Find the memory regions associated with the two sections.
4956      We call lang_output_section_find() here rather than scanning the list
4957      of output sections looking for a matching section pointer because if
4958      we have a large number of sections then a hash lookup is faster.  */
4959   cur  = lang_output_section_find (current_section->name);
4960   prev = lang_output_section_find (previous_section->name);
4961
4962   /* More paranoia.  */
4963   if (cur == NULL || prev == NULL)
4964     return new_segment;
4965
4966   /* If the regions are different then force the sections to live in
4967      different segments.  See the email thread starting at the following
4968      URL for the reasons why this is necessary:
4969      http://sourceware.org/ml/binutils/2007-02/msg00216.html  */
4970   return cur->region != prev->region;
4971 }
4972
4973 void
4974 one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
4975 {
4976   lang_statement_iteration++;
4977   lang_size_sections_1 (statement_list.head, abs_output_section,
4978                         &statement_list.head, 0, 0, relax, check_regions);
4979 }
4980
4981 void
4982 lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
4983 {
4984   expld.phase = lang_allocating_phase_enum;
4985   expld.dataseg.phase = exp_dataseg_none;
4986
4987   one_lang_size_sections_pass (relax, check_regions);
4988   if (expld.dataseg.phase == exp_dataseg_end_seen
4989       && link_info.relro && expld.dataseg.relro_end)
4990     {
4991       /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
4992          to put expld.dataseg.relro on a (common) page boundary.  */
4993       bfd_vma old_min_base, relro_end, maxpage;
4994
4995       expld.dataseg.phase = exp_dataseg_relro_adjust;
4996       old_min_base = expld.dataseg.min_base;
4997       maxpage = expld.dataseg.maxpagesize;
4998       expld.dataseg.base += (-expld.dataseg.relro_end
4999                              & (expld.dataseg.pagesize - 1));
5000       /* Compute the expected PT_GNU_RELRO segment end.  */
5001       relro_end = (expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
5002                   & ~(expld.dataseg.pagesize - 1);
5003       if (old_min_base + maxpage < expld.dataseg.base)
5004         {
5005           expld.dataseg.base -= maxpage;
5006           relro_end -= maxpage;
5007         }
5008       lang_reset_memory_regions ();
5009       one_lang_size_sections_pass (relax, check_regions);
5010       if (expld.dataseg.relro_end > relro_end)
5011         {
5012           /* The alignment of sections between DATA_SEGMENT_ALIGN
5013              and DATA_SEGMENT_RELRO_END caused huge padding to be
5014              inserted at DATA_SEGMENT_RELRO_END.  Try some other base.  */
5015           asection *sec;
5016           unsigned int max_alignment_power = 0;
5017
5018           /* Find maximum alignment power of sections between
5019              DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END.  */
5020           for (sec = link_info.output_bfd->sections; sec; sec = sec->next)
5021             if (sec->vma >= expld.dataseg.base
5022                 && sec->vma < expld.dataseg.relro_end
5023                 && sec->alignment_power > max_alignment_power)
5024               max_alignment_power = sec->alignment_power;
5025
5026           if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)
5027             {
5028               if (expld.dataseg.base - (1 << max_alignment_power)
5029                   < old_min_base)
5030                 expld.dataseg.base += expld.dataseg.pagesize;
5031               expld.dataseg.base -= (1 << max_alignment_power);
5032               lang_reset_memory_regions ();
5033               one_lang_size_sections_pass (relax, check_regions);
5034             }
5035         }
5036       link_info.relro_start = expld.dataseg.base;
5037       link_info.relro_end = expld.dataseg.relro_end;
5038     }
5039   else if (expld.dataseg.phase == exp_dataseg_end_seen)
5040     {
5041       /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5042          a page could be saved in the data segment.  */
5043       bfd_vma first, last;
5044
5045       first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
5046       last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
5047       if (first && last
5048           && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
5049               != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
5050           && first + last <= expld.dataseg.pagesize)
5051         {
5052           expld.dataseg.phase = exp_dataseg_adjust;
5053           lang_reset_memory_regions ();
5054           one_lang_size_sections_pass (relax, check_regions);
5055         }
5056     }
5057
5058   expld.phase = lang_final_phase_enum;
5059 }
5060
5061 /* Worker function for lang_do_assignments.  Recursiveness goes here.  */
5062
5063 static bfd_vma
5064 lang_do_assignments_1 (lang_statement_union_type *s,
5065                        lang_output_section_statement_type *current_os,
5066                        fill_type *fill,
5067                        bfd_vma dot)
5068 {
5069   for (; s != NULL; s = s->header.next)
5070     {
5071       switch (s->header.type)
5072         {
5073         case lang_constructors_statement_enum:
5074           dot = lang_do_assignments_1 (constructor_list.head,
5075                                        current_os, fill, dot);
5076           break;
5077
5078         case lang_output_section_statement_enum:
5079           {
5080             lang_output_section_statement_type *os;
5081
5082             os = &(s->output_section_statement);
5083             if (os->bfd_section != NULL && !os->ignored)
5084               {
5085                 dot = os->bfd_section->vma;
5086
5087                 lang_do_assignments_1 (os->children.head, os, os->fill, dot);
5088
5089                 /* .tbss sections effectively have zero size.  */
5090                 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5091                     || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
5092                     || link_info.relocatable)
5093                   dot += TO_ADDR (os->bfd_section->size);
5094               }
5095           }
5096           break;
5097
5098         case lang_wild_statement_enum:
5099
5100           dot = lang_do_assignments_1 (s->wild_statement.children.head,
5101                                        current_os, fill, dot);
5102           break;
5103
5104         case lang_object_symbols_statement_enum:
5105         case lang_output_statement_enum:
5106         case lang_target_statement_enum:
5107           break;
5108
5109         case lang_data_statement_enum:
5110           exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
5111           if (expld.result.valid_p)
5112             s->data_statement.value = (expld.result.value
5113                                        + expld.result.section->vma);
5114           else
5115             einfo (_("%F%P: invalid data statement\n"));
5116           {
5117             unsigned int size;
5118             switch (s->data_statement.type)
5119               {
5120               default:
5121                 abort ();
5122               case QUAD:
5123               case SQUAD:
5124                 size = QUAD_SIZE;
5125                 break;
5126               case LONG:
5127                 size = LONG_SIZE;
5128                 break;
5129               case SHORT:
5130                 size = SHORT_SIZE;
5131                 break;
5132               case BYTE:
5133                 size = BYTE_SIZE;
5134                 break;
5135               }
5136             if (size < TO_SIZE ((unsigned) 1))
5137               size = TO_SIZE ((unsigned) 1);
5138             dot += TO_ADDR (size);
5139           }
5140           break;
5141
5142         case lang_reloc_statement_enum:
5143           exp_fold_tree (s->reloc_statement.addend_exp,
5144                          bfd_abs_section_ptr, &dot);
5145           if (expld.result.valid_p)
5146             s->reloc_statement.addend_value = expld.result.value;
5147           else
5148             einfo (_("%F%P: invalid reloc statement\n"));
5149           dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
5150           break;
5151
5152         case lang_input_section_enum:
5153           {
5154             asection *in = s->input_section.section;
5155
5156             if ((in->flags & SEC_EXCLUDE) == 0)
5157               dot += TO_ADDR (in->size);
5158           }
5159           break;
5160
5161         case lang_input_statement_enum:
5162           break;
5163
5164         case lang_fill_statement_enum:
5165           fill = s->fill_statement.fill;
5166           break;
5167
5168         case lang_assignment_statement_enum:
5169           exp_fold_tree (s->assignment_statement.exp,
5170                          current_os->bfd_section,
5171                          &dot);
5172           break;
5173
5174         case lang_padding_statement_enum:
5175           dot += TO_ADDR (s->padding_statement.size);
5176           break;
5177
5178         case lang_group_statement_enum:
5179           dot = lang_do_assignments_1 (s->group_statement.children.head,
5180                                        current_os, fill, dot);
5181           break;
5182
5183         case lang_insert_statement_enum:
5184           break;
5185
5186         case lang_address_statement_enum:
5187           break;
5188
5189         default:
5190           FAIL ();
5191           break;
5192         }
5193     }
5194   return dot;
5195 }
5196
5197 void
5198 lang_do_assignments (void)
5199 {
5200   lang_statement_iteration++;
5201   lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);
5202 }
5203
5204 /* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
5205    operator .startof. (section_name), it produces an undefined symbol
5206    .startof.section_name.  Similarly, when it sees
5207    .sizeof. (section_name), it produces an undefined symbol
5208    .sizeof.section_name.  For all the output sections, we look for
5209    such symbols, and set them to the correct value.  */
5210
5211 static void
5212 lang_set_startof (void)
5213 {
5214   asection *s;
5215
5216   if (link_info.relocatable)
5217     return;
5218
5219   for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
5220     {
5221       const char *secname;
5222       char *buf;
5223       struct bfd_link_hash_entry *h;
5224
5225       secname = bfd_get_section_name (link_info.output_bfd, s);
5226       buf = xmalloc (10 + strlen (secname));
5227
5228       sprintf (buf, ".startof.%s", secname);
5229       h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5230       if (h != NULL && h->type == bfd_link_hash_undefined)
5231         {
5232           h->type = bfd_link_hash_defined;
5233           h->u.def.value = bfd_get_section_vma (link_info.output_bfd, s);
5234           h->u.def.section = bfd_abs_section_ptr;
5235         }
5236
5237       sprintf (buf, ".sizeof.%s", secname);
5238       h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5239       if (h != NULL && h->type == bfd_link_hash_undefined)
5240         {
5241           h->type = bfd_link_hash_defined;
5242           h->u.def.value = TO_ADDR (s->size);
5243           h->u.def.section = bfd_abs_section_ptr;
5244         }
5245
5246       free (buf);
5247     }
5248 }
5249
5250 static void
5251 lang_end (void)
5252 {
5253   struct bfd_link_hash_entry *h;
5254   bfd_boolean warn;
5255
5256   if ((link_info.relocatable && !link_info.gc_sections)
5257       || link_info.shared)
5258     warn = entry_from_cmdline;
5259   else
5260     warn = TRUE;
5261
5262   /* Force the user to specify a root when generating a relocatable with
5263      --gc-sections.  */
5264   if (link_info.gc_sections && link_info.relocatable
5265       && (entry_symbol.name == NULL
5266           && ldlang_undef_chain_list_head == NULL))
5267     einfo (_("%P%F: gc-sections requires either an entry or "
5268              "an undefined symbol\n"));
5269
5270   if (entry_symbol.name == NULL)
5271     {
5272       /* No entry has been specified.  Look for the default entry, but
5273          don't warn if we don't find it.  */
5274       entry_symbol.name = entry_symbol_default;
5275       warn = FALSE;
5276     }
5277
5278   h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
5279                             FALSE, FALSE, TRUE);
5280   if (h != NULL
5281       && (h->type == bfd_link_hash_defined
5282           || h->type == bfd_link_hash_defweak)
5283       && h->u.def.section->output_section != NULL)
5284     {
5285       bfd_vma val;
5286
5287       val = (h->u.def.value
5288              + bfd_get_section_vma (link_info.output_bfd,
5289                                     h->u.def.section->output_section)
5290              + h->u.def.section->output_offset);
5291       if (! bfd_set_start_address (link_info.output_bfd, val))
5292         einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
5293     }
5294   else
5295     {
5296       bfd_vma val;
5297       const char *send;
5298
5299       /* We couldn't find the entry symbol.  Try parsing it as a
5300          number.  */
5301       val = bfd_scan_vma (entry_symbol.name, &send, 0);
5302       if (*send == '\0')
5303         {
5304           if (! bfd_set_start_address (link_info.output_bfd, val))
5305             einfo (_("%P%F: can't set start address\n"));
5306         }
5307       else
5308         {
5309           asection *ts;
5310
5311           /* Can't find the entry symbol, and it's not a number.  Use
5312              the first address in the text section.  */
5313           ts = bfd_get_section_by_name (link_info.output_bfd, entry_section);
5314           if (ts != NULL)
5315             {
5316               if (warn)
5317                 einfo (_("%P: warning: cannot find entry symbol %s;"
5318                          " defaulting to %V\n"),
5319                        entry_symbol.name,
5320                        bfd_get_section_vma (link_info.output_bfd, ts));
5321               if (!(bfd_set_start_address
5322                     (link_info.output_bfd,
5323                      bfd_get_section_vma (link_info.output_bfd, ts))))
5324                 einfo (_("%P%F: can't set start address\n"));
5325             }
5326           else
5327             {
5328               if (warn)
5329                 einfo (_("%P: warning: cannot find entry symbol %s;"
5330                          " not setting start address\n"),
5331                        entry_symbol.name);
5332             }
5333         }
5334     }
5335
5336   /* Don't bfd_hash_table_free (&lang_definedness_table);
5337      map file output may result in a call of lang_track_definedness.  */
5338 }
5339
5340 /* This is a small function used when we want to ignore errors from
5341    BFD.  */
5342
5343 static void
5344 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
5345 {
5346   /* Don't do anything.  */
5347 }
5348
5349 /* Check that the architecture of all the input files is compatible
5350    with the output file.  Also call the backend to let it do any
5351    other checking that is needed.  */
5352
5353 static void
5354 lang_check (void)
5355 {
5356   lang_statement_union_type *file;
5357   bfd *input_bfd;
5358   const bfd_arch_info_type *compatible;
5359
5360   for (file = file_chain.head; file != NULL; file = file->input_statement.next)
5361     {
5362       input_bfd = file->input_statement.the_bfd;
5363       compatible
5364         = bfd_arch_get_compatible (input_bfd, link_info.output_bfd,
5365                                    command_line.accept_unknown_input_arch);
5366
5367       /* In general it is not possible to perform a relocatable
5368          link between differing object formats when the input
5369          file has relocations, because the relocations in the
5370          input format may not have equivalent representations in
5371          the output format (and besides BFD does not translate
5372          relocs for other link purposes than a final link).  */
5373       if ((link_info.relocatable || link_info.emitrelocations)
5374           && (compatible == NULL
5375               || (bfd_get_flavour (input_bfd)
5376                   != bfd_get_flavour (link_info.output_bfd)))
5377           && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
5378         {
5379           einfo (_("%P%F: Relocatable linking with relocations from"
5380                    " format %s (%B) to format %s (%B) is not supported\n"),
5381                  bfd_get_target (input_bfd), input_bfd,
5382                  bfd_get_target (link_info.output_bfd), link_info.output_bfd);
5383           /* einfo with %F exits.  */
5384         }
5385
5386       if (compatible == NULL)
5387         {
5388           if (command_line.warn_mismatch)
5389             einfo (_("%P%X: %s architecture of input file `%B'"
5390                      " is incompatible with %s output\n"),
5391                    bfd_printable_name (input_bfd), input_bfd,
5392                    bfd_printable_name (link_info.output_bfd));
5393         }
5394       else if (bfd_count_sections (input_bfd))
5395         {
5396           /* If the input bfd has no contents, it shouldn't set the
5397              private data of the output bfd.  */
5398
5399           bfd_error_handler_type pfn = NULL;
5400
5401           /* If we aren't supposed to warn about mismatched input
5402              files, temporarily set the BFD error handler to a
5403              function which will do nothing.  We still want to call
5404              bfd_merge_private_bfd_data, since it may set up
5405              information which is needed in the output file.  */
5406           if (! command_line.warn_mismatch)
5407             pfn = bfd_set_error_handler (ignore_bfd_errors);
5408           if (! bfd_merge_private_bfd_data (input_bfd, link_info.output_bfd))
5409             {
5410               if (command_line.warn_mismatch)
5411                 einfo (_("%P%X: failed to merge target specific data"
5412                          " of file %B\n"), input_bfd);
5413             }
5414           if (! command_line.warn_mismatch)
5415             bfd_set_error_handler (pfn);
5416         }
5417     }
5418 }
5419
5420 /* Look through all the global common symbols and attach them to the
5421    correct section.  The -sort-common command line switch may be used
5422    to roughly sort the entries by size.  */
5423
5424 static void
5425 lang_common (void)
5426 {
5427   if (command_line.inhibit_common_definition)
5428     return;
5429   if (link_info.relocatable
5430       && ! command_line.force_common_definition)
5431     return;
5432
5433   if (! config.sort_common)
5434     bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
5435   else
5436     {
5437       int power;
5438
5439       for (power = 4; power >= 0; power--)
5440         bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5441     }
5442 }
5443
5444 /* Place one common symbol in the correct section.  */
5445
5446 static bfd_boolean
5447 lang_one_common (struct bfd_link_hash_entry *h, void *info)
5448 {
5449   unsigned int power_of_two;
5450   bfd_vma size;
5451   asection *section;
5452
5453   if (h->type != bfd_link_hash_common)
5454     return TRUE;
5455
5456   size = h->u.c.size;
5457   power_of_two = h->u.c.p->alignment_power;
5458
5459   if (config.sort_common
5460       && power_of_two < (unsigned int) *(int *) info)
5461     return TRUE;
5462
5463   section = h->u.c.p->section;
5464
5465   /* Increase the size of the section to align the common sym.  */
5466   section->size += ((bfd_vma) 1 << (power_of_two + opb_shift)) - 1;
5467   section->size &= (- (bfd_vma) 1 << (power_of_two + opb_shift));
5468
5469   /* Adjust the alignment if necessary.  */
5470   if (power_of_two > section->alignment_power)
5471     section->alignment_power = power_of_two;
5472
5473   /* Change the symbol from common to defined.  */
5474   h->type = bfd_link_hash_defined;
5475   h->u.def.section = section;
5476   h->u.def.value = section->size;
5477
5478   /* Increase the size of the section.  */
5479   section->size += size;
5480
5481   /* Make sure the section is allocated in memory, and make sure that
5482      it is no longer a common section.  */
5483   section->flags |= SEC_ALLOC;
5484   section->flags &= ~SEC_IS_COMMON;
5485
5486   if (config.map_file != NULL)
5487     {
5488       static bfd_boolean header_printed;
5489       int len;
5490       char *name;
5491       char buf[50];
5492
5493       if (! header_printed)
5494         {
5495           minfo (_("\nAllocating common symbols\n"));
5496           minfo (_("Common symbol       size              file\n\n"));
5497           header_printed = TRUE;
5498         }
5499
5500       name = bfd_demangle (link_info.output_bfd, h->root.string,
5501                            DMGL_ANSI | DMGL_PARAMS);
5502       if (name == NULL)
5503         {
5504           minfo ("%s", h->root.string);
5505           len = strlen (h->root.string);
5506         }
5507       else
5508         {
5509           minfo ("%s", name);
5510           len = strlen (name);
5511           free (name);
5512         }
5513
5514       if (len >= 19)
5515         {
5516           print_nl ();
5517           len = 0;
5518         }
5519       while (len < 20)
5520         {
5521           print_space ();
5522           ++len;
5523         }
5524
5525       minfo ("0x");
5526       if (size <= 0xffffffff)
5527         sprintf (buf, "%lx", (unsigned long) size);
5528       else
5529         sprintf_vma (buf, size);
5530       minfo ("%s", buf);
5531       len = strlen (buf);
5532
5533       while (len < 16)
5534         {
5535           print_space ();
5536           ++len;
5537         }
5538
5539       minfo ("%B\n", section->owner);
5540     }
5541
5542   return TRUE;
5543 }
5544
5545 /* Run through the input files and ensure that every input section has
5546    somewhere to go.  If one is found without a destination then create
5547    an input request and place it into the statement tree.  */
5548
5549 static void
5550 lang_place_orphans (void)
5551 {
5552   LANG_FOR_EACH_INPUT_STATEMENT (file)
5553     {
5554       asection *s;
5555
5556       for (s = file->the_bfd->sections; s != NULL; s = s->next)
5557         {
5558           if (s->output_section == NULL)
5559             {
5560               /* This section of the file is not attached, root
5561                  around for a sensible place for it to go.  */
5562
5563               if (file->just_syms_flag)
5564                 bfd_link_just_syms (file->the_bfd, s, &link_info);
5565               else if ((s->flags & SEC_EXCLUDE) != 0)
5566                 s->output_section = bfd_abs_section_ptr;
5567               else if (strcmp (s->name, "COMMON") == 0)
5568                 {
5569                   /* This is a lonely common section which must have
5570                      come from an archive.  We attach to the section
5571                      with the wildcard.  */
5572                   if (! link_info.relocatable
5573                       || command_line.force_common_definition)
5574                     {
5575                       if (default_common_section == NULL)
5576                         {
5577                           default_common_section =
5578                             lang_output_section_statement_lookup (".bss");
5579
5580                         }
5581                       lang_add_section (&default_common_section->children, s,
5582                                         default_common_section);
5583                     }
5584                 }
5585               else if (ldemul_place_orphan (s))
5586                 ;
5587               else
5588                 {
5589                   lang_output_section_statement_type *os;
5590
5591                   os = lang_output_section_statement_lookup (s->name);
5592                   lang_add_section (&os->children, s, os);
5593                 }
5594             }
5595         }
5596     }
5597 }
5598
5599 void
5600 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
5601 {
5602   flagword *ptr_flags;
5603
5604   ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
5605   while (*flags)
5606     {
5607       switch (*flags)
5608         {
5609         case 'A': case 'a':
5610           *ptr_flags |= SEC_ALLOC;
5611           break;
5612
5613         case 'R': case 'r':
5614           *ptr_flags |= SEC_READONLY;
5615           break;
5616
5617         case 'W': case 'w':
5618           *ptr_flags |= SEC_DATA;
5619           break;
5620
5621         case 'X': case 'x':
5622           *ptr_flags |= SEC_CODE;
5623           break;
5624
5625         case 'L': case 'l':
5626         case 'I': case 'i':
5627           *ptr_flags |= SEC_LOAD;
5628           break;
5629
5630         default:
5631           einfo (_("%P%F: invalid syntax in flags\n"));
5632           break;
5633         }
5634       flags++;
5635     }
5636 }
5637
5638 /* Call a function on each input file.  This function will be called
5639    on an archive, but not on the elements.  */
5640
5641 void
5642 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
5643 {
5644   lang_input_statement_type *f;
5645
5646   for (f = (lang_input_statement_type *) input_file_chain.head;
5647        f != NULL;
5648        f = (lang_input_statement_type *) f->next_real_file)
5649     func (f);
5650 }
5651
5652 /* Call a function on each file.  The function will be called on all
5653    the elements of an archive which are included in the link, but will
5654    not be called on the archive file itself.  */
5655
5656 void
5657 lang_for_each_file (void (*func) (lang_input_statement_type *))
5658 {
5659   LANG_FOR_EACH_INPUT_STATEMENT (f)
5660     {
5661       func (f);
5662     }
5663 }
5664
5665 void
5666 ldlang_add_file (lang_input_statement_type *entry)
5667 {
5668   lang_statement_append (&file_chain,
5669                          (lang_statement_union_type *) entry,
5670                          &entry->next);
5671
5672   /* The BFD linker needs to have a list of all input BFDs involved in
5673      a link.  */
5674   ASSERT (entry->the_bfd->link_next == NULL);
5675   ASSERT (entry->the_bfd != link_info.output_bfd);
5676
5677   *link_info.input_bfds_tail = entry->the_bfd;
5678   link_info.input_bfds_tail = &entry->the_bfd->link_next;
5679   entry->the_bfd->usrdata = entry;
5680   bfd_set_gp_size (entry->the_bfd, g_switch_value);
5681
5682   /* Look through the sections and check for any which should not be
5683      included in the link.  We need to do this now, so that we can
5684      notice when the backend linker tries to report multiple
5685      definition errors for symbols which are in sections we aren't
5686      going to link.  FIXME: It might be better to entirely ignore
5687      symbols which are defined in sections which are going to be
5688      discarded.  This would require modifying the backend linker for
5689      each backend which might set the SEC_LINK_ONCE flag.  If we do
5690      this, we should probably handle SEC_EXCLUDE in the same way.  */
5691
5692   bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
5693 }
5694
5695 void
5696 lang_add_output (const char *name, int from_script)
5697 {
5698   /* Make -o on command line override OUTPUT in script.  */
5699   if (!had_output_filename || !from_script)
5700     {
5701       output_filename = name;
5702       had_output_filename = TRUE;
5703     }
5704 }
5705
5706 static lang_output_section_statement_type *current_section;
5707
5708 static int
5709 topower (int x)
5710 {
5711   unsigned int i = 1;
5712   int l;
5713
5714   if (x < 0)
5715     return -1;
5716
5717   for (l = 0; l < 32; l++)
5718     {
5719       if (i >= (unsigned int) x)
5720         return l;
5721       i <<= 1;
5722     }
5723
5724   return 0;
5725 }
5726
5727 lang_output_section_statement_type *
5728 lang_enter_output_section_statement (const char *output_section_statement_name,
5729                                      etree_type *address_exp,
5730                                      enum section_type sectype,
5731                                      etree_type *align,
5732                                      etree_type *subalign,
5733                                      etree_type *ebase,
5734                                      int constraint)
5735 {
5736   lang_output_section_statement_type *os;
5737
5738    os = lang_output_section_statement_lookup_1 (output_section_statement_name,
5739                                                 constraint);
5740    current_section = os;
5741
5742   /* Make next things chain into subchain of this.  */
5743
5744   if (os->addr_tree == NULL)
5745     {
5746       os->addr_tree = address_exp;
5747     }
5748   os->sectype = sectype;
5749   if (sectype != noload_section)
5750     os->flags = SEC_NO_FLAGS;
5751   else
5752     os->flags = SEC_NEVER_LOAD;
5753   os->block_value = 1;
5754   stat_ptr = &os->children;
5755
5756   os->subsection_alignment =
5757     topower (exp_get_value_int (subalign, -1, "subsection alignment"));
5758   os->section_alignment =
5759     topower (exp_get_value_int (align, -1, "section alignment"));
5760
5761   os->load_base = ebase;
5762   return os;
5763 }
5764
5765 void
5766 lang_final (void)
5767 {
5768   lang_output_statement_type *new;
5769
5770   new = new_stat (lang_output_statement, stat_ptr);
5771   new->name = output_filename;
5772 }
5773
5774 /* Reset the current counters in the regions.  */
5775
5776 void
5777 lang_reset_memory_regions (void)
5778 {
5779   lang_memory_region_type *p = lang_memory_region_list;
5780   asection *o;
5781   lang_output_section_statement_type *os;
5782
5783   for (p = lang_memory_region_list; p != NULL; p = p->next)
5784     {
5785       p->current = p->origin;
5786       p->last_os = NULL;
5787     }
5788
5789   for (os = &lang_output_section_statement.head->output_section_statement;
5790        os != NULL;
5791        os = os->next)
5792     {
5793       os->processed_vma = FALSE;
5794       os->processed_lma = FALSE;
5795     }
5796
5797   for (o = link_info.output_bfd->sections; o != NULL; o = o->next)
5798     {
5799       /* Save the last size for possible use by bfd_relax_section.  */
5800       o->rawsize = o->size;
5801       o->size = 0;
5802     }
5803 }
5804
5805 /* Worker for lang_gc_sections_1.  */
5806
5807 static void
5808 gc_section_callback (lang_wild_statement_type *ptr,
5809                      struct wildcard_list *sec ATTRIBUTE_UNUSED,
5810                      asection *section,
5811                      lang_input_statement_type *file ATTRIBUTE_UNUSED,
5812                      void *data ATTRIBUTE_UNUSED)
5813 {
5814   /* If the wild pattern was marked KEEP, the member sections
5815      should be as well.  */
5816   if (ptr->keep_sections)
5817     section->flags |= SEC_KEEP;
5818 }
5819
5820 /* Iterate over sections marking them against GC.  */
5821
5822 static void
5823 lang_gc_sections_1 (lang_statement_union_type *s)
5824 {
5825   for (; s != NULL; s = s->header.next)
5826     {
5827       switch (s->header.type)
5828         {
5829         case lang_wild_statement_enum:
5830           walk_wild (&s->wild_statement, gc_section_callback, NULL);
5831           break;
5832         case lang_constructors_statement_enum:
5833           lang_gc_sections_1 (constructor_list.head);
5834           break;
5835         case lang_output_section_statement_enum:
5836           lang_gc_sections_1 (s->output_section_statement.children.head);
5837           break;
5838         case lang_group_statement_enum:
5839           lang_gc_sections_1 (s->group_statement.children.head);
5840           break;
5841         default:
5842           break;
5843         }
5844     }
5845 }
5846
5847 static void
5848 lang_gc_sections (void)
5849 {
5850   /* Keep all sections so marked in the link script.  */
5851
5852   lang_gc_sections_1 (statement_list.head);
5853
5854   /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
5855      the special case of debug info.  (See bfd/stabs.c)
5856      Twiddle the flag here, to simplify later linker code.  */
5857   if (link_info.relocatable)
5858     {
5859       LANG_FOR_EACH_INPUT_STATEMENT (f)
5860         {
5861           asection *sec;
5862           for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
5863             if ((sec->flags & SEC_DEBUGGING) == 0)
5864               sec->flags &= ~SEC_EXCLUDE;
5865         }
5866     }
5867
5868   if (link_info.gc_sections)
5869     bfd_gc_sections (link_info.output_bfd, &link_info);
5870 }
5871
5872 /* Worker for lang_find_relro_sections_1.  */
5873
5874 static void
5875 find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
5876                              struct wildcard_list *sec ATTRIBUTE_UNUSED,
5877                              asection *section,
5878                              lang_input_statement_type *file ATTRIBUTE_UNUSED,
5879                              void *data)
5880 {
5881   /* Discarded, excluded and ignored sections effectively have zero
5882      size.  */
5883   if (section->output_section != NULL
5884       && section->output_section->owner == link_info.output_bfd
5885       && (section->output_section->flags & SEC_EXCLUDE) == 0
5886       && !IGNORE_SECTION (section)
5887       && section->size != 0)
5888     {
5889       bfd_boolean *has_relro_section = (bfd_boolean *) data;
5890       *has_relro_section = TRUE;
5891     }
5892 }
5893
5894 /* Iterate over sections for relro sections.  */
5895
5896 static void
5897 lang_find_relro_sections_1 (lang_statement_union_type *s,
5898                             bfd_boolean *has_relro_section)
5899 {
5900   if (*has_relro_section)
5901     return;
5902
5903   for (; s != NULL; s = s->header.next)
5904     {
5905       if (s == expld.dataseg.relro_end_stat)
5906         break;
5907
5908       switch (s->header.type)
5909         {
5910         case lang_wild_statement_enum:
5911           walk_wild (&s->wild_statement,
5912                      find_relro_section_callback,
5913                      has_relro_section);
5914           break;
5915         case lang_constructors_statement_enum:
5916           lang_find_relro_sections_1 (constructor_list.head,
5917                                       has_relro_section);
5918           break;
5919         case lang_output_section_statement_enum:
5920           lang_find_relro_sections_1 (s->output_section_statement.children.head,
5921                                       has_relro_section);
5922           break;
5923         case lang_group_statement_enum:
5924           lang_find_relro_sections_1 (s->group_statement.children.head,
5925                                       has_relro_section);
5926           break;
5927         default:
5928           break;
5929         }
5930     }
5931 }
5932
5933 static void
5934 lang_find_relro_sections (void)
5935 {
5936   bfd_boolean has_relro_section = FALSE;
5937
5938   /* Check all sections in the link script.  */
5939
5940   lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,
5941                               &has_relro_section);
5942
5943   if (!has_relro_section)
5944     link_info.relro = FALSE;
5945 }
5946
5947 /* Relax all sections until bfd_relax_section gives up.  */
5948
5949 static void
5950 relax_sections (void)
5951 {
5952   /* Keep relaxing until bfd_relax_section gives up.  */
5953   bfd_boolean relax_again;
5954
5955   link_info.relax_trip = -1;
5956   do
5957     {
5958       relax_again = FALSE;
5959       link_info.relax_trip++;
5960
5961       /* Note: pe-dll.c does something like this also.  If you find
5962          you need to change this code, you probably need to change
5963          pe-dll.c also.  DJ  */
5964
5965       /* Do all the assignments with our current guesses as to
5966          section sizes.  */
5967       lang_do_assignments ();
5968
5969       /* We must do this after lang_do_assignments, because it uses
5970          size.  */
5971       lang_reset_memory_regions ();
5972
5973       /* Perform another relax pass - this time we know where the
5974          globals are, so can make a better guess.  */
5975       lang_size_sections (&relax_again, FALSE);
5976     }
5977   while (relax_again);
5978 }
5979
5980 void
5981 lang_process (void)
5982 {
5983   /* Finalize dynamic list.  */
5984   if (link_info.dynamic_list)
5985     lang_finalize_version_expr_head (&link_info.dynamic_list->head);
5986
5987   current_target = default_target;
5988
5989   /* Open the output file.  */
5990   lang_for_each_statement (ldlang_open_output);
5991   init_opb ();
5992
5993   ldemul_create_output_section_statements ();
5994
5995   /* Add to the hash table all undefineds on the command line.  */
5996   lang_place_undefineds ();
5997
5998   if (!bfd_section_already_linked_table_init ())
5999     einfo (_("%P%F: Failed to create hash table\n"));
6000
6001   /* Create a bfd for each input file.  */
6002   current_target = default_target;
6003   open_input_bfds (statement_list.head, FALSE);
6004
6005   link_info.gc_sym_list = &entry_symbol;
6006   if (entry_symbol.name == NULL)
6007     link_info.gc_sym_list = ldlang_undef_chain_list_head;
6008
6009   ldemul_after_open ();
6010
6011   bfd_section_already_linked_table_free ();
6012
6013   /* Make sure that we're not mixing architectures.  We call this
6014      after all the input files have been opened, but before we do any
6015      other processing, so that any operations merge_private_bfd_data
6016      does on the output file will be known during the rest of the
6017      link.  */
6018   lang_check ();
6019
6020   /* Handle .exports instead of a version script if we're told to do so.  */
6021   if (command_line.version_exports_section)
6022     lang_do_version_exports_section ();
6023
6024   /* Build all sets based on the information gathered from the input
6025      files.  */
6026   ldctor_build_sets ();
6027
6028   /* Remove unreferenced sections if asked to.  */
6029   lang_gc_sections ();
6030
6031   /* Size up the common data.  */
6032   lang_common ();
6033
6034   /* Update wild statements.  */
6035   update_wild_statements (statement_list.head);
6036
6037   /* Run through the contours of the script and attach input sections
6038      to the correct output sections.  */
6039   map_input_to_output_sections (statement_list.head, NULL, NULL);
6040
6041   process_insert_statements ();
6042
6043   /* Find any sections not attached explicitly and handle them.  */
6044   lang_place_orphans ();
6045
6046   if (! link_info.relocatable)
6047     {
6048       asection *found;
6049
6050       /* Merge SEC_MERGE sections.  This has to be done after GC of
6051          sections, so that GCed sections are not merged, but before
6052          assigning dynamic symbols, since removing whole input sections
6053          is hard then.  */
6054       bfd_merge_sections (link_info.output_bfd, &link_info);
6055
6056       /* Look for a text section and set the readonly attribute in it.  */
6057       found = bfd_get_section_by_name (link_info.output_bfd, ".text");
6058
6059       if (found != NULL)
6060         {
6061           if (config.text_read_only)
6062             found->flags |= SEC_READONLY;
6063           else
6064             found->flags &= ~SEC_READONLY;
6065         }
6066     }
6067
6068   /* Do anything special before sizing sections.  This is where ELF
6069      and other back-ends size dynamic sections.  */
6070   ldemul_before_allocation ();
6071
6072   /* We must record the program headers before we try to fix the
6073      section positions, since they will affect SIZEOF_HEADERS.  */
6074   lang_record_phdrs ();
6075
6076   /* Check relro sections.  */
6077   if (link_info.relro && ! link_info.relocatable)
6078     lang_find_relro_sections ();
6079
6080   /* Size up the sections.  */
6081   lang_size_sections (NULL, !command_line.relax);
6082
6083   /* Now run around and relax if we can.  */
6084   if (command_line.relax)
6085     {
6086       /* We may need more than one relaxation pass.  */
6087       int i = link_info.relax_pass;
6088
6089       /* The backend can use it to determine the current pass.  */
6090       link_info.relax_pass = 0;
6091
6092       while (i--)
6093         {
6094           relax_sections ();
6095           link_info.relax_pass++;
6096         }
6097
6098       /* Final extra sizing to report errors.  */
6099       lang_do_assignments ();
6100       lang_reset_memory_regions ();
6101       lang_size_sections (NULL, TRUE);
6102     }
6103
6104   /* See if anything special should be done now we know how big
6105      everything is.  */
6106   ldemul_after_allocation ();
6107
6108   /* Fix any .startof. or .sizeof. symbols.  */
6109   lang_set_startof ();
6110
6111   /* Do all the assignments, now that we know the final resting places
6112      of all the symbols.  */
6113
6114   lang_do_assignments ();
6115
6116   ldemul_finish ();
6117
6118   /* Make sure that the section addresses make sense.  */
6119   if (! link_info.relocatable
6120       && command_line.check_section_addresses)
6121     lang_check_section_addresses ();
6122
6123   lang_end ();
6124 }
6125
6126 /* EXPORTED TO YACC */
6127
6128 void
6129 lang_add_wild (struct wildcard_spec *filespec,
6130                struct wildcard_list *section_list,
6131                bfd_boolean keep_sections)
6132 {
6133   struct wildcard_list *curr, *next;
6134   lang_wild_statement_type *new;
6135
6136   /* Reverse the list as the parser puts it back to front.  */
6137   for (curr = section_list, section_list = NULL;
6138        curr != NULL;
6139        section_list = curr, curr = next)
6140     {
6141       if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
6142         placed_commons = TRUE;
6143
6144       next = curr->next;
6145       curr->next = section_list;
6146     }
6147
6148   if (filespec != NULL && filespec->name != NULL)
6149     {
6150       if (strcmp (filespec->name, "*") == 0)
6151         filespec->name = NULL;
6152       else if (! wildcardp (filespec->name))
6153         lang_has_input_file = TRUE;
6154     }
6155
6156   new = new_stat (lang_wild_statement, stat_ptr);
6157   new->filename = NULL;
6158   new->filenames_sorted = FALSE;
6159   if (filespec != NULL)
6160     {
6161       new->filename = filespec->name;
6162       new->filenames_sorted = filespec->sorted == by_name;
6163     }
6164   new->section_list = section_list;
6165   new->keep_sections = keep_sections;
6166   lang_list_init (&new->children);
6167   analyze_walk_wild_section_handler (new);
6168 }
6169
6170 void
6171 lang_section_start (const char *name, etree_type *address,
6172                     const segment_type *segment)
6173 {
6174   lang_address_statement_type *ad;
6175
6176   ad = new_stat (lang_address_statement, stat_ptr);
6177   ad->section_name = name;
6178   ad->address = address;
6179   ad->segment = segment;
6180 }
6181
6182 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
6183    because of a -e argument on the command line, or zero if this is
6184    called by ENTRY in a linker script.  Command line arguments take
6185    precedence.  */
6186
6187 void
6188 lang_add_entry (const char *name, bfd_boolean cmdline)
6189 {
6190   if (entry_symbol.name == NULL
6191       || cmdline
6192       || ! entry_from_cmdline)
6193     {
6194       entry_symbol.name = name;
6195       entry_from_cmdline = cmdline;
6196     }
6197 }
6198
6199 /* Set the default start symbol to NAME.  .em files should use this,
6200    not lang_add_entry, to override the use of "start" if neither the
6201    linker script nor the command line specifies an entry point.  NAME
6202    must be permanently allocated.  */
6203 void
6204 lang_default_entry (const char *name)
6205 {
6206   entry_symbol_default = name;
6207 }
6208
6209 void
6210 lang_add_target (const char *name)
6211 {
6212   lang_target_statement_type *new;
6213
6214   new = new_stat (lang_target_statement, stat_ptr);
6215   new->target = name;
6216 }
6217
6218 void
6219 lang_add_map (const char *name)
6220 {
6221   while (*name)
6222     {
6223       switch (*name)
6224         {
6225         case 'F':
6226           map_option_f = TRUE;
6227           break;
6228         }
6229       name++;
6230     }
6231 }
6232
6233 void
6234 lang_add_fill (fill_type *fill)
6235 {
6236   lang_fill_statement_type *new;
6237
6238   new = new_stat (lang_fill_statement, stat_ptr);
6239   new->fill = fill;
6240 }
6241
6242 void
6243 lang_add_data (int type, union etree_union *exp)
6244 {
6245   lang_data_statement_type *new;
6246
6247   new = new_stat (lang_data_statement, stat_ptr);
6248   new->exp = exp;
6249   new->type = type;
6250 }
6251
6252 /* Create a new reloc statement.  RELOC is the BFD relocation type to
6253    generate.  HOWTO is the corresponding howto structure (we could
6254    look this up, but the caller has already done so).  SECTION is the
6255    section to generate a reloc against, or NAME is the name of the
6256    symbol to generate a reloc against.  Exactly one of SECTION and
6257    NAME must be NULL.  ADDEND is an expression for the addend.  */
6258
6259 void
6260 lang_add_reloc (bfd_reloc_code_real_type reloc,
6261                 reloc_howto_type *howto,
6262                 asection *section,
6263                 const char *name,
6264                 union etree_union *addend)
6265 {
6266   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
6267
6268   p->reloc = reloc;
6269   p->howto = howto;
6270   p->section = section;
6271   p->name = name;
6272   p->addend_exp = addend;
6273
6274   p->addend_value = 0;
6275   p->output_section = NULL;
6276   p->output_offset = 0;
6277 }
6278
6279 lang_assignment_statement_type *
6280 lang_add_assignment (etree_type *exp)
6281 {
6282   lang_assignment_statement_type *new;
6283
6284   new = new_stat (lang_assignment_statement, stat_ptr);
6285   new->exp = exp;
6286   return new;
6287 }
6288
6289 void
6290 lang_add_attribute (enum statement_enum attribute)
6291 {
6292   new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
6293 }
6294
6295 void
6296 lang_startup (const char *name)
6297 {
6298   if (startup_file != NULL)
6299     {
6300       einfo (_("%P%F: multiple STARTUP files\n"));
6301     }
6302   first_file->filename = name;
6303   first_file->local_sym_name = name;
6304   first_file->real = TRUE;
6305
6306   startup_file = name;
6307 }
6308
6309 void
6310 lang_float (bfd_boolean maybe)
6311 {
6312   lang_float_flag = maybe;
6313 }
6314
6315
6316 /* Work out the load- and run-time regions from a script statement, and
6317    store them in *LMA_REGION and *REGION respectively.
6318
6319    MEMSPEC is the name of the run-time region, or the value of
6320    DEFAULT_MEMORY_REGION if the statement didn't specify one.
6321    LMA_MEMSPEC is the name of the load-time region, or null if the
6322    statement didn't specify one.HAVE_LMA_P is TRUE if the statement
6323    had an explicit load address.
6324
6325    It is an error to specify both a load region and a load address.  */
6326
6327 static void
6328 lang_get_regions (lang_memory_region_type **region,
6329                   lang_memory_region_type **lma_region,
6330                   const char *memspec,
6331                   const char *lma_memspec,
6332                   bfd_boolean have_lma,
6333                   bfd_boolean have_vma)
6334 {
6335   *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
6336
6337   /* If no runtime region or VMA has been specified, but the load region
6338      has been specified, then use the load region for the runtime region
6339      as well.  */
6340   if (lma_memspec != NULL
6341       && ! have_vma
6342       && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
6343     *region = *lma_region;
6344   else
6345     *region = lang_memory_region_lookup (memspec, FALSE);
6346
6347   if (have_lma && lma_memspec != 0)
6348     einfo (_("%X%P:%S: section has both a load address and a load region\n"));
6349 }
6350
6351 void
6352 lang_leave_output_section_statement (fill_type *fill, const char *memspec,
6353                                      lang_output_section_phdr_list *phdrs,
6354                                      const char *lma_memspec)
6355 {
6356   lang_get_regions (&current_section->region,
6357                     &current_section->lma_region,
6358                     memspec, lma_memspec,
6359                     current_section->load_base != NULL,
6360                     current_section->addr_tree != NULL);
6361   current_section->fill = fill;
6362   current_section->phdrs = phdrs;
6363   stat_ptr = &statement_list;
6364 }
6365
6366 /* Create an absolute symbol with the given name with the value of the
6367    address of first byte of the section named.
6368
6369    If the symbol already exists, then do nothing.  */
6370
6371 void
6372 lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
6373 {
6374   struct bfd_link_hash_entry *h;
6375
6376   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6377   if (h == NULL)
6378     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6379
6380   if (h->type == bfd_link_hash_new
6381       || h->type == bfd_link_hash_undefined)
6382     {
6383       asection *sec;
6384
6385       h->type = bfd_link_hash_defined;
6386
6387       sec = bfd_get_section_by_name (link_info.output_bfd, secname);
6388       if (sec == NULL)
6389         h->u.def.value = 0;
6390       else
6391         h->u.def.value = bfd_get_section_vma (link_info.output_bfd, sec);
6392
6393       h->u.def.section = bfd_abs_section_ptr;
6394     }
6395 }
6396
6397 /* Create an absolute symbol with the given name with the value of the
6398    address of the first byte after the end of the section named.
6399
6400    If the symbol already exists, then do nothing.  */
6401
6402 void
6403 lang_abs_symbol_at_end_of (const char *secname, const char *name)
6404 {
6405   struct bfd_link_hash_entry *h;
6406
6407   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6408   if (h == NULL)
6409     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6410
6411   if (h->type == bfd_link_hash_new
6412       || h->type == bfd_link_hash_undefined)
6413     {
6414       asection *sec;
6415
6416       h->type = bfd_link_hash_defined;
6417
6418       sec = bfd_get_section_by_name (link_info.output_bfd, secname);
6419       if (sec == NULL)
6420         h->u.def.value = 0;
6421       else
6422         h->u.def.value = (bfd_get_section_vma (link_info.output_bfd, sec)
6423                           + TO_ADDR (sec->size));
6424
6425       h->u.def.section = bfd_abs_section_ptr;
6426     }
6427 }
6428
6429 void
6430 lang_statement_append (lang_statement_list_type *list,
6431                        lang_statement_union_type *element,
6432                        lang_statement_union_type **field)
6433 {
6434   *(list->tail) = element;
6435   list->tail = field;
6436 }
6437
6438 /* Set the output format type.  -oformat overrides scripts.  */
6439
6440 void
6441 lang_add_output_format (const char *format,
6442                         const char *big,
6443                         const char *little,
6444                         int from_script)
6445 {
6446   if (output_target == NULL || !from_script)
6447     {
6448       if (command_line.endian == ENDIAN_BIG
6449           && big != NULL)
6450         format = big;
6451       else if (command_line.endian == ENDIAN_LITTLE
6452                && little != NULL)
6453         format = little;
6454
6455       output_target = format;
6456     }
6457 }
6458
6459 void
6460 lang_add_insert (const char *where, int is_before)
6461 {
6462   lang_insert_statement_type *new;
6463
6464   new = new_stat (lang_insert_statement, stat_ptr);
6465   new->where = where;
6466   new->is_before = is_before;
6467   saved_script_handle = previous_script_handle;
6468 }
6469
6470 /* Enter a group.  This creates a new lang_group_statement, and sets
6471    stat_ptr to build new statements within the group.  */
6472
6473 void
6474 lang_enter_group (void)
6475 {
6476   lang_group_statement_type *g;
6477
6478   g = new_stat (lang_group_statement, stat_ptr);
6479   lang_list_init (&g->children);
6480   stat_ptr = &g->children;
6481 }
6482
6483 /* Leave a group.  This just resets stat_ptr to start writing to the
6484    regular list of statements again.  Note that this will not work if
6485    groups can occur inside anything else which can adjust stat_ptr,
6486    but currently they can't.  */
6487
6488 void
6489 lang_leave_group (void)
6490 {
6491   stat_ptr = &statement_list;
6492 }
6493
6494 /* Add a new program header.  This is called for each entry in a PHDRS
6495    command in a linker script.  */
6496
6497 void
6498 lang_new_phdr (const char *name,
6499                etree_type *type,
6500                bfd_boolean filehdr,
6501                bfd_boolean phdrs,
6502                etree_type *at,
6503                etree_type *flags)
6504 {
6505   struct lang_phdr *n, **pp;
6506
6507   n = stat_alloc (sizeof (struct lang_phdr));
6508   n->next = NULL;
6509   n->name = name;
6510   n->type = exp_get_value_int (type, 0, "program header type");
6511   n->filehdr = filehdr;
6512   n->phdrs = phdrs;
6513   n->at = at;
6514   n->flags = flags;
6515
6516   for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
6517     ;
6518   *pp = n;
6519 }
6520
6521 /* Record the program header information in the output BFD.  FIXME: We
6522    should not be calling an ELF specific function here.  */
6523
6524 static void
6525 lang_record_phdrs (void)
6526 {
6527   unsigned int alc;
6528   asection **secs;
6529   lang_output_section_phdr_list *last;
6530   struct lang_phdr *l;
6531   lang_output_section_statement_type *os;
6532
6533   alc = 10;
6534   secs = xmalloc (alc * sizeof (asection *));
6535   last = NULL;
6536
6537   for (l = lang_phdr_list; l != NULL; l = l->next)
6538     {
6539       unsigned int c;
6540       flagword flags;
6541       bfd_vma at;
6542
6543       c = 0;
6544       for (os = &lang_output_section_statement.head->output_section_statement;
6545            os != NULL;
6546            os = os->next)
6547         {
6548           lang_output_section_phdr_list *pl;
6549
6550           if (os->constraint == -1)
6551             continue;
6552
6553           pl = os->phdrs;
6554           if (pl != NULL)
6555             last = pl;
6556           else
6557             {
6558               if (os->sectype == noload_section
6559                   || os->bfd_section == NULL
6560                   || (os->bfd_section->flags & SEC_ALLOC) == 0)
6561                 continue;
6562
6563               if (last == NULL)
6564                 {
6565                   lang_output_section_statement_type * tmp_os;
6566
6567                   /* If we have not run across a section with a program
6568                      header assigned to it yet, then scan forwards to find
6569                      one.  This prevents inconsistencies in the linker's
6570                      behaviour when a script has specified just a single
6571                      header and there are sections in that script which are
6572                      not assigned to it, and which occur before the first
6573                      use of that header. See here for more details:
6574                      http://sourceware.org/ml/binutils/2007-02/msg00291.html  */
6575                   for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)
6576                     if (tmp_os->phdrs)
6577                       {
6578                         last = tmp_os->phdrs;
6579                         break;
6580                       }
6581                   if (last == NULL)
6582                     einfo (_("%F%P: no sections assigned to phdrs\n"));
6583                 }
6584               pl = last;
6585             }
6586
6587           if (os->bfd_section == NULL)
6588             continue;
6589
6590           for (; pl != NULL; pl = pl->next)
6591             {
6592               if (strcmp (pl->name, l->name) == 0)
6593                 {
6594                   if (c >= alc)
6595                     {
6596                       alc *= 2;
6597                       secs = xrealloc (secs, alc * sizeof (asection *));
6598                     }
6599                   secs[c] = os->bfd_section;
6600                   ++c;
6601                   pl->used = TRUE;
6602                 }
6603             }
6604         }
6605
6606       if (l->flags == NULL)
6607         flags = 0;
6608       else
6609         flags = exp_get_vma (l->flags, 0, "phdr flags");
6610
6611       if (l->at == NULL)
6612         at = 0;
6613       else
6614         at = exp_get_vma (l->at, 0, "phdr load address");
6615
6616       if (! bfd_record_phdr (link_info.output_bfd, l->type,
6617                              l->flags != NULL, flags, l->at != NULL,
6618                              at, l->filehdr, l->phdrs, c, secs))
6619         einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
6620     }
6621
6622   free (secs);
6623
6624   /* Make sure all the phdr assignments succeeded.  */
6625   for (os = &lang_output_section_statement.head->output_section_statement;
6626        os != NULL;
6627        os = os->next)
6628     {
6629       lang_output_section_phdr_list *pl;
6630
6631       if (os->constraint == -1
6632           || os->bfd_section == NULL)
6633         continue;
6634
6635       for (pl = os->phdrs;
6636            pl != NULL;
6637            pl = pl->next)
6638         if (! pl->used && strcmp (pl->name, "NONE") != 0)
6639           einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
6640                  os->name, pl->name);
6641     }
6642 }
6643
6644 /* Record a list of sections which may not be cross referenced.  */
6645
6646 void
6647 lang_add_nocrossref (lang_nocrossref_type *l)
6648 {
6649   struct lang_nocrossrefs *n;
6650
6651   n = xmalloc (sizeof *n);
6652   n->next = nocrossref_list;
6653   n->list = l;
6654   nocrossref_list = n;
6655
6656   /* Set notice_all so that we get informed about all symbols.  */
6657   link_info.notice_all = TRUE;
6658 }
6659 \f
6660 /* Overlay handling.  We handle overlays with some static variables.  */
6661
6662 /* The overlay virtual address.  */
6663 static etree_type *overlay_vma;
6664 /* And subsection alignment.  */
6665 static etree_type *overlay_subalign;
6666
6667 /* An expression for the maximum section size seen so far.  */
6668 static etree_type *overlay_max;
6669
6670 /* A list of all the sections in this overlay.  */
6671
6672 struct overlay_list {
6673   struct overlay_list *next;
6674   lang_output_section_statement_type *os;
6675 };
6676
6677 static struct overlay_list *overlay_list;
6678
6679 /* Start handling an overlay.  */
6680
6681 void
6682 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
6683 {
6684   /* The grammar should prevent nested overlays from occurring.  */
6685   ASSERT (overlay_vma == NULL
6686           && overlay_subalign == NULL
6687           && overlay_max == NULL);
6688
6689   overlay_vma = vma_expr;
6690   overlay_subalign = subalign;
6691 }
6692
6693 /* Start a section in an overlay.  We handle this by calling
6694    lang_enter_output_section_statement with the correct VMA.
6695    lang_leave_overlay sets up the LMA and memory regions.  */
6696
6697 void
6698 lang_enter_overlay_section (const char *name)
6699 {
6700   struct overlay_list *n;
6701   etree_type *size;
6702
6703   lang_enter_output_section_statement (name, overlay_vma, overlay_section,
6704                                        0, overlay_subalign, 0, 0);
6705
6706   /* If this is the first section, then base the VMA of future
6707      sections on this one.  This will work correctly even if `.' is
6708      used in the addresses.  */
6709   if (overlay_list == NULL)
6710     overlay_vma = exp_nameop (ADDR, name);
6711
6712   /* Remember the section.  */
6713   n = xmalloc (sizeof *n);
6714   n->os = current_section;
6715   n->next = overlay_list;
6716   overlay_list = n;
6717
6718   size = exp_nameop (SIZEOF, name);
6719
6720   /* Arrange to work out the maximum section end address.  */
6721   if (overlay_max == NULL)
6722     overlay_max = size;
6723   else
6724     overlay_max = exp_binop (MAX_K, overlay_max, size);
6725 }
6726
6727 /* Finish a section in an overlay.  There isn't any special to do
6728    here.  */
6729
6730 void
6731 lang_leave_overlay_section (fill_type *fill,
6732                             lang_output_section_phdr_list *phdrs)
6733 {
6734   const char *name;
6735   char *clean, *s2;
6736   const char *s1;
6737   char *buf;
6738
6739   name = current_section->name;
6740
6741   /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
6742      region and that no load-time region has been specified.  It doesn't
6743      really matter what we say here, since lang_leave_overlay will
6744      override it.  */
6745   lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
6746
6747   /* Define the magic symbols.  */
6748
6749   clean = xmalloc (strlen (name) + 1);
6750   s2 = clean;
6751   for (s1 = name; *s1 != '\0'; s1++)
6752     if (ISALNUM (*s1) || *s1 == '_')
6753       *s2++ = *s1;
6754   *s2 = '\0';
6755
6756   buf = xmalloc (strlen (clean) + sizeof "__load_start_");
6757   sprintf (buf, "__load_start_%s", clean);
6758   lang_add_assignment (exp_provide (buf,
6759                                     exp_nameop (LOADADDR, name),
6760                                     FALSE));
6761
6762   buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
6763   sprintf (buf, "__load_stop_%s", clean);
6764   lang_add_assignment (exp_provide (buf,
6765                                     exp_binop ('+',
6766                                                exp_nameop (LOADADDR, name),
6767                                                exp_nameop (SIZEOF, name)),
6768                                     FALSE));
6769
6770   free (clean);
6771 }
6772
6773 /* Finish an overlay.  If there are any overlay wide settings, this
6774    looks through all the sections in the overlay and sets them.  */
6775
6776 void
6777 lang_leave_overlay (etree_type *lma_expr,
6778                     int nocrossrefs,
6779                     fill_type *fill,
6780                     const char *memspec,
6781                     lang_output_section_phdr_list *phdrs,
6782                     const char *lma_memspec)
6783 {
6784   lang_memory_region_type *region;
6785   lang_memory_region_type *lma_region;
6786   struct overlay_list *l;
6787   lang_nocrossref_type *nocrossref;
6788
6789   lang_get_regions (&region, &lma_region,
6790                     memspec, lma_memspec,
6791                     lma_expr != NULL, FALSE);
6792
6793   nocrossref = NULL;
6794
6795   /* After setting the size of the last section, set '.' to end of the
6796      overlay region.  */
6797   if (overlay_list != NULL)
6798     overlay_list->os->update_dot_tree
6799       = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
6800
6801   l = overlay_list;
6802   while (l != NULL)
6803     {
6804       struct overlay_list *next;
6805
6806       if (fill != NULL && l->os->fill == NULL)
6807         l->os->fill = fill;
6808
6809       l->os->region = region;
6810       l->os->lma_region = lma_region;
6811
6812       /* The first section has the load address specified in the
6813          OVERLAY statement.  The rest are worked out from that.
6814          The base address is not needed (and should be null) if
6815          an LMA region was specified.  */
6816       if (l->next == 0)
6817         {
6818           l->os->load_base = lma_expr;
6819           l->os->sectype = normal_section;
6820         }
6821       if (phdrs != NULL && l->os->phdrs == NULL)
6822         l->os->phdrs = phdrs;
6823
6824       if (nocrossrefs)
6825         {
6826           lang_nocrossref_type *nc;
6827
6828           nc = xmalloc (sizeof *nc);
6829           nc->name = l->os->name;
6830           nc->next = nocrossref;
6831           nocrossref = nc;
6832         }
6833
6834       next = l->next;
6835       free (l);
6836       l = next;
6837     }
6838
6839   if (nocrossref != NULL)
6840     lang_add_nocrossref (nocrossref);
6841
6842   overlay_vma = NULL;
6843   overlay_list = NULL;
6844   overlay_max = NULL;
6845 }
6846 \f
6847 /* Version handling.  This is only useful for ELF.  */
6848
6849 /* This global variable holds the version tree that we build.  */
6850
6851 struct bfd_elf_version_tree *lang_elf_version_info;
6852
6853 /* If PREV is NULL, return first version pattern matching particular symbol.
6854    If PREV is non-NULL, return first version pattern matching particular
6855    symbol after PREV (previously returned by lang_vers_match).  */
6856
6857 static struct bfd_elf_version_expr *
6858 lang_vers_match (struct bfd_elf_version_expr_head *head,
6859                  struct bfd_elf_version_expr *prev,
6860                  const char *sym)
6861 {
6862   const char *cxx_sym = sym;
6863   const char *java_sym = sym;
6864   struct bfd_elf_version_expr *expr = NULL;
6865
6866   if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
6867     {
6868       cxx_sym = cplus_demangle (sym, DMGL_PARAMS | DMGL_ANSI);
6869       if (!cxx_sym)
6870         cxx_sym = sym;
6871     }
6872   if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
6873     {
6874       java_sym = cplus_demangle (sym, DMGL_JAVA);
6875       if (!java_sym)
6876         java_sym = sym;
6877     }
6878
6879   if (head->htab && (prev == NULL || prev->symbol))
6880     {
6881       struct bfd_elf_version_expr e;
6882
6883       switch (prev ? prev->mask : 0)
6884         {
6885           case 0:
6886             if (head->mask & BFD_ELF_VERSION_C_TYPE)
6887               {
6888                 e.symbol = sym;
6889                 expr = htab_find (head->htab, &e);
6890                 while (expr && strcmp (expr->symbol, sym) == 0)
6891                   if (expr->mask == BFD_ELF_VERSION_C_TYPE)
6892                     goto out_ret;
6893                   else
6894                     expr = expr->next;
6895               }
6896             /* Fallthrough */
6897           case BFD_ELF_VERSION_C_TYPE:
6898             if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
6899               {
6900                 e.symbol = cxx_sym;
6901                 expr = htab_find (head->htab, &e);
6902                 while (expr && strcmp (expr->symbol, cxx_sym) == 0)
6903                   if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
6904                     goto out_ret;
6905                   else
6906                     expr = expr->next;
6907               }
6908             /* Fallthrough */
6909           case BFD_ELF_VERSION_CXX_TYPE:
6910             if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
6911               {
6912                 e.symbol = java_sym;
6913                 expr = htab_find (head->htab, &e);
6914                 while (expr && strcmp (expr->symbol, java_sym) == 0)
6915                   if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
6916                     goto out_ret;
6917                   else
6918                     expr = expr->next;
6919               }
6920             /* Fallthrough */
6921           default:
6922             break;
6923         }
6924     }
6925
6926   /* Finally, try the wildcards.  */
6927   if (prev == NULL || prev->symbol)
6928     expr = head->remaining;
6929   else
6930     expr = prev->next;
6931   for (; expr; expr = expr->next)
6932     {
6933       const char *s;
6934
6935       if (!expr->pattern)
6936         continue;
6937
6938       if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
6939         break;
6940
6941       if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
6942         s = java_sym;
6943       else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
6944         s = cxx_sym;
6945       else
6946         s = sym;
6947       if (fnmatch (expr->pattern, s, 0) == 0)
6948         break;
6949     }
6950
6951 out_ret:
6952   if (cxx_sym != sym)
6953     free ((char *) cxx_sym);
6954   if (java_sym != sym)
6955     free ((char *) java_sym);
6956   return expr;
6957 }
6958
6959 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
6960    return a string pointing to the symbol name.  */
6961
6962 static const char *
6963 realsymbol (const char *pattern)
6964 {
6965   const char *p;
6966   bfd_boolean changed = FALSE, backslash = FALSE;
6967   char *s, *symbol = xmalloc (strlen (pattern) + 1);
6968
6969   for (p = pattern, s = symbol; *p != '\0'; ++p)
6970     {
6971       /* It is a glob pattern only if there is no preceding
6972          backslash.  */
6973       if (! backslash && (*p == '?' || *p == '*' || *p == '['))
6974         {
6975           free (symbol);
6976           return NULL;
6977         }
6978
6979       if (backslash)
6980         {
6981           /* Remove the preceding backslash.  */
6982           *(s - 1) = *p;
6983           changed = TRUE;
6984         }
6985       else
6986         *s++ = *p;
6987
6988       backslash = *p == '\\';
6989     }
6990
6991   if (changed)
6992     {
6993       *s = '\0';
6994       return symbol;
6995     }
6996   else
6997     {
6998       free (symbol);
6999       return pattern;
7000     }
7001 }
7002
7003 /* This is called for each variable name or match expression.  NEW is
7004    the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7005    pattern to be matched against symbol names.  */
7006
7007 struct bfd_elf_version_expr *
7008 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
7009                        const char *new,
7010                        const char *lang,
7011                        bfd_boolean literal_p)
7012 {
7013   struct bfd_elf_version_expr *ret;
7014
7015   ret = xmalloc (sizeof *ret);
7016   ret->next = orig;
7017   ret->pattern = literal_p ? NULL : new;
7018   ret->symver = 0;
7019   ret->script = 0;
7020   ret->symbol = literal_p ? new : realsymbol (new);
7021
7022   if (lang == NULL || strcasecmp (lang, "C") == 0)
7023     ret->mask = BFD_ELF_VERSION_C_TYPE;
7024   else if (strcasecmp (lang, "C++") == 0)
7025     ret->mask = BFD_ELF_VERSION_CXX_TYPE;
7026   else if (strcasecmp (lang, "Java") == 0)
7027     ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
7028   else
7029     {
7030       einfo (_("%X%P: unknown language `%s' in version information\n"),
7031              lang);
7032       ret->mask = BFD_ELF_VERSION_C_TYPE;
7033     }
7034
7035   return ldemul_new_vers_pattern (ret);
7036 }
7037
7038 /* This is called for each set of variable names and match
7039    expressions.  */
7040
7041 struct bfd_elf_version_tree *
7042 lang_new_vers_node (struct bfd_elf_version_expr *globals,
7043                     struct bfd_elf_version_expr *locals)
7044 {
7045   struct bfd_elf_version_tree *ret;
7046
7047   ret = xcalloc (1, sizeof *ret);
7048   ret->globals.list = globals;
7049   ret->locals.list = locals;
7050   ret->match = lang_vers_match;
7051   ret->name_indx = (unsigned int) -1;
7052   return ret;
7053 }
7054
7055 /* This static variable keeps track of version indices.  */
7056
7057 static int version_index;
7058
7059 static hashval_t
7060 version_expr_head_hash (const void *p)
7061 {
7062   const struct bfd_elf_version_expr *e = p;
7063
7064   return htab_hash_string (e->symbol);
7065 }
7066
7067 static int
7068 version_expr_head_eq (const void *p1, const void *p2)
7069 {
7070   const struct bfd_elf_version_expr *e1 = p1;
7071   const struct bfd_elf_version_expr *e2 = p2;
7072
7073   return strcmp (e1->symbol, e2->symbol) == 0;
7074 }
7075
7076 static void
7077 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
7078 {
7079   size_t count = 0;
7080   struct bfd_elf_version_expr *e, *next;
7081   struct bfd_elf_version_expr **list_loc, **remaining_loc;
7082
7083   for (e = head->list; e; e = e->next)
7084     {
7085       if (e->symbol)
7086         count++;
7087       head->mask |= e->mask;
7088     }
7089
7090   if (count)
7091     {
7092       head->htab = htab_create (count * 2, version_expr_head_hash,
7093                                 version_expr_head_eq, NULL);
7094       list_loc = &head->list;
7095       remaining_loc = &head->remaining;
7096       for (e = head->list; e; e = next)
7097         {
7098           next = e->next;
7099           if (!e->symbol)
7100             {
7101               *remaining_loc = e;
7102               remaining_loc = &e->next;
7103             }
7104           else
7105             {
7106               void **loc = htab_find_slot (head->htab, e, INSERT);
7107
7108               if (*loc)
7109                 {
7110                   struct bfd_elf_version_expr *e1, *last;
7111
7112                   e1 = *loc;
7113                   last = NULL;
7114                   do
7115                     {
7116                       if (e1->mask == e->mask)
7117                         {
7118                           last = NULL;
7119                           break;
7120                         }
7121                       last = e1;
7122                       e1 = e1->next;
7123                     }
7124                   while (e1 && strcmp (e1->symbol, e->symbol) == 0);
7125
7126                   if (last == NULL)
7127                     {
7128                       /* This is a duplicate.  */
7129                       /* FIXME: Memory leak.  Sometimes pattern is not
7130                          xmalloced alone, but in larger chunk of memory.  */
7131                       /* free (e->symbol); */
7132                       free (e);
7133                     }
7134                   else
7135                     {
7136                       e->next = last->next;
7137                       last->next = e;
7138                     }
7139                 }
7140               else
7141                 {
7142                   *loc = e;
7143                   *list_loc = e;
7144                   list_loc = &e->next;
7145                 }
7146             }
7147         }
7148       *remaining_loc = NULL;
7149       *list_loc = head->remaining;
7150     }
7151   else
7152     head->remaining = head->list;
7153 }
7154
7155 /* This is called when we know the name and dependencies of the
7156    version.  */
7157
7158 void
7159 lang_register_vers_node (const char *name,
7160                          struct bfd_elf_version_tree *version,
7161                          struct bfd_elf_version_deps *deps)
7162 {
7163   struct bfd_elf_version_tree *t, **pp;
7164   struct bfd_elf_version_expr *e1;
7165
7166   if (name == NULL)
7167     name = "";
7168
7169   if ((name[0] == '\0' && lang_elf_version_info != NULL)
7170       || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
7171     {
7172       einfo (_("%X%P: anonymous version tag cannot be combined"
7173                " with other version tags\n"));
7174       free (version);
7175       return;
7176     }
7177
7178   /* Make sure this node has a unique name.  */
7179   for (t = lang_elf_version_info; t != NULL; t = t->next)
7180     if (strcmp (t->name, name) == 0)
7181       einfo (_("%X%P: duplicate version tag `%s'\n"), name);
7182
7183   lang_finalize_version_expr_head (&version->globals);
7184   lang_finalize_version_expr_head (&version->locals);
7185
7186   /* Check the global and local match names, and make sure there
7187      aren't any duplicates.  */
7188
7189   for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
7190     {
7191       for (t = lang_elf_version_info; t != NULL; t = t->next)
7192         {
7193           struct bfd_elf_version_expr *e2;
7194
7195           if (t->locals.htab && e1->symbol)
7196             {
7197               e2 = htab_find (t->locals.htab, e1);
7198               while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
7199                 {
7200                   if (e1->mask == e2->mask)
7201                     einfo (_("%X%P: duplicate expression `%s'"
7202                              " in version information\n"), e1->symbol);
7203                   e2 = e2->next;
7204                 }
7205             }
7206           else if (!e1->symbol)
7207             for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
7208               if (strcmp (e1->pattern, e2->pattern) == 0
7209                   && e1->mask == e2->mask)
7210                 einfo (_("%X%P: duplicate expression `%s'"
7211                          " in version information\n"), e1->pattern);
7212         }
7213     }
7214
7215   for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
7216     {
7217       for (t = lang_elf_version_info; t != NULL; t = t->next)
7218         {
7219           struct bfd_elf_version_expr *e2;
7220
7221           if (t->globals.htab && e1->symbol)
7222             {
7223               e2 = htab_find (t->globals.htab, e1);
7224               while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
7225                 {
7226                   if (e1->mask == e2->mask)
7227                     einfo (_("%X%P: duplicate expression `%s'"
7228                              " in version information\n"),
7229                            e1->symbol);
7230                   e2 = e2->next;
7231                 }
7232             }
7233           else if (!e1->symbol)
7234             for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
7235               if (strcmp (e1->pattern, e2->pattern) == 0
7236                   && e1->mask == e2->mask)
7237                 einfo (_("%X%P: duplicate expression `%s'"
7238                          " in version information\n"), e1->pattern);
7239         }
7240     }
7241
7242   version->deps = deps;
7243   version->name = name;
7244   if (name[0] != '\0')
7245     {
7246       ++version_index;
7247       version->vernum = version_index;
7248     }
7249   else
7250     version->vernum = 0;
7251
7252   for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
7253     ;
7254   *pp = version;
7255 }
7256
7257 /* This is called when we see a version dependency.  */
7258
7259 struct bfd_elf_version_deps *
7260 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
7261 {
7262   struct bfd_elf_version_deps *ret;
7263   struct bfd_elf_version_tree *t;
7264
7265   ret = xmalloc (sizeof *ret);
7266   ret->next = list;
7267
7268   for (t = lang_elf_version_info; t != NULL; t = t->next)
7269     {
7270       if (strcmp (t->name, name) == 0)
7271         {
7272           ret->version_needed = t;
7273           return ret;
7274         }
7275     }
7276
7277   einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
7278
7279   return ret;
7280 }
7281
7282 static void
7283 lang_do_version_exports_section (void)
7284 {
7285   struct bfd_elf_version_expr *greg = NULL, *lreg;
7286
7287   LANG_FOR_EACH_INPUT_STATEMENT (is)
7288     {
7289       asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
7290       char *contents, *p;
7291       bfd_size_type len;
7292
7293       if (sec == NULL)
7294         continue;
7295
7296       len = sec->size;
7297       contents = xmalloc (len);
7298       if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
7299         einfo (_("%X%P: unable to read .exports section contents\n"), sec);
7300
7301       p = contents;
7302       while (p < contents + len)
7303         {
7304           greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
7305           p = strchr (p, '\0') + 1;
7306         }
7307
7308       /* Do not free the contents, as we used them creating the regex.  */
7309
7310       /* Do not include this section in the link.  */
7311       sec->flags |= SEC_EXCLUDE | SEC_KEEP;
7312     }
7313
7314   lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
7315   lang_register_vers_node (command_line.version_exports_section,
7316                            lang_new_vers_node (greg, lreg), NULL);
7317 }
7318
7319 void
7320 lang_add_unique (const char *name)
7321 {
7322   struct unique_sections *ent;
7323
7324   for (ent = unique_section_list; ent; ent = ent->next)
7325     if (strcmp (ent->name, name) == 0)
7326       return;
7327
7328   ent = xmalloc (sizeof *ent);
7329   ent->name = xstrdup (name);
7330   ent->next = unique_section_list;
7331   unique_section_list = ent;
7332 }
7333
7334 /* Append the list of dynamic symbols to the existing one.  */
7335
7336 void
7337 lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
7338 {
7339   if (link_info.dynamic_list)
7340     {
7341       struct bfd_elf_version_expr *tail;
7342       for (tail = dynamic; tail->next != NULL; tail = tail->next)
7343         ;
7344       tail->next = link_info.dynamic_list->head.list;
7345       link_info.dynamic_list->head.list = dynamic;
7346     }
7347   else
7348     {
7349       struct bfd_elf_dynamic_list *d;
7350
7351       d = xcalloc (1, sizeof *d);
7352       d->head.list = dynamic;
7353       d->match = lang_vers_match;
7354       link_info.dynamic_list = d;
7355     }
7356 }
7357
7358 /* Append the list of C++ typeinfo dynamic symbols to the existing
7359    one.  */
7360
7361 void
7362 lang_append_dynamic_list_cpp_typeinfo (void)
7363 {
7364   const char * symbols [] =
7365     {
7366       "typeinfo name for*",
7367       "typeinfo for*"
7368     };
7369   struct bfd_elf_version_expr *dynamic = NULL;
7370   unsigned int i;
7371
7372   for (i = 0; i < ARRAY_SIZE (symbols); i++)
7373     dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
7374                                      FALSE);
7375
7376   lang_append_dynamic_list (dynamic);
7377 }
7378
7379 /* Append the list of C++ operator new and delete dynamic symbols to the
7380    existing one.  */
7381
7382 void
7383 lang_append_dynamic_list_cpp_new (void)
7384 {
7385   const char * symbols [] =
7386     {
7387       "operator new*",
7388       "operator delete*"
7389     };
7390   struct bfd_elf_version_expr *dynamic = NULL;
7391   unsigned int i;
7392
7393   for (i = 0; i < ARRAY_SIZE (symbols); i++)
7394     dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
7395                                      FALSE);
7396
7397   lang_append_dynamic_list (dynamic);
7398 }