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