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.  */
4124
4125 static void
4126 lang_check_section_addresses (void)
4127 {
4128   asection *s, *os;
4129   asection **sections, **spp;
4130   unsigned int count;
4131   bfd_vma s_start;
4132   bfd_vma s_end;
4133   bfd_vma os_start;
4134   bfd_vma os_end;
4135   bfd_size_type amt;
4136
4137   if (bfd_count_sections (output_bfd) <= 1)
4138     return;
4139
4140   amt = bfd_count_sections (output_bfd) * sizeof (asection *);
4141   sections = xmalloc (amt);
4142
4143   /* Scan all sections in the output list.  */
4144   count = 0;
4145   for (s = output_bfd->sections; s != NULL; s = s->next)
4146     {
4147       /* Only consider loadable sections with real contents.  */
4148       if (IGNORE_SECTION (s) || s->size == 0)
4149         continue;
4150
4151       sections[count] = s;
4152       count++;
4153     }
4154
4155   if (count <= 1)
4156     return;
4157
4158   qsort (sections, (size_t) count, sizeof (asection *),
4159          sort_sections_by_lma);
4160
4161   spp = sections;
4162   s = *spp++;
4163   s_start = bfd_section_lma (output_bfd, s);
4164   s_end = s_start + TO_ADDR (s->size) - 1;
4165   for (count--; count; count--)
4166     {
4167       /* We must check the sections' LMA addresses not their VMA
4168          addresses because overlay sections can have overlapping VMAs
4169          but they must have distinct LMAs.  */
4170       os = s;
4171       os_start = s_start;
4172       os_end = s_end;
4173       s = *spp++;
4174       s_start = bfd_section_lma (output_bfd, s);
4175       s_end = s_start + TO_ADDR (s->size) - 1;
4176
4177       /* Look for an overlap.  */
4178       if (s_end >= os_start && s_start <= os_end)
4179         einfo (_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
4180                s->name, s_start, s_end, os->name, os_start, os_end);
4181     }
4182
4183   free (sections);
4184 }
4185
4186 /* Make sure the new address is within the region.  We explicitly permit the
4187    current address to be at the exact end of the region when the address is
4188    non-zero, in case the region is at the end of addressable memory and the
4189    calculation wraps around.  */
4190
4191 static void
4192 os_region_check (lang_output_section_statement_type *os,
4193                  lang_memory_region_type *region,
4194                  etree_type *tree,
4195                  bfd_vma base)
4196 {
4197   if ((region->current < region->origin
4198        || (region->current - region->origin > region->length))
4199       && ((region->current != region->origin + region->length)
4200           || base == 0))
4201     {
4202       if (tree != NULL)
4203         {
4204           einfo (_("%X%P: address 0x%v of %B section %s"
4205                    " is not within region %s\n"),
4206                  region->current,
4207                  os->bfd_section->owner,
4208                  os->bfd_section->name,
4209                  region->name);
4210         }
4211       else
4212         {
4213           einfo (_("%X%P: region %s is full (%B section %s)\n"),
4214                  region->name,
4215                  os->bfd_section->owner,
4216                  os->bfd_section->name);
4217         }
4218       /* Reset the region pointer.  */
4219       region->current = region->origin;
4220     }
4221 }
4222
4223 /* Set the sizes for all the output sections.  */
4224
4225 static bfd_vma
4226 lang_size_sections_1
4227   (lang_statement_union_type *s,
4228    lang_output_section_statement_type *output_section_statement,
4229    lang_statement_union_type **prev,
4230    fill_type *fill,
4231    bfd_vma dot,
4232    bfd_boolean *relax,
4233    bfd_boolean check_regions)
4234 {
4235   /* Size up the sections from their constituent parts.  */
4236   for (; s != NULL; s = s->header.next)
4237     {
4238       switch (s->header.type)
4239         {
4240         case lang_output_section_statement_enum:
4241           {
4242             bfd_vma newdot, after;
4243             lang_output_section_statement_type *os;
4244             lang_memory_region_type *r;
4245
4246             os = &s->output_section_statement;
4247             if (os->addr_tree != NULL)
4248               {
4249                 os->processed_vma = FALSE;
4250                 exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
4251
4252                 if (expld.result.valid_p)
4253                   dot = expld.result.value + expld.result.section->vma;
4254                 else if (expld.phase != lang_mark_phase_enum)
4255                   einfo (_("%F%S: non constant or forward reference"
4256                            " address expression for section %s\n"),
4257                          os->name);
4258               }
4259
4260             if (os->bfd_section == NULL)
4261               /* This section was removed or never actually created.  */
4262               break;
4263
4264             /* If this is a COFF shared library section, use the size and
4265                address from the input section.  FIXME: This is COFF
4266                specific; it would be cleaner if there were some other way
4267                to do this, but nothing simple comes to mind.  */
4268             if ((bfd_get_flavour (output_bfd) == bfd_target_ecoff_flavour
4269                  || bfd_get_flavour (output_bfd) == bfd_target_coff_flavour)
4270                 && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
4271               {
4272                 asection *input;
4273
4274                 if (os->children.head == NULL
4275                     || os->children.head->header.next != NULL
4276                     || (os->children.head->header.type
4277                         != lang_input_section_enum))
4278                   einfo (_("%P%X: Internal error on COFF shared library"
4279                            " section %s\n"), os->name);
4280
4281                 input = os->children.head->input_section.section;
4282                 bfd_set_section_vma (os->bfd_section->owner,
4283                                      os->bfd_section,
4284                                      bfd_section_vma (input->owner, input));
4285                 os->bfd_section->size = input->size;
4286                 break;
4287               }
4288
4289             newdot = dot;
4290             if (bfd_is_abs_section (os->bfd_section))
4291               {
4292                 /* No matter what happens, an abs section starts at zero.  */
4293                 ASSERT (os->bfd_section->vma == 0);
4294               }
4295             else
4296               {
4297                 int align;
4298
4299                 if (os->addr_tree == NULL)
4300                   {
4301                     /* No address specified for this section, get one
4302                        from the region specification.  */
4303                     if (os->region == NULL
4304                         || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
4305                             && os->region->name[0] == '*'
4306                             && strcmp (os->region->name,
4307                                        DEFAULT_MEMORY_REGION) == 0))
4308                       {
4309                         os->region = lang_memory_default (os->bfd_section);
4310                       }
4311
4312                     /* If a loadable section is using the default memory
4313                        region, and some non default memory regions were
4314                        defined, issue an error message.  */
4315                     if (!os->ignored
4316                         && !IGNORE_SECTION (os->bfd_section)
4317                         && ! link_info.relocatable
4318                         && check_regions
4319                         && strcmp (os->region->name,
4320                                    DEFAULT_MEMORY_REGION) == 0
4321                         && lang_memory_region_list != NULL
4322                         && (strcmp (lang_memory_region_list->name,
4323                                     DEFAULT_MEMORY_REGION) != 0
4324                             || lang_memory_region_list->next != NULL)
4325                         && expld.phase != lang_mark_phase_enum)
4326                       {
4327                         /* By default this is an error rather than just a
4328                            warning because if we allocate the section to the
4329                            default memory region we can end up creating an
4330                            excessively large binary, or even seg faulting when
4331                            attempting to perform a negative seek.  See
4332                            sources.redhat.com/ml/binutils/2003-04/msg00423.html
4333                            for an example of this.  This behaviour can be
4334                            overridden by the using the --no-check-sections
4335                            switch.  */
4336                         if (command_line.check_section_addresses)
4337                           einfo (_("%P%F: error: no memory region specified"
4338                                    " for loadable section `%s'\n"),
4339                                  bfd_get_section_name (output_bfd,
4340                                                        os->bfd_section));
4341                         else
4342                           einfo (_("%P: warning: no memory region specified"
4343                                    " for loadable section `%s'\n"),
4344                                  bfd_get_section_name (output_bfd,
4345                                                        os->bfd_section));
4346                       }
4347
4348                     newdot = os->region->current;
4349                     align = os->bfd_section->alignment_power;
4350                   }
4351                 else
4352                   align = os->section_alignment;
4353
4354                 /* Align to what the section needs.  */
4355                 if (align > 0)
4356                   {
4357                     bfd_vma savedot = newdot;
4358                     newdot = align_power (newdot, align);
4359
4360                     if (newdot != savedot
4361                         && (config.warn_section_align
4362                             || os->addr_tree != NULL)
4363                         && expld.phase != lang_mark_phase_enum)
4364                       einfo (_("%P: warning: changing start of section"
4365                                " %s by %lu bytes\n"),
4366                              os->name, (unsigned long) (newdot - savedot));
4367                   }
4368
4369                 bfd_set_section_vma (0, os->bfd_section, newdot);
4370
4371                 os->bfd_section->output_offset = 0;
4372               }
4373
4374             lang_size_sections_1 (os->children.head, os, &os->children.head,
4375                                   os->fill, newdot, relax, check_regions);
4376
4377             os->processed_vma = TRUE;
4378
4379             if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4380               /* Except for some special linker created sections,
4381                  no output section should change from zero size
4382                  after strip_excluded_output_sections.  A non-zero
4383                  size on an ignored section indicates that some
4384                  input section was not sized early enough.  */
4385               ASSERT (os->bfd_section->size == 0);
4386             else
4387               {
4388                 dot = os->bfd_section->vma;
4389
4390                 /* Put the section within the requested block size, or
4391                    align at the block boundary.  */
4392                 after = ((dot
4393                           + TO_ADDR (os->bfd_section->size)
4394                           + os->block_value - 1)
4395                          & - (bfd_vma) os->block_value);
4396
4397                 os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
4398               }
4399
4400             /* Set section lma.  */
4401             r = os->region;
4402             if (r == NULL)
4403               r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
4404
4405             if (os->load_base)
4406               {
4407                 bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
4408                 os->bfd_section->lma = lma;
4409               }
4410             else if (os->region != NULL
4411                      && os->lma_region != NULL
4412                      && os->lma_region != os->region)
4413               {
4414                 bfd_vma lma = os->lma_region->current;
4415
4416                 if (os->section_alignment != -1)
4417                   lma = align_power (lma, os->section_alignment);
4418                 os->bfd_section->lma = lma;
4419               }
4420             else if (r->last_os != NULL
4421                      && (os->bfd_section->flags & SEC_ALLOC) != 0)
4422               {
4423                 bfd_vma lma;
4424                 asection *last;
4425
4426                 last = r->last_os->output_section_statement.bfd_section;
4427
4428                 /* A backwards move of dot should be accompanied by
4429                    an explicit assignment to the section LMA (ie.
4430                    os->load_base set) because backwards moves can
4431                    create overlapping LMAs.  */
4432                 if (dot < last->vma
4433                     && os->bfd_section->size != 0
4434                     && dot + os->bfd_section->size <= last->vma)
4435                   {
4436                     /* If dot moved backwards then leave lma equal to
4437                        vma.  This is the old default lma, which might
4438                        just happen to work when the backwards move is
4439                        sufficiently large.  Nag if this changes anything,
4440                        so people can fix their linker scripts.  */
4441
4442                     if (last->vma != last->lma)
4443                       einfo (_("%P: warning: dot moved backwards before `%s'\n"),
4444                              os->name);
4445                   }
4446                 else
4447                   {
4448                     /* If this is an overlay, set the current lma to that
4449                        at the end of the previous section.  */
4450                     if (os->sectype == overlay_section)
4451                       lma = last->lma + last->size;
4452
4453                     /* Otherwise, keep the same lma to vma relationship
4454                        as the previous section.  */
4455                     else
4456                       lma = dot + last->lma - last->vma;
4457
4458                     if (os->section_alignment != -1)
4459                       lma = align_power (lma, os->section_alignment);
4460                     os->bfd_section->lma = lma;
4461                   }
4462               }
4463             os->processed_lma = TRUE;
4464
4465             if (bfd_is_abs_section (os->bfd_section) || os->ignored)
4466               break;
4467
4468             /* Keep track of normal sections using the default
4469                lma region.  We use this to set the lma for
4470                following sections.  Overlays or other linker
4471                script assignment to lma might mean that the
4472                default lma == vma is incorrect.
4473                To avoid warnings about dot moving backwards when using
4474                -Ttext, don't start tracking sections until we find one
4475                of non-zero size or with lma set differently to vma.  */
4476             if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4477                  || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)
4478                 && (os->bfd_section->flags & SEC_ALLOC) != 0
4479                 && (os->bfd_section->size != 0
4480                     || (r->last_os == NULL
4481                         && os->bfd_section->vma != os->bfd_section->lma)
4482                     || (r->last_os != NULL
4483                         && dot >= (r->last_os->output_section_statement
4484                                    .bfd_section->vma)))
4485                 && os->lma_region == NULL
4486                 && !link_info.relocatable)
4487               r->last_os = s;
4488
4489             /* .tbss sections effectively have zero size.  */
4490             if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4491                 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
4492                 || link_info.relocatable)
4493               dot += TO_ADDR (os->bfd_section->size);
4494
4495             if (os->update_dot_tree != 0)
4496               exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
4497
4498             /* Update dot in the region ?
4499                We only do this if the section is going to be allocated,
4500                since unallocated sections do not contribute to the region's
4501                overall size in memory.
4502
4503                If the SEC_NEVER_LOAD bit is not set, it will affect the
4504                addresses of sections after it. We have to update
4505                dot.  */
4506             if (os->region != NULL
4507                 && ((os->bfd_section->flags & SEC_NEVER_LOAD) == 0
4508                     || (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))))
4509               {
4510                 os->region->current = dot;
4511
4512                 if (check_regions)
4513                   /* Make sure the new address is within the region.  */
4514                   os_region_check (os, os->region, os->addr_tree,
4515                                    os->bfd_section->vma);
4516
4517                 if (os->lma_region != NULL && os->lma_region != os->region)
4518                   {
4519                     os->lma_region->current
4520                       = os->bfd_section->lma + TO_ADDR (os->bfd_section->size);
4521
4522                     if (check_regions)
4523                       os_region_check (os, os->lma_region, NULL,
4524                                        os->bfd_section->lma);
4525                   }
4526               }
4527           }
4528           break;
4529
4530         case lang_constructors_statement_enum:
4531           dot = lang_size_sections_1 (constructor_list.head,
4532                                       output_section_statement,
4533                                       &s->wild_statement.children.head,
4534                                       fill, dot, relax, check_regions);
4535           break;
4536
4537         case lang_data_statement_enum:
4538           {
4539             unsigned int size = 0;
4540
4541             s->data_statement.output_offset =
4542               dot - output_section_statement->bfd_section->vma;
4543             s->data_statement.output_section =
4544               output_section_statement->bfd_section;
4545
4546             /* We might refer to provided symbols in the expression, and
4547                need to mark them as needed.  */
4548             exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
4549
4550             switch (s->data_statement.type)
4551               {
4552               default:
4553                 abort ();
4554               case QUAD:
4555               case SQUAD:
4556                 size = QUAD_SIZE;
4557                 break;
4558               case LONG:
4559                 size = LONG_SIZE;
4560                 break;
4561               case SHORT:
4562                 size = SHORT_SIZE;
4563                 break;
4564               case BYTE:
4565                 size = BYTE_SIZE;
4566                 break;
4567               }
4568             if (size < TO_SIZE ((unsigned) 1))
4569               size = TO_SIZE ((unsigned) 1);
4570             dot += TO_ADDR (size);
4571             output_section_statement->bfd_section->size += size;
4572           }
4573           break;
4574
4575         case lang_reloc_statement_enum:
4576           {
4577             int size;
4578
4579             s->reloc_statement.output_offset =
4580               dot - output_section_statement->bfd_section->vma;
4581             s->reloc_statement.output_section =
4582               output_section_statement->bfd_section;
4583             size = bfd_get_reloc_size (s->reloc_statement.howto);
4584             dot += TO_ADDR (size);
4585             output_section_statement->bfd_section->size += size;
4586           }
4587           break;
4588
4589         case lang_wild_statement_enum:
4590           dot = lang_size_sections_1 (s->wild_statement.children.head,
4591                                       output_section_statement,
4592                                       &s->wild_statement.children.head,
4593                                       fill, dot, relax, check_regions);
4594           break;
4595
4596         case lang_object_symbols_statement_enum:
4597           link_info.create_object_symbols_section =
4598             output_section_statement->bfd_section;
4599           break;
4600
4601         case lang_output_statement_enum:
4602         case lang_target_statement_enum:
4603           break;
4604
4605         case lang_input_section_enum:
4606           {
4607             asection *i;
4608
4609             i = (*prev)->input_section.section;
4610             if (relax)
4611               {
4612                 bfd_boolean again;
4613
4614                 if (! bfd_relax_section (i->owner, i, &link_info, &again))
4615                   einfo (_("%P%F: can't relax section: %E\n"));
4616                 if (again)
4617                   *relax = TRUE;
4618               }
4619             dot = size_input_section (prev, output_section_statement,
4620                                       output_section_statement->fill, dot);
4621           }
4622           break;
4623
4624         case lang_input_statement_enum:
4625           break;
4626
4627         case lang_fill_statement_enum:
4628           s->fill_statement.output_section =
4629             output_section_statement->bfd_section;
4630
4631           fill = s->fill_statement.fill;
4632           break;
4633
4634         case lang_assignment_statement_enum:
4635           {
4636             bfd_vma newdot = dot;
4637             etree_type *tree = s->assignment_statement.exp;
4638
4639             expld.dataseg.relro = exp_dataseg_relro_none;
4640
4641             exp_fold_tree (tree,
4642                            output_section_statement->bfd_section,
4643                            &newdot);
4644
4645             if (expld.dataseg.relro == exp_dataseg_relro_start)
4646               {
4647                 if (!expld.dataseg.relro_start_stat)
4648                   expld.dataseg.relro_start_stat = s;
4649                 else
4650                   {
4651                     ASSERT (expld.dataseg.relro_start_stat == s);
4652                   }
4653               }
4654             else if (expld.dataseg.relro == exp_dataseg_relro_end)
4655               {
4656                 if (!expld.dataseg.relro_end_stat)
4657                   expld.dataseg.relro_end_stat = s;
4658                 else
4659                   {
4660                     ASSERT (expld.dataseg.relro_end_stat == s);
4661                   }
4662               }
4663             expld.dataseg.relro = exp_dataseg_relro_none;
4664
4665             /* This symbol is relative to this section.  */
4666             if ((tree->type.node_class == etree_provided
4667                  || tree->type.node_class == etree_assign)
4668                 && (tree->assign.dst [0] != '.'
4669                     || tree->assign.dst [1] != '\0'))
4670               output_section_statement->section_relative_symbol = 1;
4671
4672             if (!output_section_statement->ignored)
4673               {
4674                 if (output_section_statement == abs_output_section)
4675                   {
4676                     /* If we don't have an output section, then just adjust
4677                        the default memory address.  */
4678                     lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
4679                                                FALSE)->current = newdot;
4680                   }
4681                 else if (newdot != dot)
4682                   {
4683                     /* Insert a pad after this statement.  We can't
4684                        put the pad before when relaxing, in case the
4685                        assignment references dot.  */
4686                     insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
4687                                 output_section_statement->bfd_section, dot);
4688
4689                     /* Don't neuter the pad below when relaxing.  */
4690                     s = s->header.next;
4691
4692                     /* If dot is advanced, this implies that the section
4693                        should have space allocated to it, unless the
4694                        user has explicitly stated that the section
4695                        should never be loaded.  */
4696                     if (!(output_section_statement->flags
4697                           & (SEC_NEVER_LOAD | SEC_ALLOC)))
4698                       output_section_statement->bfd_section->flags |= SEC_ALLOC;
4699                   }
4700                 dot = newdot;
4701               }
4702           }
4703           break;
4704
4705         case lang_padding_statement_enum:
4706           /* If this is the first time lang_size_sections is called,
4707              we won't have any padding statements.  If this is the
4708              second or later passes when relaxing, we should allow
4709              padding to shrink.  If padding is needed on this pass, it
4710              will be added back in.  */
4711           s->padding_statement.size = 0;
4712
4713           /* Make sure output_offset is valid.  If relaxation shrinks
4714              the section and this pad isn't needed, it's possible to
4715              have output_offset larger than the final size of the
4716              section.  bfd_set_section_contents will complain even for
4717              a pad size of zero.  */
4718           s->padding_statement.output_offset
4719             = dot - output_section_statement->bfd_section->vma;
4720           break;
4721
4722         case lang_group_statement_enum:
4723           dot = lang_size_sections_1 (s->group_statement.children.head,
4724                                       output_section_statement,
4725                                       &s->group_statement.children.head,
4726                                       fill, dot, relax, check_regions);
4727           break;
4728
4729         default:
4730           FAIL ();
4731           break;
4732
4733           /* We can only get here when relaxing is turned on.  */
4734         case lang_address_statement_enum:
4735           break;
4736         }
4737       prev = &s->header.next;
4738     }
4739   return dot;
4740 }
4741
4742 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
4743    The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
4744    CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
4745    segments.  We are allowed an opportunity to override this decision.  */
4746
4747 bfd_boolean
4748 ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,
4749                                     bfd * abfd ATTRIBUTE_UNUSED,
4750                                     asection * current_section,
4751                                     asection * previous_section,
4752                                     bfd_boolean new_segment)
4753 {
4754   lang_output_section_statement_type * cur;
4755   lang_output_section_statement_type * prev;
4756
4757   /* The checks below are only necessary when the BFD library has decided
4758      that the two sections ought to be placed into the same segment.  */
4759   if (new_segment)
4760     return TRUE;
4761
4762   /* Paranoia checks.  */
4763   if (current_section == NULL || previous_section == NULL)
4764     return new_segment;
4765
4766   /* Find the memory regions associated with the two sections.
4767      We call lang_output_section_find() here rather than scanning the list
4768      of output sections looking for a matching section pointer because if
4769      we have a large number of sections then a hash lookup is faster.  */
4770   cur  = lang_output_section_find (current_section->name);
4771   prev = lang_output_section_find (previous_section->name);
4772
4773   /* More paranoia.  */
4774   if (cur == NULL || prev == NULL)
4775     return new_segment;
4776
4777   /* If the regions are different then force the sections to live in
4778      different segments.  See the email thread starting at the following
4779      URL for the reasons why this is necessary:
4780      http://sourceware.org/ml/binutils/2007-02/msg00216.html  */
4781   return cur->region != prev->region;
4782 }
4783
4784 void
4785 one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
4786 {
4787   lang_statement_iteration++;
4788   lang_size_sections_1 (statement_list.head, abs_output_section,
4789                         &statement_list.head, 0, 0, relax, check_regions);
4790 }
4791
4792 void
4793 lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
4794 {
4795   expld.phase = lang_allocating_phase_enum;
4796   expld.dataseg.phase = exp_dataseg_none;
4797
4798   one_lang_size_sections_pass (relax, check_regions);
4799   if (expld.dataseg.phase == exp_dataseg_end_seen
4800       && link_info.relro && expld.dataseg.relro_end)
4801     {
4802       /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
4803          to put expld.dataseg.relro on a (common) page boundary.  */
4804       bfd_vma old_min_base, relro_end, maxpage;
4805
4806       expld.dataseg.phase = exp_dataseg_relro_adjust;
4807       old_min_base = expld.dataseg.min_base;
4808       maxpage = expld.dataseg.maxpagesize;
4809       expld.dataseg.base += (-expld.dataseg.relro_end
4810                              & (expld.dataseg.pagesize - 1));
4811       /* Compute the expected PT_GNU_RELRO segment end.  */
4812       relro_end = (expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
4813                   & ~(expld.dataseg.pagesize - 1);
4814       if (old_min_base + maxpage < expld.dataseg.base)
4815         {
4816           expld.dataseg.base -= maxpage;
4817           relro_end -= maxpage;
4818         }
4819       lang_reset_memory_regions ();
4820       one_lang_size_sections_pass (relax, check_regions);
4821       if (expld.dataseg.relro_end > relro_end)
4822         {
4823           /* The alignment of sections between DATA_SEGMENT_ALIGN
4824              and DATA_SEGMENT_RELRO_END caused huge padding to be
4825              inserted at DATA_SEGMENT_RELRO_END.  Try some other base.  */
4826           asection *sec;
4827           unsigned int max_alignment_power = 0;
4828
4829           /* Find maximum alignment power of sections between
4830              DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END.  */
4831           for (sec = output_bfd->sections; sec; sec = sec->next)
4832             if (sec->vma >= expld.dataseg.base
4833                 && sec->vma < expld.dataseg.relro_end
4834                 && sec->alignment_power > max_alignment_power)
4835               max_alignment_power = sec->alignment_power;
4836
4837           if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)
4838             {
4839               if (expld.dataseg.base - (1 << max_alignment_power)
4840                   < old_min_base)
4841                 expld.dataseg.base += expld.dataseg.pagesize;
4842               expld.dataseg.base -= (1 << max_alignment_power);
4843               lang_reset_memory_regions ();
4844               one_lang_size_sections_pass (relax, check_regions);
4845             }
4846         }
4847       link_info.relro_start = expld.dataseg.base;
4848       link_info.relro_end = expld.dataseg.relro_end;
4849     }
4850   else if (expld.dataseg.phase == exp_dataseg_end_seen)
4851     {
4852       /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
4853          a page could be saved in the data segment.  */
4854       bfd_vma first, last;
4855
4856       first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
4857       last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
4858       if (first && last
4859           && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
4860               != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
4861           && first + last <= expld.dataseg.pagesize)
4862         {
4863           expld.dataseg.phase = exp_dataseg_adjust;
4864           lang_reset_memory_regions ();
4865           one_lang_size_sections_pass (relax, check_regions);
4866         }
4867     }
4868
4869   expld.phase = lang_final_phase_enum;
4870 }
4871
4872 /* Worker function for lang_do_assignments.  Recursiveness goes here.  */
4873
4874 static bfd_vma
4875 lang_do_assignments_1 (lang_statement_union_type *s,
4876                        lang_output_section_statement_type *current_os,
4877                        fill_type *fill,
4878                        bfd_vma dot)
4879 {
4880   for (; s != NULL; s = s->header.next)
4881     {
4882       switch (s->header.type)
4883         {
4884         case lang_constructors_statement_enum:
4885           dot = lang_do_assignments_1 (constructor_list.head,
4886                                        current_os, fill, dot);
4887           break;
4888
4889         case lang_output_section_statement_enum:
4890           {
4891             lang_output_section_statement_type *os;
4892
4893             os = &(s->output_section_statement);
4894             if (os->bfd_section != NULL && !os->ignored)
4895               {
4896                 dot = os->bfd_section->vma;
4897
4898                 lang_do_assignments_1 (os->children.head, os, os->fill, dot);
4899
4900                 /* .tbss sections effectively have zero size.  */
4901                 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
4902                     || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
4903                     || link_info.relocatable)
4904                   dot += TO_ADDR (os->bfd_section->size);
4905               }
4906           }
4907           break;
4908
4909         case lang_wild_statement_enum:
4910
4911           dot = lang_do_assignments_1 (s->wild_statement.children.head,
4912                                        current_os, fill, dot);
4913           break;
4914
4915         case lang_object_symbols_statement_enum:
4916         case lang_output_statement_enum:
4917         case lang_target_statement_enum:
4918           break;
4919
4920         case lang_data_statement_enum:
4921           exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
4922           if (expld.result.valid_p)
4923             s->data_statement.value = (expld.result.value
4924                                        + expld.result.section->vma);
4925           else
4926             einfo (_("%F%P: invalid data statement\n"));
4927           {
4928             unsigned int size;
4929             switch (s->data_statement.type)
4930               {
4931               default:
4932                 abort ();
4933               case QUAD:
4934               case SQUAD:
4935                 size = QUAD_SIZE;
4936                 break;
4937               case LONG:
4938                 size = LONG_SIZE;
4939                 break;
4940               case SHORT:
4941                 size = SHORT_SIZE;
4942                 break;
4943               case BYTE:
4944                 size = BYTE_SIZE;
4945                 break;
4946               }
4947             if (size < TO_SIZE ((unsigned) 1))
4948               size = TO_SIZE ((unsigned) 1);
4949             dot += TO_ADDR (size);
4950           }
4951           break;
4952
4953         case lang_reloc_statement_enum:
4954           exp_fold_tree (s->reloc_statement.addend_exp,
4955                          bfd_abs_section_ptr, &dot);
4956           if (expld.result.valid_p)
4957             s->reloc_statement.addend_value = expld.result.value;
4958           else
4959             einfo (_("%F%P: invalid reloc statement\n"));
4960           dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
4961           break;
4962
4963         case lang_input_section_enum:
4964           {
4965             asection *in = s->input_section.section;
4966
4967             if ((in->flags & SEC_EXCLUDE) == 0)
4968               dot += TO_ADDR (in->size);
4969           }
4970           break;
4971
4972         case lang_input_statement_enum:
4973           break;
4974
4975         case lang_fill_statement_enum:
4976           fill = s->fill_statement.fill;
4977           break;
4978
4979         case lang_assignment_statement_enum:
4980           exp_fold_tree (s->assignment_statement.exp,
4981                          current_os->bfd_section,
4982                          &dot);
4983           break;
4984
4985         case lang_padding_statement_enum:
4986           dot += TO_ADDR (s->padding_statement.size);
4987           break;
4988
4989         case lang_group_statement_enum:
4990           dot = lang_do_assignments_1 (s->group_statement.children.head,
4991                                        current_os, fill, dot);
4992           break;
4993
4994         default:
4995           FAIL ();
4996           break;
4997
4998         case lang_address_statement_enum:
4999           break;
5000         }
5001     }
5002   return dot;
5003 }
5004
5005 void
5006 lang_do_assignments (void)
5007 {
5008   lang_statement_iteration++;
5009   lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);
5010 }
5011
5012 /* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
5013    operator .startof. (section_name), it produces an undefined symbol
5014    .startof.section_name.  Similarly, when it sees
5015    .sizeof. (section_name), it produces an undefined symbol
5016    .sizeof.section_name.  For all the output sections, we look for
5017    such symbols, and set them to the correct value.  */
5018
5019 static void
5020 lang_set_startof (void)
5021 {
5022   asection *s;
5023
5024   if (link_info.relocatable)
5025     return;
5026
5027   for (s = output_bfd->sections; s != NULL; s = s->next)
5028     {
5029       const char *secname;
5030       char *buf;
5031       struct bfd_link_hash_entry *h;
5032
5033       secname = bfd_get_section_name (output_bfd, s);
5034       buf = xmalloc (10 + strlen (secname));
5035
5036       sprintf (buf, ".startof.%s", secname);
5037       h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5038       if (h != NULL && h->type == bfd_link_hash_undefined)
5039         {
5040           h->type = bfd_link_hash_defined;
5041           h->u.def.value = bfd_get_section_vma (output_bfd, s);
5042           h->u.def.section = bfd_abs_section_ptr;
5043         }
5044
5045       sprintf (buf, ".sizeof.%s", secname);
5046       h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5047       if (h != NULL && h->type == bfd_link_hash_undefined)
5048         {
5049           h->type = bfd_link_hash_defined;
5050           h->u.def.value = TO_ADDR (s->size);
5051           h->u.def.section = bfd_abs_section_ptr;
5052         }
5053
5054       free (buf);
5055     }
5056 }
5057
5058 static void
5059 lang_end (void)
5060 {
5061   struct bfd_link_hash_entry *h;
5062   bfd_boolean warn;
5063
5064   if (link_info.relocatable || link_info.shared)
5065     warn = FALSE;
5066   else
5067     warn = TRUE;
5068
5069   if (entry_symbol.name == NULL)
5070     {
5071       /* No entry has been specified.  Look for the default entry, but
5072          don't warn if we don't find it.  */
5073       entry_symbol.name = entry_symbol_default;
5074       warn = FALSE;
5075     }
5076
5077   h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
5078                             FALSE, FALSE, TRUE);
5079   if (h != NULL
5080       && (h->type == bfd_link_hash_defined
5081           || h->type == bfd_link_hash_defweak)
5082       && h->u.def.section->output_section != NULL)
5083     {
5084       bfd_vma val;
5085
5086       val = (h->u.def.value
5087              + bfd_get_section_vma (output_bfd,
5088                                     h->u.def.section->output_section)
5089              + h->u.def.section->output_offset);
5090       if (! bfd_set_start_address (output_bfd, val))
5091         einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
5092     }
5093   else
5094     {
5095       bfd_vma val;
5096       const char *send;
5097
5098       /* We couldn't find the entry symbol.  Try parsing it as a
5099          number.  */
5100       val = bfd_scan_vma (entry_symbol.name, &send, 0);
5101       if (*send == '\0')
5102         {
5103           if (! bfd_set_start_address (output_bfd, val))
5104             einfo (_("%P%F: can't set start address\n"));
5105         }
5106       else
5107         {
5108           asection *ts;
5109
5110           /* Can't find the entry symbol, and it's not a number.  Use
5111              the first address in the text section.  */
5112           ts = bfd_get_section_by_name (output_bfd, entry_section);
5113           if (ts != NULL)
5114             {
5115               if (warn)
5116                 einfo (_("%P: warning: cannot find entry symbol %s;"
5117                          " defaulting to %V\n"),
5118                        entry_symbol.name,
5119                        bfd_get_section_vma (output_bfd, ts));
5120               if (! bfd_set_start_address (output_bfd,
5121                                            bfd_get_section_vma (output_bfd,
5122                                                                 ts)))
5123                 einfo (_("%P%F: can't set start address\n"));
5124             }
5125           else
5126             {
5127               if (warn)
5128                 einfo (_("%P: warning: cannot find entry symbol %s;"
5129                          " not setting start address\n"),
5130                        entry_symbol.name);
5131             }
5132         }
5133     }
5134
5135   /* Don't bfd_hash_table_free (&lang_definedness_table);
5136      map file output may result in a call of lang_track_definedness.  */
5137 }
5138
5139 /* This is a small function used when we want to ignore errors from
5140    BFD.  */
5141
5142 static void
5143 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
5144 {
5145   /* Don't do anything.  */
5146 }
5147
5148 /* Check that the architecture of all the input files is compatible
5149    with the output file.  Also call the backend to let it do any
5150    other checking that is needed.  */
5151
5152 static void
5153 lang_check (void)
5154 {
5155   lang_statement_union_type *file;
5156   bfd *input_bfd;
5157   const bfd_arch_info_type *compatible;
5158
5159   for (file = file_chain.head; file != NULL; file = file->input_statement.next)
5160     {
5161       input_bfd = file->input_statement.the_bfd;
5162       compatible
5163         = bfd_arch_get_compatible (input_bfd, output_bfd,
5164                                    command_line.accept_unknown_input_arch);
5165
5166       /* In general it is not possible to perform a relocatable
5167          link between differing object formats when the input
5168          file has relocations, because the relocations in the
5169          input format may not have equivalent representations in
5170          the output format (and besides BFD does not translate
5171          relocs for other link purposes than a final link).  */
5172       if ((link_info.relocatable || link_info.emitrelocations)
5173           && (compatible == NULL
5174               || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
5175           && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
5176         {
5177           einfo (_("%P%F: Relocatable linking with relocations from"
5178                    " format %s (%B) to format %s (%B) is not supported\n"),
5179                  bfd_get_target (input_bfd), input_bfd,
5180                  bfd_get_target (output_bfd), output_bfd);
5181           /* einfo with %F exits.  */
5182         }
5183
5184       if (compatible == NULL)
5185         {
5186           if (command_line.warn_mismatch)
5187             einfo (_("%P%X: %s architecture of input file `%B'"
5188                      " is incompatible with %s output\n"),
5189                    bfd_printable_name (input_bfd), input_bfd,
5190                    bfd_printable_name (output_bfd));
5191         }
5192       else if (bfd_count_sections (input_bfd))
5193         {
5194           /* If the input bfd has no contents, it shouldn't set the
5195              private data of the output bfd.  */
5196
5197           bfd_error_handler_type pfn = NULL;
5198
5199           /* If we aren't supposed to warn about mismatched input
5200              files, temporarily set the BFD error handler to a
5201              function which will do nothing.  We still want to call
5202              bfd_merge_private_bfd_data, since it may set up
5203              information which is needed in the output file.  */
5204           if (! command_line.warn_mismatch)
5205             pfn = bfd_set_error_handler (ignore_bfd_errors);
5206           if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
5207             {
5208               if (command_line.warn_mismatch)
5209                 einfo (_("%P%X: failed to merge target specific data"
5210                          " of file %B\n"), input_bfd);
5211             }
5212           if (! command_line.warn_mismatch)
5213             bfd_set_error_handler (pfn);
5214         }
5215     }
5216 }
5217
5218 /* Look through all the global common symbols and attach them to the
5219    correct section.  The -sort-common command line switch may be used
5220    to roughly sort the entries by size.  */
5221
5222 static void
5223 lang_common (void)
5224 {
5225   if (command_line.inhibit_common_definition)
5226     return;
5227   if (link_info.relocatable
5228       && ! command_line.force_common_definition)
5229     return;
5230
5231   if (! config.sort_common)
5232     bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
5233   else
5234     {
5235       int power;
5236
5237       for (power = 4; power >= 0; power--)
5238         bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5239     }
5240 }
5241
5242 /* Place one common symbol in the correct section.  */
5243
5244 static bfd_boolean
5245 lang_one_common (struct bfd_link_hash_entry *h, void *info)
5246 {
5247   unsigned int power_of_two;
5248   bfd_vma size;
5249   asection *section;
5250
5251   if (h->type != bfd_link_hash_common)
5252     return TRUE;
5253
5254   size = h->u.c.size;
5255   power_of_two = h->u.c.p->alignment_power;
5256
5257   if (config.sort_common
5258       && power_of_two < (unsigned int) *(int *) info)
5259     return TRUE;
5260
5261   section = h->u.c.p->section;
5262
5263   /* Increase the size of the section to align the common sym.  */
5264   section->size += ((bfd_vma) 1 << (power_of_two + opb_shift)) - 1;
5265   section->size &= (- (bfd_vma) 1 << (power_of_two + opb_shift));
5266
5267   /* Adjust the alignment if necessary.  */
5268   if (power_of_two > section->alignment_power)
5269     section->alignment_power = power_of_two;
5270
5271   /* Change the symbol from common to defined.  */
5272   h->type = bfd_link_hash_defined;
5273   h->u.def.section = section;
5274   h->u.def.value = section->size;
5275
5276   /* Increase the size of the section.  */
5277   section->size += size;
5278
5279   /* Make sure the section is allocated in memory, and make sure that
5280      it is no longer a common section.  */
5281   section->flags |= SEC_ALLOC;
5282   section->flags &= ~SEC_IS_COMMON;
5283
5284   if (config.map_file != NULL)
5285     {
5286       static bfd_boolean header_printed;
5287       int len;
5288       char *name;
5289       char buf[50];
5290
5291       if (! header_printed)
5292         {
5293           minfo (_("\nAllocating common symbols\n"));
5294           minfo (_("Common symbol       size              file\n\n"));
5295           header_printed = TRUE;
5296         }
5297
5298       name = bfd_demangle (output_bfd, h->root.string,
5299                            DMGL_ANSI | DMGL_PARAMS);
5300       if (name == NULL)
5301         {
5302           minfo ("%s", h->root.string);
5303           len = strlen (h->root.string);
5304         }
5305       else
5306         {
5307           minfo ("%s", name);
5308           len = strlen (name);
5309           free (name);
5310         }
5311
5312       if (len >= 19)
5313         {
5314           print_nl ();
5315           len = 0;
5316         }
5317       while (len < 20)
5318         {
5319           print_space ();
5320           ++len;
5321         }
5322
5323       minfo ("0x");
5324       if (size <= 0xffffffff)
5325         sprintf (buf, "%lx", (unsigned long) size);
5326       else
5327         sprintf_vma (buf, size);
5328       minfo ("%s", buf);
5329       len = strlen (buf);
5330
5331       while (len < 16)
5332         {
5333           print_space ();
5334           ++len;
5335         }
5336
5337       minfo ("%B\n", section->owner);
5338     }
5339
5340   return TRUE;
5341 }
5342
5343 /* Run through the input files and ensure that every input section has
5344    somewhere to go.  If one is found without a destination then create
5345    an input request and place it into the statement tree.  */
5346
5347 static void
5348 lang_place_orphans (void)
5349 {
5350   LANG_FOR_EACH_INPUT_STATEMENT (file)
5351     {
5352       asection *s;
5353
5354       for (s = file->the_bfd->sections; s != NULL; s = s->next)
5355         {
5356           if (s->output_section == NULL)
5357             {
5358               /* This section of the file is not attached, root
5359                  around for a sensible place for it to go.  */
5360
5361               if (file->just_syms_flag)
5362                 bfd_link_just_syms (file->the_bfd, s, &link_info);
5363               else if ((s->flags & SEC_EXCLUDE) != 0)
5364                 s->output_section = bfd_abs_section_ptr;
5365               else if (strcmp (s->name, "COMMON") == 0)
5366                 {
5367                   /* This is a lonely common section which must have
5368                      come from an archive.  We attach to the section
5369                      with the wildcard.  */
5370                   if (! link_info.relocatable
5371                       || command_line.force_common_definition)
5372                     {
5373                       if (default_common_section == NULL)
5374                         {
5375                           default_common_section =
5376                             lang_output_section_statement_lookup (".bss");
5377
5378                         }
5379                       lang_add_section (&default_common_section->children, s,
5380                                         default_common_section);
5381                     }
5382                 }
5383               else if (ldemul_place_orphan (s))
5384                 ;
5385               else
5386                 {
5387                   lang_output_section_statement_type *os;
5388
5389                   os = lang_output_section_statement_lookup (s->name);
5390                   lang_add_section (&os->children, s, os);
5391                 }
5392             }
5393         }
5394     }
5395 }
5396
5397 void
5398 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
5399 {
5400   flagword *ptr_flags;
5401
5402   ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
5403   while (*flags)
5404     {
5405       switch (*flags)
5406         {
5407         case 'A': case 'a':
5408           *ptr_flags |= SEC_ALLOC;
5409           break;
5410
5411         case 'R': case 'r':
5412           *ptr_flags |= SEC_READONLY;
5413           break;
5414
5415         case 'W': case 'w':
5416           *ptr_flags |= SEC_DATA;
5417           break;
5418
5419         case 'X': case 'x':
5420           *ptr_flags |= SEC_CODE;
5421           break;
5422
5423         case 'L': case 'l':
5424         case 'I': case 'i':
5425           *ptr_flags |= SEC_LOAD;
5426           break;
5427
5428         default:
5429           einfo (_("%P%F: invalid syntax in flags\n"));
5430           break;
5431         }
5432       flags++;
5433     }
5434 }
5435
5436 /* Call a function on each input file.  This function will be called
5437    on an archive, but not on the elements.  */
5438
5439 void
5440 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
5441 {
5442   lang_input_statement_type *f;
5443
5444   for (f = (lang_input_statement_type *) input_file_chain.head;
5445        f != NULL;
5446        f = (lang_input_statement_type *) f->next_real_file)
5447     func (f);
5448 }
5449
5450 /* Call a function on each file.  The function will be called on all
5451    the elements of an archive which are included in the link, but will
5452    not be called on the archive file itself.  */
5453
5454 void
5455 lang_for_each_file (void (*func) (lang_input_statement_type *))
5456 {
5457   LANG_FOR_EACH_INPUT_STATEMENT (f)
5458     {
5459       func (f);
5460     }
5461 }
5462
5463 void
5464 ldlang_add_file (lang_input_statement_type *entry)
5465 {
5466   lang_statement_append (&file_chain,
5467                          (lang_statement_union_type *) entry,
5468                          &entry->next);
5469
5470   /* The BFD linker needs to have a list of all input BFDs involved in
5471      a link.  */
5472   ASSERT (entry->the_bfd->link_next == NULL);
5473   ASSERT (entry->the_bfd != output_bfd);
5474
5475   *link_info.input_bfds_tail = entry->the_bfd;
5476   link_info.input_bfds_tail = &entry->the_bfd->link_next;
5477   entry->the_bfd->usrdata = entry;
5478   bfd_set_gp_size (entry->the_bfd, g_switch_value);
5479
5480   /* Look through the sections and check for any which should not be
5481      included in the link.  We need to do this now, so that we can
5482      notice when the backend linker tries to report multiple
5483      definition errors for symbols which are in sections we aren't
5484      going to link.  FIXME: It might be better to entirely ignore
5485      symbols which are defined in sections which are going to be
5486      discarded.  This would require modifying the backend linker for
5487      each backend which might set the SEC_LINK_ONCE flag.  If we do
5488      this, we should probably handle SEC_EXCLUDE in the same way.  */
5489
5490   bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
5491 }
5492
5493 void
5494 lang_add_output (const char *name, int from_script)
5495 {
5496   /* Make -o on command line override OUTPUT in script.  */
5497   if (!had_output_filename || !from_script)
5498     {
5499       output_filename = name;
5500       had_output_filename = TRUE;
5501     }
5502 }
5503
5504 static lang_output_section_statement_type *current_section;
5505
5506 static int
5507 topower (int x)
5508 {
5509   unsigned int i = 1;
5510   int l;
5511
5512   if (x < 0)
5513     return -1;
5514
5515   for (l = 0; l < 32; l++)
5516     {
5517       if (i >= (unsigned int) x)
5518         return l;
5519       i <<= 1;
5520     }
5521
5522   return 0;
5523 }
5524
5525 lang_output_section_statement_type *
5526 lang_enter_output_section_statement (const char *output_section_statement_name,
5527                                      etree_type *address_exp,
5528                                      enum section_type sectype,
5529                                      etree_type *align,
5530                                      etree_type *subalign,
5531                                      etree_type *ebase,
5532                                      int constraint)
5533 {
5534   lang_output_section_statement_type *os;
5535
5536    os = lang_output_section_statement_lookup_1 (output_section_statement_name,
5537                                                 constraint);
5538    current_section = os;
5539
5540   /* Make next things chain into subchain of this.  */
5541
5542   if (os->addr_tree == NULL)
5543     {
5544       os->addr_tree = address_exp;
5545     }
5546   os->sectype = sectype;
5547   if (sectype != noload_section)
5548     os->flags = SEC_NO_FLAGS;
5549   else
5550     os->flags = SEC_NEVER_LOAD;
5551   os->block_value = 1;
5552   stat_ptr = &os->children;
5553
5554   os->subsection_alignment =
5555     topower (exp_get_value_int (subalign, -1, "subsection alignment"));
5556   os->section_alignment =
5557     topower (exp_get_value_int (align, -1, "section alignment"));
5558
5559   os->load_base = ebase;
5560   return os;
5561 }
5562
5563 void
5564 lang_final (void)
5565 {
5566   lang_output_statement_type *new;
5567
5568   new = new_stat (lang_output_statement, stat_ptr);
5569   new->name = output_filename;
5570 }
5571
5572 /* Reset the current counters in the regions.  */
5573
5574 void
5575 lang_reset_memory_regions (void)
5576 {
5577   lang_memory_region_type *p = lang_memory_region_list;
5578   asection *o;
5579   lang_output_section_statement_type *os;
5580
5581   for (p = lang_memory_region_list; p != NULL; p = p->next)
5582     {
5583       p->current = p->origin;
5584       p->last_os = NULL;
5585     }
5586
5587   for (os = &lang_output_section_statement.head->output_section_statement;
5588        os != NULL;
5589        os = os->next)
5590     {
5591       os->processed_vma = FALSE;
5592       os->processed_lma = FALSE;
5593     }
5594
5595   for (o = output_bfd->sections; o != NULL; o = o->next)
5596     {
5597       /* Save the last size for possible use by bfd_relax_section.  */
5598       o->rawsize = o->size;
5599       o->size = 0;
5600     }
5601 }
5602
5603 /* Worker for lang_gc_sections_1.  */
5604
5605 static void
5606 gc_section_callback (lang_wild_statement_type *ptr,
5607                      struct wildcard_list *sec ATTRIBUTE_UNUSED,
5608                      asection *section,
5609                      lang_input_statement_type *file ATTRIBUTE_UNUSED,
5610                      void *data ATTRIBUTE_UNUSED)
5611 {
5612   /* If the wild pattern was marked KEEP, the member sections
5613      should be as well.  */
5614   if (ptr->keep_sections)
5615     section->flags |= SEC_KEEP;
5616 }
5617
5618 /* Iterate over sections marking them against GC.  */
5619
5620 static void
5621 lang_gc_sections_1 (lang_statement_union_type *s)
5622 {
5623   for (; s != NULL; s = s->header.next)
5624     {
5625       switch (s->header.type)
5626         {
5627         case lang_wild_statement_enum:
5628           walk_wild (&s->wild_statement, gc_section_callback, NULL);
5629           break;
5630         case lang_constructors_statement_enum:
5631           lang_gc_sections_1 (constructor_list.head);
5632           break;
5633         case lang_output_section_statement_enum:
5634           lang_gc_sections_1 (s->output_section_statement.children.head);
5635           break;
5636         case lang_group_statement_enum:
5637           lang_gc_sections_1 (s->group_statement.children.head);
5638           break;
5639         default:
5640           break;
5641         }
5642     }
5643 }
5644
5645 static void
5646 lang_gc_sections (void)
5647 {
5648   struct bfd_link_hash_entry *h;
5649   ldlang_undef_chain_list_type *ulist;
5650
5651   /* Keep all sections so marked in the link script.  */
5652
5653   lang_gc_sections_1 (statement_list.head);
5654
5655   /* Keep all sections containing symbols undefined on the command-line,
5656      and the section containing the entry symbol.  */
5657
5658   for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
5659     {
5660       h = bfd_link_hash_lookup (link_info.hash, ulist->name,
5661                                 FALSE, FALSE, FALSE);
5662
5663       if (h != NULL
5664           && (h->type == bfd_link_hash_defined
5665               || h->type == bfd_link_hash_defweak)
5666           && ! bfd_is_abs_section (h->u.def.section))
5667         {
5668           h->u.def.section->flags |= SEC_KEEP;
5669         }
5670     }
5671
5672   /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
5673      the special case of debug info.  (See bfd/stabs.c)
5674      Twiddle the flag here, to simplify later linker code.  */
5675   if (link_info.relocatable)
5676     {
5677       LANG_FOR_EACH_INPUT_STATEMENT (f)
5678         {
5679           asection *sec;
5680           for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
5681             if ((sec->flags & SEC_DEBUGGING) == 0)
5682               sec->flags &= ~SEC_EXCLUDE;
5683         }
5684     }
5685
5686   if (link_info.gc_sections)
5687     bfd_gc_sections (output_bfd, &link_info);
5688 }
5689
5690 /* Worker for lang_find_relro_sections_1.  */
5691
5692 static void
5693 find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
5694                              struct wildcard_list *sec ATTRIBUTE_UNUSED,
5695                              asection *section,
5696                              lang_input_statement_type *file ATTRIBUTE_UNUSED,
5697                              void *data)
5698 {
5699   /* Discarded, excluded and ignored sections effectively have zero
5700      size.  */
5701   if (section->output_section != NULL
5702       && section->output_section->owner == output_bfd
5703       && (section->output_section->flags & SEC_EXCLUDE) == 0
5704       && !IGNORE_SECTION (section)
5705       && section->size != 0)
5706     {
5707       bfd_boolean *has_relro_section = (bfd_boolean *) data;
5708       *has_relro_section = TRUE;
5709     }
5710 }
5711
5712 /* Iterate over sections for relro sections.  */
5713
5714 static void
5715 lang_find_relro_sections_1 (lang_statement_union_type *s,
5716                             bfd_boolean *has_relro_section)
5717 {
5718   if (*has_relro_section)
5719     return;
5720
5721   for (; s != NULL; s = s->header.next)
5722     {
5723       if (s == expld.dataseg.relro_end_stat)
5724         break;
5725
5726       switch (s->header.type)
5727         {
5728         case lang_wild_statement_enum:
5729           walk_wild (&s->wild_statement,
5730                      find_relro_section_callback,
5731                      has_relro_section);
5732           break;
5733         case lang_constructors_statement_enum:
5734           lang_find_relro_sections_1 (constructor_list.head,
5735                                       has_relro_section);
5736           break;
5737         case lang_output_section_statement_enum:
5738           lang_find_relro_sections_1 (s->output_section_statement.children.head,
5739                                       has_relro_section);
5740           break;
5741         case lang_group_statement_enum:
5742           lang_find_relro_sections_1 (s->group_statement.children.head,
5743                                       has_relro_section);
5744           break;
5745         default:
5746           break;
5747         }
5748     }
5749 }
5750
5751 static void
5752 lang_find_relro_sections (void)
5753 {
5754   bfd_boolean has_relro_section = FALSE;
5755
5756   /* Check all sections in the link script.  */
5757
5758   lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,
5759                               &has_relro_section);
5760
5761   if (!has_relro_section)
5762     link_info.relro = FALSE;
5763 }
5764
5765 /* Relax all sections until bfd_relax_section gives up.  */
5766
5767 static void
5768 relax_sections (void)
5769 {
5770   /* Keep relaxing until bfd_relax_section gives up.  */
5771   bfd_boolean relax_again;
5772
5773   link_info.relax_trip = -1;
5774   do
5775     {
5776       relax_again = FALSE;
5777       link_info.relax_trip++;
5778
5779       /* Note: pe-dll.c does something like this also.  If you find
5780          you need to change this code, you probably need to change
5781          pe-dll.c also.  DJ  */
5782
5783       /* Do all the assignments with our current guesses as to
5784          section sizes.  */
5785       lang_do_assignments ();
5786
5787       /* We must do this after lang_do_assignments, because it uses
5788          size.  */
5789       lang_reset_memory_regions ();
5790
5791       /* Perform another relax pass - this time we know where the
5792          globals are, so can make a better guess.  */
5793       lang_size_sections (&relax_again, FALSE);
5794     }
5795   while (relax_again);
5796 }
5797
5798 void
5799 lang_process (void)
5800 {
5801   /* Finalize dynamic list.  */
5802   if (link_info.dynamic_list)
5803     lang_finalize_version_expr_head (&link_info.dynamic_list->head);
5804
5805   current_target = default_target;
5806
5807   /* Open the output file.  */
5808   lang_for_each_statement (ldlang_open_output);
5809   init_opb ();
5810
5811   ldemul_create_output_section_statements ();
5812
5813   /* Add to the hash table all undefineds on the command line.  */
5814   lang_place_undefineds ();
5815
5816   if (!bfd_section_already_linked_table_init ())
5817     einfo (_("%P%F: Failed to create hash table\n"));
5818
5819   /* Create a bfd for each input file.  */
5820   current_target = default_target;
5821   open_input_bfds (statement_list.head, FALSE);
5822
5823   link_info.gc_sym_list = &entry_symbol;
5824   if (entry_symbol.name == NULL)
5825     link_info.gc_sym_list = ldlang_undef_chain_list_head;
5826
5827   ldemul_after_open ();
5828
5829   bfd_section_already_linked_table_free ();
5830
5831   /* Make sure that we're not mixing architectures.  We call this
5832      after all the input files have been opened, but before we do any
5833      other processing, so that any operations merge_private_bfd_data
5834      does on the output file will be known during the rest of the
5835      link.  */
5836   lang_check ();
5837
5838   /* Handle .exports instead of a version script if we're told to do so.  */
5839   if (command_line.version_exports_section)
5840     lang_do_version_exports_section ();
5841
5842   /* Build all sets based on the information gathered from the input
5843      files.  */
5844   ldctor_build_sets ();
5845
5846   /* Remove unreferenced sections if asked to.  */
5847   lang_gc_sections ();
5848
5849   /* Size up the common data.  */
5850   lang_common ();
5851
5852   /* Update wild statements.  */
5853   update_wild_statements (statement_list.head);
5854
5855   /* Run through the contours of the script and attach input sections
5856      to the correct output sections.  */
5857   map_input_to_output_sections (statement_list.head, NULL, NULL);
5858
5859   /* Find any sections not attached explicitly and handle them.  */
5860   lang_place_orphans ();
5861
5862   if (! link_info.relocatable)
5863     {
5864       asection *found;
5865
5866       /* Merge SEC_MERGE sections.  This has to be done after GC of
5867          sections, so that GCed sections are not merged, but before
5868          assigning dynamic symbols, since removing whole input sections
5869          is hard then.  */
5870       bfd_merge_sections (output_bfd, &link_info);
5871
5872       /* Look for a text section and set the readonly attribute in it.  */
5873       found = bfd_get_section_by_name (output_bfd, ".text");
5874
5875       if (found != NULL)
5876         {
5877           if (config.text_read_only)
5878             found->flags |= SEC_READONLY;
5879           else
5880             found->flags &= ~SEC_READONLY;
5881         }
5882     }
5883
5884   /* Do anything special before sizing sections.  This is where ELF
5885      and other back-ends size dynamic sections.  */
5886   ldemul_before_allocation ();
5887
5888   /* We must record the program headers before we try to fix the
5889      section positions, since they will affect SIZEOF_HEADERS.  */
5890   lang_record_phdrs ();
5891
5892   /* Check relro sections.  */
5893   if (link_info.relro && ! link_info.relocatable)
5894     lang_find_relro_sections ();
5895
5896   /* Size up the sections.  */
5897   lang_size_sections (NULL, !command_line.relax);
5898
5899   /* Now run around and relax if we can.  */
5900   if (command_line.relax)
5901     {
5902       /* We may need more than one relaxation pass.  */
5903       int i = link_info.relax_pass;
5904
5905       /* The backend can use it to determine the current pass.  */
5906       link_info.relax_pass = 0;
5907
5908       while (i--)
5909         {
5910           relax_sections ();
5911           link_info.relax_pass++;
5912         }
5913
5914       /* Final extra sizing to report errors.  */
5915       lang_do_assignments ();
5916       lang_reset_memory_regions ();
5917       lang_size_sections (NULL, TRUE);
5918     }
5919
5920   /* See if anything special should be done now we know how big
5921      everything is.  */
5922   ldemul_after_allocation ();
5923
5924   /* Fix any .startof. or .sizeof. symbols.  */
5925   lang_set_startof ();
5926
5927   /* Do all the assignments, now that we know the final resting places
5928      of all the symbols.  */
5929
5930   lang_do_assignments ();
5931
5932   ldemul_finish ();
5933
5934   /* Make sure that the section addresses make sense.  */
5935   if (! link_info.relocatable
5936       && command_line.check_section_addresses)
5937     lang_check_section_addresses ();
5938
5939   lang_end ();
5940 }
5941
5942 /* EXPORTED TO YACC */
5943
5944 void
5945 lang_add_wild (struct wildcard_spec *filespec,
5946                struct wildcard_list *section_list,
5947                bfd_boolean keep_sections)
5948 {
5949   struct wildcard_list *curr, *next;
5950   lang_wild_statement_type *new;
5951
5952   /* Reverse the list as the parser puts it back to front.  */
5953   for (curr = section_list, section_list = NULL;
5954        curr != NULL;
5955        section_list = curr, curr = next)
5956     {
5957       if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
5958         placed_commons = TRUE;
5959
5960       next = curr->next;
5961       curr->next = section_list;
5962     }
5963
5964   if (filespec != NULL && filespec->name != NULL)
5965     {
5966       if (strcmp (filespec->name, "*") == 0)
5967         filespec->name = NULL;
5968       else if (! wildcardp (filespec->name))
5969         lang_has_input_file = TRUE;
5970     }
5971
5972   new = new_stat (lang_wild_statement, stat_ptr);
5973   new->filename = NULL;
5974   new->filenames_sorted = FALSE;
5975   if (filespec != NULL)
5976     {
5977       new->filename = filespec->name;
5978       new->filenames_sorted = filespec->sorted == by_name;
5979     }
5980   new->section_list = section_list;
5981   new->keep_sections = keep_sections;
5982   lang_list_init (&new->children);
5983   analyze_walk_wild_section_handler (new);
5984 }
5985
5986 void
5987 lang_section_start (const char *name, etree_type *address,
5988                     const segment_type *segment)
5989 {
5990   lang_address_statement_type *ad;
5991
5992   ad = new_stat (lang_address_statement, stat_ptr);
5993   ad->section_name = name;
5994   ad->address = address;
5995   ad->segment = segment;
5996 }
5997
5998 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
5999    because of a -e argument on the command line, or zero if this is
6000    called by ENTRY in a linker script.  Command line arguments take
6001    precedence.  */
6002
6003 void
6004 lang_add_entry (const char *name, bfd_boolean cmdline)
6005 {
6006   if (entry_symbol.name == NULL
6007       || cmdline
6008       || ! entry_from_cmdline)
6009     {
6010       entry_symbol.name = name;
6011       entry_from_cmdline = cmdline;
6012     }
6013 }
6014
6015 /* Set the default start symbol to NAME.  .em files should use this,
6016    not lang_add_entry, to override the use of "start" if neither the
6017    linker script nor the command line specifies an entry point.  NAME
6018    must be permanently allocated.  */
6019 void
6020 lang_default_entry (const char *name)
6021 {
6022   entry_symbol_default = name;
6023 }
6024
6025 void
6026 lang_add_target (const char *name)
6027 {
6028   lang_target_statement_type *new;
6029
6030   new = new_stat (lang_target_statement, stat_ptr);
6031   new->target = name;
6032 }
6033
6034 void
6035 lang_add_map (const char *name)
6036 {
6037   while (*name)
6038     {
6039       switch (*name)
6040         {
6041         case 'F':
6042           map_option_f = TRUE;
6043           break;
6044         }
6045       name++;
6046     }
6047 }
6048
6049 void
6050 lang_add_fill (fill_type *fill)
6051 {
6052   lang_fill_statement_type *new;
6053
6054   new = new_stat (lang_fill_statement, stat_ptr);
6055   new->fill = fill;
6056 }
6057
6058 void
6059 lang_add_data (int type, union etree_union *exp)
6060 {
6061   lang_data_statement_type *new;
6062
6063   new = new_stat (lang_data_statement, stat_ptr);
6064   new->exp = exp;
6065   new->type = type;
6066 }
6067
6068 /* Create a new reloc statement.  RELOC is the BFD relocation type to
6069    generate.  HOWTO is the corresponding howto structure (we could
6070    look this up, but the caller has already done so).  SECTION is the
6071    section to generate a reloc against, or NAME is the name of the
6072    symbol to generate a reloc against.  Exactly one of SECTION and
6073    NAME must be NULL.  ADDEND is an expression for the addend.  */
6074
6075 void
6076 lang_add_reloc (bfd_reloc_code_real_type reloc,
6077                 reloc_howto_type *howto,
6078                 asection *section,
6079                 const char *name,
6080                 union etree_union *addend)
6081 {
6082   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
6083
6084   p->reloc = reloc;
6085   p->howto = howto;
6086   p->section = section;
6087   p->name = name;
6088   p->addend_exp = addend;
6089
6090   p->addend_value = 0;
6091   p->output_section = NULL;
6092   p->output_offset = 0;
6093 }
6094
6095 lang_assignment_statement_type *
6096 lang_add_assignment (etree_type *exp)
6097 {
6098   lang_assignment_statement_type *new;
6099
6100   new = new_stat (lang_assignment_statement, stat_ptr);
6101   new->exp = exp;
6102   return new;
6103 }
6104
6105 void
6106 lang_add_attribute (enum statement_enum attribute)
6107 {
6108   new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
6109 }
6110
6111 void
6112 lang_startup (const char *name)
6113 {
6114   if (startup_file != NULL)
6115     {
6116       einfo (_("%P%F: multiple STARTUP files\n"));
6117     }
6118   first_file->filename = name;
6119   first_file->local_sym_name = name;
6120   first_file->real = TRUE;
6121
6122   startup_file = name;
6123 }
6124
6125 void
6126 lang_float (bfd_boolean maybe)
6127 {
6128   lang_float_flag = maybe;
6129 }
6130
6131
6132 /* Work out the load- and run-time regions from a script statement, and
6133    store them in *LMA_REGION and *REGION respectively.
6134
6135    MEMSPEC is the name of the run-time region, or the value of
6136    DEFAULT_MEMORY_REGION if the statement didn't specify one.
6137    LMA_MEMSPEC is the name of the load-time region, or null if the
6138    statement didn't specify one.HAVE_LMA_P is TRUE if the statement
6139    had an explicit load address.
6140
6141    It is an error to specify both a load region and a load address.  */
6142
6143 static void
6144 lang_get_regions (lang_memory_region_type **region,
6145                   lang_memory_region_type **lma_region,
6146                   const char *memspec,
6147                   const char *lma_memspec,
6148                   bfd_boolean have_lma,
6149                   bfd_boolean have_vma)
6150 {
6151   *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
6152
6153   /* If no runtime region or VMA has been specified, but the load region
6154      has been specified, then use the load region for the runtime region
6155      as well.  */
6156   if (lma_memspec != NULL
6157       && ! have_vma
6158       && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
6159     *region = *lma_region;
6160   else
6161     *region = lang_memory_region_lookup (memspec, FALSE);
6162
6163   if (have_lma && lma_memspec != 0)
6164     einfo (_("%X%P:%S: section has both a load address and a load region\n"));
6165 }
6166
6167 void
6168 lang_leave_output_section_statement (fill_type *fill, const char *memspec,
6169                                      lang_output_section_phdr_list *phdrs,
6170                                      const char *lma_memspec)
6171 {
6172   lang_get_regions (&current_section->region,
6173                     &current_section->lma_region,
6174                     memspec, lma_memspec,
6175                     current_section->load_base != NULL,
6176                     current_section->addr_tree != NULL);
6177   current_section->fill = fill;
6178   current_section->phdrs = phdrs;
6179   stat_ptr = &statement_list;
6180 }
6181
6182 /* Create an absolute symbol with the given name with the value of the
6183    address of first byte of the section named.
6184
6185    If the symbol already exists, then do nothing.  */
6186
6187 void
6188 lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
6189 {
6190   struct bfd_link_hash_entry *h;
6191
6192   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6193   if (h == NULL)
6194     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6195
6196   if (h->type == bfd_link_hash_new
6197       || h->type == bfd_link_hash_undefined)
6198     {
6199       asection *sec;
6200
6201       h->type = bfd_link_hash_defined;
6202
6203       sec = bfd_get_section_by_name (output_bfd, secname);
6204       if (sec == NULL)
6205         h->u.def.value = 0;
6206       else
6207         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
6208
6209       h->u.def.section = bfd_abs_section_ptr;
6210     }
6211 }
6212
6213 /* Create an absolute symbol with the given name with the value of the
6214    address of the first byte after the end of the section named.
6215
6216    If the symbol already exists, then do nothing.  */
6217
6218 void
6219 lang_abs_symbol_at_end_of (const char *secname, const char *name)
6220 {
6221   struct bfd_link_hash_entry *h;
6222
6223   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6224   if (h == NULL)
6225     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6226
6227   if (h->type == bfd_link_hash_new
6228       || h->type == bfd_link_hash_undefined)
6229     {
6230       asection *sec;
6231
6232       h->type = bfd_link_hash_defined;
6233
6234       sec = bfd_get_section_by_name (output_bfd, secname);
6235       if (sec == NULL)
6236         h->u.def.value = 0;
6237       else
6238         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
6239                           + TO_ADDR (sec->size));
6240
6241       h->u.def.section = bfd_abs_section_ptr;
6242     }
6243 }
6244
6245 void
6246 lang_statement_append (lang_statement_list_type *list,
6247                        lang_statement_union_type *element,
6248                        lang_statement_union_type **field)
6249 {
6250   *(list->tail) = element;
6251   list->tail = field;
6252 }
6253
6254 /* Set the output format type.  -oformat overrides scripts.  */
6255
6256 void
6257 lang_add_output_format (const char *format,
6258                         const char *big,
6259                         const char *little,
6260                         int from_script)
6261 {
6262   if (output_target == NULL || !from_script)
6263     {
6264       if (command_line.endian == ENDIAN_BIG
6265           && big != NULL)
6266         format = big;
6267       else if (command_line.endian == ENDIAN_LITTLE
6268                && little != NULL)
6269         format = little;
6270
6271       output_target = format;
6272     }
6273 }
6274
6275 /* Enter a group.  This creates a new lang_group_statement, and sets
6276    stat_ptr to build new statements within the group.  */
6277
6278 void
6279 lang_enter_group (void)
6280 {
6281   lang_group_statement_type *g;
6282
6283   g = new_stat (lang_group_statement, stat_ptr);
6284   lang_list_init (&g->children);
6285   stat_ptr = &g->children;
6286 }
6287
6288 /* Leave a group.  This just resets stat_ptr to start writing to the
6289    regular list of statements again.  Note that this will not work if
6290    groups can occur inside anything else which can adjust stat_ptr,
6291    but currently they can't.  */
6292
6293 void
6294 lang_leave_group (void)
6295 {
6296   stat_ptr = &statement_list;
6297 }
6298
6299 /* Add a new program header.  This is called for each entry in a PHDRS
6300    command in a linker script.  */
6301
6302 void
6303 lang_new_phdr (const char *name,
6304                etree_type *type,
6305                bfd_boolean filehdr,
6306                bfd_boolean phdrs,
6307                etree_type *at,
6308                etree_type *flags)
6309 {
6310   struct lang_phdr *n, **pp;
6311
6312   n = stat_alloc (sizeof (struct lang_phdr));
6313   n->next = NULL;
6314   n->name = name;
6315   n->type = exp_get_value_int (type, 0, "program header type");
6316   n->filehdr = filehdr;
6317   n->phdrs = phdrs;
6318   n->at = at;
6319   n->flags = flags;
6320
6321   for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
6322     ;
6323   *pp = n;
6324 }
6325
6326 /* Record the program header information in the output BFD.  FIXME: We
6327    should not be calling an ELF specific function here.  */
6328
6329 static void
6330 lang_record_phdrs (void)
6331 {
6332   unsigned int alc;
6333   asection **secs;
6334   lang_output_section_phdr_list *last;
6335   struct lang_phdr *l;
6336   lang_output_section_statement_type *os;
6337
6338   alc = 10;
6339   secs = xmalloc (alc * sizeof (asection *));
6340   last = NULL;
6341
6342   for (l = lang_phdr_list; l != NULL; l = l->next)
6343     {
6344       unsigned int c;
6345       flagword flags;
6346       bfd_vma at;
6347
6348       c = 0;
6349       for (os = &lang_output_section_statement.head->output_section_statement;
6350            os != NULL;
6351            os = os->next)
6352         {
6353           lang_output_section_phdr_list *pl;
6354
6355           if (os->constraint == -1)
6356             continue;
6357
6358           pl = os->phdrs;
6359           if (pl != NULL)
6360             last = pl;
6361           else
6362             {
6363               if (os->sectype == noload_section
6364                   || os->bfd_section == NULL
6365                   || (os->bfd_section->flags & SEC_ALLOC) == 0)
6366                 continue;
6367
6368               if (last == NULL)
6369                 {
6370                   lang_output_section_statement_type * tmp_os;
6371
6372                   /* If we have not run across a section with a program
6373                      header assigned to it yet, then scan forwards to find
6374                      one.  This prevents inconsistencies in the linker's
6375                      behaviour when a script has specified just a single
6376                      header and there are sections in that script which are
6377                      not assigned to it, and which occur before the first
6378                      use of that header. See here for more details:
6379                      http://sourceware.org/ml/binutils/2007-02/msg00291.html  */
6380                   for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)
6381                     if (tmp_os->phdrs)
6382                       {
6383                         last = tmp_os->phdrs;
6384                         break;
6385                       }
6386                   if (last == NULL)
6387                     einfo (_("%F%P: no sections assigned to phdrs\n"));
6388                 }
6389               pl = last;
6390             }
6391
6392           if (os->bfd_section == NULL)
6393             continue;
6394
6395           for (; pl != NULL; pl = pl->next)
6396             {
6397               if (strcmp (pl->name, l->name) == 0)
6398                 {
6399                   if (c >= alc)
6400                     {
6401                       alc *= 2;
6402                       secs = xrealloc (secs, alc * sizeof (asection *));
6403                     }
6404                   secs[c] = os->bfd_section;
6405                   ++c;
6406                   pl->used = TRUE;
6407                 }
6408             }
6409         }
6410
6411       if (l->flags == NULL)
6412         flags = 0;
6413       else
6414         flags = exp_get_vma (l->flags, 0, "phdr flags");
6415
6416       if (l->at == NULL)
6417         at = 0;
6418       else
6419         at = exp_get_vma (l->at, 0, "phdr load address");
6420
6421       if (! bfd_record_phdr (output_bfd, l->type,
6422                              l->flags != NULL, flags, l->at != NULL,
6423                              at, l->filehdr, l->phdrs, c, secs))
6424         einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
6425     }
6426
6427   free (secs);
6428
6429   /* Make sure all the phdr assignments succeeded.  */
6430   for (os = &lang_output_section_statement.head->output_section_statement;
6431        os != NULL;
6432        os = os->next)
6433     {
6434       lang_output_section_phdr_list *pl;
6435
6436       if (os->constraint == -1
6437           || os->bfd_section == NULL)
6438         continue;
6439
6440       for (pl = os->phdrs;
6441            pl != NULL;
6442            pl = pl->next)
6443         if (! pl->used && strcmp (pl->name, "NONE") != 0)
6444           einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
6445                  os->name, pl->name);
6446     }
6447 }
6448
6449 /* Record a list of sections which may not be cross referenced.  */
6450
6451 void
6452 lang_add_nocrossref (lang_nocrossref_type *l)
6453 {
6454   struct lang_nocrossrefs *n;
6455
6456   n = xmalloc (sizeof *n);
6457   n->next = nocrossref_list;
6458   n->list = l;
6459   nocrossref_list = n;
6460
6461   /* Set notice_all so that we get informed about all symbols.  */
6462   link_info.notice_all = TRUE;
6463 }
6464 \f
6465 /* Overlay handling.  We handle overlays with some static variables.  */
6466
6467 /* The overlay virtual address.  */
6468 static etree_type *overlay_vma;
6469 /* And subsection alignment.  */
6470 static etree_type *overlay_subalign;
6471
6472 /* An expression for the maximum section size seen so far.  */
6473 static etree_type *overlay_max;
6474
6475 /* A list of all the sections in this overlay.  */
6476
6477 struct overlay_list {
6478   struct overlay_list *next;
6479   lang_output_section_statement_type *os;
6480 };
6481
6482 static struct overlay_list *overlay_list;
6483
6484 /* Start handling an overlay.  */
6485
6486 void
6487 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
6488 {
6489   /* The grammar should prevent nested overlays from occurring.  */
6490   ASSERT (overlay_vma == NULL
6491           && overlay_subalign == NULL
6492           && overlay_max == NULL);
6493
6494   overlay_vma = vma_expr;
6495   overlay_subalign = subalign;
6496 }
6497
6498 /* Start a section in an overlay.  We handle this by calling
6499    lang_enter_output_section_statement with the correct VMA.
6500    lang_leave_overlay sets up the LMA and memory regions.  */
6501
6502 void
6503 lang_enter_overlay_section (const char *name)
6504 {
6505   struct overlay_list *n;
6506   etree_type *size;
6507
6508   lang_enter_output_section_statement (name, overlay_vma, overlay_section,
6509                                        0, overlay_subalign, 0, 0);
6510
6511   /* If this is the first section, then base the VMA of future
6512      sections on this one.  This will work correctly even if `.' is
6513      used in the addresses.  */
6514   if (overlay_list == NULL)
6515     overlay_vma = exp_nameop (ADDR, name);
6516
6517   /* Remember the section.  */
6518   n = xmalloc (sizeof *n);
6519   n->os = current_section;
6520   n->next = overlay_list;
6521   overlay_list = n;
6522
6523   size = exp_nameop (SIZEOF, name);
6524
6525   /* Arrange to work out the maximum section end address.  */
6526   if (overlay_max == NULL)
6527     overlay_max = size;
6528   else
6529     overlay_max = exp_binop (MAX_K, overlay_max, size);
6530 }
6531
6532 /* Finish a section in an overlay.  There isn't any special to do
6533    here.  */
6534
6535 void
6536 lang_leave_overlay_section (fill_type *fill,
6537                             lang_output_section_phdr_list *phdrs)
6538 {
6539   const char *name;
6540   char *clean, *s2;
6541   const char *s1;
6542   char *buf;
6543
6544   name = current_section->name;
6545
6546   /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
6547      region and that no load-time region has been specified.  It doesn't
6548      really matter what we say here, since lang_leave_overlay will
6549      override it.  */
6550   lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
6551
6552   /* Define the magic symbols.  */
6553
6554   clean = xmalloc (strlen (name) + 1);
6555   s2 = clean;
6556   for (s1 = name; *s1 != '\0'; s1++)
6557     if (ISALNUM (*s1) || *s1 == '_')
6558       *s2++ = *s1;
6559   *s2 = '\0';
6560
6561   buf = xmalloc (strlen (clean) + sizeof "__load_start_");
6562   sprintf (buf, "__load_start_%s", clean);
6563   lang_add_assignment (exp_provide (buf,
6564                                     exp_nameop (LOADADDR, name),
6565                                     FALSE));
6566
6567   buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
6568   sprintf (buf, "__load_stop_%s", clean);
6569   lang_add_assignment (exp_provide (buf,
6570                                     exp_binop ('+',
6571                                                exp_nameop (LOADADDR, name),
6572                                                exp_nameop (SIZEOF, name)),
6573                                     FALSE));
6574
6575   free (clean);
6576 }
6577
6578 /* Finish an overlay.  If there are any overlay wide settings, this
6579    looks through all the sections in the overlay and sets them.  */
6580
6581 void
6582 lang_leave_overlay (etree_type *lma_expr,
6583                     int nocrossrefs,
6584                     fill_type *fill,
6585                     const char *memspec,
6586                     lang_output_section_phdr_list *phdrs,
6587                     const char *lma_memspec)
6588 {
6589   lang_memory_region_type *region;
6590   lang_memory_region_type *lma_region;
6591   struct overlay_list *l;
6592   lang_nocrossref_type *nocrossref;
6593
6594   lang_get_regions (&region, &lma_region,
6595                     memspec, lma_memspec,
6596                     lma_expr != NULL, FALSE);
6597
6598   nocrossref = NULL;
6599
6600   /* After setting the size of the last section, set '.' to end of the
6601      overlay region.  */
6602   if (overlay_list != NULL)
6603     overlay_list->os->update_dot_tree
6604       = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
6605
6606   l = overlay_list;
6607   while (l != NULL)
6608     {
6609       struct overlay_list *next;
6610
6611       if (fill != NULL && l->os->fill == NULL)
6612         l->os->fill = fill;
6613
6614       l->os->region = region;
6615       l->os->lma_region = lma_region;
6616
6617       /* The first section has the load address specified in the
6618          OVERLAY statement.  The rest are worked out from that.
6619          The base address is not needed (and should be null) if
6620          an LMA region was specified.  */
6621       if (l->next == 0)
6622         {
6623           l->os->load_base = lma_expr;
6624           l->os->sectype = normal_section;
6625         }
6626       if (phdrs != NULL && l->os->phdrs == NULL)
6627         l->os->phdrs = phdrs;
6628
6629       if (nocrossrefs)
6630         {
6631           lang_nocrossref_type *nc;
6632
6633           nc = xmalloc (sizeof *nc);
6634           nc->name = l->os->name;
6635           nc->next = nocrossref;
6636           nocrossref = nc;
6637         }
6638
6639       next = l->next;
6640       free (l);
6641       l = next;
6642     }
6643
6644   if (nocrossref != NULL)
6645     lang_add_nocrossref (nocrossref);
6646
6647   overlay_vma = NULL;
6648   overlay_list = NULL;
6649   overlay_max = NULL;
6650 }
6651 \f
6652 /* Version handling.  This is only useful for ELF.  */
6653
6654 /* This global variable holds the version tree that we build.  */
6655
6656 struct bfd_elf_version_tree *lang_elf_version_info;
6657
6658 /* If PREV is NULL, return first version pattern matching particular symbol.
6659    If PREV is non-NULL, return first version pattern matching particular
6660    symbol after PREV (previously returned by lang_vers_match).  */
6661
6662 static struct bfd_elf_version_expr *
6663 lang_vers_match (struct bfd_elf_version_expr_head *head,
6664                  struct bfd_elf_version_expr *prev,
6665                  const char *sym)
6666 {
6667   const char *cxx_sym = sym;
6668   const char *java_sym = sym;
6669   struct bfd_elf_version_expr *expr = NULL;
6670
6671   if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
6672     {
6673       cxx_sym = cplus_demangle (sym, DMGL_PARAMS | DMGL_ANSI);
6674       if (!cxx_sym)
6675         cxx_sym = sym;
6676     }
6677   if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
6678     {
6679       java_sym = cplus_demangle (sym, DMGL_JAVA);
6680       if (!java_sym)
6681         java_sym = sym;
6682     }
6683
6684   if (head->htab && (prev == NULL || prev->symbol))
6685     {
6686       struct bfd_elf_version_expr e;
6687
6688       switch (prev ? prev->mask : 0)
6689         {
6690           case 0:
6691             if (head->mask & BFD_ELF_VERSION_C_TYPE)
6692               {
6693                 e.symbol = sym;
6694                 expr = htab_find (head->htab, &e);
6695                 while (expr && strcmp (expr->symbol, sym) == 0)
6696                   if (expr->mask == BFD_ELF_VERSION_C_TYPE)
6697                     goto out_ret;
6698                   else
6699                     expr = expr->next;
6700               }
6701             /* Fallthrough */
6702           case BFD_ELF_VERSION_C_TYPE:
6703             if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
6704               {
6705                 e.symbol = cxx_sym;
6706                 expr = htab_find (head->htab, &e);
6707                 while (expr && strcmp (expr->symbol, cxx_sym) == 0)
6708                   if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
6709                     goto out_ret;
6710                   else
6711                     expr = expr->next;
6712               }
6713             /* Fallthrough */
6714           case BFD_ELF_VERSION_CXX_TYPE:
6715             if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
6716               {
6717                 e.symbol = java_sym;
6718                 expr = htab_find (head->htab, &e);
6719                 while (expr && strcmp (expr->symbol, java_sym) == 0)
6720                   if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
6721                     goto out_ret;
6722                   else
6723                     expr = expr->next;
6724               }
6725             /* Fallthrough */
6726           default:
6727             break;
6728         }
6729     }
6730
6731   /* Finally, try the wildcards.  */
6732   if (prev == NULL || prev->symbol)
6733     expr = head->remaining;
6734   else
6735     expr = prev->next;
6736   for (; expr; expr = expr->next)
6737     {
6738       const char *s;
6739
6740       if (!expr->pattern)
6741         continue;
6742
6743       if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
6744         break;
6745
6746       if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
6747         s = java_sym;
6748       else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
6749         s = cxx_sym;
6750       else
6751         s = sym;
6752       if (fnmatch (expr->pattern, s, 0) == 0)
6753         break;
6754     }
6755
6756 out_ret:
6757   if (cxx_sym != sym)
6758     free ((char *) cxx_sym);
6759   if (java_sym != sym)
6760     free ((char *) java_sym);
6761   return expr;
6762 }
6763
6764 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
6765    return a string pointing to the symbol name.  */
6766
6767 static const char *
6768 realsymbol (const char *pattern)
6769 {
6770   const char *p;
6771   bfd_boolean changed = FALSE, backslash = FALSE;
6772   char *s, *symbol = xmalloc (strlen (pattern) + 1);
6773
6774   for (p = pattern, s = symbol; *p != '\0'; ++p)
6775     {
6776       /* It is a glob pattern only if there is no preceding
6777          backslash.  */
6778       if (! backslash && (*p == '?' || *p == '*' || *p == '['))
6779         {
6780           free (symbol);
6781           return NULL;
6782         }
6783
6784       if (backslash)
6785         {
6786           /* Remove the preceding backslash.  */
6787           *(s - 1) = *p;
6788           changed = TRUE;
6789         }
6790       else
6791         *s++ = *p;
6792
6793       backslash = *p == '\\';
6794     }
6795
6796   if (changed)
6797     {
6798       *s = '\0';
6799       return symbol;
6800     }
6801   else
6802     {
6803       free (symbol);
6804       return pattern;
6805     }
6806 }
6807
6808 /* This is called for each variable name or match expression.  NEW is
6809    the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
6810    pattern to be matched against symbol names.  */
6811
6812 struct bfd_elf_version_expr *
6813 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
6814                        const char *new,
6815                        const char *lang,
6816                        bfd_boolean literal_p)
6817 {
6818   struct bfd_elf_version_expr *ret;
6819
6820   ret = xmalloc (sizeof *ret);
6821   ret->next = orig;
6822   ret->pattern = literal_p ? NULL : new;
6823   ret->symver = 0;
6824   ret->script = 0;
6825   ret->symbol = literal_p ? new : realsymbol (new);
6826
6827   if (lang == NULL || strcasecmp (lang, "C") == 0)
6828     ret->mask = BFD_ELF_VERSION_C_TYPE;
6829   else if (strcasecmp (lang, "C++") == 0)
6830     ret->mask = BFD_ELF_VERSION_CXX_TYPE;
6831   else if (strcasecmp (lang, "Java") == 0)
6832     ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
6833   else
6834     {
6835       einfo (_("%X%P: unknown language `%s' in version information\n"),
6836              lang);
6837       ret->mask = BFD_ELF_VERSION_C_TYPE;
6838     }
6839
6840   return ldemul_new_vers_pattern (ret);
6841 }
6842
6843 /* This is called for each set of variable names and match
6844    expressions.  */
6845
6846 struct bfd_elf_version_tree *
6847 lang_new_vers_node (struct bfd_elf_version_expr *globals,
6848                     struct bfd_elf_version_expr *locals)
6849 {
6850   struct bfd_elf_version_tree *ret;
6851
6852   ret = xcalloc (1, sizeof *ret);
6853   ret->globals.list = globals;
6854   ret->locals.list = locals;
6855   ret->match = lang_vers_match;
6856   ret->name_indx = (unsigned int) -1;
6857   return ret;
6858 }
6859
6860 /* This static variable keeps track of version indices.  */
6861
6862 static int version_index;
6863
6864 static hashval_t
6865 version_expr_head_hash (const void *p)
6866 {
6867   const struct bfd_elf_version_expr *e = p;
6868
6869   return htab_hash_string (e->symbol);
6870 }
6871
6872 static int
6873 version_expr_head_eq (const void *p1, const void *p2)
6874 {
6875   const struct bfd_elf_version_expr *e1 = p1;
6876   const struct bfd_elf_version_expr *e2 = p2;
6877
6878   return strcmp (e1->symbol, e2->symbol) == 0;
6879 }
6880
6881 static void
6882 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
6883 {
6884   size_t count = 0;
6885   struct bfd_elf_version_expr *e, *next;
6886   struct bfd_elf_version_expr **list_loc, **remaining_loc;
6887
6888   for (e = head->list; e; e = e->next)
6889     {
6890       if (e->symbol)
6891         count++;
6892       head->mask |= e->mask;
6893     }
6894
6895   if (count)
6896     {
6897       head->htab = htab_create (count * 2, version_expr_head_hash,
6898                                 version_expr_head_eq, NULL);
6899       list_loc = &head->list;
6900       remaining_loc = &head->remaining;
6901       for (e = head->list; e; e = next)
6902         {
6903           next = e->next;
6904           if (!e->symbol)
6905             {
6906               *remaining_loc = e;
6907               remaining_loc = &e->next;
6908             }
6909           else
6910             {
6911               void **loc = htab_find_slot (head->htab, e, INSERT);
6912
6913               if (*loc)
6914                 {
6915                   struct bfd_elf_version_expr *e1, *last;
6916
6917                   e1 = *loc;
6918                   last = NULL;
6919                   do
6920                     {
6921                       if (e1->mask == e->mask)
6922                         {
6923                           last = NULL;
6924                           break;
6925                         }
6926                       last = e1;
6927                       e1 = e1->next;
6928                     }
6929                   while (e1 && strcmp (e1->symbol, e->symbol) == 0);
6930
6931                   if (last == NULL)
6932                     {
6933                       /* This is a duplicate.  */
6934                       /* FIXME: Memory leak.  Sometimes pattern is not
6935                          xmalloced alone, but in larger chunk of memory.  */
6936                       /* free (e->symbol); */
6937                       free (e);
6938                     }
6939                   else
6940                     {
6941                       e->next = last->next;
6942                       last->next = e;
6943                     }
6944                 }
6945               else
6946                 {
6947                   *loc = e;
6948                   *list_loc = e;
6949                   list_loc = &e->next;
6950                 }
6951             }
6952         }
6953       *remaining_loc = NULL;
6954       *list_loc = head->remaining;
6955     }
6956   else
6957     head->remaining = head->list;
6958 }
6959
6960 /* This is called when we know the name and dependencies of the
6961    version.  */
6962
6963 void
6964 lang_register_vers_node (const char *name,
6965                          struct bfd_elf_version_tree *version,
6966                          struct bfd_elf_version_deps *deps)
6967 {
6968   struct bfd_elf_version_tree *t, **pp;
6969   struct bfd_elf_version_expr *e1;
6970
6971   if (name == NULL)
6972     name = "";
6973
6974   if ((name[0] == '\0' && lang_elf_version_info != NULL)
6975       || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
6976     {
6977       einfo (_("%X%P: anonymous version tag cannot be combined"
6978                " with other version tags\n"));
6979       free (version);
6980       return;
6981     }
6982
6983   /* Make sure this node has a unique name.  */
6984   for (t = lang_elf_version_info; t != NULL; t = t->next)
6985     if (strcmp (t->name, name) == 0)
6986       einfo (_("%X%P: duplicate version tag `%s'\n"), name);
6987
6988   lang_finalize_version_expr_head (&version->globals);
6989   lang_finalize_version_expr_head (&version->locals);
6990
6991   /* Check the global and local match names, and make sure there
6992      aren't any duplicates.  */
6993
6994   for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
6995     {
6996       for (t = lang_elf_version_info; t != NULL; t = t->next)
6997         {
6998           struct bfd_elf_version_expr *e2;
6999
7000           if (t->locals.htab && e1->symbol)
7001             {
7002               e2 = htab_find (t->locals.htab, e1);
7003               while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
7004                 {
7005                   if (e1->mask == e2->mask)
7006                     einfo (_("%X%P: duplicate expression `%s'"
7007                              " in version information\n"), e1->symbol);
7008                   e2 = e2->next;
7009                 }
7010             }
7011           else if (!e1->symbol)
7012             for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
7013               if (strcmp (e1->pattern, e2->pattern) == 0
7014                   && e1->mask == e2->mask)
7015                 einfo (_("%X%P: duplicate expression `%s'"
7016                          " in version information\n"), e1->pattern);
7017         }
7018     }
7019
7020   for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
7021     {
7022       for (t = lang_elf_version_info; t != NULL; t = t->next)
7023         {
7024           struct bfd_elf_version_expr *e2;
7025
7026           if (t->globals.htab && e1->symbol)
7027             {
7028               e2 = htab_find (t->globals.htab, e1);
7029               while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
7030                 {
7031                   if (e1->mask == e2->mask)
7032                     einfo (_("%X%P: duplicate expression `%s'"
7033                              " in version information\n"),
7034                            e1->symbol);
7035                   e2 = e2->next;
7036                 }
7037             }
7038           else if (!e1->symbol)
7039             for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
7040               if (strcmp (e1->pattern, e2->pattern) == 0
7041                   && e1->mask == e2->mask)
7042                 einfo (_("%X%P: duplicate expression `%s'"
7043                          " in version information\n"), e1->pattern);
7044         }
7045     }
7046
7047   version->deps = deps;
7048   version->name = name;
7049   if (name[0] != '\0')
7050     {
7051       ++version_index;
7052       version->vernum = version_index;
7053     }
7054   else
7055     version->vernum = 0;
7056
7057   for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
7058     ;
7059   *pp = version;
7060 }
7061
7062 /* This is called when we see a version dependency.  */
7063
7064 struct bfd_elf_version_deps *
7065 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
7066 {
7067   struct bfd_elf_version_deps *ret;
7068   struct bfd_elf_version_tree *t;
7069
7070   ret = xmalloc (sizeof *ret);
7071   ret->next = list;
7072
7073   for (t = lang_elf_version_info; t != NULL; t = t->next)
7074     {
7075       if (strcmp (t->name, name) == 0)
7076         {
7077           ret->version_needed = t;
7078           return ret;
7079         }
7080     }
7081
7082   einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
7083
7084   return ret;
7085 }
7086
7087 static void
7088 lang_do_version_exports_section (void)
7089 {
7090   struct bfd_elf_version_expr *greg = NULL, *lreg;
7091
7092   LANG_FOR_EACH_INPUT_STATEMENT (is)
7093     {
7094       asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
7095       char *contents, *p;
7096       bfd_size_type len;
7097
7098       if (sec == NULL)
7099         continue;
7100
7101       len = sec->size;
7102       contents = xmalloc (len);
7103       if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
7104         einfo (_("%X%P: unable to read .exports section contents\n"), sec);
7105
7106       p = contents;
7107       while (p < contents + len)
7108         {
7109           greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
7110           p = strchr (p, '\0') + 1;
7111         }
7112
7113       /* Do not free the contents, as we used them creating the regex.  */
7114
7115       /* Do not include this section in the link.  */
7116       sec->flags |= SEC_EXCLUDE | SEC_KEEP;
7117     }
7118
7119   lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
7120   lang_register_vers_node (command_line.version_exports_section,
7121                            lang_new_vers_node (greg, lreg), NULL);
7122 }
7123
7124 void
7125 lang_add_unique (const char *name)
7126 {
7127   struct unique_sections *ent;
7128
7129   for (ent = unique_section_list; ent; ent = ent->next)
7130     if (strcmp (ent->name, name) == 0)
7131       return;
7132
7133   ent = xmalloc (sizeof *ent);
7134   ent->name = xstrdup (name);
7135   ent->next = unique_section_list;
7136   unique_section_list = ent;
7137 }
7138
7139 /* Append the list of dynamic symbols to the existing one.  */
7140
7141 void
7142 lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
7143 {
7144   if (link_info.dynamic_list)
7145     {
7146       struct bfd_elf_version_expr *tail;
7147       for (tail = dynamic; tail->next != NULL; tail = tail->next)
7148         ;
7149       tail->next = link_info.dynamic_list->head.list;
7150       link_info.dynamic_list->head.list = dynamic;
7151     }
7152   else
7153     {
7154       struct bfd_elf_dynamic_list *d;
7155
7156       d = xcalloc (1, sizeof *d);
7157       d->head.list = dynamic;
7158       d->match = lang_vers_match;
7159       link_info.dynamic_list = d;
7160     }
7161 }
7162
7163 /* Append the list of C++ typeinfo dynamic symbols to the existing
7164    one.  */
7165
7166 void
7167 lang_append_dynamic_list_cpp_typeinfo (void)
7168 {
7169   const char * symbols [] =
7170     {
7171       "typeinfo name for*",
7172       "typeinfo for*"
7173     };
7174   struct bfd_elf_version_expr *dynamic = NULL;
7175   unsigned int i;
7176
7177   for (i = 0; i < ARRAY_SIZE (symbols); i++)
7178     dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
7179                                      FALSE);
7180
7181   lang_append_dynamic_list (dynamic);
7182 }
7183
7184 /* Append the list of C++ operator new and delete dynamic symbols to the
7185    existing one.  */
7186
7187 void
7188 lang_append_dynamic_list_cpp_new (void)
7189 {
7190   const char * symbols [] =
7191     {
7192       "operator new*",
7193       "operator delete*"
7194     };
7195   struct bfd_elf_version_expr *dynamic = NULL;
7196   unsigned int i;
7197
7198   for (i = 0; i < ARRAY_SIZE (symbols); i++)
7199     dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
7200                                      FALSE);
7201
7202   lang_append_dynamic_list (dynamic);
7203 }