ld/ldlang.c

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