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