ld/ldlang.c

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