ld/ldlang.c

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