ld/ldlang.c

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