ld/ldlang.c

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