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