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