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