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