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