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