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