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