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)
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)
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)
3037                       einfo (_("%F%S: non constant address expression for section %s\n"),
3038                              os->name);
3039
3040                     dot = r.value + r.section->bfd_section->vma;
3041                   }
3042
3043                 /* The section starts here.
3044                    First, align to what the section needs.  */
3045
3046                 if (os->section_alignment != -1)
3047                   dot = align_power (dot, os->section_alignment);
3048
3049                 bfd_set_section_vma (0, os->bfd_section, dot);
3050
3051                 os->bfd_section->output_offset = 0;
3052               }
3053
3054             lang_size_sections_1 (os->children.head, os, &os->children.head,
3055                                   os->fill, dot, relax);
3056
3057             /* Put the section within the requested block size, or
3058                align at the block boundary.  */
3059             after = align_n (os->bfd_section->vma
3060                              + os->bfd_section->_raw_size / opb,
3061                              (bfd_vma) os->block_value);
3062
3063             if (bfd_is_abs_section (os->bfd_section))
3064               ASSERT (after == os->bfd_section->vma);
3065             else if ((os->bfd_section->flags & SEC_HAS_CONTENTS) == 0
3066                      && (os->bfd_section->flags & SEC_THREAD_LOCAL)
3067                      && ! link_info.relocateable)
3068               os->bfd_section->_raw_size = 0;
3069             else
3070               os->bfd_section->_raw_size =
3071                 (after - os->bfd_section->vma) * opb;
3072
3073             dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3074             os->processed = true;
3075
3076             if (os->update_dot_tree != 0)
3077               exp_fold_tree (os->update_dot_tree, abs_output_section,
3078                              lang_allocating_phase_enum, dot, &dot);
3079
3080             /* Update dot in the region ?
3081                We only do this if the section is going to be allocated,
3082                since unallocated sections do not contribute to the region's
3083                overall size in memory.
3084
3085                If the SEC_NEVER_LOAD bit is not set, it will affect the
3086                addresses of sections after it. We have to update
3087                dot.  */
3088             if (os->region != (lang_memory_region_type *) NULL
3089                 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
3090                      & SEC_NEVER_LOAD) == 0
3091                     || (bfd_get_section_flags (output_bfd, os->bfd_section)
3092                         & (SEC_ALLOC | SEC_LOAD))))
3093               {
3094                 os->region->current = dot;
3095
3096                 /* Make sure the new address is within the region.  */
3097                 os_region_check (os, os->region, os->addr_tree,
3098                                  os->bfd_section->vma);
3099
3100                 /* If there's no load address specified, use the run
3101                    region as the load region.  */
3102                 if (os->lma_region == NULL && os->load_base == NULL)
3103                   os->lma_region = os->region;
3104
3105                 if (os->lma_region != NULL && os->lma_region != os->region)
3106                   {
3107                     /* Set load_base, which will be handled later.  */
3108                     os->load_base = exp_intop (os->lma_region->current);
3109                     os->lma_region->current +=
3110                       os->bfd_section->_raw_size / opb;
3111                     os_region_check (os, os->lma_region, NULL,
3112                                      os->bfd_section->lma);
3113                   }
3114               }
3115           }
3116           break;
3117
3118         case lang_constructors_statement_enum:
3119           dot = lang_size_sections_1 (constructor_list.head,
3120                                       output_section_statement,
3121                                       &s->wild_statement.children.head,
3122                                       fill, dot, relax);
3123           break;
3124
3125         case lang_data_statement_enum:
3126           {
3127             unsigned int size = 0;
3128
3129             s->data_statement.output_vma =
3130               dot - output_section_statement->bfd_section->vma;
3131             s->data_statement.output_section =
3132               output_section_statement->bfd_section;
3133
3134             switch (s->data_statement.type)
3135               {
3136               default:
3137                 abort ();
3138               case QUAD:
3139               case SQUAD:
3140                 size = QUAD_SIZE;
3141                 break;
3142               case LONG:
3143                 size = LONG_SIZE;
3144                 break;
3145               case SHORT:
3146                 size = SHORT_SIZE;
3147                 break;
3148               case BYTE:
3149                 size = BYTE_SIZE;
3150                 break;
3151               }
3152             if (size < opb)
3153               size = opb;
3154             dot += size / opb;
3155             output_section_statement->bfd_section->_raw_size += size;
3156             /* The output section gets contents, and then we inspect for
3157                any flags set in the input script which override any ALLOC.  */
3158             output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
3159             if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3160               {
3161                 output_section_statement->bfd_section->flags |=
3162                   SEC_ALLOC | SEC_LOAD;
3163               }
3164           }
3165           break;
3166
3167         case lang_reloc_statement_enum:
3168           {
3169             int size;
3170
3171             s->reloc_statement.output_vma =
3172               dot - output_section_statement->bfd_section->vma;
3173             s->reloc_statement.output_section =
3174               output_section_statement->bfd_section;
3175             size = bfd_get_reloc_size (s->reloc_statement.howto);
3176             dot += size / opb;
3177             output_section_statement->bfd_section->_raw_size += size;
3178           }
3179           break;
3180
3181         case lang_wild_statement_enum:
3182
3183           dot = lang_size_sections_1 (s->wild_statement.children.head,
3184                                       output_section_statement,
3185                                       &s->wild_statement.children.head,
3186                                       fill, dot, relax);
3187
3188           break;
3189
3190         case lang_object_symbols_statement_enum:
3191           link_info.create_object_symbols_section =
3192             output_section_statement->bfd_section;
3193           break;
3194         case lang_output_statement_enum:
3195         case lang_target_statement_enum:
3196           break;
3197         case lang_input_section_enum:
3198           {
3199             asection *i;
3200
3201             i = (*prev)->input_section.section;
3202             if (! relax)
3203               {
3204                 if (i->_cooked_size == 0)
3205                   i->_cooked_size = i->_raw_size;
3206               }
3207             else
3208               {
3209                 boolean again;
3210
3211                 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3212                   einfo (_("%P%F: can't relax section: %E\n"));
3213                 if (again)
3214                   *relax = true;
3215               }
3216             dot = size_input_section (prev, output_section_statement,
3217                                       output_section_statement->fill, dot);
3218           }
3219           break;
3220         case lang_input_statement_enum:
3221           break;
3222         case lang_fill_statement_enum:
3223           s->fill_statement.output_section =
3224             output_section_statement->bfd_section;
3225
3226           fill = s->fill_statement.fill;
3227           break;
3228         case lang_assignment_statement_enum:
3229           {
3230             bfd_vma newdot = dot;
3231
3232             exp_fold_tree (s->assignment_statement.exp,
3233                            output_section_statement,
3234                            lang_allocating_phase_enum,
3235                            dot,
3236                            &newdot);
3237
3238             if (newdot != dot)
3239               {
3240                 if (output_section_statement == abs_output_section)
3241                   {
3242                     /* If we don't have an output section, then just adjust
3243                        the default memory address.  */
3244                     lang_memory_region_lookup ("*default*")->current = newdot;
3245                   }
3246                 else
3247                   {
3248                     /* Insert a pad after this statement.  We can't
3249                        put the pad before when relaxing, in case the
3250                        assignment references dot.  */
3251                     insert_pad (&s->header.next, fill, (newdot - dot) * opb,
3252                                 output_section_statement->bfd_section, dot);
3253
3254                     /* Don't neuter the pad below when relaxing.  */
3255                     s = s->header.next;
3256                   }
3257
3258                 dot = newdot;
3259               }
3260           }
3261           break;
3262
3263         case lang_padding_statement_enum:
3264           /* If this is the first time lang_size_sections is called,
3265              we won't have any padding statements.  If this is the
3266              second or later passes when relaxing, we should allow
3267              padding to shrink.  If padding is needed on this pass, it
3268              will be added back in.  */
3269           s->padding_statement.size = 0;
3270
3271           /* Make sure output_offset is valid.  If relaxation shrinks
3272              the section and this pad isn't needed, it's possible to
3273              have output_offset larger than the final size of the
3274              section.  bfd_set_section_contents will complain even for
3275              a pad size of zero.  */
3276           s->padding_statement.output_offset
3277             = dot - output_section_statement->bfd_section->vma;
3278           break;
3279
3280         case lang_group_statement_enum:
3281           dot = lang_size_sections_1 (s->group_statement.children.head,
3282                                       output_section_statement,
3283                                       &s->group_statement.children.head,
3284                                       fill, dot, relax);
3285           break;
3286
3287         default:
3288           FAIL ();
3289           break;
3290
3291           /* We can only get here when relaxing is turned on.  */
3292         case lang_address_statement_enum:
3293           break;
3294         }
3295       prev = &s->header.next;
3296     }
3297   return dot;
3298 }
3299
3300 bfd_vma
3301 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
3302      lang_statement_union_type *s;
3303      lang_output_section_statement_type *output_section_statement;
3304      lang_statement_union_type **prev;
3305      fill_type *fill;
3306      bfd_vma dot;
3307      boolean *relax;
3308 {
3309   bfd_vma result;
3310
3311   exp_data_seg.phase = exp_dataseg_none;
3312   result = lang_size_sections_1 (s, output_section_statement, prev, fill,
3313                                  dot, relax);
3314   if (exp_data_seg.phase == exp_dataseg_end_seen)
3315     {
3316       /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3317          a page could be saved in the data segment.  */
3318       bfd_vma first, last;
3319
3320       first = -exp_data_seg.base & (exp_data_seg.pagesize - 1);
3321       last = exp_data_seg.end & (exp_data_seg.pagesize - 1);
3322       if (first && last
3323           && ((exp_data_seg.base & ~(exp_data_seg.pagesize - 1))
3324               != (exp_data_seg.end & ~(exp_data_seg.pagesize - 1)))
3325           && first + last <= exp_data_seg.pagesize)
3326         {
3327           exp_data_seg.phase = exp_dataseg_adjust;
3328           result = lang_size_sections_1 (s, output_section_statement, prev,
3329                                          fill, dot, relax);
3330         }
3331     }
3332
3333   return result;
3334 }
3335
3336 bfd_vma
3337 lang_do_assignments (s, output_section_statement, fill, dot)
3338      lang_statement_union_type *s;
3339      lang_output_section_statement_type *output_section_statement;
3340      fill_type *fill;
3341      bfd_vma dot;
3342 {
3343   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3344                                                 ldfile_output_machine);
3345
3346   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3347     {
3348       switch (s->header.type)
3349         {
3350         case lang_constructors_statement_enum:
3351           dot = lang_do_assignments (constructor_list.head,
3352                                      output_section_statement,
3353                                      fill,
3354                                      dot);
3355           break;
3356
3357         case lang_output_section_statement_enum:
3358           {
3359             lang_output_section_statement_type *os;
3360
3361             os = &(s->output_section_statement);
3362             if (os->bfd_section != NULL)
3363               {
3364                 dot = os->bfd_section->vma;
3365                 (void) lang_do_assignments (os->children.head, os,
3366                                             os->fill, dot);
3367                 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3368
3369               }
3370             if (os->load_base)
3371               {
3372                 /* If nothing has been placed into the output section then
3373                    it won't have a bfd_section.  */
3374                 if (os->bfd_section)
3375                   {
3376                     os->bfd_section->lma
3377                       = exp_get_abs_int (os->load_base, 0, "load base",
3378                                          lang_final_phase_enum);
3379                   }
3380               }
3381           }
3382           break;
3383         case lang_wild_statement_enum:
3384
3385           dot = lang_do_assignments (s->wild_statement.children.head,
3386                                      output_section_statement,
3387                                      fill, dot);
3388
3389           break;
3390
3391         case lang_object_symbols_statement_enum:
3392         case lang_output_statement_enum:
3393         case lang_target_statement_enum:
3394 #if 0
3395         case lang_common_statement_enum:
3396 #endif
3397           break;
3398         case lang_data_statement_enum:
3399           {
3400             etree_value_type value;
3401
3402             value = exp_fold_tree (s->data_statement.exp,
3403                                    abs_output_section,
3404                                    lang_final_phase_enum, dot, &dot);
3405             s->data_statement.value = value.value;
3406             if (!value.valid_p)
3407               einfo (_("%F%P: invalid data statement\n"));
3408           }
3409           {
3410             unsigned int size;
3411             switch (s->data_statement.type)
3412               {
3413               default:
3414                 abort ();
3415               case QUAD:
3416               case SQUAD:
3417                 size = QUAD_SIZE;
3418                 break;
3419               case LONG:
3420                 size = LONG_SIZE;
3421                 break;
3422               case SHORT:
3423                 size = SHORT_SIZE;
3424                 break;
3425               case BYTE:
3426                 size = BYTE_SIZE;
3427                 break;
3428               }
3429             if (size < opb)
3430               size = opb;
3431             dot += size / opb;
3432           }
3433           break;
3434
3435         case lang_reloc_statement_enum:
3436           {
3437             etree_value_type value;
3438
3439             value = exp_fold_tree (s->reloc_statement.addend_exp,
3440                                    abs_output_section,
3441                                    lang_final_phase_enum, dot, &dot);
3442             s->reloc_statement.addend_value = value.value;
3443             if (!value.valid_p)
3444               einfo (_("%F%P: invalid reloc statement\n"));
3445           }
3446           dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
3447           break;
3448
3449         case lang_input_section_enum:
3450           {
3451             asection *in = s->input_section.section;
3452
3453             if (in->_cooked_size != 0)
3454               dot += in->_cooked_size / opb;
3455             else
3456               dot += in->_raw_size / opb;
3457           }
3458           break;
3459
3460         case lang_input_statement_enum:
3461           break;
3462         case lang_fill_statement_enum:
3463           fill = s->fill_statement.fill;
3464           break;
3465         case lang_assignment_statement_enum:
3466           {
3467             exp_fold_tree (s->assignment_statement.exp,
3468                            output_section_statement,
3469                            lang_final_phase_enum,
3470                            dot,
3471                            &dot);
3472           }
3473
3474           break;
3475         case lang_padding_statement_enum:
3476           dot += s->padding_statement.size / opb;
3477           break;
3478
3479         case lang_group_statement_enum:
3480           dot = lang_do_assignments (s->group_statement.children.head,
3481                                      output_section_statement,
3482                                      fill, dot);
3483
3484           break;
3485
3486         default:
3487           FAIL ();
3488           break;
3489         case lang_address_statement_enum:
3490           break;
3491         }
3492
3493     }
3494   return dot;
3495 }
3496
3497 /* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
3498    operator .startof. (section_name), it produces an undefined symbol
3499    .startof.section_name.  Similarly, when it sees
3500    .sizeof. (section_name), it produces an undefined symbol
3501    .sizeof.section_name.  For all the output sections, we look for
3502    such symbols, and set them to the correct value.  */
3503
3504 static void
3505 lang_set_startof ()
3506 {
3507   asection *s;
3508
3509   if (link_info.relocateable)
3510     return;
3511
3512   for (s = output_bfd->sections; s != NULL; s = s->next)
3513     {
3514       const char *secname;
3515       char *buf;
3516       struct bfd_link_hash_entry *h;
3517
3518       secname = bfd_get_section_name (output_bfd, s);
3519       buf = xmalloc (10 + strlen (secname));
3520
3521       sprintf (buf, ".startof.%s", secname);
3522       h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3523       if (h != NULL && h->type == bfd_link_hash_undefined)
3524         {
3525           h->type = bfd_link_hash_defined;
3526           h->u.def.value = bfd_get_section_vma (output_bfd, s);
3527           h->u.def.section = bfd_abs_section_ptr;
3528         }
3529
3530       sprintf (buf, ".sizeof.%s", secname);
3531       h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3532       if (h != NULL && h->type == bfd_link_hash_undefined)
3533         {
3534           unsigned opb;
3535
3536           opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3537                                                ldfile_output_machine);
3538           h->type = bfd_link_hash_defined;
3539           if (s->_cooked_size != 0)
3540             h->u.def.value = s->_cooked_size / opb;
3541           else
3542             h->u.def.value = s->_raw_size / opb;
3543           h->u.def.section = bfd_abs_section_ptr;
3544         }
3545
3546       free (buf);
3547     }
3548 }
3549
3550 static void
3551 lang_finish ()
3552 {
3553   struct bfd_link_hash_entry *h;
3554   boolean warn;
3555
3556   if (link_info.relocateable || link_info.shared)
3557     warn = false;
3558   else
3559     warn = true;
3560
3561   if (entry_symbol.name == (const char *) NULL)
3562     {
3563       /* No entry has been specified.  Look for start, but don't warn
3564          if we don't find it.  */
3565       entry_symbol.name = "start";
3566       warn = false;
3567     }
3568
3569   h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
3570                             false, false, true);
3571   if (h != (struct bfd_link_hash_entry *) NULL
3572       && (h->type == bfd_link_hash_defined
3573           || h->type == bfd_link_hash_defweak)
3574       && h->u.def.section->output_section != NULL)
3575     {
3576       bfd_vma val;
3577
3578       val = (h->u.def.value
3579              + bfd_get_section_vma (output_bfd,
3580                                     h->u.def.section->output_section)
3581              + h->u.def.section->output_offset);
3582       if (! bfd_set_start_address (output_bfd, val))
3583         einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
3584     }
3585   else
3586     {
3587       bfd_vma val;
3588       const char *send;
3589
3590       /* We couldn't find the entry symbol.  Try parsing it as a
3591          number.  */
3592       val = bfd_scan_vma (entry_symbol.name, &send, 0);
3593       if (*send == '\0')
3594         {
3595           if (! bfd_set_start_address (output_bfd, val))
3596             einfo (_("%P%F: can't set start address\n"));
3597         }
3598       else
3599         {
3600           asection *ts;
3601
3602           /* Can't find the entry symbol, and it's not a number.  Use
3603              the first address in the text section.  */
3604           ts = bfd_get_section_by_name (output_bfd, entry_section);
3605           if (ts != (asection *) NULL)
3606             {
3607               if (warn)
3608                 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3609                        entry_symbol.name,
3610                        bfd_get_section_vma (output_bfd, ts));
3611               if (! bfd_set_start_address (output_bfd,
3612                                            bfd_get_section_vma (output_bfd,
3613                                                                 ts)))
3614                 einfo (_("%P%F: can't set start address\n"));
3615             }
3616           else
3617             {
3618               if (warn)
3619                 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3620                        entry_symbol.name);
3621             }
3622         }
3623     }
3624 }
3625
3626 /* This is a small function used when we want to ignore errors from
3627    BFD.  */
3628
3629 static void
3630 #ifdef ANSI_PROTOTYPES
3631 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3632 #else
3633 ignore_bfd_errors (s)
3634      const char *s ATTRIBUTE_UNUSED;
3635 #endif
3636 {
3637   /* Don't do anything.  */
3638 }
3639
3640 /* Check that the architecture of all the input files is compatible
3641    with the output file.  Also call the backend to let it do any
3642    other checking that is needed.  */
3643
3644 static void
3645 lang_check ()
3646 {
3647   lang_statement_union_type *file;
3648   bfd *input_bfd;
3649   const bfd_arch_info_type *compatible;
3650
3651   for (file = file_chain.head;
3652        file != (lang_statement_union_type *) NULL;
3653        file = file->input_statement.next)
3654     {
3655       input_bfd = file->input_statement.the_bfd;
3656       compatible = bfd_arch_get_compatible (input_bfd, output_bfd);
3657
3658       /* In general it is not possible to perform a relocatable
3659          link between differing object formats when the input
3660          file has relocations, because the relocations in the
3661          input format may not have equivalent representations in
3662          the output format (and besides BFD does not translate
3663          relocs for other link purposes than a final link).  */
3664       if ((link_info.relocateable || link_info.emitrelocations)
3665           && (compatible == NULL
3666               || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
3667           && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
3668         {
3669           einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3670                  bfd_get_target (input_bfd), input_bfd,
3671                  bfd_get_target (output_bfd), output_bfd);
3672           /* einfo with %F exits.  */
3673         }
3674
3675       if (compatible == NULL)
3676         {
3677           if (command_line.warn_mismatch)
3678             einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3679                    bfd_printable_name (input_bfd), input_bfd,
3680                    bfd_printable_name (output_bfd));
3681         }
3682       else if (bfd_count_sections (input_bfd))
3683         {
3684           /* If the input bfd has no contents, it shouldn't set the
3685              private data of the output bfd.  */
3686
3687           bfd_error_handler_type pfn = NULL;
3688
3689           /* If we aren't supposed to warn about mismatched input
3690              files, temporarily set the BFD error handler to a
3691              function which will do nothing.  We still want to call
3692              bfd_merge_private_bfd_data, since it may set up
3693              information which is needed in the output file.  */
3694           if (! command_line.warn_mismatch)
3695             pfn = bfd_set_error_handler (ignore_bfd_errors);
3696           if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3697             {
3698               if (command_line.warn_mismatch)
3699                 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3700                        input_bfd);
3701             }
3702           if (! command_line.warn_mismatch)
3703             bfd_set_error_handler (pfn);
3704         }
3705     }
3706 }
3707
3708 /* Look through all the global common symbols and attach them to the
3709    correct section.  The -sort-common command line switch may be used
3710    to roughly sort the entries by size.  */
3711
3712 static void
3713 lang_common ()
3714 {
3715   if (command_line.inhibit_common_definition)
3716     return;
3717   if (link_info.relocateable
3718       && ! command_line.force_common_definition)
3719     return;
3720
3721   if (! config.sort_common)
3722     bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3723   else
3724     {
3725       int power;
3726
3727       for (power = 4; power >= 0; power--)
3728         bfd_link_hash_traverse (link_info.hash, lang_one_common,
3729                                 (PTR) &power);
3730     }
3731 }
3732
3733 /* Place one common symbol in the correct section.  */
3734
3735 static boolean
3736 lang_one_common (h, info)
3737      struct bfd_link_hash_entry *h;
3738      PTR info;
3739 {
3740   unsigned int power_of_two;
3741   bfd_vma size;
3742   asection *section;
3743   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3744                                                 ldfile_output_machine);
3745
3746   if (h->type != bfd_link_hash_common)
3747     return true;
3748
3749   size = h->u.c.size;
3750   power_of_two = h->u.c.p->alignment_power;
3751
3752   if (config.sort_common
3753       && power_of_two < (unsigned int) *(int *) info)
3754     return true;
3755
3756   section = h->u.c.p->section;
3757
3758   /* Increase the size of the section.  */
3759   section->_cooked_size = align_n ((section->_cooked_size + opb - 1) / opb,
3760                                    (bfd_vma) 1 << power_of_two) * opb;
3761
3762   /* Adjust the alignment if necessary.  */
3763   if (power_of_two > section->alignment_power)
3764     section->alignment_power = power_of_two;
3765
3766   /* Change the symbol from common to defined.  */
3767   h->type = bfd_link_hash_defined;
3768   h->u.def.section = section;
3769   h->u.def.value = section->_cooked_size;
3770
3771   /* Increase the size of the section.  */
3772   section->_cooked_size += size;
3773
3774   /* Make sure the section is allocated in memory, and make sure that
3775      it is no longer a common section.  */
3776   section->flags |= SEC_ALLOC;
3777   section->flags &= ~SEC_IS_COMMON;
3778
3779   if (config.map_file != NULL)
3780     {
3781       static boolean header_printed;
3782       int len;
3783       char *name;
3784       char buf[50];
3785
3786       if (! header_printed)
3787         {
3788           minfo (_("\nAllocating common symbols\n"));
3789           minfo (_("Common symbol       size              file\n\n"));
3790           header_printed = true;
3791         }
3792
3793       name = demangle (h->root.string);
3794       minfo ("%s", name);
3795       len = strlen (name);
3796       free (name);
3797
3798       if (len >= 19)
3799         {
3800           print_nl ();
3801           len = 0;
3802         }
3803       while (len < 20)
3804         {
3805           print_space ();
3806           ++len;
3807         }
3808
3809       minfo ("0x");
3810       if (size <= 0xffffffff)
3811         sprintf (buf, "%lx", (unsigned long) size);
3812       else
3813         sprintf_vma (buf, size);
3814       minfo ("%s", buf);
3815       len = strlen (buf);
3816
3817       while (len < 16)
3818         {
3819           print_space ();
3820           ++len;
3821         }
3822
3823       minfo ("%B\n", section->owner);
3824     }
3825
3826   return true;
3827 }
3828
3829 /* Run through the input files and ensure that every input section has
3830    somewhere to go.  If one is found without a destination then create
3831    an input request and place it into the statement tree.  */
3832
3833 static void
3834 lang_place_orphans ()
3835 {
3836   LANG_FOR_EACH_INPUT_STATEMENT (file)
3837     {
3838       asection *s;
3839
3840       for (s = file->the_bfd->sections;
3841            s != (asection *) NULL;
3842            s = s->next)
3843         {
3844           if (s->output_section == (asection *) NULL)
3845             {
3846               /* This section of the file is not attatched, root
3847                  around for a sensible place for it to go.  */
3848
3849               if (file->just_syms_flag)
3850                 {
3851                   abort ();
3852                 }
3853               else if (strcmp (s->name, "COMMON") == 0)
3854                 {
3855                   /* This is a lonely common section which must have
3856                      come from an archive.  We attach to the section
3857                      with the wildcard.  */
3858                   if (! link_info.relocateable
3859                       || command_line.force_common_definition)
3860                     {
3861                       if (default_common_section == NULL)
3862                         {
3863 #if 0
3864                           /* This message happens when using the
3865                              svr3.ifile linker script, so I have
3866                              disabled it.  */
3867                           info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3868 #endif
3869                           default_common_section =
3870                             lang_output_section_statement_lookup (".bss");
3871
3872                         }
3873                       lang_add_section (&default_common_section->children, s,
3874                                         default_common_section, file);
3875                     }
3876                 }
3877               else if (ldemul_place_orphan (file, s))
3878                 ;
3879               else
3880                 {
3881                   lang_output_section_statement_type *os;
3882
3883                   os = lang_output_section_statement_lookup (s->name);
3884                   lang_add_section (&os->children, s, os, file);
3885                 }
3886             }
3887         }
3888     }
3889 }
3890
3891 void
3892 lang_set_flags (ptr, flags, invert)
3893      lang_memory_region_type *ptr;
3894      const char *flags;
3895      int invert;
3896 {
3897   flagword *ptr_flags;
3898
3899   ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3900   while (*flags)
3901     {
3902       switch (*flags)
3903         {
3904         case 'A': case 'a':
3905           *ptr_flags |= SEC_ALLOC;
3906           break;
3907
3908         case 'R': case 'r':
3909           *ptr_flags |= SEC_READONLY;
3910           break;
3911
3912         case 'W': case 'w':
3913           *ptr_flags |= SEC_DATA;
3914           break;
3915
3916         case 'X': case 'x':
3917           *ptr_flags |= SEC_CODE;
3918           break;
3919
3920         case 'L': case 'l':
3921         case 'I': case 'i':
3922           *ptr_flags |= SEC_LOAD;
3923           break;
3924
3925         default:
3926           einfo (_("%P%F: invalid syntax in flags\n"));
3927           break;
3928         }
3929       flags++;
3930     }
3931 }
3932
3933 /* Call a function on each input file.  This function will be called
3934    on an archive, but not on the elements.  */
3935
3936 void
3937 lang_for_each_input_file (func)
3938      void (*func) PARAMS ((lang_input_statement_type *));
3939 {
3940   lang_input_statement_type *f;
3941
3942   for (f = (lang_input_statement_type *) input_file_chain.head;
3943        f != NULL;
3944        f = (lang_input_statement_type *) f->next_real_file)
3945     func (f);
3946 }
3947
3948 /* Call a function on each file.  The function will be called on all
3949    the elements of an archive which are included in the link, but will
3950    not be called on the archive file itself.  */
3951
3952 void
3953 lang_for_each_file (func)
3954      void (*func) PARAMS ((lang_input_statement_type *));
3955 {
3956   LANG_FOR_EACH_INPUT_STATEMENT (f)
3957     {
3958       func (f);
3959     }
3960 }
3961
3962 #if 0
3963
3964 /* Not used.  */
3965
3966 void
3967 lang_for_each_input_section (func)
3968      void (*func) PARAMS ((bfd *ab, asection *as));
3969 {
3970   LANG_FOR_EACH_INPUT_STATEMENT (f)
3971     {
3972       asection *s;
3973
3974       for (s = f->the_bfd->sections;
3975            s != (asection *) NULL;
3976            s = s->next)
3977         {
3978           func (f->the_bfd, s);
3979         }
3980     }
3981 }
3982
3983 #endif
3984
3985 void
3986 ldlang_add_file (entry)
3987      lang_input_statement_type *entry;
3988 {
3989   bfd **pp;
3990
3991   lang_statement_append (&file_chain,
3992                          (lang_statement_union_type *) entry,
3993                          &entry->next);
3994
3995   /* The BFD linker needs to have a list of all input BFDs involved in
3996      a link.  */
3997   ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3998   ASSERT (entry->the_bfd != output_bfd);
3999   for (pp = &link_info.input_bfds;
4000        *pp != (bfd *) NULL;
4001        pp = &(*pp)->link_next)
4002     ;
4003   *pp = entry->the_bfd;
4004   entry->the_bfd->usrdata = (PTR) entry;
4005   bfd_set_gp_size (entry->the_bfd, g_switch_value);
4006
4007   /* Look through the sections and check for any which should not be
4008      included in the link.  We need to do this now, so that we can
4009      notice when the backend linker tries to report multiple
4010      definition errors for symbols which are in sections we aren't
4011      going to link.  FIXME: It might be better to entirely ignore
4012      symbols which are defined in sections which are going to be
4013      discarded.  This would require modifying the backend linker for
4014      each backend which might set the SEC_LINK_ONCE flag.  If we do
4015      this, we should probably handle SEC_EXCLUDE in the same way.  */
4016
4017   bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
4018 }
4019
4020 void
4021 lang_add_output (name, from_script)
4022      const char *name;
4023      int from_script;
4024 {
4025   /* Make -o on command line override OUTPUT in script.  */
4026   if (!had_output_filename || !from_script)
4027     {
4028       output_filename = name;
4029       had_output_filename = true;
4030     }
4031 }
4032
4033 static lang_output_section_statement_type *current_section;
4034
4035 static int
4036 topower (x)
4037      int x;
4038 {
4039   unsigned int i = 1;
4040   int l;
4041
4042   if (x < 0)
4043     return -1;
4044
4045   for (l = 0; l < 32; l++)
4046     {
4047       if (i >= (unsigned int) x)
4048         return l;
4049       i <<= 1;
4050     }
4051
4052   return 0;
4053 }
4054
4055 lang_output_section_statement_type *
4056 lang_enter_output_section_statement (output_section_statement_name,
4057                                      address_exp, sectype, block_value,
4058                                      align, subalign, ebase)
4059      const char *output_section_statement_name;
4060      etree_type *address_exp;
4061      enum section_type sectype;
4062      bfd_vma block_value;
4063      etree_type *align;
4064      etree_type *subalign;
4065      etree_type *ebase;
4066 {
4067   lang_output_section_statement_type *os;
4068
4069   current_section =
4070    os =
4071     lang_output_section_statement_lookup (output_section_statement_name);
4072
4073   /* Add this statement to tree.  */
4074 #if 0
4075   add_statement (lang_output_section_statement_enum,
4076                  output_section_statement);
4077 #endif
4078   /* Make next things chain into subchain of this.  */
4079
4080   if (os->addr_tree == (etree_type *) NULL)
4081     {
4082       os->addr_tree = address_exp;
4083     }
4084   os->sectype = sectype;
4085   if (sectype != noload_section)
4086     os->flags = SEC_NO_FLAGS;
4087   else
4088     os->flags = SEC_NEVER_LOAD;
4089   os->block_value = block_value ? block_value : 1;
4090   stat_ptr = &os->children;
4091
4092   os->subsection_alignment =
4093     topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
4094   os->section_alignment =
4095     topower (exp_get_value_int (align, -1, "section alignment", 0));
4096
4097   os->load_base = ebase;
4098   return os;
4099 }
4100
4101 void
4102 lang_final ()
4103 {
4104   lang_output_statement_type *new =
4105     new_stat (lang_output_statement, stat_ptr);
4106
4107   new->name = output_filename;
4108 }
4109
4110 /* Reset the current counters in the regions.  */
4111
4112 void
4113 lang_reset_memory_regions ()
4114 {
4115   lang_memory_region_type *p = lang_memory_region_list;
4116   asection *o;
4117
4118   for (p = lang_memory_region_list;
4119        p != (lang_memory_region_type *) NULL;
4120        p = p->next)
4121     {
4122       p->old_length = (bfd_size_type) (p->current - p->origin);
4123       p->current = p->origin;
4124     }
4125
4126   for (o = output_bfd->sections; o != NULL; o = o->next)
4127     o->_raw_size = 0;
4128 }
4129
4130 /* If the wild pattern was marked KEEP, the member sections
4131    should be as well.  */
4132
4133 static void
4134 gc_section_callback (ptr, sec, section, file, data)
4135      lang_wild_statement_type *ptr;
4136      struct wildcard_list *sec ATTRIBUTE_UNUSED;
4137      asection *section;
4138      lang_input_statement_type *file ATTRIBUTE_UNUSED;
4139      PTR data ATTRIBUTE_UNUSED;
4140 {
4141   if (ptr->keep_sections)
4142     section->flags |= SEC_KEEP;
4143 }
4144
4145 /* Handle a wild statement, marking it against GC.  */
4146
4147 static void
4148 lang_gc_wild (s)
4149      lang_wild_statement_type *s;
4150 {
4151   walk_wild (s, gc_section_callback, NULL);
4152 }
4153
4154 /* Iterate over sections marking them against GC.  */
4155
4156 static void
4157 lang_gc_sections_1 (s)
4158      lang_statement_union_type *s;
4159 {
4160   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
4161     {
4162       switch (s->header.type)
4163         {
4164         case lang_wild_statement_enum:
4165           lang_gc_wild (&s->wild_statement);
4166           break;
4167         case lang_constructors_statement_enum:
4168           lang_gc_sections_1 (constructor_list.head);
4169           break;
4170         case lang_output_section_statement_enum:
4171           lang_gc_sections_1 (s->output_section_statement.children.head);
4172           break;
4173         case lang_group_statement_enum:
4174           lang_gc_sections_1 (s->group_statement.children.head);
4175           break;
4176         default:
4177           break;
4178         }
4179     }
4180 }
4181
4182 static void
4183 lang_gc_sections ()
4184 {
4185   struct bfd_link_hash_entry *h;
4186   ldlang_undef_chain_list_type *ulist;
4187
4188   /* Keep all sections so marked in the link script.  */
4189
4190   lang_gc_sections_1 (statement_list.head);
4191
4192   /* Keep all sections containing symbols undefined on the command-line,
4193      and the section containing the entry symbol.  */
4194
4195   for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
4196     {
4197       h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4198                                 false, false, false);
4199
4200       if (h != (struct bfd_link_hash_entry *) NULL
4201           && (h->type == bfd_link_hash_defined
4202               || h->type == bfd_link_hash_defweak)
4203           && ! bfd_is_abs_section (h->u.def.section))
4204         {
4205           h->u.def.section->flags |= SEC_KEEP;
4206         }
4207     }
4208
4209   bfd_gc_sections (output_bfd, &link_info);
4210 }
4211
4212 void
4213 lang_process ()
4214 {
4215   lang_reasonable_defaults ();
4216   current_target = default_target;
4217
4218   /* Open the output file.  */
4219   lang_for_each_statement (ldlang_open_output);
4220
4221   ldemul_create_output_section_statements ();
4222
4223   /* Add to the hash table all undefineds on the command line.  */
4224   lang_place_undefineds ();
4225
4226   already_linked_table_init ();
4227
4228   /* Create a bfd for each input file.  */
4229   current_target = default_target;
4230   open_input_bfds (statement_list.head, false);
4231
4232   link_info.gc_sym_list = &entry_symbol;
4233   if (entry_symbol.name == NULL)
4234     link_info.gc_sym_list = ldlang_undef_chain_list_head;
4235
4236   ldemul_after_open ();
4237
4238   already_linked_table_free ();
4239
4240   /* Make sure that we're not mixing architectures.  We call this
4241      after all the input files have been opened, but before we do any
4242      other processing, so that any operations merge_private_bfd_data
4243      does on the output file will be known during the rest of the
4244      link.  */
4245   lang_check ();
4246
4247   /* Handle .exports instead of a version script if we're told to do so.  */
4248   if (command_line.version_exports_section)
4249     lang_do_version_exports_section ();
4250
4251   /* Build all sets based on the information gathered from the input
4252      files.  */
4253   ldctor_build_sets ();
4254
4255   /* Remove unreferenced sections if asked to.  */
4256   if (command_line.gc_sections)
4257     lang_gc_sections ();
4258
4259   /* If there were any SEC_MERGE sections, finish their merging, so that
4260      section sizes can be computed.  This has to be done after GC of sections,
4261      so that GCed sections are not merged, but before assigning output
4262      sections, since removing whole input sections is hard then.  */
4263   bfd_merge_sections (output_bfd, &link_info);
4264
4265   /* Size up the common data.  */
4266   lang_common ();
4267
4268   /* Run through the contours of the script and attach input sections
4269      to the correct output sections.  */
4270   map_input_to_output_sections (statement_list.head, (char *) NULL,
4271                                 (lang_output_section_statement_type *) NULL);
4272
4273   /* Find any sections not attached explicitly and handle them.  */
4274   lang_place_orphans ();
4275
4276   if (! link_info.relocateable)
4277     {
4278       /* Look for a text section and set the readonly attribute in it.  */
4279       asection *found = bfd_get_section_by_name (output_bfd, ".text");
4280
4281       if (found != (asection *) NULL)
4282         {
4283           if (config.text_read_only)
4284             found->flags |= SEC_READONLY;
4285           else
4286             found->flags &= ~SEC_READONLY;
4287         }
4288     }
4289
4290   /* Do anything special before sizing sections.  This is where ELF
4291      and other back-ends size dynamic sections.  */
4292   ldemul_before_allocation ();
4293
4294   if (!link_info.relocateable)
4295     strip_excluded_output_sections ();
4296
4297   /* We must record the program headers before we try to fix the
4298      section positions, since they will affect SIZEOF_HEADERS.  */
4299   lang_record_phdrs ();
4300
4301   /* Size up the sections.  */
4302   lang_size_sections (statement_list.head,
4303                       abs_output_section,
4304                       &statement_list.head, 0, (bfd_vma) 0, NULL);
4305
4306   /* Now run around and relax if we can.  */
4307   if (command_line.relax)
4308     {
4309       /* Keep relaxing until bfd_relax_section gives up.  */
4310       boolean relax_again;
4311
4312       do
4313         {
4314           lang_reset_memory_regions ();
4315
4316           relax_again = false;
4317
4318           /* Note: pe-dll.c does something like this also.  If you find
4319              you need to change this code, you probably need to change
4320              pe-dll.c also.  DJ  */
4321
4322           /* Do all the assignments with our current guesses as to
4323              section sizes.  */
4324           lang_do_assignments (statement_list.head,
4325                                abs_output_section,
4326                                (fill_type *) 0, (bfd_vma) 0);
4327
4328           /* Perform another relax pass - this time we know where the
4329              globals are, so can make a better guess.  */
4330           lang_size_sections (statement_list.head,
4331                               abs_output_section,
4332                               &statement_list.head, 0, (bfd_vma) 0,
4333                               &relax_again);
4334         }
4335       while (relax_again);
4336     }
4337
4338   /* See if anything special should be done now we know how big
4339      everything is.  */
4340   ldemul_after_allocation ();
4341
4342   /* Fix any .startof. or .sizeof. symbols.  */
4343   lang_set_startof ();
4344
4345   /* Do all the assignments, now that we know the final resting places
4346      of all the symbols.  */
4347
4348   lang_do_assignments (statement_list.head,
4349                        abs_output_section,
4350                        (fill_type *) 0, (bfd_vma) 0);
4351
4352   /* Make sure that the section addresses make sense.  */
4353   if (! link_info.relocateable
4354       && command_line.check_section_addresses)
4355     lang_check_section_addresses ();
4356
4357   /* Final stuffs.  */
4358
4359   ldemul_finish ();
4360   lang_finish ();
4361 }
4362
4363 /* EXPORTED TO YACC */
4364
4365 void
4366 lang_add_wild (filespec, section_list, keep_sections)
4367      struct wildcard_spec *filespec;
4368      struct wildcard_list *section_list;
4369      boolean keep_sections;
4370 {
4371   struct wildcard_list *curr, *next;
4372   lang_wild_statement_type *new;
4373
4374   /* Reverse the list as the parser puts it back to front.  */
4375   for (curr = section_list, section_list = NULL;
4376        curr != NULL;
4377        section_list = curr, curr = next)
4378     {
4379       if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
4380         placed_commons = true;
4381
4382       next = curr->next;
4383       curr->next = section_list;
4384     }
4385
4386   if (filespec != NULL && filespec->name != NULL)
4387     {
4388       if (strcmp (filespec->name, "*") == 0)
4389         filespec->name = NULL;
4390       else if (! wildcardp (filespec->name))
4391         lang_has_input_file = true;
4392     }
4393
4394   new = new_stat (lang_wild_statement, stat_ptr);
4395   new->filename = NULL;
4396   new->filenames_sorted = false;
4397   if (filespec != NULL)
4398     {
4399       new->filename = filespec->name;
4400       new->filenames_sorted = filespec->sorted;
4401     }
4402   new->section_list = section_list;
4403   new->keep_sections = keep_sections;
4404   lang_list_init (&new->children);
4405 }
4406
4407 void
4408 lang_section_start (name, address)
4409      const char *name;
4410      etree_type *address;
4411 {
4412   lang_address_statement_type *ad;
4413
4414   ad = new_stat (lang_address_statement, stat_ptr);
4415   ad->section_name = name;
4416   ad->address = address;
4417 }
4418
4419 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
4420    because of a -e argument on the command line, or zero if this is
4421    called by ENTRY in a linker script.  Command line arguments take
4422    precedence.  */
4423
4424 void
4425 lang_add_entry (name, cmdline)
4426      const char *name;
4427      boolean cmdline;
4428 {
4429   if (entry_symbol.name == NULL
4430       || cmdline
4431       || ! entry_from_cmdline)
4432     {
4433       entry_symbol.name = name;
4434       entry_from_cmdline = cmdline;
4435     }
4436 }
4437
4438 void
4439 lang_add_target (name)
4440      const char *name;
4441 {
4442   lang_target_statement_type *new = new_stat (lang_target_statement,
4443                                               stat_ptr);
4444
4445   new->target = name;
4446
4447 }
4448
4449 void
4450 lang_add_map (name)
4451      const char *name;
4452 {
4453   while (*name)
4454     {
4455       switch (*name)
4456         {
4457         case 'F':
4458           map_option_f = true;
4459           break;
4460         }
4461       name++;
4462     }
4463 }
4464
4465 void
4466 lang_add_fill (fill)
4467      fill_type *fill;
4468 {
4469   lang_fill_statement_type *new = new_stat (lang_fill_statement,
4470                                             stat_ptr);
4471
4472   new->fill = fill;
4473 }
4474
4475 void
4476 lang_add_data (type, exp)
4477      int type;
4478      union etree_union *exp;
4479 {
4480
4481   lang_data_statement_type *new = new_stat (lang_data_statement,
4482                                             stat_ptr);
4483
4484   new->exp = exp;
4485   new->type = type;
4486
4487 }
4488
4489 /* Create a new reloc statement.  RELOC is the BFD relocation type to
4490    generate.  HOWTO is the corresponding howto structure (we could
4491    look this up, but the caller has already done so).  SECTION is the
4492    section to generate a reloc against, or NAME is the name of the
4493    symbol to generate a reloc against.  Exactly one of SECTION and
4494    NAME must be NULL.  ADDEND is an expression for the addend.  */
4495
4496 void
4497 lang_add_reloc (reloc, howto, section, name, addend)
4498      bfd_reloc_code_real_type reloc;
4499      reloc_howto_type *howto;
4500      asection *section;
4501      const char *name;
4502      union etree_union *addend;
4503 {
4504   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4505
4506   p->reloc = reloc;
4507   p->howto = howto;
4508   p->section = section;
4509   p->name = name;
4510   p->addend_exp = addend;
4511
4512   p->addend_value = 0;
4513   p->output_section = NULL;
4514   p->output_vma = 0;
4515 }
4516
4517 lang_assignment_statement_type *
4518 lang_add_assignment (exp)
4519      etree_type *exp;
4520 {
4521   lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4522                                                   stat_ptr);
4523
4524   new->exp = exp;
4525   return new;
4526 }
4527
4528 void
4529 lang_add_attribute (attribute)
4530      enum statement_enum attribute;
4531 {
4532   new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4533 }
4534
4535 void
4536 lang_startup (name)
4537      const char *name;
4538 {
4539   if (startup_file != (char *) NULL)
4540     {
4541       einfo (_("%P%Fmultiple STARTUP files\n"));
4542     }
4543   first_file->filename = name;
4544   first_file->local_sym_name = name;
4545   first_file->real = true;
4546
4547   startup_file = name;
4548 }
4549
4550 void
4551 lang_float (maybe)
4552      boolean maybe;
4553 {
4554   lang_float_flag = maybe;
4555 }
4556
4557
4558 /* Work out the load- and run-time regions from a script statement, and
4559    store them in *LMA_REGION and *REGION respectively.
4560
4561    MEMSPEC is the name of the run-time region, or "*default*" if the
4562    statement didn't specify one.  LMA_MEMSPEC is the name of the
4563    load-time region, or null if the statement didn't specify one.
4564    HAVE_LMA_P is true if the statement had an explicit load address.
4565
4566    It is an error to specify both a load region and a load address.  */
4567
4568 static void
4569 lang_get_regions (region, lma_region, memspec, lma_memspec, have_lma_p)
4570      struct memory_region_struct **region, **lma_region;
4571      const char *memspec, *lma_memspec;
4572      int have_lma_p;
4573 {
4574   *lma_region = lang_memory_region_lookup (lma_memspec);
4575
4576   /* If no runtime region has been given, but the load region has
4577      been, use the load region.  */
4578   if (lma_memspec != 0 && strcmp (memspec, "*default*") == 0)
4579     *region = *lma_region;
4580   else
4581     *region = lang_memory_region_lookup (memspec);
4582
4583   if (have_lma_p && lma_memspec != 0)
4584     einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4585 }
4586
4587 void
4588 lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
4589      fill_type *fill;
4590      const char *memspec;
4591      struct lang_output_section_phdr_list *phdrs;
4592      const char *lma_memspec;
4593 {
4594   lang_get_regions (&current_section->region,
4595                     &current_section->lma_region,
4596                     memspec, lma_memspec,
4597                     current_section->load_base != 0);
4598   current_section->fill = fill;
4599   current_section->phdrs = phdrs;
4600   stat_ptr = &statement_list;
4601 }
4602
4603 /* Create an absolute symbol with the given name with the value of the
4604    address of first byte of the section named.
4605
4606    If the symbol already exists, then do nothing.  */
4607
4608 void
4609 lang_abs_symbol_at_beginning_of (secname, name)
4610      const char *secname;
4611      const char *name;
4612 {
4613   struct bfd_link_hash_entry *h;
4614
4615   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4616   if (h == (struct bfd_link_hash_entry *) NULL)
4617     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4618
4619   if (h->type == bfd_link_hash_new
4620       || h->type == bfd_link_hash_undefined)
4621     {
4622       asection *sec;
4623
4624       h->type = bfd_link_hash_defined;
4625
4626       sec = bfd_get_section_by_name (output_bfd, secname);
4627       if (sec == (asection *) NULL)
4628         h->u.def.value = 0;
4629       else
4630         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4631
4632       h->u.def.section = bfd_abs_section_ptr;
4633     }
4634 }
4635
4636 /* Create an absolute symbol with the given name with the value of the
4637    address of the first byte after the end of the section named.
4638
4639    If the symbol already exists, then do nothing.  */
4640
4641 void
4642 lang_abs_symbol_at_end_of (secname, name)
4643      const char *secname;
4644      const char *name;
4645 {
4646   struct bfd_link_hash_entry *h;
4647
4648   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4649   if (h == (struct bfd_link_hash_entry *) NULL)
4650     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4651
4652   if (h->type == bfd_link_hash_new
4653       || h->type == bfd_link_hash_undefined)
4654     {
4655       asection *sec;
4656
4657       h->type = bfd_link_hash_defined;
4658
4659       sec = bfd_get_section_by_name (output_bfd, secname);
4660       if (sec == (asection *) NULL)
4661         h->u.def.value = 0;
4662       else
4663         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4664                           + bfd_section_size (output_bfd, sec) /
4665                           bfd_octets_per_byte (output_bfd));
4666
4667       h->u.def.section = bfd_abs_section_ptr;
4668     }
4669 }
4670
4671 void
4672 lang_statement_append (list, element, field)
4673      lang_statement_list_type *list;
4674      lang_statement_union_type *element;
4675      lang_statement_union_type **field;
4676 {
4677   *(list->tail) = element;
4678   list->tail = field;
4679 }
4680
4681 /* Set the output format type.  -oformat overrides scripts.  */
4682
4683 void
4684 lang_add_output_format (format, big, little, from_script)
4685      const char *format;
4686      const char *big;
4687      const char *little;
4688      int from_script;
4689 {
4690   if (output_target == NULL || !from_script)
4691     {
4692       if (command_line.endian == ENDIAN_BIG
4693           && big != NULL)
4694         format = big;
4695       else if (command_line.endian == ENDIAN_LITTLE
4696                && little != NULL)
4697         format = little;
4698
4699       output_target = format;
4700     }
4701 }
4702
4703 /* Enter a group.  This creates a new lang_group_statement, and sets
4704    stat_ptr to build new statements within the group.  */
4705
4706 void
4707 lang_enter_group ()
4708 {
4709   lang_group_statement_type *g;
4710
4711   g = new_stat (lang_group_statement, stat_ptr);
4712   lang_list_init (&g->children);
4713   stat_ptr = &g->children;
4714 }
4715
4716 /* Leave a group.  This just resets stat_ptr to start writing to the
4717    regular list of statements again.  Note that this will not work if
4718    groups can occur inside anything else which can adjust stat_ptr,
4719    but currently they can't.  */
4720
4721 void
4722 lang_leave_group ()
4723 {
4724   stat_ptr = &statement_list;
4725 }
4726
4727 /* Add a new program header.  This is called for each entry in a PHDRS
4728    command in a linker script.  */
4729
4730 void
4731 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4732      const char *name;
4733      etree_type *type;
4734      boolean filehdr;
4735      boolean phdrs;
4736      etree_type *at;
4737      etree_type *flags;
4738 {
4739   struct lang_phdr *n, **pp;
4740
4741   n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4742   n->next = NULL;
4743   n->name = name;
4744   n->type = exp_get_value_int (type, 0, "program header type",
4745                                lang_final_phase_enum);
4746   n->filehdr = filehdr;
4747   n->phdrs = phdrs;
4748   n->at = at;
4749   n->flags = flags;
4750
4751   for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4752     ;
4753   *pp = n;
4754 }
4755
4756 /* Record the program header information in the output BFD.  FIXME: We
4757    should not be calling an ELF specific function here.  */
4758
4759 static void
4760 lang_record_phdrs ()
4761 {
4762   unsigned int alc;
4763   asection **secs;
4764   struct lang_output_section_phdr_list *last;
4765   struct lang_phdr *l;
4766   lang_statement_union_type *u;
4767
4768   alc = 10;
4769   secs = (asection **) xmalloc (alc * sizeof (asection *));
4770   last = NULL;
4771   for (l = lang_phdr_list; l != NULL; l = l->next)
4772     {
4773       unsigned int c;
4774       flagword flags;
4775       bfd_vma at;
4776
4777       c = 0;
4778       for (u = lang_output_section_statement.head;
4779            u != NULL;
4780            u = u->output_section_statement.next)
4781         {
4782           lang_output_section_statement_type *os;
4783           struct lang_output_section_phdr_list *pl;
4784
4785           os = &u->output_section_statement;
4786
4787           pl = os->phdrs;
4788           if (pl != NULL)
4789             last = pl;
4790           else
4791             {
4792               if (os->sectype == noload_section
4793                   || os->bfd_section == NULL
4794                   || (os->bfd_section->flags & SEC_ALLOC) == 0)
4795                 continue;
4796               pl = last;
4797             }
4798
4799           if (os->bfd_section == NULL)
4800             continue;
4801
4802           for (; pl != NULL; pl = pl->next)
4803             {
4804               if (strcmp (pl->name, l->name) == 0)
4805                 {
4806                   if (c >= alc)
4807                     {
4808                       alc *= 2;
4809                       secs = ((asection **)
4810                               xrealloc (secs, alc * sizeof (asection *)));
4811                     }
4812                   secs[c] = os->bfd_section;
4813                   ++c;
4814                   pl->used = true;
4815                 }
4816             }
4817         }
4818
4819       if (l->flags == NULL)
4820         flags = 0;
4821       else
4822         flags = exp_get_vma (l->flags, 0, "phdr flags",
4823                              lang_final_phase_enum);
4824
4825       if (l->at == NULL)
4826         at = 0;
4827       else
4828         at = exp_get_vma (l->at, 0, "phdr load address",
4829                           lang_final_phase_enum);
4830
4831       if (! bfd_record_phdr (output_bfd, l->type,
4832                              l->flags != NULL, flags, l->at != NULL,
4833                              at, l->filehdr, l->phdrs, c, secs))
4834         einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4835     }
4836
4837   free (secs);
4838
4839   /* Make sure all the phdr assignments succeeded.  */
4840   for (u = lang_output_section_statement.head;
4841        u != NULL;
4842        u = u->output_section_statement.next)
4843     {
4844       struct lang_output_section_phdr_list *pl;
4845
4846       if (u->output_section_statement.bfd_section == NULL)
4847         continue;
4848
4849       for (pl = u->output_section_statement.phdrs;
4850            pl != NULL;
4851            pl = pl->next)
4852         if (! pl->used && strcmp (pl->name, "NONE") != 0)
4853           einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4854                  u->output_section_statement.name, pl->name);
4855     }
4856 }
4857
4858 /* Record a list of sections which may not be cross referenced.  */
4859
4860 void
4861 lang_add_nocrossref (l)
4862      struct lang_nocrossref *l;
4863 {
4864   struct lang_nocrossrefs *n;
4865
4866   n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4867   n->next = nocrossref_list;
4868   n->list = l;
4869   nocrossref_list = n;
4870
4871   /* Set notice_all so that we get informed about all symbols.  */
4872   link_info.notice_all = true;
4873 }
4874 \f
4875 /* Overlay handling.  We handle overlays with some static variables.  */
4876
4877 /* The overlay virtual address.  */
4878 static etree_type *overlay_vma;
4879
4880 /* An expression for the maximum section size seen so far.  */
4881 static etree_type *overlay_max;
4882
4883 /* A list of all the sections in this overlay.  */
4884
4885 struct overlay_list {
4886   struct overlay_list *next;
4887   lang_output_section_statement_type *os;
4888 };
4889
4890 static struct overlay_list *overlay_list;
4891
4892 /* Start handling an overlay.  */
4893
4894 void
4895 lang_enter_overlay (vma_expr)
4896      etree_type *vma_expr;
4897 {
4898   /* The grammar should prevent nested overlays from occurring.  */
4899   ASSERT (overlay_vma == NULL && overlay_max == NULL);
4900
4901   overlay_vma = vma_expr;
4902 }
4903
4904 /* Start a section in an overlay.  We handle this by calling
4905    lang_enter_output_section_statement with the correct VMA.
4906    lang_leave_overlay sets up the LMA and memory regions.  */
4907
4908 void
4909 lang_enter_overlay_section (name)
4910      const char *name;
4911 {
4912   struct overlay_list *n;
4913   etree_type *size;
4914
4915   lang_enter_output_section_statement (name, overlay_vma, normal_section,
4916                                        0, 0, 0, 0);
4917
4918   /* If this is the first section, then base the VMA of future
4919      sections on this one.  This will work correctly even if `.' is
4920      used in the addresses.  */
4921   if (overlay_list == NULL)
4922     overlay_vma = exp_nameop (ADDR, name);
4923
4924   /* Remember the section.  */
4925   n = (struct overlay_list *) xmalloc (sizeof *n);
4926   n->os = current_section;
4927   n->next = overlay_list;
4928   overlay_list = n;
4929
4930   size = exp_nameop (SIZEOF, name);
4931
4932   /* Arrange to work out the maximum section end address.  */
4933   if (overlay_max == NULL)
4934     overlay_max = size;
4935   else
4936     overlay_max = exp_binop (MAX_K, overlay_max, size);
4937 }
4938
4939 /* Finish a section in an overlay.  There isn't any special to do
4940    here.  */
4941
4942 void
4943 lang_leave_overlay_section (fill, phdrs)
4944      fill_type *fill;
4945      struct lang_output_section_phdr_list *phdrs;
4946 {
4947   const char *name;
4948   char *clean, *s2;
4949   const char *s1;
4950   char *buf;
4951
4952   name = current_section->name;
4953
4954   /* For now, assume that "*default*" is the run-time memory region and
4955      that no load-time region has been specified.  It doesn't really
4956      matter what we say here, since lang_leave_overlay will override it.  */
4957   lang_leave_output_section_statement (fill, "*default*", phdrs, 0);
4958
4959   /* Define the magic symbols.  */
4960
4961   clean = xmalloc (strlen (name) + 1);
4962   s2 = clean;
4963   for (s1 = name; *s1 != '\0'; s1++)
4964     if (ISALNUM (*s1) || *s1 == '_')
4965       *s2++ = *s1;
4966   *s2 = '\0';
4967
4968   buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4969   sprintf (buf, "__load_start_%s", clean);
4970   lang_add_assignment (exp_assop ('=', buf,
4971                                   exp_nameop (LOADADDR, name)));
4972
4973   buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4974   sprintf (buf, "__load_stop_%s", clean);
4975   lang_add_assignment (exp_assop ('=', buf,
4976                                   exp_binop ('+',
4977                                              exp_nameop (LOADADDR, name),
4978                                              exp_nameop (SIZEOF, name))));
4979
4980   free (clean);
4981 }
4982
4983 /* Finish an overlay.  If there are any overlay wide settings, this
4984    looks through all the sections in the overlay and sets them.  */
4985
4986 void
4987 lang_leave_overlay (lma_expr, nocrossrefs, fill, memspec, phdrs, lma_memspec)
4988      etree_type *lma_expr;
4989      int nocrossrefs;
4990      fill_type *fill;
4991      const char *memspec;
4992      struct lang_output_section_phdr_list *phdrs;
4993      const char *lma_memspec;
4994 {
4995   lang_memory_region_type *region;
4996   lang_memory_region_type *lma_region;
4997   struct overlay_list *l;
4998   struct lang_nocrossref *nocrossref;
4999
5000   lang_get_regions (&region, &lma_region,
5001                     memspec, lma_memspec,
5002                     lma_expr != 0);
5003
5004   nocrossref = NULL;
5005
5006   /* After setting the size of the last section, set '.' to end of the
5007      overlay region.  */
5008   if (overlay_list != NULL)
5009     overlay_list->os->update_dot_tree
5010       = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
5011
5012   l = overlay_list;
5013   while (l != NULL)
5014     {
5015       struct overlay_list *next;
5016
5017       if (fill != (fill_type *) 0 && l->os->fill == (fill_type *) 0)
5018         l->os->fill = fill;
5019
5020       l->os->region = region;
5021       l->os->lma_region = lma_region;
5022
5023       /* The first section has the load address specified in the
5024          OVERLAY statement.  The rest are worked out from that.
5025          The base address is not needed (and should be null) if
5026          an LMA region was specified.  */
5027       if (l->next == 0)
5028         l->os->load_base = lma_expr;
5029       else if (lma_region == 0)
5030         l->os->load_base = exp_binop ('+',
5031                                       exp_nameop (LOADADDR, l->next->os->name),
5032                                       exp_nameop (SIZEOF, l->next->os->name));
5033
5034       if (phdrs != NULL && l->os->phdrs == NULL)
5035         l->os->phdrs = phdrs;
5036
5037       if (nocrossrefs)
5038         {
5039           struct lang_nocrossref *nc;
5040
5041           nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
5042           nc->name = l->os->name;
5043           nc->next = nocrossref;
5044           nocrossref = nc;
5045         }
5046
5047       next = l->next;
5048       free (l);
5049       l = next;
5050     }
5051
5052   if (nocrossref != NULL)
5053     lang_add_nocrossref (nocrossref);
5054
5055   overlay_vma = NULL;
5056   overlay_list = NULL;
5057   overlay_max = NULL;
5058 }
5059 \f
5060 /* Version handling.  This is only useful for ELF.  */
5061
5062 /* This global variable holds the version tree that we build.  */
5063
5064 struct bfd_elf_version_tree *lang_elf_version_info;
5065
5066 static int
5067 lang_vers_match_lang_c (expr, sym)
5068      struct bfd_elf_version_expr *expr;
5069      const char *sym;
5070 {
5071   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5072     return 1;
5073   return fnmatch (expr->pattern, sym, 0) == 0;
5074 }
5075
5076 static int
5077 lang_vers_match_lang_cplusplus (expr, sym)
5078      struct bfd_elf_version_expr *expr;
5079      const char *sym;
5080 {
5081   char *alt_sym;
5082   int result;
5083
5084   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5085     return 1;
5086
5087   alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
5088   if (!alt_sym)
5089     {
5090       /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5091          Should we early out false in this case?  */
5092       result = fnmatch (expr->pattern, sym, 0) == 0;
5093     }
5094   else
5095     {
5096       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5097       free (alt_sym);
5098     }
5099
5100   return result;
5101 }
5102
5103 static int
5104 lang_vers_match_lang_java (expr, sym)
5105      struct bfd_elf_version_expr *expr;
5106      const char *sym;
5107 {
5108   char *alt_sym;
5109   int result;
5110
5111   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5112     return 1;
5113
5114   alt_sym = cplus_demangle (sym, DMGL_JAVA);
5115   if (!alt_sym)
5116     {
5117       /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5118          Should we early out false in this case?  */
5119       result = fnmatch (expr->pattern, sym, 0) == 0;
5120     }
5121   else
5122     {
5123       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5124       free (alt_sym);
5125     }
5126
5127   return result;
5128 }
5129
5130 /* This is called for each variable name or match expression.  */
5131
5132 struct bfd_elf_version_expr *
5133 lang_new_vers_pattern (orig, new, lang)
5134      struct bfd_elf_version_expr *orig;
5135      const char *new;
5136      const char *lang;
5137 {
5138   struct bfd_elf_version_expr *ret;
5139
5140   ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
5141   ret->next = orig;
5142   ret->pattern = new;
5143   ret->symver = 0;
5144   ret->script = 0;
5145
5146   if (lang == NULL || strcasecmp (lang, "C") == 0)
5147     ret->match = lang_vers_match_lang_c;
5148   else if (strcasecmp (lang, "C++") == 0)
5149     ret->match = lang_vers_match_lang_cplusplus;
5150   else if (strcasecmp (lang, "Java") == 0)
5151     ret->match = lang_vers_match_lang_java;
5152   else
5153     {
5154       einfo (_("%X%P: unknown language `%s' in version information\n"),
5155              lang);
5156       ret->match = lang_vers_match_lang_c;
5157     }
5158
5159   return ldemul_new_vers_pattern (ret);
5160 }
5161
5162 /* This is called for each set of variable names and match
5163    expressions.  */
5164
5165 struct bfd_elf_version_tree *
5166 lang_new_vers_node (globals, locals)
5167      struct bfd_elf_version_expr *globals;
5168      struct bfd_elf_version_expr *locals;
5169 {
5170   struct bfd_elf_version_tree *ret;
5171
5172   ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5173   ret->next = NULL;
5174   ret->name = NULL;
5175   ret->vernum = 0;
5176   ret->globals = globals;
5177   ret->locals = locals;
5178   ret->deps = NULL;
5179   ret->name_indx = (unsigned int) -1;
5180   ret->used = 0;
5181   return ret;
5182 }
5183
5184 /* This static variable keeps track of version indices.  */
5185
5186 static int version_index;
5187
5188 /* This is called when we know the name and dependencies of the
5189    version.  */
5190
5191 void
5192 lang_register_vers_node (name, version, deps)
5193      const char *name;
5194      struct bfd_elf_version_tree *version;
5195      struct bfd_elf_version_deps *deps;
5196 {
5197   struct bfd_elf_version_tree *t, **pp;
5198   struct bfd_elf_version_expr *e1;
5199
5200   if (name == NULL)
5201     name = "";
5202
5203   if ((name[0] == '\0' && lang_elf_version_info != NULL)
5204       || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
5205     {
5206       einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5207       return;
5208     }
5209
5210   /* Make sure this node has a unique name.  */
5211   for (t = lang_elf_version_info; t != NULL; t = t->next)
5212     if (strcmp (t->name, name) == 0)
5213       einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5214
5215   /* Check the global and local match names, and make sure there
5216      aren't any duplicates.  */
5217
5218   for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5219     {
5220       for (t = lang_elf_version_info; t != NULL; t = t->next)
5221         {
5222           struct bfd_elf_version_expr *e2;
5223
5224           for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5225             if (strcmp (e1->pattern, e2->pattern) == 0)
5226               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5227                      e1->pattern);
5228         }
5229     }
5230
5231   for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5232     {
5233       for (t = lang_elf_version_info; t != NULL; t = t->next)
5234         {
5235           struct bfd_elf_version_expr *e2;
5236
5237           for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5238             if (strcmp (e1->pattern, e2->pattern) == 0)
5239               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5240                      e1->pattern);
5241         }
5242     }
5243
5244   version->deps = deps;
5245   version->name = name;
5246   if (name[0] != '\0')
5247     {
5248       ++version_index;
5249       version->vernum = version_index;
5250     }
5251   else
5252     version->vernum = 0;
5253
5254   for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5255     ;
5256   *pp = version;
5257 }
5258
5259 /* This is called when we see a version dependency.  */
5260
5261 struct bfd_elf_version_deps *
5262 lang_add_vers_depend (list, name)
5263      struct bfd_elf_version_deps *list;
5264      const char *name;
5265 {
5266   struct bfd_elf_version_deps *ret;
5267   struct bfd_elf_version_tree *t;
5268
5269   ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5270   ret->next = list;
5271
5272   for (t = lang_elf_version_info; t != NULL; t = t->next)
5273     {
5274       if (strcmp (t->name, name) == 0)
5275         {
5276           ret->version_needed = t;
5277           return ret;
5278         }
5279     }
5280
5281   einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5282
5283   return ret;
5284 }
5285
5286 static void
5287 lang_do_version_exports_section ()
5288 {
5289   struct bfd_elf_version_expr *greg = NULL, *lreg;
5290
5291   LANG_FOR_EACH_INPUT_STATEMENT (is)
5292     {
5293       asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5294       char *contents, *p;
5295       bfd_size_type len;
5296
5297       if (sec == NULL)
5298         continue;
5299
5300       len = bfd_section_size (is->the_bfd, sec);
5301       contents = xmalloc (len);
5302       if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5303         einfo (_("%X%P: unable to read .exports section contents\n"), sec);
5304
5305       p = contents;
5306       while (p < contents + len)
5307         {
5308           greg = lang_new_vers_pattern (greg, p, NULL);
5309           p = strchr (p, '\0') + 1;
5310         }
5311
5312       /* Do not free the contents, as we used them creating the regex.  */
5313
5314       /* Do not include this section in the link.  */
5315       bfd_set_section_flags (is->the_bfd, sec,
5316         bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5317     }
5318
5319   lreg = lang_new_vers_pattern (NULL, "*", NULL);
5320   lang_register_vers_node (command_line.version_exports_section,
5321                            lang_new_vers_node (greg, lreg), NULL);
5322 }
5323
5324 void
5325 lang_add_unique (name)
5326      const char *name;
5327 {
5328   struct unique_sections *ent;
5329
5330   for (ent = unique_section_list; ent; ent = ent->next)
5331     if (strcmp (ent->name, name) == 0)
5332       return;
5333
5334   ent = (struct unique_sections *) xmalloc (sizeof *ent);
5335   ent->name = xstrdup (name);
5336   ent->next = unique_section_list;
5337   unique_section_list = ent;
5338 }