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